| // Derived from Inferno utils/6l/l.h and related files. | |
| // http://code.google.com/p/inferno-os/source/browse/utils/6l/l.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 obj | |
| import "encoding/binary" | |
| // An Addr is an argument to an instruction. | |
| // The general forms and their encodings are: | |
| // | |
| // sym±offset(symkind)(reg)(index*scale) | |
| // Memory reference at address &sym(symkind) + offset + reg + index*scale. | |
| // Any of sym(symkind), ±offset, (reg), (index*scale), and *scale can be omitted. | |
| // If (reg) and *scale are both omitted, the resulting expression (index) is parsed as (reg). | |
| // To force a parsing as index*scale, write (index*1). | |
| // Encoding: | |
| // type = TYPE_MEM | |
| // name = symkind (NAME_AUTO, ...) or 0 (NAME_NONE) | |
| // sym = sym | |
| // offset = ±offset | |
| // reg = reg (REG_*) | |
| // index = index (REG_*) | |
| // scale = scale (1, 2, 4, 8) | |
| // | |
| // $<mem> | |
| // Effective address of memory reference <mem>, defined above. | |
| // Encoding: same as memory reference, but type = TYPE_ADDR. | |
| // | |
| // $<±integer value> | |
| // This is a special case of $<mem>, in which only ±offset is present. | |
| // It has a separate type for easy recognition. | |
| // Encoding: | |
| // type = TYPE_CONST | |
| // offset = ±integer value | |
| // | |
| // *<mem> | |
| // Indirect reference through memory reference <mem>, defined above. | |
| // Only used on x86 for CALL/JMP *sym(SB), which calls/jumps to a function | |
| // pointer stored in the data word sym(SB), not a function named sym(SB). | |
| // Encoding: same as above, but type = TYPE_INDIR. | |
| // | |
| // $*$<mem> | |
| // No longer used. | |
| // On machines with actual SB registers, $*$<mem> forced the | |
| // instruction encoding to use a full 32-bit constant, never a | |
| // reference relative to SB. | |
| // | |
| // $<floating point literal> | |
| // Floating point constant value. | |
| // Encoding: | |
| // type = TYPE_FCONST | |
| // val = floating point value | |
| // | |
| // $<string literal, up to 8 chars> | |
| // String literal value (raw bytes used for DATA instruction). | |
| // Encoding: | |
| // type = TYPE_SCONST | |
| // val = string | |
| // | |
| // <register name> | |
| // Any register: integer, floating point, control, segment, and so on. | |
| // If looking for specific register kind, must check type and reg value range. | |
| // Encoding: | |
| // type = TYPE_REG | |
| // reg = reg (REG_*) | |
| // | |
| // x(PC) | |
| // Encoding: | |
| // type = TYPE_BRANCH | |
| // val = Prog* reference OR ELSE offset = target pc (branch takes priority) | |
| // | |
| // $±x-±y | |
| // Final argument to TEXT, specifying local frame size x and argument size y. | |
| // In this form, x and y are integer literals only, not arbitrary expressions. | |
| // This avoids parsing ambiguities due to the use of - as a separator. | |
| // The ± are optional. | |
| // If the final argument to TEXT omits the -±y, the encoding should still | |
| // use TYPE_TEXTSIZE (not TYPE_CONST), with u.argsize = ArgsSizeUnknown. | |
| // Encoding: | |
| // type = TYPE_TEXTSIZE | |
| // offset = x | |
| // val = int32(y) | |
| // | |
| // reg<<shift, reg>>shift, reg->shift, reg@>shift | |
| // Shifted register value, for ARM. | |
| // In this form, reg must be a register and shift can be a register or an integer constant. | |
| // Encoding: | |
| // type = TYPE_SHIFT | |
| // offset = (reg&15) | shifttype<<5 | count | |
| // shifttype = 0, 1, 2, 3 for <<, >>, ->, @> | |
| // count = (reg&15)<<8 | 1<<4 for a register shift count, (n&31)<<7 for an integer constant. | |
| // | |
| // (reg, reg) | |
| // A destination register pair. When used as the last argument of an instruction, | |
| // this form makes clear that both registers are destinations. | |
| // Encoding: | |
| // type = TYPE_REGREG | |
| // reg = first register | |
| // offset = second register | |
| // | |
| // [reg, reg, reg-reg] | |
| // Register list for ARM. | |
| // Encoding: | |
| // type = TYPE_REGLIST | |
| // offset = bit mask of registers in list; R0 is low bit. | |
| // | |
| // reg, reg | |
| // Register pair for ARM. | |
| // TYPE_REGREG2 | |
| // | |
| // (reg+reg) | |
| // Register pair for PPC64. | |
| // Encoding: | |
| // type = TYPE_MEM | |
| // reg = first register | |
| // index = second register | |
| // scale = 1 | |
| // | |
| type Addr struct { | |
| Type int16 | |
| Reg int16 | |
| Reg2 int16 // RHS of register pair. AX:DX (386) | |
| Index int16 | |
| Scale int16 // Sometimes holds a register. | |
| Name int8 | |
| Class int8 | |
| Etype uint8 | |
| Offset int64 | |
| Width int64 | |
| Sym *LSym | |
| Gotype *LSym | |
| // argument value: | |
| // for TYPE_SCONST, a string | |
| // for TYPE_FCONST, a float64 | |
| // for TYPE_BRANCH, a *Prog (optional) | |
| // for TYPE_TEXTSIZE, an int32 (optional) | |
| Val interface{} | |
| Node interface{} // for use by compiler | |
| } | |
| const ( | |
| NAME_NONE = 0 + iota | |
| NAME_EXTERN | |
| NAME_STATIC | |
| NAME_AUTO | |
| NAME_PARAM | |
| ) | |
| const ( | |
| TYPE_NONE = 0 | |
| ) | |
| const ( | |
| TYPE_BRANCH = 5 + iota | |
| TYPE_TEXTSIZE | |
| TYPE_MEM | |
| TYPE_CONST | |
| TYPE_FCONST | |
| TYPE_SCONST | |
| TYPE_REG | |
| TYPE_ADDR | |
| TYPE_SHIFT | |
| TYPE_REGREG | |
| TYPE_REGREG2 | |
| TYPE_INDIR | |
| TYPE_REGLIST | |
| ) | |
| // TODO(rsc): Describe prog. | |
| // TODO(rsc): Describe TEXT/GLOBL flag in from3, DATA width in from3. | |
| type Prog struct { | |
| Ctxt *Link | |
| Link *Prog | |
| From Addr | |
| From3 Addr | |
| To Addr | |
| To2 Addr | |
| Opt interface{} | |
| Forwd *Prog | |
| Pcond *Prog | |
| Comefrom *Prog | |
| Pcrel *Prog | |
| Pc int64 | |
| Lineno int32 | |
| Spadj int32 | |
| As int16 | |
| Reg int16 | |
| Mark uint16 | |
| Optab uint16 | |
| Scond uint8 | |
| Back uint8 | |
| Ft uint8 | |
| F3t uint8 | |
| Tt uint8 | |
| Isize uint8 | |
| Printed uint8 | |
| Width int8 | |
| Mode int8 | |
| Info ProgInfo | |
| } | |
| // ProgInfo holds information about the instruction for use | |
| // by clients such as the compiler. The exact meaning of this | |
| // data is up to the client and is not interpreted by the cmd/internal/obj/... packages. | |
| type ProgInfo struct { | |
| Flags uint32 // flag bits | |
| Reguse uint64 // registers implicitly used by this instruction | |
| Regset uint64 // registers implicitly set by this instruction | |
| Regindex uint64 // registers used by addressing mode | |
| } | |
| // Prog.as opcodes. | |
| // These are the portable opcodes, common to all architectures. | |
| // Each architecture defines many more arch-specific opcodes, | |
| // with values starting at A_ARCHSPECIFIC. | |
| // Each architecture adds an offset to this so each machine has | |
| // distinct space for its instructions. The offset is a power of | |
| // two so it can be masked to return to origin zero. | |
| // See the definitions of ABase386 etc. | |
| const ( | |
| AXXX = 0 + iota | |
| ACALL | |
| ACHECKNIL | |
| ADATA | |
| ADUFFCOPY | |
| ADUFFZERO | |
| AEND | |
| AFUNCDATA | |
| AGLOBL | |
| AJMP | |
| ANOP | |
| APCDATA | |
| ARET | |
| ATEXT | |
| ATYPE | |
| AUNDEF | |
| AUSEFIELD | |
| AVARDEF | |
| AVARKILL | |
| A_ARCHSPECIFIC | |
| ) | |
| type LSym struct { | |
| Name string | |
| Type int16 | |
| Version int16 | |
| Dupok uint8 | |
| Cfunc uint8 | |
| Nosplit uint8 | |
| Leaf uint8 | |
| Seenglobl uint8 | |
| Onlist uint8 | |
| Args int32 | |
| Locals int32 | |
| Value int64 | |
| Size int64 | |
| Next *LSym | |
| Gotype *LSym | |
| Autom *Auto | |
| Text *Prog | |
| Etext *Prog | |
| Pcln *Pcln | |
| P []byte | |
| R []Reloc | |
| } | |
| type Pcln struct { | |
| Pcsp Pcdata | |
| Pcfile Pcdata | |
| Pcline Pcdata | |
| Pcdata []Pcdata | |
| Funcdata []*LSym | |
| Funcdataoff []int64 | |
| File []*LSym | |
| Lastfile *LSym | |
| Lastindex int | |
| } | |
| // LSym.type | |
| const ( | |
| Sxxx = iota | |
| STEXT | |
| SELFRXSECT | |
| STYPE | |
| SSTRING | |
| SGOSTRING | |
| SGOFUNC | |
| SRODATA | |
| SFUNCTAB | |
| STYPELINK | |
| SSYMTAB | |
| SPCLNTAB | |
| SELFROSECT | |
| SMACHOPLT | |
| SELFSECT | |
| SMACHO | |
| SMACHOGOT | |
| SWINDOWS | |
| SELFGOT | |
| SNOPTRDATA | |
| SINITARR | |
| SDATA | |
| SBSS | |
| SNOPTRBSS | |
| STLSBSS | |
| SXREF | |
| SMACHOSYMSTR | |
| SMACHOSYMTAB | |
| SMACHOINDIRECTPLT | |
| SMACHOINDIRECTGOT | |
| SFILE | |
| SFILEPATH | |
| SCONST | |
| SDYNIMPORT | |
| SHOSTOBJ | |
| SSUB = 1 << 8 | |
| SMASK = SSUB - 1 | |
| SHIDDEN = 1 << 9 | |
| ) | |
| type Reloc struct { | |
| Off int32 | |
| Siz uint8 | |
| Type int32 | |
| Add int64 | |
| Xadd int64 | |
| Sym *LSym | |
| Xsym *LSym | |
| } | |
| // Reloc.type | |
| const ( | |
| R_ADDR = 1 + iota | |
| R_ADDRPOWER | |
| R_SIZE | |
| R_CALL | |
| R_CALLARM | |
| R_CALLARM64 | |
| R_CALLIND | |
| R_CALLPOWER | |
| R_CONST | |
| R_PCREL | |
| R_TLS | |
| R_TLS_LE | |
| R_TLS_IE | |
| R_GOTOFF | |
| R_PLT0 | |
| R_PLT1 | |
| R_PLT2 | |
| R_USEFIELD | |
| R_POWER_TOC | |
| ) | |
| type Auto struct { | |
| Asym *LSym | |
| Link *Auto | |
| Aoffset int32 | |
| Name int16 | |
| Gotype *LSym | |
| } | |
| // Auto.name | |
| const ( | |
| A_AUTO = 1 + iota | |
| A_PARAM | |
| ) | |
| type Pcdata struct { | |
| P []byte | |
| } | |
| // Pcdata iterator. | |
| // for(pciterinit(ctxt, &it, &pcd); !it.done; pciternext(&it)) { it.value holds in [it.pc, it.nextpc) } | |
| type Pciter struct { | |
| d Pcdata | |
| p []byte | |
| pc uint32 | |
| nextpc uint32 | |
| pcscale uint32 | |
| value int32 | |
| start int | |
| done int | |
| } | |
| // symbol version, incremented each time a file is loaded. | |
| // version==1 is reserved for savehist. | |
| const ( | |
| HistVersion = 1 | |
| ) | |
| // Link holds the context for writing object code from a compiler | |
| // to be linker input or for reading that input into the linker. | |
| type Link struct { | |
| Goarm int32 | |
| Headtype int | |
| Arch *LinkArch | |
| Debugasm int32 | |
| Debugvlog int32 | |
| Debugzerostack int32 | |
| Debugdivmod int32 | |
| Debugpcln int32 | |
| Flag_shared int32 | |
| Bso *Biobuf | |
| Pathname string | |
| Windows int32 | |
| Trimpath string | |
| Goroot string | |
| Goroot_final string | |
| Enforce_data_order int32 | |
| Hash map[SymVer]*LSym | |
| LineHist LineHist | |
| Imports []string | |
| Plist *Plist | |
| Plast *Plist | |
| Sym_div *LSym | |
| Sym_divu *LSym | |
| Sym_mod *LSym | |
| Sym_modu *LSym | |
| Symmorestack [2]*LSym | |
| Tlsg *LSym | |
| Plan9privates *LSym | |
| Curp *Prog | |
| Printp *Prog | |
| Blitrl *Prog | |
| Elitrl *Prog | |
| Rexflag int | |
| Rep int | |
| Repn int | |
| Lock int | |
| Asmode int | |
| Andptr []byte | |
| And [100]uint8 | |
| Instoffset int64 | |
| Autosize int32 | |
| Armsize int32 | |
| Pc int64 | |
| Tlsoffset int | |
| Diag func(string, ...interface{}) | |
| Mode int | |
| Cursym *LSym | |
| Version int | |
| Textp *LSym | |
| Etextp *LSym | |
| } | |
| type SymVer struct { | |
| Name string | |
| Version int | |
| } | |
| // LinkArch is the definition of a single architecture. | |
| type LinkArch struct { | |
| ByteOrder binary.ByteOrder | |
| Name string | |
| Thechar int | |
| Preprocess func(*Link, *LSym) | |
| Assemble func(*Link, *LSym) | |
| Follow func(*Link, *LSym) | |
| Progedit func(*Link, *Prog) | |
| UnaryDst map[int]bool // Instruction takes one operand, a destination. | |
| Minlc int | |
| Ptrsize int | |
| Regsize int | |
| } | |
| /* executable header types */ | |
| const ( | |
| Hunknown = 0 + iota | |
| Hdarwin | |
| Hdragonfly | |
| Helf | |
| Hfreebsd | |
| Hlinux | |
| Hnacl | |
| Hnetbsd | |
| Hopenbsd | |
| Hplan9 | |
| Hsolaris | |
| Hwindows | |
| ) | |
| type Plist struct { | |
| Name *LSym | |
| Firstpc *Prog | |
| Recur int | |
| Link *Plist | |
| } | |
| /* | |
| * start a new Prog list. | |
| */ | |
| func Linknewplist(ctxt *Link) *Plist { | |
| pl := new(Plist) | |
| *pl = Plist{} | |
| if ctxt.Plist == nil { | |
| ctxt.Plist = pl | |
| } else { | |
| ctxt.Plast.Link = pl | |
| } | |
| ctxt.Plast = pl | |
| return pl | |
| } |