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