path: root/src/cmd/link/internal/sym/symbol.go

// Copyright 2017 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 sym

import (
	"cmd/internal/obj"
	"cmd/internal/objabi"
	"cmd/internal/sys"
	"debug/elf"
	"fmt"
	"log"
)

// Symbol is an entry in the symbol table.
type Symbol struct {
	Name        string
	Type        SymKind
	Version     int16
	Attr        Attribute
	Dynid       int32
	Align       int32
	Elfsym      int32
	LocalElfsym int32
	Value       int64
	Size        int64
	Sub         *Symbol
	Outer       *Symbol
	Gotype      *Symbol
	File        string // actually package!
	auxinfo     *AuxSymbol
	Sect        *Section
	FuncInfo    *FuncInfo
	Unit        *CompilationUnit
	// P contains the raw symbol data.
	P []byte
	R []Reloc
}

// AuxSymbol contains less-frequently used sym.Symbol fields.
type AuxSymbol struct {
	extname    string
	dynimplib  string
	dynimpvers string
	localentry uint8
	plt        int32
	got        int32
	// ElfType is set for symbols read from shared libraries by ldshlibsyms. It
	// is not set for symbols defined by the packages being linked or by symbols
	// read by ldelf (and so is left as elf.STT_NOTYPE).
	elftype elf.SymType
}

const (
	SymVerABI0        = 0
	SymVerABIInternal = 1
	SymVerStatic      = 10 // Minimum version used by static (file-local) syms
)

func ABIToVersion(abi obj.ABI) int {
	switch abi {
	case obj.ABI0:
		return SymVerABI0
	case obj.ABIInternal:
		return SymVerABIInternal
	}
	return -1
}

func VersionToABI(v int) (obj.ABI, bool) {
	switch v {
	case SymVerABI0:
		return obj.ABI0, true
	case SymVerABIInternal:
		return obj.ABIInternal, true
	}
	return ^obj.ABI(0), false
}

func (s *Symbol) String() string {
	if s.Version == 0 {
		return s.Name
	}
	return fmt.Sprintf("%s<%d>", s.Name, s.Version)
}

func (s *Symbol) IsFileLocal() bool {
	return s.Version >= SymVerStatic
}

func (s *Symbol) ElfsymForReloc() int32 {
	// If putelfsym created a local version of this symbol, use that in all
	// relocations.
	if s.LocalElfsym != 0 {
		return s.LocalElfsym
	} else {
		return s.Elfsym
	}
}

func (s *Symbol) Len() int64 {
	return s.Size
}

func (s *Symbol) Length(dwarfContext interface{}) int64 {
	return s.Size
}

func (s *Symbol) Grow(siz int64) {
	if int64(int(siz)) != siz {
		log.Fatalf("symgrow size %d too long", siz)
	}
	if int64(len(s.P)) >= siz {
		return
	}
	if cap(s.P) < int(siz) {
		p := make([]byte, 2*(siz+1))
		s.P = append(p[:0], s.P...)
	}
	s.P = s.P[:siz]
}

func (s *Symbol) AddBytes(bytes []byte) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	s.P = append(s.P, bytes...)
	s.Size = int64(len(s.P))

	return s.Size
}

func (s *Symbol) AddUint8(v uint8) int64 {
	off := s.Size
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	s.Size++
	s.P = append(s.P, v)

	return off
}

func (s *Symbol) AddUint16(arch *sys.Arch, v uint16) int64 {
	return s.AddUintXX(arch, uint64(v), 2)
}

func (s *Symbol) AddUint32(arch *sys.Arch, v uint32) int64 {
	return s.AddUintXX(arch, uint64(v), 4)
}

func (s *Symbol) AddUint64(arch *sys.Arch, v uint64) int64 {
	return s.AddUintXX(arch, v, 8)
}

func (s *Symbol) AddUint(arch *sys.Arch, v uint64) int64 {
	return s.AddUintXX(arch, v, arch.PtrSize)
}

func (s *Symbol) SetUint8(arch *sys.Arch, r int64, v uint8) int64 {
	return s.setUintXX(arch, r, uint64(v), 1)
}

func (s *Symbol) SetUint16(arch *sys.Arch, r int64, v uint16) int64 {
	return s.setUintXX(arch, r, uint64(v), 2)
}

func (s *Symbol) SetUint32(arch *sys.Arch, r int64, v uint32) int64 {
	return s.setUintXX(arch, r, uint64(v), 4)
}

func (s *Symbol) SetUint(arch *sys.Arch, r int64, v uint64) int64 {
	return s.setUintXX(arch, r, v, int64(arch.PtrSize))
}

