src/cmd/link/internal/loader/symbolbuilder.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 package loader
   6
   7 import (
   8         "cmd/internal/objabi"
   9         "cmd/internal/sys"
  10         "cmd/link/internal/sym"
  11         "fmt"
  12 )
  13
  14 // SymbolBuilder is a helper designed to help with the construction
  15 // of new symbol contents.
  16 type SymbolBuilder struct {
  17         *extSymPayload         // points to payload being updated
  18         symIdx         Sym     // index of symbol being updated/constructed
  19         l              *Loader // loader
  20 }
  21
  22 // MakeSymbolBuilder creates a symbol builder for use in constructing
  23 // an entirely new symbol.
  24 func (l *Loader) MakeSymbolBuilder(name string) *SymbolBuilder {
  25         // for now assume that any new sym is intended to be static
  26         symIdx := l.CreateExtSym(name)
  27         if l.Syms[symIdx] != nil {
  28                 panic("can't build if sym.Symbol already present")
  29         }
  30         sb := &SymbolBuilder{l: l, symIdx: symIdx}
  31         sb.extSymPayload = l.getPayload(symIdx)
  32         return sb
  33 }
  34
  35 // MakeSymbolUpdater creates a symbol builder helper for an existing
  36 // symbol 'symIdx'. If 'symIdx' is not an external symbol, then create
  37 // a clone of it (copy name, properties, etc) fix things up so that
  38 // the lookup tables and caches point to the new version, not the old
  39 // version. Returns a SymbolBuilder and a Sym (which may be different
  40 // from the original if we had to clone).
  41 func (l *Loader) MakeSymbolUpdater(symIdx Sym) (*SymbolBuilder, Sym) {
  42         if symIdx == 0 {
  43                 panic("can't update the null symbol")
  44         }
  45         if !l.IsExternal(symIdx) {
  46                 // Create a clone with the same name/version/kind etc.
  47                 l.cloneToExternal(symIdx)
  48         }
  49         if l.Syms[symIdx] != nil {
  50                 panic(fmt.Sprintf("can't build if sym.Symbol %q already present", l.RawSymName(symIdx)))
  51         }
  52
  53         // Construct updater and return.
  54         sb := &SymbolBuilder{l: l, symIdx: symIdx}
  55         sb.extSymPayload = l.getPayload(symIdx)
  56         return sb, symIdx
  57 }
  58
  59 // Getters for properties of the symbol we're working on.
  60
  61 func (sb *SymbolBuilder) Sym() Sym               { return sb.symIdx }
  62 func (sb *SymbolBuilder) Name() string           { return sb.name }
  63 func (sb *SymbolBuilder) Version() int           { return sb.ver }
  64 func (sb *SymbolBuilder) Type() sym.SymKind      { return sb.kind }
  65 func (sb *SymbolBuilder) Size() int64            { return sb.size }
  66 func (sb *SymbolBuilder) Data() []byte           { return sb.data }
  67 func (sb *SymbolBuilder) Value() int64           { return sb.l.SymValue(sb.symIdx) }
  68 func (sb *SymbolBuilder) Align() int32           { return sb.l.SymAlign(sb.symIdx) }
  69 func (sb *SymbolBuilder) Localentry() uint8      { return sb.l.SymLocalentry(sb.symIdx) }
  70 func (sb *SymbolBuilder) OnList() bool           { return sb.l.AttrOnList(sb.symIdx) }
  71 func (sb *SymbolBuilder) External() bool         { return sb.l.AttrExternal(sb.symIdx) }
  72 func (sb *SymbolBuilder) Extname() string        { return sb.l.SymExtname(sb.symIdx) }
  73 func (sb *SymbolBuilder) CgoExportDynamic() bool { return sb.l.AttrCgoExportDynamic(sb.symIdx) }
  74 func (sb *SymbolBuilder) Dynimplib() string      { return sb.l.SymDynimplib(sb.symIdx) }
  75 func (sb *SymbolBuilder) Dynimpvers() string     { return sb.l.SymDynimpvers(sb.symIdx) }
  76 func (sb *SymbolBuilder) SubSym() Sym            { return sb.l.SubSym(sb.symIdx) }
  77
  78 // Setters for symbol properties.
  79
  80 func (sb *SymbolBuilder) SetType(kind sym.SymKind)   { sb.kind = kind }
  81 func (sb *SymbolBuilder) SetSize(size int64)         { sb.size = size }
  82 func (sb *SymbolBuilder) SetData(data []byte)        { sb.data = data }
  83 func (sb *SymbolBuilder) SetOnList(v bool)           { sb.l.SetAttrOnList(sb.symIdx, v) }
  84 func (sb *SymbolBuilder) SetExternal(v bool)         { sb.l.SetAttrExternal(sb.symIdx, v) }
  85 func (sb *SymbolBuilder) SetValue(v int64)           { sb.l.SetSymValue(sb.symIdx, v) }
  86 func (sb *SymbolBuilder) SetAlign(align int32)       { sb.l.SetSymAlign(sb.symIdx, align) }
  87 func (sb *SymbolBuilder) SetLocalentry(value uint8)  { sb.l.SetSymLocalentry(sb.symIdx, value) }
  88 func (sb *SymbolBuilder) SetExtname(value string)    { sb.l.SetSymExtname(sb.symIdx, value) }
  89 func (sb *SymbolBuilder) SetDynimplib(value string)  { sb.l.SetSymDynimplib(sb.symIdx, value) }
  90 func (sb *SymbolBuilder) SetDynimpvers(value string) { sb.l.SetSymDynimpvers(sb.symIdx, value) }
  91 func (sb *SymbolBuilder) SetPlt(value int32)         { sb.l.SetPlt(sb.symIdx, value) }
  92 func (sb *SymbolBuilder) SetGot(value int32)         { sb.l.SetGot(sb.symIdx, value) }
  93
  94 func (sb *SymbolBuilder) AddBytes(data []byte) {
  95         sb.setReachable()
  96         if sb.kind == 0 {
  97                 sb.kind = sym.SDATA
  98         }
  99         sb.data = append(sb.data, data...)
 100         sb.size = int64(len(sb.data))
 101 }
 102
 103 func (sb *SymbolBuilder) Relocs() []Reloc {
 104         return sb.relocs
 105 }
 106
 107 func (sb *SymbolBuilder) SetRelocs(rslice []Reloc) {
 108         sb.relocs = rslice
 109 }
 110
 111 func (sb *SymbolBuilder) AddReloc(r Reloc) {
 112         sb.relocs = append(sb.relocs, r)
 113 }
 114
 115 func (sb *SymbolBuilder) Reachable() bool {
 116         return sb.l.AttrReachable(sb.symIdx)
 117 }
 118
 119 func (sb *SymbolBuilder) setReachable() {
 120         sb.l.SetAttrReachable(sb.symIdx, true)
 121 }
 122
 123 func (sb *SymbolBuilder) ReadOnly() bool {
 124         return sb.l.AttrReadOnly(sb.symIdx)
 125 }
 126
 127 func (sb *SymbolBuilder) SetReadOnly(v bool) {
 128         sb.l.SetAttrReadOnly(sb.symIdx, v)
 129 }
 130
 131 func (sb *SymbolBuilder) DuplicateOK() bool {
 132         return sb.l.AttrDuplicateOK(sb.symIdx)
 133 }
 134
 135 func (sb *SymbolBuilder) SetDuplicateOK(v bool) {
 136         sb.l.SetAttrDuplicateOK(sb.symIdx, v)
 137 }
 138
 139 func (sb *SymbolBuilder) Outer() Sym {
 140         return sb.l.OuterSym(sb.symIdx)
 141 }
 142
 143 func (sb *SymbolBuilder) Sub() Sym {
 144         return sb.l.SubSym(sb.symIdx)
 145 }
 146
 147 func (sb *SymbolBuilder) SortSub() {
 148         sb.l.SortSub(sb.symIdx)
 149 }
 150
 151 func (sb *SymbolBuilder) PrependSub(sub Sym) {
 152         sb.l.PrependSub(sb.symIdx, sub)
 153 }
 154
 155 func (sb *SymbolBuilder) AddUint8(v uint8) int64 {
 156         off := sb.size
 157         if sb.kind == 0 {
 158                 sb.kind = sym.SDATA
 159         }
 160         sb.setReachable()
 161         sb.size++
 162         sb.data = append(sb.data, v)
 163         return off
 164 }
 165
 166 func (sb *SymbolBuilder) AddUintXX(arch *sys.Arch, v uint64, wid int) int64 {
 167         off := sb.size
 168         sb.setReachable()
 169         sb.setUintXX(arch, off, v, int64(wid))
 170         return off
 171 }
 172
 173 func (sb *SymbolBuilder) setUintXX(arch *sys.Arch, off int64, v uint64, wid int64) int64 {
 174         if sb.kind == 0 {
 175                 sb.kind = sym.SDATA
 176         }
 177         if sb.size < off+wid {
 178                 sb.size = off + wid
 179                 sb.Grow(sb.size)
 180         }
 181
 182         switch wid {
 183         case 1:
 184                 sb.data[off] = uint8(v)
 185         case 2:
 186                 arch.ByteOrder.PutUint16(sb.data[off:], uint16(v))
 187         case 4:
 188                 arch.ByteOrder.PutUint32(sb.data[off:], uint32(v))
 189         case 8:
 190                 arch.ByteOrder.PutUint64(sb.data[off:], v)
 191         }
 192
 193         return off + wid
 194 }
 195
 196 func (sb *SymbolBuilder) AddUint16(arch *sys.Arch, v uint16) int64 {
 197         return sb.AddUintXX(arch, uint64(v), 2)
 198 }
 199
 200 func (sb *SymbolBuilder) AddUint32(arch *sys.Arch, v uint32) int64 {
 201         return sb.AddUintXX(arch, uint64(v), 4)
 202 }
 203
 204 func (sb *SymbolBuilder) AddUint64(arch *sys.Arch, v uint64) int64 {
 205         return sb.AddUintXX(arch, v, 8)
 206 }
 207
 208 func (sb *SymbolBuilder) AddUint(arch *sys.Arch, v uint64) int64 {
 209         return sb.AddUintXX(arch, v, arch.PtrSize)
 210 }
 211
 212 func (sb *SymbolBuilder) SetUint8(arch *sys.Arch, r int64, v uint8) int64 {
 213         sb.setReachable()
 214         return sb.setUintXX(arch, r, uint64(v), 1)
 215 }
 216
 217 func (sb *SymbolBuilder) SetUint16(arch *sys.Arch, r int64, v uint16) int64 {
 218         sb.setReachable()
 219         return sb.setUintXX(arch, r, uint64(v), 2)
 220 }
 221
 222 func (sb *SymbolBuilder) SetUint32(arch *sys.Arch, r int64, v uint32) int64 {
 223         sb.setReachable()
 224         return sb.setUintXX(arch, r, uint64(v), 4)
 225 }
 226
 227 func (sb *SymbolBuilder) SetUint(arch *sys.Arch, r int64, v uint64) int64 {
 228         sb.setReachable()
 229         return sb.setUintXX(arch, r, v, int64(arch.PtrSize))
 230 }
 231
 232 func (sb *SymbolBuilder) Addstring(str string) int64 {
 233         sb.setReachable()
 234         if sb.kind == 0 {
 235                 sb.kind = sym.SNOPTRDATA
 236         }
 237         r := sb.size
 238         if sb.name == ".shstrtab" {
 239                 // FIXME: find a better mechanism for this
 240                 sb.l.elfsetstring(nil, str, int(r))
 241         }
 242         sb.data = append(sb.data, str...)
 243         sb.data = append(sb.data, 0)
 244         sb.size = int64(len(sb.data))
 245         return r
 246 }
 247
 248 func (sb *SymbolBuilder) addRel() *Reloc {
 249         sb.relocs = append(sb.relocs, Reloc{})
 250         return &sb.relocs[len(sb.relocs)-1]
 251 }
 252
 253 func (sb *SymbolBuilder) addAddrPlus(tgt Sym, add int64, typ objabi.RelocType, rsize int) int64 {
 254         if sb.kind == 0 {
 255                 sb.kind = sym.SDATA
 256         }
 257         i := sb.size
 258
 259         sb.size += int64(rsize)
 260         sb.Grow(sb.size)
 261
 262         r := sb.addRel()
 263         r.Sym = tgt
 264         r.Off = int32(i)
 265         r.Size = uint8(rsize)
 266         r.Type = typ
 267         r.Add = add
 268
 269         return i + int64(r.Size)
 270 }
 271
 272 func (sb *SymbolBuilder) AddAddrPlus(arch *sys.Arch, tgt Sym, add int64) int64 {
 273         sb.setReachable()
 274         return sb.addAddrPlus(tgt, add, objabi.R_ADDR, arch.PtrSize)
 275 }
 276
 277 func (sb *SymbolBuilder) AddAddrPlus4(arch *sys.Arch, tgt Sym, add int64) int64 {
 278         sb.setReachable()
 279         return sb.addAddrPlus(tgt, add, objabi.R_ADDR, 4)
 280 }
 281
 282 func (sb *SymbolBuilder) AddCURelativeAddrPlus(arch *sys.Arch, tgt Sym, add int64) int64 {
 283         sb.setReachable()
 284         return sb.addAddrPlus(tgt, add, objabi.R_ADDRCUOFF, arch.PtrSize)
 285 }