objfile.go

     1  // Copyright 2019 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // This package defines the Go object file format, and provide "low-level" functions
     6  // for reading and writing object files.
     7  
     8  // The object file is understood by the compiler, assembler, linker, and tools. They
     9  // have "high level" code that operates on object files, handling application-specific
    10  // logics, and use this package for the actual reading and writing. Specifically, the
    11  // code below:
    12  //
    13  // - cmd/internal/obj/objfile.go (used by cmd/asm and cmd/compile)
    14  // - cmd/internal/objfile/goobj.go (used cmd/nm, cmd/objdump)
    15  // - cmd/link/internal/loader package (used by cmd/link)
    16  //
    17  // If the object file format changes, they may (or may not) need to change.
    18  
    19  package goobj
    20  
    21  import (
    22  	"cmd/internal/bio"
    23  	"encoding/binary"
    24  	"errors"
    25  	"fmt"
    26  	"unsafe"
    27  )
    28  
    29  // New object file format.
    30  //
    31  //    Header struct {
    32  //       Magic       [...]byte   // "\x00go120ld"
    33  //       Fingerprint [8]byte
    34  //       Flags       uint32
    35  //       Offsets     [...]uint32 // byte offset of each block below
    36  //    }
    37  //
    38  //    Strings [...]struct {
    39  //       Data [...]byte
    40  //    }
    41  //
    42  //    Autolib  [...]struct { // imported packages (for file loading)
    43  //       Pkg         string
    44  //       Fingerprint [8]byte
    45  //    }
    46  //
    47  //    PkgIndex [...]string // referenced packages by index
    48  //
    49  //    Files [...]string
    50  //
    51  //    SymbolDefs [...]struct {
    52  //       Name  string
    53  //       ABI   uint16
    54  //       Type  uint8
    55  //       Flag  uint8
    56  //       Flag2 uint8
    57  //       Size  uint32
    58  //       Align uint32
    59  //    }
    60  //    Hashed64Defs [...]struct { // short hashed (content-addressable) symbol definitions
    61  //       ... // same as SymbolDefs
    62  //    }
    63  //    HashedDefs [...]struct { // hashed (content-addressable) symbol definitions
    64  //       ... // same as SymbolDefs
    65  //    }
    66  //    NonPkgDefs [...]struct { // non-pkg symbol definitions
    67  //       ... // same as SymbolDefs
    68  //    }
    69  //    NonPkgRefs [...]struct { // non-pkg symbol references
    70  //       ... // same as SymbolDefs
    71  //    }
    72  //
    73  //    RefFlags [...]struct { // referenced symbol flags
    74  //       Sym   symRef
    75  //       Flag  uint8
    76  //       Flag2 uint8
    77  //    }
    78  //
    79  //    Hash64 [...][8]byte
    80  //    Hash   [...][N]byte
    81  //
    82  //    RelocIndex [...]uint32 // index to Relocs
    83  //    AuxIndex   [...]uint32 // index to Aux
    84  //    DataIndex  [...]uint32 // offset to Data
    85  //
    86  //    Relocs [...]struct {
    87  //       Off  int32
    88  //       Size uint8
    89  //       Type uint16
    90  //       Add  int64
    91  //       Sym  symRef
    92  //    }
    93  //
    94  //    Aux [...]struct {
    95  //       Type uint8
    96  //       Sym  symRef
    97  //    }
    98  //
    99  //    Data   [...]byte
   100  //
   101  //    // blocks only used by tools (objdump, nm)
   102  //
   103  //    RefNames [...]struct { // referenced symbol names
   104  //       Sym  symRef
   105  //       Name string
   106  //       // TODO: include ABI version as well?
   107  //    }
   108  //
   109  // string is encoded as is a uint32 length followed by a uint32 offset
   110  // that points to the corresponding string bytes.
   111  //
   112  // symRef is struct { PkgIdx, SymIdx uint32 }.
   113  //
   114  // Slice type (e.g. []symRef) is encoded as a length prefix (uint32)
   115  // followed by that number of elements.
   116  //
   117  // The types below correspond to the encoded data structure in the
   118  // object file.
   119  
   120  // Symbol indexing.
   121  //
   122  // Each symbol is referenced with a pair of indices, { PkgIdx, SymIdx },
   123  // as the symRef struct above.
   124  //
   125  // PkgIdx is either a predeclared index (see PkgIdxNone below) or
   126  // an index of an imported package. For the latter case, PkgIdx is the
   127  // index of the package in the PkgIndex array. 0 is an invalid index.
   128  //
   129  // SymIdx is the index of the symbol in the given package.
   130  // - If PkgIdx is PkgIdxSelf, SymIdx is the index of the symbol in the
   131  //   SymbolDefs array.
   132  // - If PkgIdx is PkgIdxHashed64, SymIdx is the index of the symbol in the
   133  //   Hashed64Defs array.
   134  // - If PkgIdx is PkgIdxHashed, SymIdx is the index of the symbol in the
   135  //   HashedDefs array.
   136  // - If PkgIdx is PkgIdxNone, SymIdx is the index of the symbol in the
   137  //   NonPkgDefs array (could naturally overflow to NonPkgRefs array).
   138  // - Otherwise, SymIdx is the index of the symbol in some other package's
   139  //   SymbolDefs array.
   140  //
   141  // {0, 0} represents a nil symbol. Otherwise PkgIdx should not be 0.
   142  //
   143  // Hash contains the content hashes of content-addressable symbols, of
   144  // which PkgIdx is PkgIdxHashed, in the same order of HashedDefs array.
   145  // Hash64 is similar, for PkgIdxHashed64 symbols.
   146  //
   147  // RelocIndex, AuxIndex, and DataIndex contains indices/offsets to
   148  // Relocs/Aux/Data blocks, one element per symbol, first for all the
   149  // defined symbols, then all the defined hashed and non-package symbols,
   150  // in the same order of SymbolDefs/Hashed64Defs/HashedDefs/NonPkgDefs
   151  // arrays. For N total defined symbols, the array is of length N+1. The
   152  // last element is the total number of relocations (aux symbols, data
   153  // blocks, etc.).
   154  //
   155  // They can be accessed by index. For the i-th symbol, its relocations
   156  // are the RelocIndex[i]-th (inclusive) to RelocIndex[i+1]-th (exclusive)
   157  // elements in the Relocs array. Aux/Data are likewise. (The index is
   158  // 0-based.)
   159  
   160  // Auxiliary symbols.
   161  //
   162  // Each symbol may (or may not) be associated with a number of auxiliary
   163  // symbols. They are described in the Aux block. See Aux struct below.
   164  // Currently a symbol's Gotype, FuncInfo, and associated DWARF symbols
   165  // are auxiliary symbols.
   166  
   167  const stringRefSize = 8 // two uint32s
   168  
   169  type FingerprintType [8]byte
   170  
   171  func (fp FingerprintType) IsZero() bool { return fp == FingerprintType{} }
   172  
   173  // Package Index.
   174  const (
   175  	PkgIdxNone     = (1<<31 - 1) - iota // Non-package symbols
   176  	PkgIdxHashed64                      // Short hashed (content-addressable) symbols
   177  	PkgIdxHashed                        // Hashed (content-addressable) symbols
   178  	PkgIdxBuiltin                       // Predefined runtime symbols (ex: runtime.newobject)
   179  	PkgIdxSelf                          // Symbols defined in the current package
   180  	PkgIdxSpecial  = PkgIdxSelf         // Indices above it has special meanings
   181  	PkgIdxInvalid  = 0
   182  	// The index of other referenced packages starts from 1.
   183  )
   184  
   185  // Blocks
   186  const (
   187  	BlkAutolib = iota
   188  	BlkPkgIdx
   189  	BlkFile
   190  	BlkSymdef
   191  	BlkHashed64def
   192  	BlkHasheddef
   193  	BlkNonpkgdef
   194  	BlkNonpkgref
   195  	BlkRefFlags
   196  	BlkHash64
   197  	BlkHash
   198  	BlkRelocIdx
   199  	BlkAuxIdx
   200  	BlkDataIdx
   201  	BlkReloc
   202  	BlkAux
   203  	BlkData
   204  	BlkRefName
   205  	BlkEnd
   206  	NBlk
   207  )
   208  
   209  // File header.
   210  // TODO: probably no need to export this.
   211  type Header struct {
   212  	Magic       string
   213  	Fingerprint FingerprintType
   214  	Flags       uint32
   215  	Offsets     [NBlk]uint32
   216  }
   217  
   218  const Magic = "\x00go120ld"
   219  
   220  func (h *Header) Write(w *Writer) {
   221  	w.RawString(h.Magic)
   222  	w.Bytes(h.Fingerprint[:])
   223  	w.Uint32(h.Flags)
   224  	for _, x := range h.Offsets {
   225  		w.Uint32(x)
   226  	}
   227  }
   228  
   229  func (h *Header) Read(r *Reader) error {
   230  	b := r.BytesAt(0, len(Magic))
   231  	h.Magic = string(b)
   232  	if h.Magic != Magic {
   233  		return errors.New("wrong magic, not a Go object file")
   234  	}
   235  	off := uint32(len(h.Magic))
   236  	copy(h.Fingerprint[:], r.BytesAt(off, len(h.Fingerprint)))
   237  	off += 8
   238  	h.Flags = r.uint32At(off)
   239  	off += 4
   240  	for i := range h.Offsets {
   241  		h.Offsets[i] = r.uint32At(off)
   242  		off += 4
   243  	}
   244  	return nil
   245  }
   246  
   247  func (h *Header) Size() int {
   248  	return len(h.Magic) + len(h.Fingerprint) + 4 + 4*len(h.Offsets)
   249  }
   250  
   251  // Autolib
   252  type ImportedPkg struct {
   253  	Pkg         string
   254  	Fingerprint FingerprintType
   255  }
   256  
   257  const importedPkgSize = stringRefSize + 8
   258  
   259  func (p *ImportedPkg) Write(w *Writer) {
   260  	w.StringRef(p.Pkg)
   261  	w.Bytes(p.Fingerprint[:])
   262  }
   263  
   264  // Symbol definition.
   265  //
   266  // Serialized format:
   267  //
   268  //	Sym struct {
   269  //	   Name  string
   270  //	   ABI   uint16
   271  //	   Type  uint8
   272  //	   Flag  uint8
   273  //	   Flag2 uint8
   274  //	   Siz   uint32
   275  //	   Align uint32
   276  //	}
   277  type Sym [SymSize]byte
   278  
   279  const SymSize = stringRefSize + 2 + 1 + 1 + 1 + 4 + 4
   280  
   281  const SymABIstatic = ^uint16(0)
   282  
   283  const (
   284  	ObjFlagShared       = 1 << iota // this object is built with -shared
   285  	_                               // was ObjFlagNeedNameExpansion
   286  	ObjFlagFromAssembly             // object is from asm src, not go
   287  	ObjFlagUnlinkable               // unlinkable package (linker will emit an error)
   288  	ObjFlagStd                      // standard library package
   289  )
   290  
   291  // Sym.Flag
   292  const (
   293  	SymFlagDupok = 1 << iota
   294  	SymFlagLocal
   295  	SymFlagTypelink
   296  	SymFlagLeaf
   297  	SymFlagNoSplit
   298  	SymFlagReflectMethod
   299  	SymFlagGoType
   300  )
   301  
   302  // Sym.Flag2
   303  const (
   304  	SymFlagUsedInIface = 1 << iota
   305  	SymFlagItab
   306  	SymFlagDict
   307  	SymFlagPkgInit
   308  	SymFlagLinkname
   309  	SymFlagABIWrapper
   310  	SymFlagWasmExport
   311  )
   312  
   313  // Returns the length of the name of the symbol.
   314  func (s *Sym) NameLen(r *Reader) int {
   315  	return int(binary.LittleEndian.Uint32(s[:]))
   316  }
   317  
   318  func (s *Sym) Name(r *Reader) string {
   319  	len := binary.LittleEndian.Uint32(s[:])
   320  	off := binary.LittleEndian.Uint32(s[4:])
   321  	return r.StringAt(off, len)
   322  }
   323  
   324  func (s *Sym) ABI() uint16   { return binary.LittleEndian.Uint16(s[8:]) }
   325  func (s *Sym) Type() uint8   { return s[10] }
   326  func (s *Sym) Flag() uint8   { return s[11] }
   327  func (s *Sym) Flag2() uint8  { return s[12] }
   328  func (s *Sym) Siz() uint32   { return binary.LittleEndian.Uint32(s[13:]) }
   329  func (s *Sym) Align() uint32 { return binary.LittleEndian.Uint32(s[17:]) }
   330  
   331  func (s *Sym) Dupok() bool         { return s.Flag()&SymFlagDupok != 0 }
   332  func (s *Sym) Local() bool         { return s.Flag()&SymFlagLocal != 0 }
   333  func (s *Sym) Typelink() bool      { return s.Flag()&SymFlagTypelink != 0 }
   334  func (s *Sym) Leaf() bool          { return s.Flag()&SymFlagLeaf != 0 }
   335  func (s *Sym) NoSplit() bool       { return s.Flag()&SymFlagNoSplit != 0 }
   336  func (s *Sym) ReflectMethod() bool { return s.Flag()&SymFlagReflectMethod != 0 }
   337  func (s *Sym) IsGoType() bool      { return s.Flag()&SymFlagGoType != 0 }
   338  func (s *Sym) UsedInIface() bool   { return s.Flag2()&SymFlagUsedInIface != 0 }
   339  func (s *Sym) IsItab() bool        { return s.Flag2()&SymFlagItab != 0 }
   340  func (s *Sym) IsDict() bool        { return s.Flag2()&SymFlagDict != 0 }
   341  func (s *Sym) IsPkgInit() bool     { return s.Flag2()&SymFlagPkgInit != 0 }
   342  func (s *Sym) IsLinkname() bool    { return s.Flag2()&SymFlagLinkname != 0 }
   343  func (s *Sym) ABIWrapper() bool    { return s.Flag2()&SymFlagABIWrapper != 0 }
   344  func (s *Sym) WasmExport() bool    { return s.Flag2()&SymFlagWasmExport != 0 }
   345  
   346  func (s *Sym) SetName(x string, w *Writer) {
   347  	binary.LittleEndian.PutUint32(s[:], uint32(len(x)))
   348  	binary.LittleEndian.PutUint32(s[4:], w.stringOff(x))
   349  }
   350  
   351  func (s *Sym) SetABI(x uint16)   { binary.LittleEndian.PutUint16(s[8:], x) }
   352  func (s *Sym) SetType(x uint8)   { s[10] = x }
   353  func (s *Sym) SetFlag(x uint8)   { s[11] = x }
   354  func (s *Sym) SetFlag2(x uint8)  { s[12] = x }
   355  func (s *Sym) SetSiz(x uint32)   { binary.LittleEndian.PutUint32(s[13:], x) }
   356  func (s *Sym) SetAlign(x uint32) { binary.LittleEndian.PutUint32(s[17:], x) }
   357  
   358  func (s *Sym) Write(w *Writer) { w.Bytes(s[:]) }
   359  
   360  // for testing
   361  func (s *Sym) fromBytes(b []byte) { copy(s[:], b) }
   362  
   363  // Symbol reference.
   364  type SymRef struct {
   365  	PkgIdx uint32
   366  	SymIdx uint32
   367  }
   368  
   369  func (s SymRef) IsZero() bool { return s == SymRef{} }
   370  
   371  // Hash64
   372  type Hash64Type [Hash64Size]byte
   373  
   374  const Hash64Size = 8
   375  
   376  // Hash
   377  type HashType [HashSize]byte
   378  
   379  const HashSize = 16 // truncated SHA256
   380  
   381  // Relocation.
   382  //
   383  // Serialized format:
   384  //
   385  //	Reloc struct {
   386  //	   Off  int32
   387  //	   Siz  uint8
   388  //	   Type uint16
   389  //	   Add  int64
   390  //	   Sym  SymRef
   391  //	}
   392  type Reloc [RelocSize]byte
   393  
   394  const RelocSize = 4 + 1 + 2 + 8 + 8
   395  
   396  func (r *Reloc) Off() int32   { return int32(binary.LittleEndian.Uint32(r[:])) }
   397  func (r *Reloc) Siz() uint8   { return r[4] }
   398  func (r *Reloc) Type() uint16 { return binary.LittleEndian.Uint16(r[5:]) }
   399  func (r *Reloc) Add() int64   { return int64(binary.LittleEndian.Uint64(r[7:])) }
   400  func (r *Reloc) Sym() SymRef {
   401  	return SymRef{binary.LittleEndian.Uint32(r[15:]), binary.LittleEndian.Uint32(r[19:])}
   402  }
   403  
   404  func (r *Reloc) SetOff(x int32)   { binary.LittleEndian.PutUint32(r[:], uint32(x)) }
   405  func (r *Reloc) SetSiz(x uint8)   { r[4] = x }
   406  func (r *Reloc) SetType(x uint16) { binary.LittleEndian.PutUint16(r[5:], x) }
   407  func (r *Reloc) SetAdd(x int64)   { binary.LittleEndian.PutUint64(r[7:], uint64(x)) }
   408  func (r *Reloc) SetSym(x SymRef) {
   409  	binary.LittleEndian.PutUint32(r[15:], x.PkgIdx)
   410  	binary.LittleEndian.PutUint32(r[19:], x.SymIdx)
   411  }
   412  
   413  func (r *Reloc) Set(off int32, size uint8, typ uint16, add int64, sym SymRef) {
   414  	r.SetOff(off)
   415  	r.SetSiz(size)
   416  	r.SetType(typ)
   417  	r.SetAdd(add)
   418  	r.SetSym(sym)
   419  }
   420  
   421  func (r *Reloc) Write(w *Writer) { w.Bytes(r[:]) }
   422  
   423  // for testing
   424  func (r *Reloc) fromBytes(b []byte) { copy(r[:], b) }
   425  
   426  // Aux symbol info.
   427  //
   428  // Serialized format:
   429  //
   430  //	Aux struct {
   431  //	   Type uint8
   432  //	   Sym  SymRef
   433  //	}
   434  type Aux [AuxSize]byte
   435  
   436  const AuxSize = 1 + 8
   437  
   438  // Aux Type
   439  const (
   440  	AuxGotype = iota
   441  	AuxFuncInfo
   442  	AuxFuncdata
   443  	AuxDwarfInfo
   444  	AuxDwarfLoc
   445  	AuxDwarfRanges
   446  	AuxDwarfLines
   447  	AuxPcsp
   448  	AuxPcfile
   449  	AuxPcline
   450  	AuxPcinline
   451  	AuxPcdata
   452  	AuxWasmImport
   453  	AuxWasmType
   454  	AuxSehUnwindInfo
   455  )
   456  
   457  func (a *Aux) Type() uint8 { return a[0] }
   458  func (a *Aux) Sym() SymRef {
   459  	return SymRef{binary.LittleEndian.Uint32(a[1:]), binary.LittleEndian.Uint32(a[5:])}
   460  }
   461  
   462  func (a *Aux) SetType(x uint8) { a[0] = x }
   463  func (a *Aux) SetSym(x SymRef) {
   464  	binary.LittleEndian.PutUint32(a[1:], x.PkgIdx)
   465  	binary.LittleEndian.PutUint32(a[5:], x.SymIdx)
   466  }
   467  
   468  func (a *Aux) Write(w *Writer) { w.Bytes(a[:]) }
   469  
   470  // for testing
   471  func (a *Aux) fromBytes(b []byte) { copy(a[:], b) }
   472  
   473  // Referenced symbol flags.
   474  //
   475  // Serialized format:
   476  //
   477  //	RefFlags struct {
   478  //	   Sym   symRef
   479  //	   Flag  uint8
   480  //	   Flag2 uint8
   481  //	}
   482  type RefFlags [RefFlagsSize]byte
   483  
   484  const RefFlagsSize = 8 + 1 + 1
   485  
   486  func (r *RefFlags) Sym() SymRef {
   487  	return SymRef{binary.LittleEndian.Uint32(r[:]), binary.LittleEndian.Uint32(r[4:])}
   488  }
   489  func (r *RefFlags) Flag() uint8  { return r[8] }
   490  func (r *RefFlags) Flag2() uint8 { return r[9] }
   491  
   492  func (r *RefFlags) SetSym(x SymRef) {
   493  	binary.LittleEndian.PutUint32(r[:], x.PkgIdx)
   494  	binary.LittleEndian.PutUint32(r[4:], x.SymIdx)
   495  }
   496  func (r *RefFlags) SetFlag(x uint8)  { r[8] = x }
   497  func (r *RefFlags) SetFlag2(x uint8) { r[9] = x }
   498  
   499  func (r *RefFlags) Write(w *Writer) { w.Bytes(r[:]) }
   500  
   501  // Used to construct an artificially large array type when reading an
   502  // item from the object file relocs section or aux sym section (needs
   503  // to work on 32-bit as well as 64-bit). See issue 41621.
   504  const huge = (1<<31 - 1) / RelocSize
   505  
   506  // Referenced symbol name.
   507  //
   508  // Serialized format:
   509  //
   510  //	RefName struct {
   511  //	   Sym  symRef
   512  //	   Name string
   513  //	}
   514  type RefName [RefNameSize]byte
   515  
   516  const RefNameSize = 8 + stringRefSize
   517  
   518  func (n *RefName) Sym() SymRef {
   519  	return SymRef{binary.LittleEndian.Uint32(n[:]), binary.LittleEndian.Uint32(n[4:])}
   520  }
   521  func (n *RefName) Name(r *Reader) string {
   522  	len := binary.LittleEndian.Uint32(n[8:])
   523  	off := binary.LittleEndian.Uint32(n[12:])
   524  	return r.StringAt(off, len)
   525  }
   526  
   527  func (n *RefName) SetSym(x SymRef) {
   528  	binary.LittleEndian.PutUint32(n[:], x.PkgIdx)
   529  	binary.LittleEndian.PutUint32(n[4:], x.SymIdx)
   530  }
   531  func (n *RefName) SetName(x string, w *Writer) {
   532  	binary.LittleEndian.PutUint32(n[8:], uint32(len(x)))
   533  	binary.LittleEndian.PutUint32(n[12:], w.stringOff(x))
   534  }
   535  
   536  func (n *RefName) Write(w *Writer) { w.Bytes(n[:]) }
   537  
   538  type Writer struct {
   539  	wr        *bio.Writer
   540  	stringMap map[string]uint32
   541  	off       uint32 // running offset
   542  
   543  	b [8]byte // scratch space for writing bytes
   544  }
   545  
   546  func NewWriter(wr *bio.Writer) *Writer {
   547  	return &Writer{wr: wr, stringMap: make(map[string]uint32)}
   548  }
   549  
   550  func (w *Writer) AddString(s string) {
   551  	if _, ok := w.stringMap[s]; ok {
   552  		return
   553  	}
   554  	w.stringMap[s] = w.off
   555  	w.RawString(s)
   556  }
   557  
   558  func (w *Writer) stringOff(s string) uint32 {
   559  	off, ok := w.stringMap[s]
   560  	if !ok {
   561  		panic(fmt.Sprintf("writeStringRef: string not added: %q", s))
   562  	}
   563  	return off
   564  }
   565  
   566  func (w *Writer) StringRef(s string) {
   567  	w.Uint32(uint32(len(s)))
   568  	w.Uint32(w.stringOff(s))
   569  }
   570  
   571  func (w *Writer) RawString(s string) {
   572  	w.wr.WriteString(s)
   573  	w.off += uint32(len(s))
   574  }
   575  
   576  func (w *Writer) Bytes(s []byte) {
   577  	w.wr.Write(s)
   578  	w.off += uint32(len(s))
   579  }
   580  
   581  func (w *Writer) Uint64(x uint64) {
   582  	binary.LittleEndian.PutUint64(w.b[:], x)
   583  	w.wr.Write(w.b[:])
   584  	w.off += 8
   585  }
   586  
   587  func (w *Writer) Uint32(x uint32) {
   588  	binary.LittleEndian.PutUint32(w.b[:4], x)
   589  	w.wr.Write(w.b[:4])
   590  	w.off += 4
   591  }
   592  
   593  func (w *Writer) Uint16(x uint16) {
   594  	binary.LittleEndian.PutUint16(w.b[:2], x)
   595  	w.wr.Write(w.b[:2])
   596  	w.off += 2
   597  }
   598  
   599  func (w *Writer) Uint8(x uint8) {
   600  	w.wr.WriteByte(x)
   601  	w.off++
   602  }
   603  
   604  func (w *Writer) Offset() uint32 {
   605  	return w.off
   606  }
   607  
   608  type Reader struct {
   609  	b        []byte // mmapped bytes, if not nil
   610  	readonly bool   // whether b is backed with read-only memory
   611  
   612  	start uint32
   613  	h     Header // keep block offsets
   614  }
   615  
   616  func NewReaderFromBytes(b []byte, readonly bool) *Reader {
   617  	r := &Reader{b: b, readonly: readonly, start: 0}
   618  	err := r.h.Read(r)
   619  	if err != nil {
   620  		return nil
   621  	}
   622  	return r
   623  }
   624  
   625  func (r *Reader) BytesAt(off uint32, len int) []byte {
   626  	if len == 0 {
   627  		return nil
   628  	}
   629  	end := int(off) + len
   630  	return r.b[int(off):end:end]
   631  }
   632  
   633  func (r *Reader) uint64At(off uint32) uint64 {
   634  	b := r.BytesAt(off, 8)
   635  	return binary.LittleEndian.Uint64(b)
   636  }
   637  
   638  func (r *Reader) int64At(off uint32) int64 {
   639  	return int64(r.uint64At(off))
   640  }
   641  
   642  func (r *Reader) uint32At(off uint32) uint32 {
   643  	b := r.BytesAt(off, 4)
   644  	return binary.LittleEndian.Uint32(b)
   645  }
   646  
   647  func (r *Reader) int32At(off uint32) int32 {
   648  	return int32(r.uint32At(off))
   649  }
   650  
   651  func (r *Reader) uint16At(off uint32) uint16 {
   652  	b := r.BytesAt(off, 2)
   653  	return binary.LittleEndian.Uint16(b)
   654  }
   655  
   656  func (r *Reader) uint8At(off uint32) uint8 {
   657  	b := r.BytesAt(off, 1)
   658  	return b[0]
   659  }
   660  
   661  func (r *Reader) StringAt(off uint32, len uint32) string {
   662  	b := r.b[off : off+len]
   663  	if r.readonly {
   664  		return toString(b) // backed by RO memory, ok to make unsafe string
   665  	}
   666  	return string(b)
   667  }
   668  
   669  func toString(b []byte) string {
   670  	if len(b) == 0 {
   671  		return ""
   672  	}
   673  	return unsafe.String(&b[0], len(b))
   674  }
   675  
   676  func (r *Reader) StringRef(off uint32) string {
   677  	l := r.uint32At(off)
   678  	return r.StringAt(r.uint32At(off+4), l)
   679  }
   680  
   681  func (r *Reader) Fingerprint() FingerprintType {
   682  	return r.h.Fingerprint
   683  }
   684  
   685  func (r *Reader) Autolib() []ImportedPkg {
   686  	n := (r.h.Offsets[BlkAutolib+1] - r.h.Offsets[BlkAutolib]) / importedPkgSize
   687  	s := make([]ImportedPkg, n)
   688  	off := r.h.Offsets[BlkAutolib]
   689  	for i := range s {
   690  		s[i].Pkg = r.StringRef(off)
   691  		copy(s[i].Fingerprint[:], r.BytesAt(off+stringRefSize, len(s[i].Fingerprint)))
   692  		off += importedPkgSize
   693  	}
   694  	return s
   695  }
   696  
   697  func (r *Reader) Pkglist() []string {
   698  	n := (r.h.Offsets[BlkPkgIdx+1] - r.h.Offsets[BlkPkgIdx]) / stringRefSize
   699  	s := make([]string, n)
   700  	off := r.h.Offsets[BlkPkgIdx]
   701  	for i := range s {
   702  		s[i] = r.StringRef(off)
   703  		off += stringRefSize
   704  	}
   705  	return s
   706  }
   707  
   708  func (r *Reader) NPkg() int {
   709  	return int(r.h.Offsets[BlkPkgIdx+1]-r.h.Offsets[BlkPkgIdx]) / stringRefSize
   710  }
   711  
   712  func (r *Reader) Pkg(i int) string {
   713  	off := r.h.Offsets[BlkPkgIdx] + uint32(i)*stringRefSize
   714  	return r.StringRef(off)
   715  }
   716  
   717  func (r *Reader) NFile() int {
   718  	return int(r.h.Offsets[BlkFile+1]-r.h.Offsets[BlkFile]) / stringRefSize
   719  }
   720  
   721  func (r *Reader) File(i int) string {
   722  	off := r.h.Offsets[BlkFile] + uint32(i)*stringRefSize
   723  	return r.StringRef(off)
   724  }
   725  
   726  func (r *Reader) NSym() int {
   727  	return int(r.h.Offsets[BlkSymdef+1]-r.h.Offsets[BlkSymdef]) / SymSize
   728  }
   729  
   730  func (r *Reader) NHashed64def() int {
   731  	return int(r.h.Offsets[BlkHashed64def+1]-r.h.Offsets[BlkHashed64def]) / SymSize
   732  }
   733  
   734  func (r *Reader) NHasheddef() int {
   735  	return int(r.h.Offsets[BlkHasheddef+1]-r.h.Offsets[BlkHasheddef]) / SymSize
   736  }
   737  
   738  func (r *Reader) NNonpkgdef() int {
   739  	return int(r.h.Offsets[BlkNonpkgdef+1]-r.h.Offsets[BlkNonpkgdef]) / SymSize
   740  }
   741  
   742  func (r *Reader) NNonpkgref() int {
   743  	return int(r.h.Offsets[BlkNonpkgref+1]-r.h.Offsets[BlkNonpkgref]) / SymSize
   744  }
   745  
   746  // SymOff returns the offset of the i-th symbol.
   747  func (r *Reader) SymOff(i uint32) uint32 {
   748  	return r.h.Offsets[BlkSymdef] + uint32(i*SymSize)
   749  }
   750  
   751  // Sym returns a pointer to the i-th symbol.
   752  func (r *Reader) Sym(i uint32) *Sym {
   753  	off := r.SymOff(i)
   754  	return (*Sym)(unsafe.Pointer(&r.b[off]))
   755  }
   756  
   757  // NRefFlags returns the number of referenced symbol flags.
   758  func (r *Reader) NRefFlags() int {
   759  	return int(r.h.Offsets[BlkRefFlags+1]-r.h.Offsets[BlkRefFlags]) / RefFlagsSize
   760  }
   761  
   762  // RefFlags returns a pointer to the i-th referenced symbol flags.
   763  // Note: here i is not a local symbol index, just a counter.
   764  func (r *Reader) RefFlags(i int) *RefFlags {
   765  	off := r.h.Offsets[BlkRefFlags] + uint32(i*RefFlagsSize)
   766  	return (*RefFlags)(unsafe.Pointer(&r.b[off]))
   767  }
   768  
   769  // Hash64 returns the i-th short hashed symbol's hash.
   770  // Note: here i is the index of short hashed symbols, not all symbols
   771  // (unlike other accessors).
   772  func (r *Reader) Hash64(i uint32) uint64 {
   773  	off := r.h.Offsets[BlkHash64] + uint32(i*Hash64Size)
   774  	return r.uint64At(off)
   775  }
   776  
   777  // Hash returns a pointer to the i-th hashed symbol's hash.
   778  // Note: here i is the index of hashed symbols, not all symbols
   779  // (unlike other accessors).
   780  func (r *Reader) Hash(i uint32) *HashType {
   781  	off := r.h.Offsets[BlkHash] + uint32(i*HashSize)
   782  	return (*HashType)(unsafe.Pointer(&r.b[off]))
   783  }
   784  
   785  // NReloc returns the number of relocations of the i-th symbol.
   786  func (r *Reader) NReloc(i uint32) int {
   787  	relocIdxOff := r.h.Offsets[BlkRelocIdx] + uint32(i*4)
   788  	return int(r.uint32At(relocIdxOff+4) - r.uint32At(relocIdxOff))
   789  }
   790  
   791  // RelocOff returns the offset of the j-th relocation of the i-th symbol.
   792  func (r *Reader) RelocOff(i uint32, j int) uint32 {
   793  	relocIdxOff := r.h.Offsets[BlkRelocIdx] + uint32(i*4)
   794  	relocIdx := r.uint32At(relocIdxOff)
   795  	return r.h.Offsets[BlkReloc] + (relocIdx+uint32(j))*uint32(RelocSize)
   796  }
   797  
   798  // Reloc returns a pointer to the j-th relocation of the i-th symbol.
   799  func (r *Reader) Reloc(i uint32, j int) *Reloc {
   800  	off := r.RelocOff(i, j)
   801  	return (*Reloc)(unsafe.Pointer(&r.b[off]))
   802  }
   803  
   804  // Relocs returns a pointer to the relocations of the i-th symbol.
   805  func (r *Reader) Relocs(i uint32) []Reloc {
   806  	off := r.RelocOff(i, 0)
   807  	n := r.NReloc(i)
   808  	return (*[huge]Reloc)(unsafe.Pointer(&r.b[off]))[:n:n]
   809  }
   810  
   811  // NAux returns the number of aux symbols of the i-th symbol.
   812  func (r *Reader) NAux(i uint32) int {
   813  	auxIdxOff := r.h.Offsets[BlkAuxIdx] + i*4
   814  	return int(r.uint32At(auxIdxOff+4) - r.uint32At(auxIdxOff))
   815  }
   816  
   817  // AuxOff returns the offset of the j-th aux symbol of the i-th symbol.
   818  func (r *Reader) AuxOff(i uint32, j int) uint32 {
   819  	auxIdxOff := r.h.Offsets[BlkAuxIdx] + i*4
   820  	auxIdx := r.uint32At(auxIdxOff)
   821  	return r.h.Offsets[BlkAux] + (auxIdx+uint32(j))*uint32(AuxSize)
   822  }
   823  
   824  // Aux returns a pointer to the j-th aux symbol of the i-th symbol.
   825  func (r *Reader) Aux(i uint32, j int) *Aux {
   826  	off := r.AuxOff(i, j)
   827  	return (*Aux)(unsafe.Pointer(&r.b[off]))
   828  }
   829  
   830  // Auxs returns the aux symbols of the i-th symbol.
   831  func (r *Reader) Auxs(i uint32) []Aux {
   832  	off := r.AuxOff(i, 0)
   833  	n := r.NAux(i)
   834  	return (*[huge]Aux)(unsafe.Pointer(&r.b[off]))[:n:n]
   835  }
   836  
   837  // DataOff returns the offset of the i-th symbol's data.
   838  func (r *Reader) DataOff(i uint32) uint32 {
   839  	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
   840  	return r.h.Offsets[BlkData] + r.uint32At(dataIdxOff)
   841  }
   842  
   843  // DataSize returns the size of the i-th symbol's data.
   844  func (r *Reader) DataSize(i uint32) int {
   845  	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
   846  	return int(r.uint32At(dataIdxOff+4) - r.uint32At(dataIdxOff))
   847  }
   848  
   849  // Data returns the i-th symbol's data.
   850  func (r *Reader) Data(i uint32) []byte {
   851  	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
   852  	base := r.h.Offsets[BlkData]
   853  	off := r.uint32At(dataIdxOff)
   854  	end := r.uint32At(dataIdxOff + 4)
   855  	return r.BytesAt(base+off, int(end-off))
   856  }
   857  
   858  // DataString returns the i-th symbol's data as a string.
   859  func (r *Reader) DataString(i uint32) string {
   860  	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
   861  	base := r.h.Offsets[BlkData]
   862  	off := r.uint32At(dataIdxOff)
   863  	end := r.uint32At(dataIdxOff + 4)
   864  	return r.StringAt(base+off, end-off)
   865  }
   866  
   867  // NRefName returns the number of referenced symbol names.
   868  func (r *Reader) NRefName() int {
   869  	return int(r.h.Offsets[BlkRefName+1]-r.h.Offsets[BlkRefName]) / RefNameSize
   870  }
   871  
   872  // RefName returns a pointer to the i-th referenced symbol name.
   873  // Note: here i is not a local symbol index, just a counter.
   874  func (r *Reader) RefName(i int) *RefName {
   875  	off := r.h.Offsets[BlkRefName] + uint32(i*RefNameSize)
   876  	return (*RefName)(unsafe.Pointer(&r.b[off]))
   877  }
   878  
   879  // ReadOnly returns whether r.BytesAt returns read-only bytes.
   880  func (r *Reader) ReadOnly() bool {
   881  	return r.readonly
   882  }
   883  
   884  // Flags returns the flag bits read from the object file header.
   885  func (r *Reader) Flags() uint32 {
   886  	return r.h.Flags
   887  }
   888  
   889  func (r *Reader) Shared() bool       { return r.Flags()&ObjFlagShared != 0 }
   890  func (r *Reader) FromAssembly() bool { return r.Flags()&ObjFlagFromAssembly != 0 }
   891  func (r *Reader) Unlinkable() bool   { return r.Flags()&ObjFlagUnlinkable != 0 }
   892  func (r *Reader) Std() bool          { return r.Flags()&ObjFlagStd != 0 }
   893
View as plain text