func (s *Symbol) addAddrPlus(arch *sys.Arch, t *Symbol, add int64, typ objabi.RelocType) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	i := s.Size
	s.Size += int64(arch.PtrSize)
	s.Grow(s.Size)
	r := s.AddRel()
	r.Sym = t
	r.Off = int32(i)
	r.Siz = uint8(arch.PtrSize)
	r.Type = typ
	r.Add = add
	return i + int64(r.Siz)
}

func (s *Symbol) AddAddrPlus(arch *sys.Arch, t *Symbol, add int64) int64 {
	return s.addAddrPlus(arch, t, add, objabi.R_ADDR)
}

func (s *Symbol) AddCURelativeAddrPlus(arch *sys.Arch, t *Symbol, add int64) int64 {
	return s.addAddrPlus(arch, t, add, objabi.R_ADDRCUOFF)
}

func (s *Symbol) AddPCRelPlus(arch *sys.Arch, t *Symbol, add int64) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	i := s.Size
	s.Size += 4
	s.Grow(s.Size)
	r := s.AddRel()
	r.Sym = t
	r.Off = int32(i)
	r.Add = add
	r.Type = objabi.R_PCREL
	r.Siz = 4
	if arch.Family == sys.S390X || arch.Family == sys.PPC64 {
		r.InitExt()
	}
	if arch.Family == sys.S390X {
		r.Variant = RV_390_DBL
	}
	return i + int64(r.Siz)
}

func (s *Symbol) AddAddr(arch *sys.Arch, t *Symbol) int64 {
	return s.AddAddrPlus(arch, t, 0)
}

func (s *Symbol) SetAddrPlus(arch *sys.Arch, off int64, t *Symbol, add int64) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	if off+int64(arch.PtrSize) > s.Size {
		s.Size = off + int64(arch.PtrSize)
		s.Grow(s.Size)
	}

	r := s.AddRel()
	r.Sym = t
	r.Off = int32(off)
	r.Siz = uint8(arch.PtrSize)
	r.Type = objabi.R_ADDR
	r.Add = add
	return off + int64(r.Siz)
}

func (s *Symbol) SetAddr(arch *sys.Arch, off int64, t *Symbol) int64 {
	return s.SetAddrPlus(arch, off, t, 0)
}

func (s *Symbol) AddSize(arch *sys.Arch, t *Symbol) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	i := s.Size
	s.Size += int64(arch.PtrSize)
	s.Grow(s.Size)
	r := s.AddRel()
	r.Sym = t
	r.Off = int32(i)
	r.Siz = uint8(arch.PtrSize)
	r.Type = objabi.R_SIZE
	return i + int64(r.Siz)
}

func (s *Symbol) AddAddrPlus4(t *Symbol, add int64) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	i := s.Size
	s.Size += 4
	s.Grow(s.Size)
	r := s.AddRel()
	r.Sym = t
	r.Off = int32(i)
	r.Siz = 4
	r.Type = objabi.R_ADDR
	r.Add = add
	return i + int64(r.Siz)
}

func (s *Symbol) AddRel() *Reloc {
	s.R = append(s.R, Reloc{})
	return &s.R[len(s.R)-1]
}

func (s *Symbol) AddUintXX(arch *sys.Arch, v uint64, wid int) int64 {
	off := s.Size
	s.setUintXX(arch, off, v, int64(wid))
	return off
}

func (s *Symbol) setUintXX(arch *sys.Arch, off int64, v uint64, wid int64) int64 {
	if s.Type == 0 {
		s.Type = SDATA
	}
	s.Attr |= AttrReachable
	if s.Size < off+wid {
		s.Size = off + wid
		s.Grow(s.Size)
	}

	switch wid {
	case 1:
		s.P[off] = uint8(v)
	case 2:
		arch.ByteOrder.PutUint16(s.P[off:], uint16(v))
	case 4:
		arch.ByteOrder.PutUint32(s.P[off:], uint32(v))
	case 8:
		arch.ByteOrder.PutUint64(s.P[off:], v)
	}

	return off + wid
}

func (s *Symbol) makeAuxInfo() {
	if s.auxinfo == nil {
		s.auxinfo = &AuxSymbol{extname: s.Name, plt: -1, got: -1}
	}
}

func (s *Symbol) Extname() string {
	if s.auxinfo == nil {
		return s.Name
	}
	return s.auxinfo.extname
}

func (s *Symbol) SetExtname(n string) {
	if s.auxinfo == nil {
		if s.Name == n {
			return
		}
		s.makeAuxInfo()
	}
	s.auxinfo.extname = n
}

