src/cmd/link/internal/ld/data2.go - third_party/go - Git at Google

 // Copyright 2020 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 ld

 import (
 	"cmd/internal/objabi"
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
 	"fmt"
 	"log"
 	"strings"
 	"sync"
 )

 // Temporary dumping around for sym.Symbol version of helper
 // functions in dodata(), still being used for some archs/oses.
 // FIXME: get rid of this file when dodata() is completely
 // converted.

 func Addstring(s *sym.Symbol, str string) int64 {
 	if s.Type == 0 {
 		s.Type = sym.SNOPTRDATA
 	}
 	s.Attr |= sym.AttrReachable
 	r := s.Size
 	if s.Name == ".shstrtab" {
 		elfsetstring(s, str, int(r))
 	}
 	s.P = append(s.P, str...)
 	s.P = append(s.P, 0)
 	s.Size = int64(len(s.P))
 	return r
 }

 // symalign returns the required alignment for the given symbol s.
 func symalign(s *sym.Symbol) int32 {
 	min := int32(thearch.Minalign)
 	if s.Align >= min {
 		return s.Align
 	} else if s.Align != 0 {
 		return min
 	}
 	if strings.HasPrefix(s.Name, "go.string.") || strings.HasPrefix(s.Name, "type..namedata.") {
 		// String data is just bytes.
 		// If we align it, we waste a lot of space to padding.
 		return min
 	}
 	align := int32(thearch.Maxalign)
 	for int64(align) > s.Size && align > min {
 		align >>= 1
 	}
 	s.Align = align
 	return align
 }

 func relocsym2(target *Target, ldr *loader.Loader, err *ErrorReporter, syms *ArchSyms, s *sym.Symbol) {
 	if len(s.R) == 0 {
 		return
 	}
 	for ri := int32(0); ri < int32(len(s.R)); ri++ {
 		r := &s.R[ri]
 		if r.Done {
 			// Relocation already processed by an earlier phase.
 			continue
 		}
 		r.Done = true
 		off := r.Off
 		siz := int32(r.Siz)
 		if off < 0 || off+siz > int32(len(s.P)) {
 			rname := ""
 			if r.Sym != nil {
 				rname = r.Sym.Name
 			}
 			Errorf(s, "invalid relocation %s: %d+%d not in [%d,%d)", rname, off, siz, 0, len(s.P))
 			continue
 		}

 		if r.Sym != nil && ((r.Sym.Type == sym.Sxxx && !r.Sym.Attr.VisibilityHidden()) || r.Sym.Type == sym.SXREF) {
 			// When putting the runtime but not main into a shared library
 			// these symbols are undefined and that's OK.
 			if target.IsShared() || target.IsPlugin() {
 				if r.Sym.Name == "main.main" || (!target.IsPlugin() && r.Sym.Name == "main..inittask") {
 					r.Sym.Type = sym.SDYNIMPORT
 				} else if strings.HasPrefix(r.Sym.Name, "go.info.") {
 					// Skip go.info symbols. They are only needed to communicate
 					// DWARF info between the compiler and linker.
 					continue
 				}
 			} else {
 				err.errorUnresolved2(s, r)
 				continue
 			}
 		}

 		if r.Type >= objabi.ElfRelocOffset {
 			continue
 		}
 		if r.Siz == 0 { // informational relocation - no work to do
 			continue
 		}

 		// We need to be able to reference dynimport symbols when linking against
 		// shared libraries, and Solaris, Darwin and AIX need it always
 		if !target.IsSolaris() && !target.IsDarwin() && !target.IsAIX() && r.Sym != nil && r.Sym.Type == sym.SDYNIMPORT && !target.IsDynlinkingGo() && !r.Sym.Attr.SubSymbol() {
 			if !(target.IsPPC64() && target.IsExternal() && r.Sym.Name == ".TOC.") {
 				Errorf(s, "unhandled relocation for %s (type %d (%s) rtype %d (%s))", r.Sym.Name, r.Sym.Type, r.Sym.Type, r.Type, sym.RelocName(target.Arch, r.Type))
 			}
 		}
 		if r.Sym != nil && r.Sym.Type != sym.STLSBSS && r.Type != objabi.R_WEAKADDROFF && !r.Sym.Attr.Reachable() {
 			Errorf(s, "unreachable sym in relocation: %s", r.Sym.Name)
 		}

 		if target.IsExternal() {
 			r.InitExt()
 		}

 		// TODO(mundaym): remove this special case - see issue 14218.
 		if target.IsS390X() {
 			switch r.Type {
 			case objabi.R_PCRELDBL:
 				r.InitExt()
 				r.Type = objabi.R_PCREL
 				r.Variant = sym.RV_390_DBL
 			case objabi.R_CALL:
 				r.InitExt()
 				r.Variant = sym.RV_390_DBL
 			}
 		}

 		var o int64
 		switch r.Type {
 		default:
 			switch siz {
 			default:
 				Errorf(s, "bad reloc size %#x for %s", uint32(siz), r.Sym.Name)
 			case 1:
 				o = int64(s.P[off])
 			case 2:
 				o = int64(target.Arch.ByteOrder.Uint16(s.P[off:]))
 			case 4:
 				o = int64(target.Arch.ByteOrder.Uint32(s.P[off:]))
 			case 8:
 				o = int64(target.Arch.ByteOrder.Uint64(s.P[off:]))
 			}
 			if offset, ok := thearch.Archreloc(target, syms, r, s, o); ok {
 				o = offset
 			} else {
 				Errorf(s, "unknown reloc to %v: %d (%s)", r.Sym.Name, r.Type, sym.RelocName(target.Arch, r.Type))
 			}
 		case objabi.R_TLS_LE:
 			if target.IsExternal() && target.IsElf() {
 				r.Done = false
 				if r.Sym == nil {
 					r.Sym = syms.Tlsg
 				}
 				r.Xsym = r.Sym
 				r.Xadd = r.Add
 				o = 0
 				if !target.IsAMD64() {
 					o = r.Add
 				}
 				break
 			}

 			if target.IsElf() && target.IsARM() {
 				// On ELF ARM, the thread pointer is 8 bytes before
 				// the start of the thread-local data block, so add 8
 				// to the actual TLS offset (r->sym->value).
 				// This 8 seems to be a fundamental constant of
 				// ELF on ARM (or maybe Glibc on ARM); it is not
 				// related to the fact that our own TLS storage happens
 				// to take up 8 bytes.
 				o = 8 + r.Sym.Value
 			} else if target.IsElf() || target.IsPlan9() || target.IsDarwin() {
 				o = int64(syms.Tlsoffset) + r.Add
 			} else if target.IsWindows() {
 				o = r.Add
 			} else {
 				log.Fatalf("unexpected R_TLS_LE relocation for %v", target.HeadType)
 			}
 		case objabi.R_TLS_IE:
 			if target.IsExternal() && target.IsElf() {
 				r.Done = false
 				if r.Sym == nil {
 					r.Sym = syms.Tlsg
 				}
 				r.Xsym = r.Sym
 				r.Xadd = r.Add
 				o = 0
 				if !target.IsAMD64() {
 					o = r.Add
 				}
 				break
 			}
 			if target.IsPIE() && target.IsElf() {
 				// We are linking the final executable, so we
 				// can optimize any TLS IE relocation to LE.
 				if thearch.TLSIEtoLE == nil {
 					log.Fatalf("internal linking of TLS IE not supported on %v", target.Arch.Family)
 				}
 				thearch.TLSIEtoLE(s.P, int(off), int(r.Siz))
 				o = int64(syms.Tlsoffset)
 				// TODO: o += r.Add when !target.IsAmd64()?
 				// Why do we treat r.Add differently on AMD64?
 				// Is the external linker using Xadd at all?
 			} else {
 				log.Fatalf("cannot handle R_TLS_IE (sym %s) when linking internally", s.Name)
 			}
 		case objabi.R_ADDR:
 			if target.IsExternal() && r.Sym.Type != sym.SCONST {
 				r.Done = false

 				// set up addend for eventual relocation via outer symbol.
 				rs := r.Sym

 				r.Xadd = r.Add
 				for rs.Outer != nil {
 					r.Xadd += Symaddr(rs) - Symaddr(rs.Outer)
 					rs = rs.Outer
 				}

 				if rs.Type != sym.SHOSTOBJ && rs.Type != sym.SDYNIMPORT && rs.Type != sym.SUNDEFEXT && rs.Sect == nil {
 					Errorf(s, "missing section for relocation target %s", rs.Name)
 				}
 				r.Xsym = rs

 				o = r.Xadd
 				if target.IsElf() {
 					if target.IsAMD64() {
 						o = 0
 					}
 				} else if target.IsDarwin() {
 					if rs.Type != sym.SHOSTOBJ {
 						o += Symaddr(rs)
 					}
 				} else if target.IsWindows() {
 					// nothing to do
 				} else if target.IsAIX() {
 					o = Symaddr(r.Sym) + r.Add
 				} else {
 					Errorf(s, "unhandled pcrel relocation to %s on %v", rs.Name, target.HeadType)
 				}

 				break
 			}

 			// On AIX, a second relocation must be done by the loader,
 			// as section addresses can change once loaded.
 			// The "default" symbol address is still needed by the loader so
 			// the current relocation can't be skipped.
 			if target.IsAIX() && r.Sym.Type != sym.SDYNIMPORT {
 				// It's not possible to make a loader relocation in a
 				// symbol which is not inside .data section.
 				// FIXME: It should be forbidden to have R_ADDR from a
 				// symbol which isn't in .data. However, as .text has the
 				// same address once loaded, this is possible.
 				if s.Sect.Seg == &Segdata {
 					Xcoffadddynrel(target, ldr, s, r)
 				}
 			}

 			o = Symaddr(r.Sym) + r.Add

 			// On amd64, 4-byte offsets will be sign-extended, so it is impossible to
 			// access more than 2GB of static data; fail at link time is better than
 			// fail at runtime. See https://golang.org/issue/7980.
 			// Instead of special casing only amd64, we treat this as an error on all
 			// 64-bit architectures so as to be future-proof.
 			if int32(o) < 0 && target.Arch.PtrSize > 4 && siz == 4 {
 				Errorf(s, "non-pc-relative relocation address for %s is too big: %#x (%#x + %#x)", r.Sym.Name, uint64(o), Symaddr(r.Sym), r.Add)
 				errorexit()
 			}
 		case objabi.R_DWARFSECREF:
 			if r.Sym.Sect == nil {
 				Errorf(s, "missing DWARF section for relocation target %s", r.Sym.Name)
 			}

 			if target.IsExternal() {
 				r.Done = false

 				// On most platforms, the external linker needs to adjust DWARF references
 				// as it combines DWARF sections. However, on Darwin, dsymutil does the
 				// DWARF linking, and it understands how to follow section offsets.
 				// Leaving in the relocation records confuses it (see
 				// https://golang.org/issue/22068) so drop them for Darwin.
 				if target.IsDarwin() {
 					r.Done = true
 				}

 				// PE code emits IMAGE_REL_I386_SECREL and IMAGE_REL_AMD64_SECREL
 				// for R_DWARFSECREF relocations, while R_ADDR is replaced with
 				// IMAGE_REL_I386_DIR32, IMAGE_REL_AMD64_ADDR64 and IMAGE_REL_AMD64_ADDR32.
 				// Do not replace R_DWARFSECREF with R_ADDR for windows -
 				// let PE code emit correct relocations.
 				if !target.IsWindows() {
 					r.Type = objabi.R_ADDR
 				}

 				r.Xsym = r.Sym.Sect.Sym
 				r.Xadd = r.Add + Symaddr(r.Sym) - int64(r.Sym.Sect.Vaddr)

 				o = r.Xadd
 				if target.IsElf() && target.IsAMD64() {
 					o = 0
 				}
 				break
 			}
 			o = Symaddr(r.Sym) + r.Add - int64(r.Sym.Sect.Vaddr)
 		case objabi.R_WEAKADDROFF:
 			if !r.Sym.Attr.Reachable() {
 				continue
 			}
 			fallthrough
 		case objabi.R_ADDROFF:
 			// The method offset tables using this relocation expect the offset to be relative
 			// to the start of the first text section, even if there are multiple.
 			if r.Sym.Sect.Name == ".text" {
 				o = Symaddr(r.Sym) - int64(Segtext.Sections[0].Vaddr) + r.Add
 			} else {
 				o = Symaddr(r.Sym) - int64(r.Sym.Sect.Vaddr) + r.Add
 			}

 		case objabi.R_ADDRCUOFF:
 			// debug_range and debug_loc elements use this relocation type to get an
 			// offset from the start of the compile unit.
 			u := ldr.SymUnit(loader.Sym(r.Sym.SymIdx))
 			o = Symaddr(r.Sym) + r.Add - Symaddr(ldr.Syms[u.Textp2[0]])

 			// r->sym can be null when CALL $(constant) is transformed from absolute PC to relative PC call.
 		case objabi.R_GOTPCREL:
 			if target.IsDynlinkingGo() && target.IsDarwin() && r.Sym != nil && r.Sym.Type != sym.SCONST {
 				r.Done = false
 				r.Xadd = r.Add
 				r.Xadd -= int64(r.Siz) // relative to address after the relocated chunk
 				r.Xsym = r.Sym

 				o = r.Xadd
 				o += int64(r.Siz)
 				break
 			}
 			fallthrough
 		case objabi.R_CALL, objabi.R_PCREL:
 			if target.IsExternal() && r.Sym != nil && r.Sym.Type == sym.SUNDEFEXT {
 				// pass through to the external linker.
 				r.Done = false
 				r.Xadd = 0
 				if target.IsElf() {
 					r.Xadd -= int64(r.Siz)
 				}
 				r.Xsym = r.Sym
 				o = 0
 				break
 			}
 			if target.IsExternal() && r.Sym != nil && r.Sym.Type != sym.SCONST && (r.Sym.Sect != s.Sect || r.Type == objabi.R_GOTPCREL) {
 				r.Done = false

 				// set up addend for eventual relocation via outer symbol.
 				rs := r.Sym

 				r.Xadd = r.Add
 				for rs.Outer != nil {
 					r.Xadd += Symaddr(rs) - Symaddr(rs.Outer)
 					rs = rs.Outer
 				}

 				r.Xadd -= int64(r.Siz) // relative to address after the relocated chunk
 				if rs.Type != sym.SHOSTOBJ && rs.Type != sym.SDYNIMPORT && rs.Sect == nil {
 					Errorf(s, "missing section for relocation target %s", rs.Name)
 				}
 				r.Xsym = rs

 				o = r.Xadd
 				if target.IsElf() {
 					if target.IsAMD64() {
 						o = 0
 					}
 				} else if target.IsDarwin() {
 					if r.Type == objabi.R_CALL {
 						if target.IsExternal() && rs.Type == sym.SDYNIMPORT {
 							if target.IsAMD64() {
 								// AMD64 dynamic relocations are relative to the end of the relocation.
 								o += int64(r.Siz)
 							}
 						} else {
 							if rs.Type != sym.SHOSTOBJ {
 								o += int64(uint64(Symaddr(rs)) - rs.Sect.Vaddr)
 							}
 							o -= int64(r.Off) // relative to section offset, not symbol
 						}
 					} else {
 						o += int64(r.Siz)
 					}
 				} else if target.IsWindows() && target.IsAMD64() { // only amd64 needs PCREL
 					// PE/COFF's PC32 relocation uses the address after the relocated
 					// bytes as the base. Compensate by skewing the addend.
 					o += int64(r.Siz)
 				} else {
 					Errorf(s, "unhandled pcrel relocation to %s on %v", rs.Name, target.HeadType)
 				}

 				break
 			}

 			o = 0
 			if r.Sym != nil {
 				o += Symaddr(r.Sym)
 			}

 			o += r.Add - (s.Value + int64(r.Off) + int64(r.Siz))
 		case objabi.R_SIZE:
 			o = r.Sym.Size + r.Add

 		case objabi.R_XCOFFREF:
 			if !target.IsAIX() {
 				Errorf(s, "find XCOFF R_REF on non-XCOFF files")
 			}
 			if !target.IsExternal() {
 				Errorf(s, "find XCOFF R_REF with internal linking")
 			}
 			r.Xsym = r.Sym
 			r.Xadd = r.Add
 			r.Done = false

 			// This isn't a real relocation so it must not update
 			// its offset value.
 			continue

 		case objabi.R_DWARFFILEREF:
 			// The final file index is saved in r.Add in dwarf.go:writelines.
 			o = r.Add
 		}

 		if target.IsPPC64() || target.IsS390X() {
 			r.InitExt()
 			if r.Variant != sym.RV_NONE {
 				o = thearch.Archrelocvariant(target, syms, r, s, o)
 			}
 		}

 		if false {
 			nam := "<nil>"
 			var addr int64
 			if r.Sym != nil {
 				nam = r.Sym.Name
 				addr = Symaddr(r.Sym)
 			}
 			xnam := "<nil>"
 			if r.Xsym != nil {
 				xnam = r.Xsym.Name
 			}
 			fmt.Printf("relocate %s %#x (%#x+%#x, size %d) => %s %#x +%#x (xsym: %s +%#x) [type %d (%s)/%d, %x]\n", s.Name, s.Value+int64(off), s.Value, r.Off, r.Siz, nam, addr, r.Add, xnam, r.Xadd, r.Type, sym.RelocName(target.Arch, r.Type), r.Variant, o)
 		}
 		switch siz {
 		default:
 			Errorf(s, "bad reloc size %#x for %s", uint32(siz), r.Sym.Name)
 			fallthrough

 			// TODO(rsc): Remove.
 		case 1:
 			s.P[off] = byte(int8(o))
 		case 2:
 			if o != int64(int16(o)) {
 				Errorf(s, "relocation address for %s is too big: %#x", r.Sym.Name, o)
 			}
 			i16 := int16(o)
 			target.Arch.ByteOrder.PutUint16(s.P[off:], uint16(i16))
 		case 4:
 			if r.Type == objabi.R_PCREL || r.Type == objabi.R_CALL {
 				if o != int64(int32(o)) {
 					Errorf(s, "pc-relative relocation address for %s is too big: %#x", r.Sym.Name, o)
 				}
 			} else {
 				if o != int64(int32(o)) && o != int64(uint32(o)) {
 					Errorf(s, "non-pc-relative relocation address for %s is too big: %#x", r.Sym.Name, uint64(o))
 				}
 			}

 			fl := int32(o)
 			target.Arch.ByteOrder.PutUint32(s.P[off:], uint32(fl))
 		case 8:
 			target.Arch.ByteOrder.PutUint64(s.P[off:], uint64(o))
 		}
 	}
 }

 func (ctxt *Link) reloc2() {
 	var wg sync.WaitGroup
 	target := &ctxt.Target
 	ldr := ctxt.loader
 	reporter := &ctxt.ErrorReporter
 	syms := &ctxt.ArchSyms
 	wg.Add(3)
 	go func() {
 		if !ctxt.IsWasm() { // On Wasm, text relocations are applied in Asmb2.
 			for _, s := range ctxt.Textp {
 				relocsym2(target, ldr, reporter, syms, s)
 			}
 		}
 		wg.Done()
 	}()
 	go func() {
 		for _, s := range ctxt.datap {
 			relocsym2(target, ldr, reporter, syms, s)
 		}
 		wg.Done()
 	}()
 	go func() {
 		for _, si := range dwarfp {
 			for _, s := range si.syms {
 				relocsym2(target, ldr, reporter, syms, s)
 			}
 		}
 		wg.Done()
 	}()
 	wg.Wait()
 }
	// Copyright 2020 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 ld

	import (
	"cmd/internal/objabi"
	"cmd/link/internal/loader"
	"cmd/link/internal/sym"
	"fmt"
	"log"
	"strings"
	"sync"
	)

	// Temporary dumping around for sym.Symbol version of helper
	// functions in dodata(), still being used for some archs/oses.
	// FIXME: get rid of this file when dodata() is completely
	// converted.

	func Addstring(s *sym.Symbol, str string) int64 {
	if s.Type == 0 {
	s.Type = sym.SNOPTRDATA
	}
	s.Attr \|= sym.AttrReachable
	r := s.Size
	if s.Name == ".shstrtab" {
	elfsetstring(s, str, int(r))
	}
	s.P = append(s.P, str...)
	s.P = append(s.P, 0)
	s.Size = int64(len(s.P))
	return r
	}

	// symalign returns the required alignment for the given symbol s.
	func symalign(s *sym.Symbol) int32 {
	min := int32(thearch.Minalign)
	if s.Align >= min {
	return s.Align
	} else if s.Align != 0 {
	return min
	}
	if strings.HasPrefix(s.Name, "go.string.") \|\| strings.HasPrefix(s.Name, "type..namedata.") {
	// String data is just bytes.
	// If we align it, we waste a lot of space to padding.
	return min
	}
	align := int32(thearch.Maxalign)
	for int64(align) > s.Size && align > min {
	align >>= 1
	}
	s.Align = align
	return align
	}

	func relocsym2(target Target, ldr loader.Loader, err ErrorReporter, syms ArchSyms, s *sym.Symbol) {
	if len(s.R) == 0 {
	return
	}
	for ri := int32(0); ri < int32(len(s.R)); ri++ {
	r := &s.R[ri]
	if r.Done {
	// Relocation already processed by an earlier phase.
	continue
	}
	r.Done = true
	off := r.Off
	siz := int32(r.Siz)
	if off < 0 \|\| off+siz > int32(len(s.P)) {
	rname := ""
	if r.Sym != nil {
	rname = r.Sym.Name
	}
	Errorf(s, "invalid relocation %s: %d+%d not in [%d,%d)", rname, off, siz, 0, len(s.P))
	continue
	}

	if r.Sym != nil && ((r.Sym.Type == sym.Sxxx && !r.Sym.Attr.VisibilityHidden()) \|\| r.Sym.Type == sym.SXREF) {
	// When putting the runtime but not main into a shared library
	// these symbols are undefined and that's OK.
	if target.IsShared() \|\| target.IsPlugin() {
	if r.Sym.Name == "main.main" \|\| (!target.IsPlugin() && r.Sym.Name == "main..inittask") {
	r.Sym.Type = sym.SDYNIMPORT
	} else if strings.HasPrefix(r.Sym.Name, "go.info.") {
	// Skip go.info symbols. They are only needed to communicate
	// DWARF info between the compiler and linker.
	continue
	}
	} else {
	err.errorUnresolved2(s, r)
	continue
	}
	}

	if r.Type >= objabi.ElfRelocOffset {
	continue
	}
	if r.Siz == 0 { // informational relocation - no work to do
	continue
	}

	// We need to be able to reference dynimport symbols when linking against
	// shared libraries, and Solaris, Darwin and AIX need it always
	if !target.IsSolaris() && !target.IsDarwin() && !target.IsAIX() && r.Sym != nil && r.Sym.Type == sym.SDYNIMPORT && !target.IsDynlinkingGo() && !r.Sym.Attr.SubSymbol() {
	if !(target.IsPPC64() && target.IsExternal() && r.Sym.Name == ".TOC.") {
	Errorf(s, "unhandled relocation for %s (type %d (%s) rtype %d (%s))", r.Sym.Name, r.Sym.Type, r.Sym.Type, r.Type, sym.RelocName(target.Arch, r.Type))
	}
	}
	if r.Sym != nil && r.Sym.Type != sym.STLSBSS && r.Type != objabi.R_WEAKADDROFF && !r.Sym.Attr.Reachable() {
	Errorf(s, "unreachable sym in relocation: %s", r.Sym.Name)
	}

	if target.IsExternal() {
	r.InitExt()
	}

	// TODO(mundaym): remove this special case - see issue 14218.
	if target.IsS390X() {
	switch r.Type {
	case objabi.R_PCRELDBL:
	r.InitExt()
	r.Type = objabi.R_PCREL
	r.Variant = sym.RV_390_DBL
	case objabi.R_CALL:
	r.InitExt()
	r.Variant = sym.RV_390_DBL
	}
	}

	var o int64
	switch r.Type {
	default:
	switch siz {
	default:
	Errorf(s, "bad reloc size %#x for %s", uint32(siz), r.Sym.Name)
	case 1:
	o = int64(s.P[off])
	case 2:
	o = int64(target.Arch.ByteOrder.Uint16(s.P[off:]))
	case 4:
	o = int64(target.Arch.ByteOrder.Uint32(s.P[off:]))
	case 8:
	o = int64(target.Arch.ByteOrder.Uint64(s.P[off:]))
	}
	if offset, ok := thearch.Archreloc(target, syms, r, s, o); ok {
	o = offset
	} else {
	Errorf(s, "unknown reloc to %v: %d (%s)", r.Sym.Name, r.Type, sym.RelocName(target.Arch, r.Type))
	}
	case objabi.R_TLS_LE:
	if target.IsExternal() && target.IsElf() {
	r.Done = false
	if r.Sym == nil {
	r.Sym = syms.Tlsg
	}
	r.Xsym = r.Sym
	r.Xadd = r.Add
	o = 0
	if !target.IsAMD64() {
	o = r.Add
	}
	break
	}

	if target.IsElf() && target.IsARM() {
	// On ELF ARM, the thread pointer is 8 bytes before
	// the start of the thread-local data block, so add 8
	// to the actual TLS offset (r->sym->value).
	// This 8 seems to be a fundamental constant of
	// ELF on ARM (or maybe Glibc on ARM); it is not
	// related to the fact that our own TLS storage happens
	// to take up 8 bytes.
	o = 8 + r.Sym.Value
	} else if target.IsElf() \|\| target.IsPlan9() \|\| target.IsDarwin() {
	o = int64(syms.Tlsoffset) + r.Add
	} else if target.IsWindows() {
	o = r.Add
	} else {
	log.Fatalf("unexpected R_TLS_LE relocation for %v", target.HeadType)
	}
	case objabi.R_TLS_IE:
	if target.IsExternal() && target.IsElf() {
	r.Done = false
	if r.Sym == nil {
	r.Sym = syms.Tlsg
	}
	r.Xsym = r.Sym
	r.Xadd = r.Add
	o = 0
	if !target.IsAMD64() {
	o = r.Add
	}
	break
	}
	if target.IsPIE() && target.IsElf() {
	// We are linking the final executable, so we
	// can optimize any TLS IE relocation to LE.
	if thearch.TLSIEtoLE == nil {
	log.Fatalf("internal linking of TLS IE not supported on %v", target.Arch.Family)
	}
	thearch.TLSIEtoLE(s.P, int(off), int(r.Siz))
	o = int64(syms.Tlsoffset)
	// TODO: o += r.Add when !target.IsAmd64()?
	// Why do we treat r.Add differently on AMD64?
	// Is the external linker using Xadd at all?
	} else {
	log.Fatalf("cannot handle R_TLS_IE (sym %s) when linking internally", s.Name)
	}
	case objabi.R_ADDR:
	if target.IsExternal() && r.Sym.Type != sym.SCONST {
	r.Done = false

	// set up addend for eventual relocation via outer symbol.
	rs := r.Sym

	r.Xadd = r.Add
	for rs.Outer != nil {
	r.Xadd += Symaddr(rs) - Symaddr(rs.Outer)
	rs = rs.Outer
	}

	if rs.Type != sym.SHOSTOBJ && rs.Type != sym.SDYNIMPORT && rs.Type != sym.SUNDEFEXT && rs.Sect == nil {
	Errorf(s, "missing section for relocation target %s", rs.Name)
	}
	r.Xsym = rs

	o = r.Xadd
	if target.IsElf() {
	if target.IsAMD64() {
	o = 0
	}
	} else if target.IsDarwin() {
	if rs.Type != sym.SHOSTOBJ {
	o += Symaddr(rs)
	}
	} else if target.IsWindows() {
	// nothing to do
	} else if target.IsAIX() {
	o = Symaddr(r.Sym) + r.Add
	} else {
	Errorf(s, "unhandled pcrel relocation to %s on %v", rs.Name, target.HeadType)
	}

	break
	}

	// On AIX, a second relocation must be done by the loader,
	// as section addresses can change once loaded.
	// The "default" symbol address is still needed by the loader so
	// the current relocation can't be skipped.
	if target.IsAIX() && r.Sym.Type != sym.SDYNIMPORT {
	// It's not possible to make a loader relocation in a
	// symbol which is not inside .data section.
	// FIXME: It should be forbidden to have R_ADDR from a
	// symbol which isn't in .data. However, as .text has the
	// same address once loaded, this is possible.
	if s.Sect.Seg == &Segdata {
	Xcoffadddynrel(target, ldr, s, r)
	}
	}

	o = Symaddr(r.Sym) + r.Add

	// On amd64, 4-byte offsets will be sign-extended, so it is impossible to
	// access more than 2GB of static data; fail at link time is better than
	// fail at runtime. See https://golang.org/issue/7980.
	// Instead of special casing only amd64, we treat this as an error on all
	// 64-bit architectures so as to be future-proof.
	if int32(o) < 0 && target.Arch.PtrSize > 4 && siz == 4 {
	Errorf(s, "non-pc-relative relocation address for %s is too big: %#x (%#x + %#x)", r.Sym.Name, uint64(o), Symaddr(r.Sym), r.Add)
	errorexit()
	}
	case objabi.R_DWARFSECREF:
	if r.Sym.Sect == nil {
	Errorf(s, "missing DWARF section for relocation target %s", r.Sym.Name)
	}

	if target.IsExternal() {
	r.Done = false

	// On most platforms, the external linker needs to adjust DWARF references
	// as it combines DWARF sections. However, on Darwin, dsymutil does the
	// DWARF linking, and it understands how to follow section offsets.
	// Leaving in the relocation records confuses it (see
	// https://golang.org/issue/22068) so drop them for Darwin.
	if target.IsDarwin() {
	r.Done = true
	}

	// PE code emits IMAGE_REL_I386_SECREL and IMAGE_REL_AMD64_SECREL
	// for R_DWARFSECREF relocations, while R_ADDR is replaced with
	// IMAGE_REL_I386_DIR32, IMAGE_REL_AMD64_ADDR64 and IMAGE_REL_AMD64_ADDR32.
	// Do not replace R_DWARFSECREF with R_ADDR for windows -
	// let PE code emit correct relocations.
	if !target.IsWindows() {
	r.Type = objabi.R_ADDR
	}

	r.Xsym = r.Sym.Sect.Sym
	r.Xadd = r.Add + Symaddr(r.Sym) - int64(r.Sym.Sect.Vaddr)

	o = r.Xadd
	if target.IsElf() && target.IsAMD64() {
	o = 0
	}
	break
	}
	o = Symaddr(r.Sym) + r.Add - int64(r.Sym.Sect.Vaddr)
	case objabi.R_WEAKADDROFF:
	if !r.Sym.Attr.Reachable() {
	continue
	}
	fallthrough
	case objabi.R_ADDROFF:
	// The method offset tables using this relocation expect the offset to be relative
	// to the start of the first text section, even if there are multiple.
	if r.Sym.Sect.Name == ".text" {
	o = Symaddr(r.Sym) - int64(Segtext.Sections[0].Vaddr) + r.Add
	} else {
	o = Symaddr(r.Sym) - int64(r.Sym.Sect.Vaddr) + r.Add
	}

	case objabi.R_ADDRCUOFF:
	// debug_range and debug_loc elements use this relocation type to get an
	// offset from the start of the compile unit.
	u := ldr.SymUnit(loader.Sym(r.Sym.SymIdx))
	o = Symaddr(r.Sym) + r.Add - Symaddr(ldr.Syms[u.Textp2[0]])

	// r->sym can be null when CALL $(constant) is transformed from absolute PC to relative PC call.
	case objabi.R_GOTPCREL:
	if target.IsDynlinkingGo() && target.IsDarwin() && r.Sym != nil && r.Sym.Type != sym.SCONST {
	r.Done = false
	r.Xadd = r.Add
	r.Xadd -= int64(r.Siz) // relative to address after the relocated chunk
	r.Xsym = r.Sym

	o = r.Xadd
	o += int64(r.Siz)
	break
	}
	fallthrough
	case objabi.R_CALL, objabi.R_PCREL:
	if target.IsExternal() && r.Sym != nil && r.Sym.Type == sym.SUNDEFEXT {
	// pass through to the external linker.
	r.Done = false
	r.Xadd = 0
	if target.IsElf() {
	r.Xadd -= int64(r.Siz)
	}
	r.Xsym = r.Sym
	o = 0
	break
	}
	if target.IsExternal() && r.Sym != nil && r.Sym.Type != sym.SCONST && (r.Sym.Sect != s.Sect \|\| r.Type == objabi.R_GOTPCREL) {
	r.Done = false

	// set up addend for eventual relocation via outer symbol.
	rs := r.Sym

	r.Xadd = r.Add
	for rs.Outer != nil {
	r.Xadd += Symaddr(rs) - Symaddr(rs.Outer)
	rs = rs.Outer
	}

	r.Xadd -= int64(r.Siz) // relative to address after the relocated chunk
	if rs.Type != sym.SHOSTOBJ && rs.Type != sym.SDYNIMPORT && rs.Sect == nil {
	Errorf(s, "missing section for relocation target %s", rs.Name)
	}
	r.Xsym = rs

	o = r.Xadd
	if target.IsElf() {
	if target.IsAMD64() {
	o = 0
	}
	} else if target.IsDarwin() {
	if r.Type == objabi.R_CALL {
	if target.IsExternal() && rs.Type == sym.SDYNIMPORT {
	if target.IsAMD64() {
	// AMD64 dynamic relocations are relative to the end of the relocation.
	o += int64(r.Siz)
	}
	} else {
	if rs.Type != sym.SHOSTOBJ {
	o += int64(uint64(Symaddr(rs)) - rs.Sect.Vaddr)
	}
	o -= int64(r.Off) // relative to section offset, not symbol
	}
	} else {
	o += int64(r.Siz)
	}
	} else if target.IsWindows() && target.IsAMD64() { // only amd64 needs PCREL
	// PE/COFF's PC32 relocation uses the address after the relocated
	// bytes as the base. Compensate by skewing the addend.
	o += int64(r.Siz)
	} else {
	Errorf(s, "unhandled pcrel relocation to %s on %v", rs.Name, target.HeadType)
	}

	break
	}

	o = 0
	if r.Sym != nil {
	o += Symaddr(r.Sym)
	}

	o += r.Add - (s.Value + int64(r.Off) + int64(r.Siz))
	case objabi.R_SIZE:
	o = r.Sym.Size + r.Add

	case objabi.R_XCOFFREF:
	if !target.IsAIX() {
	Errorf(s, "find XCOFF R_REF on non-XCOFF files")
	}
	if !target.IsExternal() {
	Errorf(s, "find XCOFF R_REF with internal linking")
	}
	r.Xsym = r.Sym
	r.Xadd = r.Add
	r.Done = false

	// This isn't a real relocation so it must not update
	// its offset value.
	continue

	case objabi.R_DWARFFILEREF:
	// The final file index is saved in r.Add in dwarf.go:writelines.
	o = r.Add
	}

	if target.IsPPC64() \|\| target.IsS390X() {
	r.InitExt()
	if r.Variant != sym.RV_NONE {
	o = thearch.Archrelocvariant(target, syms, r, s, o)
	}
	}

	if false {
	nam := "<nil>"
	var addr int64
	if r.Sym != nil {
	nam = r.Sym.Name
	addr = Symaddr(r.Sym)
	}
	xnam := "<nil>"
	if r.Xsym != nil {
	xnam = r.Xsym.Name
	}
	fmt.Printf("relocate %s %#x (%#x+%#x, size %d) => %s %#x +%#x (xsym: %s +%#x) [type %d (%s)/%d, %x]\n", s.Name, s.Value+int64(off), s.Value, r.Off, r.Siz, nam, addr, r.Add, xnam, r.Xadd, r.Type, sym.RelocName(target.Arch, r.Type), r.Variant, o)
	}
	switch siz {
	default:
	Errorf(s, "bad reloc size %#x for %s", uint32(siz), r.Sym.Name)
	fallthrough

	// TODO(rsc): Remove.
	case 1:
	s.P[off] = byte(int8(o))
	case 2:
	if o != int64(int16(o)) {
	Errorf(s, "relocation address for %s is too big: %#x", r.Sym.Name, o)
	}
	i16 := int16(o)
	target.Arch.ByteOrder.PutUint16(s.P[off:], uint16(i16))
	case 4:
	if r.Type == objabi.R_PCREL \|\| r.Type == objabi.R_CALL {
	if o != int64(int32(o)) {
	Errorf(s, "pc-relative relocation address for %s is too big: %#x", r.Sym.Name, o)
	}
	} else {
	if o != int64(int32(o)) && o != int64(uint32(o)) {
	Errorf(s, "non-pc-relative relocation address for %s is too big: %#x", r.Sym.Name, uint64(o))
	}
	}

	fl := int32(o)
	target.Arch.ByteOrder.PutUint32(s.P[off:], uint32(fl))
	case 8:
	target.Arch.ByteOrder.PutUint64(s.P[off:], uint64(o))
	}
	}
	}

	func (ctxt *Link) reloc2() {
	var wg sync.WaitGroup
	target := &ctxt.Target
	ldr := ctxt.loader
	reporter := &ctxt.ErrorReporter
	syms := &ctxt.ArchSyms
	wg.Add(3)
	go func() {
	if !ctxt.IsWasm() { // On Wasm, text relocations are applied in Asmb2.
	for _, s := range ctxt.Textp {
	relocsym2(target, ldr, reporter, syms, s)
	}
	}
	wg.Done()
	}()
	go func() {
	for _, s := range ctxt.datap {
	relocsym2(target, ldr, reporter, syms, s)
	}
	wg.Done()
	}()
	go func() {
	for _, si := range dwarfp {
	for _, s := range si.syms {
	relocsym2(target, ldr, reporter, syms, s)
	}
	}
	wg.Done()
	}()
	wg.Wait()
	}