mirror of
https://github.com/golang/go
synced 2024-11-19 08:44:39 -07:00
cmd/internal/obj/i386: delete
Now unused. Change-Id: I0ba27e58721ad66cc3068346d6d31ba0ac37ad64 Reviewed-on: https://go-review.googlesource.com/6893 Reviewed-by: Rob Pike <r@golang.org> Reviewed-by: Minux Ma <minux@golang.org>
This commit is contained in:
Russ Cox
parent
2897d6dea7
commit
818eff0367
@ -1,594 +0,0 @@
|
||||
// Inferno utils/8c/8.out.h
|
||||
// http://code.google.com/p/inferno-os/source/browse/utils/8c/8.out.h
|
||||
//
|
||||
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
||||
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
||||
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
||||
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
||||
// Portions Copyright © 2004,2006 Bruce Ellis
|
||||
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
||||
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
||||
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
package i386
|
||||
|
||||
import "cmd/internal/obj"
|
||||
|
||||
const (
|
||||
AAAA = obj.ABase386 + obj.A_ARCHSPECIFIC + iota
|
||||
AAAD
|
||||
AAAM
|
||||
AAAS
|
||||
AADCB
|
||||
AADCL
|
||||
AADCW
|
||||
AADDB
|
||||
AADDL
|
||||
AADDW
|
||||
AADJSP
|
||||
AANDB
|
||||
AANDL
|
||||
AANDW
|
||||
AARPL
|
||||
ABOUNDL
|
||||
ABOUNDW
|
||||
ABSFL
|
||||
ABSFW
|
||||
ABSRL
|
||||
ABSRW
|
||||
ABTL
|
||||
ABTW
|
||||
ABTCL
|
||||
ABTCW
|
||||
ABTRL
|
||||
ABTRW
|
||||
ABTSL
|
||||
ABTSW
|
||||
ABYTE
|
||||
ACLC
|
||||
ACLD
|
||||
ACLI
|
||||
ACLTS
|
||||
ACMC
|
||||
ACMPB
|
||||
ACMPL
|
||||
ACMPW
|
||||
ACMPSB
|
||||
ACMPSL
|
||||
ACMPSW
|
||||
ADAA
|
||||
ADAS
|
||||
ADECB
|
||||
ADECL
|
||||
ADECW
|
||||
ADIVB
|
||||
ADIVL
|
||||
ADIVW
|
||||
AENTER
|
||||
AHLT
|
||||
AIDIVB
|
||||
AIDIVL
|
||||
AIDIVW
|
||||
AIMULB
|
||||
AIMULL
|
||||
AIMULW
|
||||
AINB
|
||||
AINL
|
||||
AINW
|
||||
AINCB
|
||||
AINCL
|
||||
AINCW
|
||||
AINSB
|
||||
AINSL
|
||||
AINSW
|
||||
AINT
|
||||
AINTO
|
||||
AIRETL
|
||||
AIRETW
|
||||
AJCC
|
||||
AJCS
|
||||
AJCXZL
|
||||
AJCXZW
|
||||
AJEQ
|
||||
AJGE
|
||||
AJGT
|
||||
AJHI
|
||||
AJLE
|
||||
AJLS
|
||||
AJLT
|
||||
AJMI
|
||||
AJNE
|
||||
AJOC
|
||||
AJOS
|
||||
AJPC
|
||||
AJPL
|
||||
AJPS
|
||||
ALAHF
|
||||
ALARL
|
||||
ALARW
|
||||
ALEAL
|
||||
ALEAW
|
||||
ALEAVEL
|
||||
ALEAVEW
|
||||
ALOCK
|
||||
ALODSB
|
||||
ALODSL
|
||||
ALODSW
|
||||
ALONG
|
||||
ALOOP
|
||||
ALOOPEQ
|
||||
ALOOPNE
|
||||
ALSLL
|
||||
ALSLW
|
||||
AMOVB
|
||||
AMOVL
|
||||
AMOVW
|
||||
AMOVQ
|
||||
AMOVBLSX
|
||||
AMOVBLZX
|
||||
AMOVBWSX
|
||||
AMOVBWZX
|
||||
AMOVWLSX
|
||||
AMOVWLZX
|
||||
AMOVSB
|
||||
AMOVSL
|
||||
AMOVSW
|
||||
AMULB
|
||||
AMULL
|
||||
AMULW
|
||||
ANEGB
|
||||
ANEGL
|
||||
ANEGW
|
||||
ANOTB
|
||||
ANOTL
|
||||
ANOTW
|
||||
AORB
|
||||
AORL
|
||||
AORW
|
||||
AOUTB
|
||||
AOUTL
|
||||
AOUTW
|
||||
AOUTSB
|
||||
AOUTSL
|
||||
AOUTSW
|
||||
APAUSE
|
||||
APOPAL
|
||||
APOPAW
|
||||
APOPFL
|
||||
APOPFW
|
||||
APOPL
|
||||
APOPW
|
||||
APUSHAL
|
||||
APUSHAW
|
||||
APUSHFL
|
||||
APUSHFW
|
||||
APUSHL
|
||||
APUSHW
|
||||
ARCLB
|
||||
ARCLL
|
||||
ARCLW
|
||||
ARCRB
|
||||
ARCRL
|
||||
ARCRW
|
||||
AREP
|
||||
AREPN
|
||||
AROLB
|
||||
AROLL
|
||||
AROLW
|
||||
ARORB
|
||||
ARORL
|
||||
ARORW
|
||||
ASAHF
|
||||
ASALB
|
||||
ASALL
|
||||
ASALW
|
||||
ASARB
|
||||
ASARL
|
||||
ASARW
|
||||
ASBBB
|
||||
ASBBL
|
||||
ASBBW
|
||||
ASCASB
|
||||
ASCASL
|
||||
ASCASW
|
||||
ASETCC
|
||||
ASETCS
|
||||
ASETEQ
|
||||
ASETGE
|
||||
ASETGT
|
||||
ASETHI
|
||||
ASETLE
|
||||
ASETLS
|
||||
ASETLT
|
||||
ASETMI
|
||||
ASETNE
|
||||
ASETOC
|
||||
ASETOS
|
||||
ASETPC
|
||||
ASETPL
|
||||
ASETPS
|
||||
ACDQ
|
||||
ACWD
|
||||
ASHLB
|
||||
ASHLL
|
||||
ASHLW
|
||||
ASHRB
|
||||
ASHRL
|
||||
ASHRW
|
||||
ASTC
|
||||
ASTD
|
||||
ASTI
|
||||
ASTOSB
|
||||
ASTOSL
|
||||
ASTOSW
|
||||
ASUBB
|
||||
ASUBL
|
||||
ASUBW
|
||||
ASYSCALL
|
||||
ATESTB
|
||||
ATESTL
|
||||
ATESTW
|
||||
AVERR
|
||||
AVERW
|
||||
AWAIT
|
||||
AWORD
|
||||
AXCHGB
|
||||
AXCHGL
|
||||
AXCHGW
|
||||
AXLAT
|
||||
AXORB
|
||||
AXORL
|
||||
AXORW
|
||||
AFMOVB
|
||||
AFMOVBP
|
||||
AFMOVD
|
||||
AFMOVDP
|
||||
AFMOVF
|
||||
AFMOVFP
|
||||
AFMOVL
|
||||
AFMOVLP
|
||||
AFMOVV
|
||||
AFMOVVP
|
||||
AFMOVW
|
||||
AFMOVWP
|
||||
AFMOVX
|
||||
AFMOVXP
|
||||
AFCOMB
|
||||
AFCOMBP
|
||||
AFCOMD
|
||||
AFCOMDP
|
||||
AFCOMDPP
|
||||
AFCOMF
|
||||
AFCOMFP
|
||||
AFCOMI
|
||||
AFCOMIP
|
||||
AFCOML
|
||||
AFCOMLP
|
||||
AFCOMW
|
||||
AFCOMWP
|
||||
AFUCOM
|
||||
AFUCOMI
|
||||
AFUCOMIP
|
||||
AFUCOMP
|
||||
AFUCOMPP
|
||||
AFADDDP
|
||||
AFADDW
|
||||
AFADDL
|
||||
AFADDF
|
||||
AFADDD
|
||||
AFMULDP
|
||||
AFMULW
|
||||
AFMULL
|
||||
AFMULF
|
||||
AFMULD
|
||||
AFSUBDP
|
||||
AFSUBW
|
||||
AFSUBL
|
||||
AFSUBF
|
||||
AFSUBD
|
||||
AFSUBRDP
|
||||
AFSUBRW
|
||||
AFSUBRL
|
||||
AFSUBRF
|
||||
AFSUBRD
|
||||
AFDIVDP
|
||||
AFDIVW
|
||||
AFDIVL
|
||||
AFDIVF
|
||||
AFDIVD
|
||||
AFDIVRDP
|
||||
AFDIVRW
|
||||
AFDIVRL
|
||||
AFDIVRF
|
||||
AFDIVRD
|
||||
AFXCHD
|
||||
AFFREE
|
||||
AFLDCW
|
||||
AFLDENV
|
||||
AFRSTOR
|
||||
AFSAVE
|
||||
AFSTCW
|
||||
AFSTENV
|
||||
AFSTSW
|
||||
AF2XM1
|
||||
AFABS
|
||||
AFCHS
|
||||
AFCLEX
|
||||
AFCOS
|
||||
AFDECSTP
|
||||
AFINCSTP
|
||||
AFINIT
|
||||
AFLD1
|
||||
AFLDL2E
|
||||
AFLDL2T
|
||||
AFLDLG2
|
||||
AFLDLN2
|
||||
AFLDPI
|
||||
AFLDZ
|
||||
AFNOP
|
||||
AFPATAN
|
||||
AFPREM
|
||||
AFPREM1
|
||||
AFPTAN
|
||||
AFRNDINT
|
||||
AFSCALE
|
||||
AFSIN
|
||||
AFSINCOS
|
||||
AFSQRT
|
||||
AFTST
|
||||
AFXAM
|
||||
AFXTRACT
|
||||
AFYL2X
|
||||
AFYL2XP1
|
||||
ACMPXCHGB
|
||||
ACMPXCHGL
|
||||
ACMPXCHGW
|
||||
ACMPXCHG8B
|
||||
ACPUID
|
||||
ARDTSC
|
||||
AXADDB
|
||||
AXADDL
|
||||
AXADDW
|
||||
ACMOVLCC
|
||||
ACMOVLCS
|
||||
ACMOVLEQ
|
||||
ACMOVLGE
|
||||
ACMOVLGT
|
||||
ACMOVLHI
|
||||
ACMOVLLE
|
||||
ACMOVLLS
|
||||
ACMOVLLT
|
||||
ACMOVLMI
|
||||
ACMOVLNE
|
||||
ACMOVLOC
|
||||
ACMOVLOS
|
||||
ACMOVLPC
|
||||
ACMOVLPL
|
||||
ACMOVLPS
|
||||
ACMOVWCC
|
||||
ACMOVWCS
|
||||
ACMOVWEQ
|
||||
ACMOVWGE
|
||||
ACMOVWGT
|
||||
ACMOVWHI
|
||||
ACMOVWLE
|
||||
ACMOVWLS
|
||||
ACMOVWLT
|
||||
ACMOVWMI
|
||||
ACMOVWNE
|
||||
ACMOVWOC
|
||||
ACMOVWOS
|
||||
ACMOVWPC
|
||||
ACMOVWPL
|
||||
ACMOVWPS
|
||||
AFCMOVCC
|
||||
AFCMOVCS
|
||||
AFCMOVEQ
|
||||
AFCMOVHI
|
||||
AFCMOVLS
|
||||
AFCMOVNE
|
||||
AFCMOVNU
|
||||
AFCMOVUN
|
||||
ALFENCE
|
||||
AMFENCE
|
||||
ASFENCE
|
||||
AEMMS
|
||||
APREFETCHT0
|
||||
APREFETCHT1
|
||||
APREFETCHT2
|
||||
APREFETCHNTA
|
||||
ABSWAPL
|
||||
AADDPD
|
||||
AADDPS
|
||||
AADDSD
|
||||
AADDSS
|
||||
AANDNPD
|
||||
AANDNPS
|
||||
AANDPD
|
||||
AANDPS
|
||||
ACMPPD
|
||||
ACMPPS
|
||||
ACMPSD
|
||||
ACMPSS
|
||||
ACOMISD
|
||||
ACOMISS
|
||||
ACVTPL2PD
|
||||
ACVTPL2PS
|
||||
ACVTPD2PL
|
||||
ACVTPD2PS
|
||||
ACVTPS2PL
|
||||
ACVTPS2PD
|
||||
ACVTSD2SL
|
||||
ACVTSD2SS
|
||||
ACVTSL2SD
|
||||
ACVTSL2SS
|
||||
ACVTSS2SD
|
||||
ACVTSS2SL
|
||||
ACVTTPD2PL
|
||||
ACVTTPS2PL
|
||||
ACVTTSD2SL
|
||||
ACVTTSS2SL
|
||||
ADIVPD
|
||||
ADIVPS
|
||||
ADIVSD
|
||||
ADIVSS
|
||||
AMASKMOVOU
|
||||
AMAXPD
|
||||
AMAXPS
|
||||
AMAXSD
|
||||
AMAXSS
|
||||
AMINPD
|
||||
AMINPS
|
||||
AMINSD
|
||||
AMINSS
|
||||
AMOVAPD
|
||||
AMOVAPS
|
||||
AMOVO
|
||||
AMOVOU
|
||||
AMOVHLPS
|
||||
AMOVHPD
|
||||
AMOVHPS
|
||||
AMOVLHPS
|
||||
AMOVLPD
|
||||
AMOVLPS
|
||||
AMOVMSKPD
|
||||
AMOVMSKPS
|
||||
AMOVNTO
|
||||
AMOVNTPD
|
||||
AMOVNTPS
|
||||
AMOVSD
|
||||
AMOVSS
|
||||
AMOVUPD
|
||||
AMOVUPS
|
||||
AMULPD
|
||||
AMULPS
|
||||
AMULSD
|
||||
AMULSS
|
||||
AORPD
|
||||
AORPS
|
||||
APADDQ
|
||||
APAND
|
||||
APCMPEQB
|
||||
APMAXSW
|
||||
APMAXUB
|
||||
APMINSW
|
||||
APMINUB
|
||||
APMOVMSKB
|
||||
APSADBW
|
||||
APSUBB
|
||||
APSUBL
|
||||
APSUBQ
|
||||
APSUBSB
|
||||
APSUBSW
|
||||
APSUBUSB
|
||||
APSUBUSW
|
||||
APSUBW
|
||||
APUNPCKHQDQ
|
||||
APUNPCKLQDQ
|
||||
APXOR
|
||||
ARCPPS
|
||||
ARCPSS
|
||||
ARSQRTPS
|
||||
ARSQRTSS
|
||||
ASQRTPD
|
||||
ASQRTPS
|
||||
ASQRTSD
|
||||
ASQRTSS
|
||||
ASUBPD
|
||||
ASUBPS
|
||||
ASUBSD
|
||||
ASUBSS
|
||||
AUCOMISD
|
||||
AUCOMISS
|
||||
AUNPCKHPD
|
||||
AUNPCKHPS
|
||||
AUNPCKLPD
|
||||
AUNPCKLPS
|
||||
AXORPD
|
||||
AXORPS
|
||||
APSHUFHW
|
||||
APSHUFL
|
||||
APSHUFLW
|
||||
AAESENC
|
||||
APINSRD
|
||||
APSHUFB
|
||||
ALAST
|
||||
)
|
||||
|
||||
const (
|
||||
REG_NONE = 0
|
||||
REG_AL = obj.RBase386 + 0 + iota - 1
|
||||
REG_CL
|
||||
REG_DL
|
||||
REG_BL
|
||||
REG_AH = obj.RBase386 + 4 + iota - 5
|
||||
REG_CH
|
||||
REG_DH
|
||||
REG_BH
|
||||
REG_AX = obj.RBase386 + 8 + iota - 9
|
||||
REG_CX
|
||||
REG_DX
|
||||
REG_BX
|
||||
REG_SP
|
||||
REG_BP
|
||||
REG_SI
|
||||
REG_DI
|
||||
REG_F0 = obj.RBase386 + 16
|
||||
REG_F7 = obj.RBase386 + REG_F0 + 7
|
||||
REG_CS = obj.RBase386 + 24 + iota - 19
|
||||
REG_SS
|
||||
REG_DS
|
||||
REG_ES
|
||||
REG_FS
|
||||
REG_GS
|
||||
REG_GDTR
|
||||
REG_IDTR
|
||||
REG_LDTR
|
||||
REG_MSW
|
||||
REG_TASK
|
||||
REG_CR = obj.RBase386 + 35
|
||||
REG_DR = obj.RBase386 + 43
|
||||
REG_TR = obj.RBase386 + 51
|
||||
REG_X0 = obj.RBase386 + 59 + iota - 33
|
||||
REG_X1
|
||||
REG_X2
|
||||
REG_X3
|
||||
REG_X4
|
||||
REG_X5
|
||||
REG_X6
|
||||
REG_X7
|
||||
REG_TLS = obj.RBase386 + 67
|
||||
MAXREG = obj.RBase386 + 68
|
||||
T_TYPE = 1 << 0
|
||||
T_INDEX = 1 << 1
|
||||
T_OFFSET = 1 << 2
|
||||
T_FCONST = 1 << 3
|
||||
T_SYM = 1 << 4
|
||||
T_SCONST = 1 << 5
|
||||
T_OFFSET2 = 1 << 6
|
||||
T_GOTYPE = 1 << 7
|
||||
REGARG = -1
|
||||
REGRET = REG_AX
|
||||
FREGRET = REG_F0
|
||||
REGSP = REG_SP
|
||||
REGTMP = REG_DI
|
||||
REGCTXT = REG_DX
|
||||
)
|
||||
@ -1,507 +0,0 @@
|
||||
package i386
|
||||
|
||||
import "cmd/internal/obj"
|
||||
|
||||
/*
|
||||
* this is the ranlib header
|
||||
*/
|
||||
var Anames = []string{
|
||||
obj.A_ARCHSPECIFIC: "AAA",
|
||||
"AAD",
|
||||
"AAM",
|
||||
"AAS",
|
||||
"ADCB",
|
||||
"ADCL",
|
||||
"ADCW",
|
||||
"ADDB",
|
||||
"ADDL",
|
||||
"ADDW",
|
||||
"ADJSP",
|
||||
"ANDB",
|
||||
"ANDL",
|
||||
"ANDW",
|
||||
"ARPL",
|
||||
"BOUNDL",
|
||||
"BOUNDW",
|
||||
"BSFL",
|
||||
"BSFW",
|
||||
"BSRL",
|
||||
"BSRW",
|
||||
"BTL",
|
||||
"BTW",
|
||||
"BTCL",
|
||||
"BTCW",
|
||||
"BTRL",
|
||||
"BTRW",
|
||||
"BTSL",
|
||||
"BTSW",
|
||||
"BYTE",
|
||||
"CLC",
|
||||
"CLD",
|
||||
"CLI",
|
||||
"CLTS",
|
||||
"CMC",
|
||||
"CMPB",
|
||||
"CMPL",
|
||||
"CMPW",
|
||||
"CMPSB",
|
||||
"CMPSL",
|
||||
"CMPSW",
|
||||
"DAA",
|
||||
"DAS",
|
||||
"DECB",
|
||||
"DECL",
|
||||
"DECW",
|
||||
"DIVB",
|
||||
"DIVL",
|
||||
"DIVW",
|
||||
"ENTER",
|
||||
"HLT",
|
||||
"IDIVB",
|
||||
"IDIVL",
|
||||
"IDIVW",
|
||||
"IMULB",
|
||||
"IMULL",
|
||||
"IMULW",
|
||||
"INB",
|
||||
"INL",
|
||||
"INW",
|
||||
"INCB",
|
||||
"INCL",
|
||||
"INCW",
|
||||
"INSB",
|
||||
"INSL",
|
||||
"INSW",
|
||||
"INT",
|
||||
"INTO",
|
||||
"IRETL",
|
||||
"IRETW",
|
||||
"JCC",
|
||||
"JCS",
|
||||
"JCXZL",
|
||||
"JCXZW",
|
||||
"JEQ",
|
||||
"JGE",
|
||||
"JGT",
|
||||
"JHI",
|
||||
"JLE",
|
||||
"JLS",
|
||||
"JLT",
|
||||
"JMI",
|
||||
"JNE",
|
||||
"JOC",
|
||||
"JOS",
|
||||
"JPC",
|
||||
"JPL",
|
||||
"JPS",
|
||||
"LAHF",
|
||||
"LARL",
|
||||
"LARW",
|
||||
"LEAL",
|
||||
"LEAW",
|
||||
"LEAVEL",
|
||||
"LEAVEW",
|
||||
"LOCK",
|
||||
"LODSB",
|
||||
"LODSL",
|
||||
"LODSW",
|
||||
"LONG",
|
||||
"LOOP",
|
||||
"LOOPEQ",
|
||||
"LOOPNE",
|
||||
"LSLL",
|
||||
"LSLW",
|
||||
"MOVB",
|
||||
"MOVL",
|
||||
"MOVW",
|
||||
"MOVQ",
|
||||
"MOVBLSX",
|
||||
"MOVBLZX",
|
||||
"MOVBWSX",
|
||||
"MOVBWZX",
|
||||
"MOVWLSX",
|
||||
"MOVWLZX",
|
||||
"MOVSB",
|
||||
"MOVSL",
|
||||
"MOVSW",
|
||||
"MULB",
|
||||
"MULL",
|
||||
"MULW",
|
||||
"NEGB",
|
||||
"NEGL",
|
||||
"NEGW",
|
||||
"NOTB",
|
||||
"NOTL",
|
||||
"NOTW",
|
||||
"ORB",
|
||||
"ORL",
|
||||
"ORW",
|
||||
"OUTB",
|
||||
"OUTL",
|
||||
"OUTW",
|
||||
"OUTSB",
|
||||
"OUTSL",
|
||||
"OUTSW",
|
||||
"PAUSE",
|
||||
"POPAL",
|
||||
"POPAW",
|
||||
"POPFL",
|
||||
"POPFW",
|
||||
"POPL",
|
||||
"POPW",
|
||||
"PUSHAL",
|
||||
"PUSHAW",
|
||||
"PUSHFL",
|
||||
"PUSHFW",
|
||||
"PUSHL",
|
||||
"PUSHW",
|
||||
"RCLB",
|
||||
"RCLL",
|
||||
"RCLW",
|
||||
"RCRB",
|
||||
"RCRL",
|
||||
"RCRW",
|
||||
"REP",
|
||||
"REPN",
|
||||
"ROLB",
|
||||
"ROLL",
|
||||
"ROLW",
|
||||
"RORB",
|
||||
"RORL",
|
||||
"RORW",
|
||||
"SAHF",
|
||||
"SALB",
|
||||
"SALL",
|
||||
"SALW",
|
||||
"SARB",
|
||||
"SARL",
|
||||
"SARW",
|
||||
"SBBB",
|
||||
"SBBL",
|
||||
"SBBW",
|
||||
"SCASB",
|
||||
"SCASL",
|
||||
"SCASW",
|
||||
"SETCC",
|
||||
"SETCS",
|
||||
"SETEQ",
|
||||
"SETGE",
|
||||
"SETGT",
|
||||
"SETHI",
|
||||
"SETLE",
|
||||
"SETLS",
|
||||
"SETLT",
|
||||
"SETMI",
|
||||
"SETNE",
|
||||
"SETOC",
|
||||
"SETOS",
|
||||
"SETPC",
|
||||
"SETPL",
|
||||
"SETPS",
|
||||
"CDQ",
|
||||
"CWD",
|
||||
"SHLB",
|
||||
"SHLL",
|
||||
"SHLW",
|
||||
"SHRB",
|
||||
"SHRL",
|
||||
"SHRW",
|
||||
"STC",
|
||||
"STD",
|
||||
"STI",
|
||||
"STOSB",
|
||||
"STOSL",
|
||||
"STOSW",
|
||||
"SUBB",
|
||||
"SUBL",
|
||||
"SUBW",
|
||||
"SYSCALL",
|
||||
"TESTB",
|
||||
"TESTL",
|
||||
"TESTW",
|
||||
"VERR",
|
||||
"VERW",
|
||||
"WAIT",
|
||||
"WORD",
|
||||
"XCHGB",
|
||||
"XCHGL",
|
||||
"XCHGW",
|
||||
"XLAT",
|
||||
"XORB",
|
||||
"XORL",
|
||||
"XORW",
|
||||
"FMOVB",
|
||||
"FMOVBP",
|
||||
"FMOVD",
|
||||
"FMOVDP",
|
||||
"FMOVF",
|
||||
"FMOVFP",
|
||||
"FMOVL",
|
||||
"FMOVLP",
|
||||
"FMOVV",
|
||||
"FMOVVP",
|
||||
"FMOVW",
|
||||
"FMOVWP",
|
||||
"FMOVX",
|
||||
"FMOVXP",
|
||||
"FCOMB",
|
||||
"FCOMBP",
|
||||
"FCOMD",
|
||||
"FCOMDP",
|
||||
"FCOMDPP",
|
||||
"FCOMF",
|
||||
"FCOMFP",
|
||||
"FCOMI",
|
||||
"FCOMIP",
|
||||
"FCOML",
|
||||
"FCOMLP",
|
||||
"FCOMW",
|
||||
"FCOMWP",
|
||||
"FUCOM",
|
||||
"FUCOMI",
|
||||
"FUCOMIP",
|
||||
"FUCOMP",
|
||||
"FUCOMPP",
|
||||
"FADDDP",
|
||||
"FADDW",
|
||||
"FADDL",
|
||||
"FADDF",
|
||||
"FADDD",
|
||||
"FMULDP",
|
||||
"FMULW",
|
||||
"FMULL",
|
||||
"FMULF",
|
||||
"FMULD",
|
||||
"FSUBDP",
|
||||
"FSUBW",
|
||||
"FSUBL",
|
||||
"FSUBF",
|
||||
"FSUBD",
|
||||
"FSUBRDP",
|
||||
"FSUBRW",
|
||||
"FSUBRL",
|
||||
"FSUBRF",
|
||||
"FSUBRD",
|
||||
"FDIVDP",
|
||||
"FDIVW",
|
||||
"FDIVL",
|
||||
"FDIVF",
|
||||
"FDIVD",
|
||||
"FDIVRDP",
|
||||
"FDIVRW",
|
||||
"FDIVRL",
|
||||
"FDIVRF",
|
||||
"FDIVRD",
|
||||
"FXCHD",
|
||||
"FFREE",
|
||||
"FLDCW",
|
||||
"FLDENV",
|
||||
"FRSTOR",
|
||||
"FSAVE",
|
||||
"FSTCW",
|
||||
"FSTENV",
|
||||
"FSTSW",
|
||||
"F2XM1",
|
||||
"FABS",
|
||||
"FCHS",
|
||||
"FCLEX",
|
||||
"FCOS",
|
||||
"FDECSTP",
|
||||
"FINCSTP",
|
||||
"FINIT",
|
||||
"FLD1",
|
||||
"FLDL2E",
|
||||
"FLDL2T",
|
||||
"FLDLG2",
|
||||
"FLDLN2",
|
||||
"FLDPI",
|
||||
"FLDZ",
|
||||
"FNOP",
|
||||
"FPATAN",
|
||||
"FPREM",
|
||||
"FPREM1",
|
||||
"FPTAN",
|
||||
"FRNDINT",
|
||||
"FSCALE",
|
||||
"FSIN",
|
||||
"FSINCOS",
|
||||
"FSQRT",
|
||||
"FTST",
|
||||
"FXAM",
|
||||
"FXTRACT",
|
||||
"FYL2X",
|
||||
"FYL2XP1",
|
||||
"CMPXCHGB",
|
||||
"CMPXCHGL",
|
||||
"CMPXCHGW",
|
||||
"CMPXCHG8B",
|
||||
"CPUID",
|
||||
"RDTSC",
|
||||
"XADDB",
|
||||
"XADDL",
|
||||
"XADDW",
|
||||
"CMOVLCC",
|
||||
"CMOVLCS",
|
||||
"CMOVLEQ",
|
||||
"CMOVLGE",
|
||||
"CMOVLGT",
|
||||
"CMOVLHI",
|
||||
"CMOVLLE",
|
||||
"CMOVLLS",
|
||||
"CMOVLLT",
|
||||
"CMOVLMI",
|
||||
"CMOVLNE",
|
||||
"CMOVLOC",
|
||||
"CMOVLOS",
|
||||
"CMOVLPC",
|
||||
"CMOVLPL",
|
||||
"CMOVLPS",
|
||||
"CMOVWCC",
|
||||
"CMOVWCS",
|
||||
"CMOVWEQ",
|
||||
"CMOVWGE",
|
||||
"CMOVWGT",
|
||||
"CMOVWHI",
|
||||
"CMOVWLE",
|
||||
"CMOVWLS",
|
||||
"CMOVWLT",
|
||||
"CMOVWMI",
|
||||
"CMOVWNE",
|
||||
"CMOVWOC",
|
||||
"CMOVWOS",
|
||||
"CMOVWPC",
|
||||
"CMOVWPL",
|
||||
"CMOVWPS",
|
||||
"FCMOVCC",
|
||||
"FCMOVCS",
|
||||
"FCMOVEQ",
|
||||
"FCMOVHI",
|
||||
"FCMOVLS",
|
||||
"FCMOVNE",
|
||||
"FCMOVNU",
|
||||
"FCMOVUN",
|
||||
"LFENCE",
|
||||
"MFENCE",
|
||||
"SFENCE",
|
||||
"EMMS",
|
||||
"PREFETCHT0",
|
||||
"PREFETCHT1",
|
||||
"PREFETCHT2",
|
||||
"PREFETCHNTA",
|
||||
"BSWAPL",
|
||||
"ADDPD",
|
||||
"ADDPS",
|
||||
"ADDSD",
|
||||
"ADDSS",
|
||||
"ANDNPD",
|
||||
"ANDNPS",
|
||||
"ANDPD",
|
||||
"ANDPS",
|
||||
"CMPPD",
|
||||
"CMPPS",
|
||||
"CMPSD",
|
||||
"CMPSS",
|
||||
"COMISD",
|
||||
"COMISS",
|
||||
"CVTPL2PD",
|
||||
"CVTPL2PS",
|
||||
"CVTPD2PL",
|
||||
"CVTPD2PS",
|
||||
"CVTPS2PL",
|
||||
"CVTPS2PD",
|
||||
"CVTSD2SL",
|
||||
"CVTSD2SS",
|
||||
"CVTSL2SD",
|
||||
"CVTSL2SS",
|
||||
"CVTSS2SD",
|
||||
"CVTSS2SL",
|
||||
"CVTTPD2PL",
|
||||
"CVTTPS2PL",
|
||||
"CVTTSD2SL",
|
||||
"CVTTSS2SL",
|
||||
"DIVPD",
|
||||
"DIVPS",
|
||||
"DIVSD",
|
||||
"DIVSS",
|
||||
"MASKMOVOU",
|
||||
"MAXPD",
|
||||
"MAXPS",
|
||||
"MAXSD",
|
||||
"MAXSS",
|
||||
"MINPD",
|
||||
"MINPS",
|
||||
"MINSD",
|
||||
"MINSS",
|
||||
"MOVAPD",
|
||||
"MOVAPS",
|
||||
"MOVO",
|
||||
"MOVOU",
|
||||
"MOVHLPS",
|
||||
"MOVHPD",
|
||||
"MOVHPS",
|
||||
"MOVLHPS",
|
||||
"MOVLPD",
|
||||
"MOVLPS",
|
||||
"MOVMSKPD",
|
||||
"MOVMSKPS",
|
||||
"MOVNTO",
|
||||
"MOVNTPD",
|
||||
"MOVNTPS",
|
||||
"MOVSD",
|
||||
"MOVSS",
|
||||
"MOVUPD",
|
||||
"MOVUPS",
|
||||
"MULPD",
|
||||
"MULPS",
|
||||
"MULSD",
|
||||
"MULSS",
|
||||
"ORPD",
|
||||
"ORPS",
|
||||
"PADDQ",
|
||||
"PAND",
|
||||
"PCMPEQB",
|
||||
"PMAXSW",
|
||||
"PMAXUB",
|
||||
"PMINSW",
|
||||
"PMINUB",
|
||||
"PMOVMSKB",
|
||||
"PSADBW",
|
||||
"PSUBB",
|
||||
"PSUBL",
|
||||
"PSUBQ",
|
||||
"PSUBSB",
|
||||
"PSUBSW",
|
||||
"PSUBUSB",
|
||||
"PSUBUSW",
|
||||
"PSUBW",
|
||||
"PUNPCKHQDQ",
|
||||
"PUNPCKLQDQ",
|
||||
"PXOR",
|
||||
"RCPPS",
|
||||
"RCPSS",
|
||||
"RSQRTPS",
|
||||
"RSQRTSS",
|
||||
"SQRTPD",
|
||||
"SQRTPS",
|
||||
"SQRTSD",
|
||||
"SQRTSS",
|
||||
"SUBPD",
|
||||
"SUBPS",
|
||||
"SUBSD",
|
||||
"SUBSS",
|
||||
"UCOMISD",
|
||||
"UCOMISS",
|
||||
"UNPCKHPD",
|
||||
"UNPCKHPS",
|
||||
"UNPCKLPD",
|
||||
"UNPCKLPS",
|
||||
"XORPD",
|
||||
"XORPS",
|
||||
"PSHUFHW",
|
||||
"PSHUFL",
|
||||
"PSHUFLW",
|
||||
"AESENC",
|
||||
"PINSRD",
|
||||
"PSHUFB",
|
||||
"LAST",
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,161 +0,0 @@
|
||||
// Inferno utils/8c/list.c
|
||||
// http://code.google.com/p/inferno-os/source/browse/utils/8c/list.c
|
||||
//
|
||||
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
||||
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
||||
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
||||
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
||||
// Portions Copyright © 2004,2006 Bruce Ellis
|
||||
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
||||
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
||||
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
package i386
|
||||
|
||||
import (
|
||||
"cmd/internal/obj"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
const (
|
||||
STRINGSZ = 1000
|
||||
)
|
||||
|
||||
var bigP *obj.Prog
|
||||
|
||||
func Pconv(p *obj.Prog) string {
|
||||
var str string
|
||||
|
||||
switch p.As {
|
||||
case obj.ADATA:
|
||||
str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
|
||||
p.Pc, p.Line(), obj.Aconv(int(p.As)), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
|
||||
|
||||
case obj.ATEXT:
|
||||
if p.From3.Offset != 0 {
|
||||
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
|
||||
p.Pc, p.Line(), obj.Aconv(int(p.As)), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
|
||||
break
|
||||
}
|
||||
|
||||
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
|
||||
p.Pc, p.Line(), obj.Aconv(int(p.As)), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
|
||||
|
||||
default:
|
||||
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
|
||||
p.Pc, p.Line(), obj.Aconv(int(p.As)), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
|
||||
|
||||
// TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
|
||||
// SHRQ $32(DX*0), AX
|
||||
// Remove.
|
||||
if (p.From.Type == obj.TYPE_REG || p.From.Type == obj.TYPE_CONST) && p.From.Index != 0 {
|
||||
str += fmt.Sprintf(":%v", Rconv(int(p.From.Index)))
|
||||
}
|
||||
}
|
||||
|
||||
var fp string
|
||||
fp += str
|
||||
return fp
|
||||
}
|
||||
|
||||
var Register = []string{
|
||||
"AL", /* [REG_AL] */
|
||||
"CL",
|
||||
"DL",
|
||||
"BL",
|
||||
"AH",
|
||||
"CH",
|
||||
"DH",
|
||||
"BH",
|
||||
"AX", /* [REG_AX] */
|
||||
"CX",
|
||||
"DX",
|
||||
"BX",
|
||||
"SP",
|
||||
"BP",
|
||||
"SI",
|
||||
"DI",
|
||||
"F0", /* [REG_F0] */
|
||||
"F1",
|
||||
"F2",
|
||||
"F3",
|
||||
"F4",
|
||||
"F5",
|
||||
"F6",
|
||||
"F7",
|
||||
"CS", /* [REG_CS] */
|
||||
"SS",
|
||||
"DS",
|
||||
"ES",
|
||||
"FS",
|
||||
"GS",
|
||||
"GDTR", /* [REG_GDTR] */
|
||||
"IDTR", /* [REG_IDTR] */
|
||||
"LDTR", /* [REG_LDTR] */
|
||||
"MSW", /* [REG_MSW] */
|
||||
"TASK", /* [REG_TASK] */
|
||||
"CR0", /* [REG_CR] */
|
||||
"CR1",
|
||||
"CR2",
|
||||
"CR3",
|
||||
"CR4",
|
||||
"CR5",
|
||||
"CR6",
|
||||
"CR7",
|
||||
"DR0", /* [REG_DR] */
|
||||
"DR1",
|
||||
"DR2",
|
||||
"DR3",
|
||||
"DR4",
|
||||
"DR5",
|
||||
"DR6",
|
||||
"DR7",
|
||||
"TR0", /* [REG_TR] */
|
||||
"TR1",
|
||||
"TR2",
|
||||
"TR3",
|
||||
"TR4",
|
||||
"TR5",
|
||||
"TR6",
|
||||
"TR7",
|
||||
"X0", /* [REG_X0] */
|
||||
"X1",
|
||||
"X2",
|
||||
"X3",
|
||||
"X4",
|
||||
"X5",
|
||||
"X6",
|
||||
"X7",
|
||||
"TLS", /* [REG_TLS] */
|
||||
"MAXREG", /* [MAXREG] */
|
||||
}
|
||||
|
||||
func init() {
|
||||
obj.RegisterRegister(obj.RBase386, obj.RBase386+len(Register), Rconv)
|
||||
obj.RegisterOpcode(obj.ABase386, Anames)
|
||||
}
|
||||
|
||||
func Rconv(r int) string {
|
||||
if r >= REG_AL && r-REG_AL < len(Register) {
|
||||
return Register[r-REG_AL]
|
||||
}
|
||||
return fmt.Sprintf("Rgok(%d)", r-obj.RBase386)
|
||||
}
|
||||
@ -1,942 +0,0 @@
|
||||
// Inferno utils/8l/pass.c
|
||||
// http://code.google.com/p/inferno-os/source/browse/utils/8l/pass.c
|
||||
//
|
||||
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
||||
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
||||
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
||||
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
||||
// Portions Copyright © 2004,2006 Bruce Ellis
|
||||
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
||||
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
||||
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
package i386
|
||||
|
||||
import (
|
||||
"cmd/internal/obj"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
)
|
||||
|
||||
func canuselocaltls(ctxt *obj.Link) bool {
|
||||
switch ctxt.Headtype {
|
||||
case obj.Hlinux,
|
||||
obj.Hnacl,
|
||||
obj.Hplan9,
|
||||
obj.Hwindows:
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func progedit(ctxt *obj.Link, p *obj.Prog) {
|
||||
// See obj6.c for discussion of TLS.
|
||||
if canuselocaltls(ctxt) {
|
||||
// Reduce TLS initial exec model to TLS local exec model.
|
||||
// Sequences like
|
||||
// MOVL TLS, BX
|
||||
// ... off(BX)(TLS*1) ...
|
||||
// become
|
||||
// NOP
|
||||
// ... off(TLS) ...
|
||||
if p.As == AMOVL && p.From.Type == obj.TYPE_REG && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_DI {
|
||||
p.As = obj.ANOP
|
||||
p.From.Type = obj.TYPE_NONE
|
||||
p.To.Type = obj.TYPE_NONE
|
||||
}
|
||||
|
||||
if p.From.Type == obj.TYPE_MEM && p.From.Index == REG_TLS && REG_AX <= p.From.Reg && p.From.Reg <= REG_DI {
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_TLS
|
||||
p.From.Scale = 0
|
||||
p.From.Index = REG_NONE
|
||||
}
|
||||
|
||||
if p.To.Type == obj.TYPE_MEM && p.To.Index == REG_TLS && REG_AX <= p.To.Reg && p.To.Reg <= REG_DI {
|
||||
p.To.Type = obj.TYPE_MEM
|
||||
p.To.Reg = REG_TLS
|
||||
p.To.Scale = 0
|
||||
p.To.Index = REG_NONE
|
||||
}
|
||||
} else {
|
||||
// As a courtesy to the C compilers, rewrite TLS local exec load as TLS initial exec load.
|
||||
// The instruction
|
||||
// MOVL off(TLS), BX
|
||||
// becomes the sequence
|
||||
// MOVL TLS, BX
|
||||
// MOVL off(BX)(TLS*1), BX
|
||||
// This allows the C compilers to emit references to m and g using the direct off(TLS) form.
|
||||
if p.As == AMOVL && p.From.Type == obj.TYPE_MEM && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_DI {
|
||||
q := obj.Appendp(ctxt, p)
|
||||
q.As = p.As
|
||||
q.From.Type = obj.TYPE_MEM
|
||||
q.From.Reg = p.To.Reg
|
||||
q.From.Index = REG_TLS
|
||||
q.From.Scale = 2 // TODO: use 1
|
||||
q.To = p.To
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_TLS
|
||||
p.From.Index = REG_NONE
|
||||
p.From.Offset = 0
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Remove.
|
||||
if ctxt.Headtype == obj.Hplan9 {
|
||||
if p.From.Scale == 1 && p.From.Index == REG_TLS {
|
||||
p.From.Scale = 2
|
||||
}
|
||||
if p.To.Scale == 1 && p.To.Index == REG_TLS {
|
||||
p.To.Scale = 2
|
||||
}
|
||||
}
|
||||
|
||||
// Rewrite CALL/JMP/RET to symbol as TYPE_BRANCH.
|
||||
switch p.As {
|
||||
case obj.ACALL,
|
||||
obj.AJMP,
|
||||
obj.ARET:
|
||||
if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
}
|
||||
}
|
||||
|
||||
// Rewrite float constants to values stored in memory.
|
||||
switch p.As {
|
||||
// Convert AMOVSS $(0), Xx to AXORPS Xx, Xx
|
||||
case AMOVSS:
|
||||
if p.From.Type == obj.TYPE_FCONST {
|
||||
if p.From.U.Dval == 0 {
|
||||
if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X7 {
|
||||
p.As = AXORPS
|
||||
p.From = p.To
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
fallthrough
|
||||
|
||||
// fallthrough
|
||||
|
||||
case AFMOVF,
|
||||
AFADDF,
|
||||
AFSUBF,
|
||||
AFSUBRF,
|
||||
AFMULF,
|
||||
AFDIVF,
|
||||
AFDIVRF,
|
||||
AFCOMF,
|
||||
AFCOMFP,
|
||||
AADDSS,
|
||||
ASUBSS,
|
||||
AMULSS,
|
||||
ADIVSS,
|
||||
ACOMISS,
|
||||
AUCOMISS:
|
||||
if p.From.Type == obj.TYPE_FCONST {
|
||||
f32 := float32(p.From.U.Dval)
|
||||
i32 := math.Float32bits(f32)
|
||||
literal := fmt.Sprintf("$f32.%08x", i32)
|
||||
s := obj.Linklookup(ctxt, literal, 0)
|
||||
if s.Type == 0 {
|
||||
s.Type = obj.SRODATA
|
||||
obj.Adduint32(ctxt, s, i32)
|
||||
s.Reachable = 0
|
||||
}
|
||||
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Name = obj.NAME_EXTERN
|
||||
p.From.Sym = s
|
||||
p.From.Offset = 0
|
||||
}
|
||||
|
||||
// Convert AMOVSD $(0), Xx to AXORPS Xx, Xx
|
||||
case AMOVSD:
|
||||
if p.From.Type == obj.TYPE_FCONST {
|
||||
if p.From.U.Dval == 0 {
|
||||
if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X7 {
|
||||
p.As = AXORPS
|
||||
p.From = p.To
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
fallthrough
|
||||
|
||||
// fallthrough
|
||||
|
||||
case AFMOVD,
|
||||
AFADDD,
|
||||
AFSUBD,
|
||||
AFSUBRD,
|
||||
AFMULD,
|
||||
AFDIVD,
|
||||
AFDIVRD,
|
||||
AFCOMD,
|
||||
AFCOMDP,
|
||||
AADDSD,
|
||||
ASUBSD,
|
||||
AMULSD,
|
||||
ADIVSD,
|
||||
ACOMISD,
|
||||
AUCOMISD:
|
||||
if p.From.Type == obj.TYPE_FCONST {
|
||||
i64 := math.Float64bits(p.From.U.Dval)
|
||||
literal := fmt.Sprintf("$f64.%016x", i64)
|
||||
s := obj.Linklookup(ctxt, literal, 0)
|
||||
if s.Type == 0 {
|
||||
s.Type = obj.SRODATA
|
||||
obj.Adduint64(ctxt, s, i64)
|
||||
s.Reachable = 0
|
||||
}
|
||||
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Name = obj.NAME_EXTERN
|
||||
p.From.Sym = s
|
||||
p.From.Offset = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
|
||||
if ctxt.Symmorestack[0] == nil {
|
||||
ctxt.Symmorestack[0] = obj.Linklookup(ctxt, "runtime.morestack", 0)
|
||||
ctxt.Symmorestack[1] = obj.Linklookup(ctxt, "runtime.morestack_noctxt", 0)
|
||||
}
|
||||
|
||||
if ctxt.Headtype == obj.Hplan9 && ctxt.Plan9privates == nil {
|
||||
ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
|
||||
}
|
||||
|
||||
ctxt.Cursym = cursym
|
||||
|
||||
if cursym.Text == nil || cursym.Text.Link == nil {
|
||||
return
|
||||
}
|
||||
|
||||
p := cursym.Text
|
||||
autoffset := int32(p.To.Offset)
|
||||
if autoffset < 0 {
|
||||
autoffset = 0
|
||||
}
|
||||
|
||||
cursym.Locals = autoffset
|
||||
cursym.Args = p.To.U.Argsize
|
||||
|
||||
if p.From3.Offset&obj.NOSPLIT == 0 || (p.From3.Offset&obj.WRAPPER != 0) {
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p = load_g_cx(ctxt, p) // load g into CX
|
||||
}
|
||||
|
||||
var q *obj.Prog
|
||||
if cursym.Text.From3.Offset&obj.NOSPLIT == 0 {
|
||||
p = stacksplit(ctxt, p, autoffset, cursym.Text.From3.Offset&obj.NEEDCTXT == 0, &q) // emit split check
|
||||
}
|
||||
|
||||
if autoffset != 0 {
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AADJSP
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = int64(autoffset)
|
||||
p.Spadj = autoffset
|
||||
} else {
|
||||
// zero-byte stack adjustment.
|
||||
// Insert a fake non-zero adjustment so that stkcheck can
|
||||
// recognize the end of the stack-splitting prolog.
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = obj.ANOP
|
||||
p.Spadj = int32(-ctxt.Arch.Ptrsize)
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = obj.ANOP
|
||||
p.Spadj = int32(ctxt.Arch.Ptrsize)
|
||||
}
|
||||
|
||||
if q != nil {
|
||||
q.Pcond = p
|
||||
}
|
||||
deltasp := autoffset
|
||||
|
||||
if cursym.Text.From3.Offset&obj.WRAPPER != 0 {
|
||||
// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
|
||||
//
|
||||
// MOVL g_panic(CX), BX
|
||||
// TESTL BX, BX
|
||||
// JEQ end
|
||||
// LEAL (autoffset+4)(SP), DI
|
||||
// CMPL panic_argp(BX), DI
|
||||
// JNE end
|
||||
// MOVL SP, panic_argp(BX)
|
||||
// end:
|
||||
// NOP
|
||||
//
|
||||
// The NOP is needed to give the jumps somewhere to land.
|
||||
// It is a liblink NOP, not an x86 NOP: it encodes to 0 instruction bytes.
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_CX
|
||||
p.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_BX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ATESTL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_BX
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_BX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AJEQ
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
p1 := p
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ALEAL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_SP
|
||||
p.From.Offset = int64(autoffset) + 4
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_DI
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ACMPL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_BX
|
||||
p.From.Offset = 0 // Panic.argp
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_DI
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AJNE
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
p2 := p
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_SP
|
||||
p.To.Type = obj.TYPE_MEM
|
||||
p.To.Reg = REG_BX
|
||||
p.To.Offset = 0 // Panic.argp
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = obj.ANOP
|
||||
p1.Pcond = p
|
||||
p2.Pcond = p
|
||||
}
|
||||
|
||||
if ctxt.Debugzerostack != 0 && autoffset != 0 && cursym.Text.From3.Offset&obj.NOSPLIT == 0 {
|
||||
// 8l -Z means zero the stack frame on entry.
|
||||
// This slows down function calls but can help avoid
|
||||
// false positives in garbage collection.
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_SP
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_DI
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = int64(autoffset) / 4
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_CX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = 0
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_AX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AREP
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ASTOSL
|
||||
}
|
||||
|
||||
var a int
|
||||
for ; p != nil; p = p.Link {
|
||||
a = int(p.From.Name)
|
||||
if a == obj.NAME_AUTO {
|
||||
p.From.Offset += int64(deltasp)
|
||||
}
|
||||
if a == obj.NAME_PARAM {
|
||||
p.From.Offset += int64(deltasp) + 4
|
||||
}
|
||||
a = int(p.To.Name)
|
||||
if a == obj.NAME_AUTO {
|
||||
p.To.Offset += int64(deltasp)
|
||||
}
|
||||
if a == obj.NAME_PARAM {
|
||||
p.To.Offset += int64(deltasp) + 4
|
||||
}
|
||||
|
||||
switch p.As {
|
||||
default:
|
||||
continue
|
||||
|
||||
case APUSHL,
|
||||
APUSHFL:
|
||||
deltasp += 4
|
||||
p.Spadj = 4
|
||||
continue
|
||||
|
||||
case APUSHW,
|
||||
APUSHFW:
|
||||
deltasp += 2
|
||||
p.Spadj = 2
|
||||
continue
|
||||
|
||||
case APOPL,
|
||||
APOPFL:
|
||||
deltasp -= 4
|
||||
p.Spadj = -4
|
||||
continue
|
||||
|
||||
case APOPW,
|
||||
APOPFW:
|
||||
deltasp -= 2
|
||||
p.Spadj = -2
|
||||
continue
|
||||
|
||||
case obj.ARET:
|
||||
break
|
||||
}
|
||||
|
||||
if autoffset != deltasp {
|
||||
ctxt.Diag("unbalanced PUSH/POP")
|
||||
}
|
||||
|
||||
if autoffset != 0 {
|
||||
p.As = AADJSP
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = int64(-autoffset)
|
||||
p.Spadj = -autoffset
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = obj.ARET
|
||||
|
||||
// If there are instructions following
|
||||
// this ARET, they come from a branch
|
||||
// with the same stackframe, so undo
|
||||
// the cleanup.
|
||||
p.Spadj = +autoffset
|
||||
}
|
||||
|
||||
if p.To.Sym != nil { // retjmp
|
||||
p.As = obj.AJMP
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Append code to p to load g into cx.
|
||||
// Overwrites p with the first instruction (no first appendp).
|
||||
// Overwriting p is unusual but it lets use this in both the
|
||||
// prologue (caller must call appendp first) and in the epilogue.
|
||||
// Returns last new instruction.
|
||||
func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog {
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_TLS
|
||||
p.From.Offset = 0
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_CX
|
||||
|
||||
next := p.Link
|
||||
progedit(ctxt, p)
|
||||
for p.Link != next {
|
||||
p = p.Link
|
||||
}
|
||||
|
||||
if p.From.Index == REG_TLS {
|
||||
p.From.Scale = 2
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// Append code to p to check for stack split.
|
||||
// Appends to (does not overwrite) p.
|
||||
// Assumes g is in CX.
|
||||
// Returns last new instruction.
|
||||
// On return, *jmpok is the instruction that should jump
|
||||
// to the stack frame allocation if no split is needed.
|
||||
func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool, jmpok **obj.Prog) *obj.Prog {
|
||||
if ctxt.Debugstack != 0 {
|
||||
// 8l -K means check not only for stack
|
||||
// overflow but stack underflow.
|
||||
// On underflow, INT 3 (breakpoint).
|
||||
// Underflow itself is rare but this also
|
||||
// catches out-of-sync stack guard info.
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = ACMPL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_CX
|
||||
p.From.Offset = 4
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_SP
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AJCC
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
p.To.Offset = 4
|
||||
q1 := p
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AINT
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = 3
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = obj.ANOP
|
||||
q1.Pcond = p
|
||||
}
|
||||
|
||||
var q1 *obj.Prog
|
||||
|
||||
if framesize <= obj.StackSmall {
|
||||
// small stack: SP <= stackguard
|
||||
// CMPL SP, stackguard
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = ACMPL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_SP
|
||||
p.To.Type = obj.TYPE_MEM
|
||||
p.To.Reg = REG_CX
|
||||
p.To.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
|
||||
if ctxt.Cursym.Cfunc != 0 {
|
||||
p.To.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
|
||||
}
|
||||
} else if framesize <= obj.StackBig {
|
||||
// large stack: SP-framesize <= stackguard-StackSmall
|
||||
// LEAL -(framesize-StackSmall)(SP), AX
|
||||
// CMPL AX, stackguard
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = ALEAL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_SP
|
||||
p.From.Offset = -(int64(framesize) - obj.StackSmall)
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_AX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ACMPL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_AX
|
||||
p.To.Type = obj.TYPE_MEM
|
||||
p.To.Reg = REG_CX
|
||||
p.To.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
|
||||
if ctxt.Cursym.Cfunc != 0 {
|
||||
p.To.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
|
||||
}
|
||||
} else {
|
||||
// Such a large stack we need to protect against wraparound
|
||||
// if SP is close to zero.
|
||||
// SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
|
||||
// The +StackGuard on both sides is required to keep the left side positive:
|
||||
// SP is allowed to be slightly below stackguard. See stack.h.
|
||||
//
|
||||
// Preemption sets stackguard to StackPreempt, a very large value.
|
||||
// That breaks the math above, so we have to check for that explicitly.
|
||||
// MOVL stackguard, CX
|
||||
// CMPL CX, $StackPreempt
|
||||
// JEQ label-of-call-to-morestack
|
||||
// LEAL StackGuard(SP), AX
|
||||
// SUBL stackguard, AX
|
||||
// CMPL AX, $(framesize+(StackGuard-StackSmall))
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = AMOVL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_CX
|
||||
p.From.Offset = 0
|
||||
p.From.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
|
||||
if ctxt.Cursym.Cfunc != 0 {
|
||||
p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
|
||||
}
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_SI
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ACMPL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_SI
|
||||
p.To.Type = obj.TYPE_CONST
|
||||
p.To.Offset = int64(uint32(obj.StackPreempt & (1<<32 - 1)))
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = AJEQ
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
q1 = p
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ALEAL
|
||||
p.From.Type = obj.TYPE_MEM
|
||||
p.From.Reg = REG_SP
|
||||
p.From.Offset = obj.StackGuard
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_AX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ASUBL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_SI
|
||||
p.From.Offset = 0
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = REG_AX
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = ACMPL
|
||||
p.From.Type = obj.TYPE_REG
|
||||
p.From.Reg = REG_AX
|
||||
p.To.Type = obj.TYPE_CONST
|
||||
p.To.Offset = int64(framesize) + (obj.StackGuard - obj.StackSmall)
|
||||
}
|
||||
|
||||
// common
|
||||
p = obj.Appendp(ctxt, p)
|
||||
|
||||
p.As = AJHI
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
p.To.Offset = 4
|
||||
q := p
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = obj.ACALL
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
if ctxt.Cursym.Cfunc != 0 {
|
||||
p.To.Sym = obj.Linklookup(ctxt, "runtime.morestackc", 0)
|
||||
} else {
|
||||
p.To.Sym = ctxt.Symmorestack[bool2int(noctxt)]
|
||||
}
|
||||
|
||||
p = obj.Appendp(ctxt, p)
|
||||
p.As = obj.AJMP
|
||||
p.To.Type = obj.TYPE_BRANCH
|
||||
p.Pcond = ctxt.Cursym.Text.Link
|
||||
|
||||
if q != nil {
|
||||
q.Pcond = p.Link
|
||||
}
|
||||
if q1 != nil {
|
||||
q1.Pcond = q.Link
|
||||
}
|
||||
|
||||
*jmpok = q
|
||||
return p
|
||||
}
|
||||
|
||||
func follow(ctxt *obj.Link, s *obj.LSym) {
|
||||
ctxt.Cursym = s
|
||||
|
||||
firstp := ctxt.NewProg()
|
||||
lastp := firstp
|
||||
xfol(ctxt, s.Text, &lastp)
|
||||
lastp.Link = nil
|
||||
s.Text = firstp.Link
|
||||
}
|
||||
|
||||
func nofollow(a int) bool {
|
||||
switch a {
|
||||
case obj.AJMP,
|
||||
obj.ARET,
|
||||
AIRETL,
|
||||
AIRETW,
|
||||
obj.AUNDEF:
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func pushpop(a int) bool {
|
||||
switch a {
|
||||
case APUSHL,
|
||||
APUSHFL,
|
||||
APUSHW,
|
||||
APUSHFW,
|
||||
APOPL,
|
||||
APOPFL,
|
||||
APOPW,
|
||||
APOPFW:
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func relinv(a int) int {
|
||||
switch a {
|
||||
case AJEQ:
|
||||
return AJNE
|
||||
case AJNE:
|
||||
return AJEQ
|
||||
case AJLE:
|
||||
return AJGT
|
||||
case AJLS:
|
||||
return AJHI
|
||||
case AJLT:
|
||||
return AJGE
|
||||
case AJMI:
|
||||
return AJPL
|
||||
case AJGE:
|
||||
return AJLT
|
||||
case AJPL:
|
||||
return AJMI
|
||||
case AJGT:
|
||||
return AJLE
|
||||
case AJHI:
|
||||
return AJLS
|
||||
case AJCS:
|
||||
return AJCC
|
||||
case AJCC:
|
||||
return AJCS
|
||||
case AJPS:
|
||||
return AJPC
|
||||
case AJPC:
|
||||
return AJPS
|
||||
case AJOS:
|
||||
return AJOC
|
||||
case AJOC:
|
||||
return AJOS
|
||||
}
|
||||
|
||||
log.Fatalf("unknown relation: %s", Anames[a])
|
||||
return 0
|
||||
}
|
||||
|
||||
func xfol(ctxt *obj.Link, p *obj.Prog, last **obj.Prog) {
|
||||
var q *obj.Prog
|
||||
var i int
|
||||
var a int
|
||||
|
||||
loop:
|
||||
if p == nil {
|
||||
return
|
||||
}
|
||||
if p.As == obj.AJMP {
|
||||
q = p.Pcond
|
||||
if q != nil && q.As != obj.ATEXT {
|
||||
/* mark instruction as done and continue layout at target of jump */
|
||||
p.Mark = 1
|
||||
|
||||
p = q
|
||||
if p.Mark == 0 {
|
||||
goto loop
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if p.Mark != 0 {
|
||||
/*
|
||||
* p goes here, but already used it elsewhere.
|
||||
* copy up to 4 instructions or else branch to other copy.
|
||||
*/
|
||||
i = 0
|
||||
q = p
|
||||
for ; i < 4; (func() { i++; q = q.Link })() {
|
||||
if q == nil {
|
||||
break
|
||||
}
|
||||
if q == *last {
|
||||
break
|
||||
}
|
||||
a = int(q.As)
|
||||
if a == obj.ANOP {
|
||||
i--
|
||||
continue
|
||||
}
|
||||
|
||||
if nofollow(a) || pushpop(a) {
|
||||
break // NOTE(rsc): arm does goto copy
|
||||
}
|
||||
if q.Pcond == nil || q.Pcond.Mark != 0 {
|
||||
continue
|
||||
}
|
||||
if a == obj.ACALL || a == ALOOP {
|
||||
continue
|
||||
}
|
||||
for {
|
||||
if p.As == obj.ANOP {
|
||||
p = p.Link
|
||||
continue
|
||||
}
|
||||
|
||||
q = obj.Copyp(ctxt, p)
|
||||
p = p.Link
|
||||
q.Mark = 1
|
||||
(*last).Link = q
|
||||
*last = q
|
||||
if int(q.As) != a || q.Pcond == nil || q.Pcond.Mark != 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
q.As = int16(relinv(int(q.As)))
|
||||
p = q.Pcond
|
||||
q.Pcond = q.Link
|
||||
q.Link = p
|
||||
xfol(ctxt, q.Link, last)
|
||||
p = q.Link
|
||||
if p.Mark != 0 {
|
||||
return
|
||||
}
|
||||
goto loop
|
||||
/* */
|
||||
}
|
||||
}
|
||||
q = ctxt.NewProg()
|
||||
q.As = obj.AJMP
|
||||
q.Lineno = p.Lineno
|
||||
q.To.Type = obj.TYPE_BRANCH
|
||||
q.To.Offset = p.Pc
|
||||
q.Pcond = p
|
||||
p = q
|
||||
}
|
||||
|
||||
/* emit p */
|
||||
p.Mark = 1
|
||||
|
||||
(*last).Link = p
|
||||
*last = p
|
||||
a = int(p.As)
|
||||
|
||||
/* continue loop with what comes after p */
|
||||
if nofollow(a) {
|
||||
return
|
||||
}
|
||||
if p.Pcond != nil && a != obj.ACALL {
|
||||
/*
|
||||
* some kind of conditional branch.
|
||||
* recurse to follow one path.
|
||||
* continue loop on the other.
|
||||
*/
|
||||
q = obj.Brchain(ctxt, p.Pcond)
|
||||
if q != nil {
|
||||
p.Pcond = q
|
||||
}
|
||||
q = obj.Brchain(ctxt, p.Link)
|
||||
if q != nil {
|
||||
p.Link = q
|
||||
}
|
||||
if p.From.Type == obj.TYPE_CONST {
|
||||
if p.From.Offset == 1 {
|
||||
/*
|
||||
* expect conditional jump to be taken.
|
||||
* rewrite so that's the fall-through case.
|
||||
*/
|
||||
p.As = int16(relinv(a))
|
||||
|
||||
q = p.Link
|
||||
p.Link = p.Pcond
|
||||
p.Pcond = q
|
||||
}
|
||||
} else {
|
||||
q = p.Link
|
||||
if q.Mark != 0 {
|
||||
if a != ALOOP {
|
||||
p.As = int16(relinv(a))
|
||||
p.Link = p.Pcond
|
||||
p.Pcond = q
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
xfol(ctxt, p.Link, last)
|
||||
if p.Pcond.Mark != 0 {
|
||||
return
|
||||
}
|
||||
p = p.Pcond
|
||||
goto loop
|
||||
}
|
||||
|
||||
p = p.Link
|
||||
goto loop
|
||||
}
|
||||
|
||||
var unaryDst = map[int]bool{
|
||||
ABSWAPL: true,
|
||||
ACMPXCHG8B: true,
|
||||
ADECB: true,
|
||||
ADECL: true,
|
||||
ADECW: true,
|
||||
AINCB: true,
|
||||
AINCL: true,
|
||||
AINCW: true,
|
||||
ANEGB: true,
|
||||
ANEGL: true,
|
||||
ANEGW: true,
|
||||
ANOTB: true,
|
||||
ANOTL: true,
|
||||
ANOTW: true,
|
||||
APOPL: true,
|
||||
APOPW: true,
|
||||
ASETCC: true,
|
||||
ASETCS: true,
|
||||
ASETEQ: true,
|
||||
ASETGE: true,
|
||||
ASETGT: true,
|
||||
ASETHI: true,
|
||||
ASETLE: true,
|
||||
ASETLS: true,
|
||||
ASETLT: true,
|
||||
ASETMI: true,
|
||||
ASETNE: true,
|
||||
ASETOC: true,
|
||||
ASETOS: true,
|
||||
ASETPC: true,
|
||||
ASETPL: true,
|
||||
ASETPS: true,
|
||||
AFFREE: true,
|
||||
AFLDENV: true,
|
||||
AFSAVE: true,
|
||||
AFSTCW: true,
|
||||
AFSTENV: true,
|
||||
AFSTSW: true,
|
||||
}
|
||||
|
||||
var Link386 = obj.LinkArch{
|
||||
ByteOrder: binary.LittleEndian,
|
||||
Pconv: Pconv,
|
||||
Name: "386",
|
||||
Thechar: '8',
|
||||
Preprocess: preprocess,
|
||||
Assemble: span8,
|
||||
Follow: follow,
|
||||
Progedit: progedit,
|
||||
UnaryDst: unaryDst,
|
||||
Minlc: 1,
|
||||
Ptrsize: 4,
|
||||
Regsize: 4,
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package i386
|
||||
|
||||
func bool2int(b bool) int {
|
||||
if b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user