func (s *Symbol) Dynimplib() string {
	if s.auxinfo == nil {
		return ""
	}
	return s.auxinfo.dynimplib
}

func (s *Symbol) Dynimpvers() string {
	if s.auxinfo == nil {
		return ""
	}
	return s.auxinfo.dynimpvers
}

func (s *Symbol) SetDynimplib(lib string) {
	if s.auxinfo == nil {
		s.makeAuxInfo()
	}
	s.auxinfo.dynimplib = lib
}

func (s *Symbol) SetDynimpvers(vers string) {
	if s.auxinfo == nil {
		s.makeAuxInfo()
	}
	s.auxinfo.dynimpvers = vers
}

func (s *Symbol) ResetDyninfo() {
	if s.auxinfo != nil {
		s.auxinfo.dynimplib = ""
		s.auxinfo.dynimpvers = ""
	}
}

func (s *Symbol) Localentry() uint8 {
	if s.auxinfo == nil {
		return 0
	}
	return s.auxinfo.localentry
}

func (s *Symbol) SetLocalentry(val uint8) {
	if s.auxinfo == nil {
		if val != 0 {
			return
		}
		s.makeAuxInfo()
	}
	s.auxinfo.localentry = val
}

func (s *Symbol) Plt() int32 {
	if s.auxinfo == nil {
		return -1
	}
	return s.auxinfo.plt
}

func (s *Symbol) SetPlt(val int32) {
	if s.auxinfo == nil {
		if val == -1 {
			return
		}
		s.makeAuxInfo()
	}
	s.auxinfo.plt = val
}

func (s *Symbol) Got() int32 {
	if s.auxinfo == nil {
		return -1
	}
	return s.auxinfo.got
}

func (s *Symbol) SetGot(val int32) {
	if s.auxinfo == nil {
		if val == -1 {
			return
		}
		s.makeAuxInfo()
	}
	s.auxinfo.got = val
}

func (s *Symbol) ElfType() elf.SymType {
	if s.auxinfo == nil {
		return elf.STT_NOTYPE
	}
	return s.auxinfo.elftype
}

func (s *Symbol) SetElfType(val elf.SymType) {
	if s.auxinfo == nil {
		if val == elf.STT_NOTYPE {
			return
		}
		s.makeAuxInfo()
	}
	s.auxinfo.elftype = val
}

// SortSub sorts a linked-list (by Sub) of *Symbol by Value.
// Used for sub-symbols when loading host objects (see e.g. ldelf.go).
func SortSub(l *Symbol) *Symbol {
	if l == nil || l.Sub == nil {
		return l
	}

	l1 := l
	l2 := l
	for {
		l2 = l2.Sub
		if l2 == nil {
			break
		}
		l2 = l2.Sub
		if l2 == nil {
			break
		}
		l1 = l1.Sub
	}

	l2 = l1.Sub
	l1.Sub = nil
	l1 = SortSub(l)
	l2 = SortSub(l2)

	/* set up lead element */
	if l1.Value < l2.Value {
		l = l1
		l1 = l1.Sub
	} else {
		l = l2
		l2 = l2.Sub
	}

	le := l

	for {
		if l1 == nil {
			for l2 != nil {
				le.Sub = l2
				le = l2
				l2 = l2.Sub
			}

			le.Sub = nil
			break
		}

		if l2 == nil {
			for l1 != nil {
				le.Sub = l1
				le = l1
				l1 = l1.Sub
			}

			break
		}

		if l1.Value < l2.Value {
			le.Sub = l1
			le = l1
			l1 = l1.Sub
		} else {
			le.Sub = l2
			le = l2
			l2 = l2.Sub
		}
	}

	le.Sub = nil
	return l
}

type FuncInfo struct {
	Args        int32
	Locals      int32
	Pcsp        Pcdata
	Pcfile      Pcdata
	Pcline      Pcdata
	Pcinline    Pcdata
	Pcdata      []Pcdata
	Funcdata    []*Symbol
	Funcdataoff []int64
	File        []*Symbol
	InlTree     []InlinedCall
}

// InlinedCall is a node in a local inlining tree (FuncInfo.InlTree).
type InlinedCall struct {
	Parent   int32   // index of parent in InlTree
	File     *Symbol // file of the inlined call
	Line     int32   // line number of the inlined call
	Func     string  // name of the function that was inlined
	ParentPC int32   // PC of the instruction just before the inlined body (offset from function start)
}

type Pcdata struct {
	P []byte
}