2015-02-27 22:57:28 -05:00
|
|
|
// Inferno utils/5l/asm.c
|
2016-08-28 17:04:46 -07:00
|
|
|
// https://bitbucket.org/inferno-os/inferno-os/src/default/utils/5l/asm.c
|
2015-02-27 22:57:28 -05:00
|
|
|
//
|
|
|
|
|
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
|
|
|
|
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
|
|
|
|
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
|
|
|
|
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
|
|
|
|
// Portions Copyright © 2004,2006 Bruce Ellis
|
|
|
|
|
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
|
|
|
|
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
2016-04-10 14:32:26 -07:00
|
|
|
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
2015-02-27 22:57:28 -05:00
|
|
|
//
|
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
|
|
|
// in the Software without restriction, including without limitation the rights
|
|
|
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
|
|
|
// furnished to do so, subject to the following conditions:
|
|
|
|
|
//
|
|
|
|
|
// The above copyright notice and this permission notice shall be included in
|
|
|
|
|
// all copies or substantial portions of the Software.
|
|
|
|
|
//
|
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
|
// THE SOFTWARE.
|
|
|
|
|
|
2015-05-21 13:28:10 -04:00
|
|
|
package ppc64
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
import (
|
2017-04-18 12:53:25 -07:00
|
|
|
"cmd/internal/objabi"
|
2017-09-30 21:10:49 +00:00
|
|
|
"cmd/internal/sys"
|
2015-05-21 13:28:10 -04:00
|
|
|
"cmd/link/internal/ld"
|
2015-03-01 22:02:13 -05:00
|
|
|
"encoding/binary"
|
2015-02-27 22:57:28 -05:00
|
|
|
"fmt"
|
|
|
|
|
"log"
|
|
|
|
|
)
|
|
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
func genplt(ctxt *ld.Link) {
|
2015-02-27 22:57:28 -05:00
|
|
|
// The ppc64 ABI PLT has similar concepts to other
|
2016-03-01 23:21:55 +00:00
|
|
|
// architectures, but is laid out quite differently. When we
|
2015-02-27 22:57:28 -05:00
|
|
|
// see an R_PPC64_REL24 relocation to a dynamic symbol
|
|
|
|
|
// (indicating that the call needs to go through the PLT), we
|
|
|
|
|
// generate up to three stubs and reserve a PLT slot.
|
|
|
|
|
//
|
|
|
|
|
// 1) The call site will be bl x; nop (where the relocation
|
|
|
|
|
// applies to the bl). We rewrite this to bl x_stub; ld
|
|
|
|
|
// r2,24(r1). The ld is necessary because x_stub will save
|
|
|
|
|
// r2 (the TOC pointer) at 24(r1) (the "TOC save slot").
|
|
|
|
|
//
|
|
|
|
|
// 2) We reserve space for a pointer in the .plt section (once
|
|
|
|
|
// per referenced dynamic function). .plt is a data
|
|
|
|
|
// section filled solely by the dynamic linker (more like
|
|
|
|
|
// .plt.got on other architectures). Initially, the
|
|
|
|
|
// dynamic linker will fill each slot with a pointer to the
|
|
|
|
|
// corresponding x@plt entry point.
|
|
|
|
|
//
|
|
|
|
|
// 3) We generate the "call stub" x_stub (once per dynamic
|
|
|
|
|
// function/object file pair). This saves the TOC in the
|
|
|
|
|
// TOC save slot, reads the function pointer from x's .plt
|
|
|
|
|
// slot and calls it like any other global entry point
|
|
|
|
|
// (including setting r12 to the function address).
|
|
|
|
|
//
|
|
|
|
|
// 4) We generate the "symbol resolver stub" x@plt (once per
|
|
|
|
|
// dynamic function). This is solely a branch to the glink
|
|
|
|
|
// resolver stub.
|
|
|
|
|
//
|
|
|
|
|
// 5) We generate the glink resolver stub (only once). This
|
|
|
|
|
// computes which symbol resolver stub we came through and
|
|
|
|
|
// invokes the dynamic resolver via a pointer provided by
|
2016-03-01 23:21:55 +00:00
|
|
|
// the dynamic linker. This will patch up the .plt slot to
|
2015-02-27 22:57:28 -05:00
|
|
|
// point directly at the function so future calls go
|
|
|
|
|
// straight from the call stub to the real function, and
|
|
|
|
|
// then call the function.
|
|
|
|
|
|
|
|
|
|
// NOTE: It's possible we could make ppc64 closer to other
|
|
|
|
|
// architectures: ppc64's .plt is like .plt.got on other
|
|
|
|
|
// platforms and ppc64's .glink is like .plt on other
|
|
|
|
|
// platforms.
|
|
|
|
|
|
|
|
|
|
// Find all R_PPC64_REL24 relocations that reference dynamic
|
2016-03-01 23:21:55 +00:00
|
|
|
// imports. Reserve PLT entries for these symbols and
|
|
|
|
|
// generate call stubs. The call stubs need to live in .text,
|
2015-02-27 22:57:28 -05:00
|
|
|
// which is why we need to do this pass this early.
|
|
|
|
|
//
|
|
|
|
|
// This assumes "case 1" from the ABI, where the caller needs
|
|
|
|
|
// us to save and restore the TOC pointer.
|
2017-03-13 08:24:46 -04:00
|
|
|
var stubs []*ld.Symbol
|
2016-08-21 13:52:23 -04:00
|
|
|
for _, s := range ctxt.Textp {
|
2016-04-20 14:40:18 -04:00
|
|
|
for i := range s.R {
|
|
|
|
|
r := &s.R[i]
|
2017-04-19 15:15:35 +12:00
|
|
|
if r.Type != 256+ld.R_PPC64_REL24 || r.Sym.Type != ld.SDYNIMPORT {
|
2015-02-27 22:57:28 -05:00
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reserve PLT entry and generate symbol
|
|
|
|
|
// resolver
|
2016-08-21 13:52:23 -04:00
|
|
|
addpltsym(ctxt, r.Sym)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Generate call stub
|
2016-04-20 14:40:18 -04:00
|
|
|
n := fmt.Sprintf("%s.%s", s.Name, r.Sym.Name)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
stub := ctxt.Syms.Lookup(n, 0)
|
2016-03-02 07:59:49 -05:00
|
|
|
if s.Attr.Reachable() {
|
|
|
|
|
stub.Attr |= ld.AttrReachable
|
|
|
|
|
}
|
2015-02-27 22:57:28 -05:00
|
|
|
if stub.Size == 0 {
|
|
|
|
|
// Need outer to resolve .TOC.
|
|
|
|
|
stub.Outer = s
|
2017-03-13 08:24:46 -04:00
|
|
|
stubs = append(stubs, stub)
|
2016-08-21 13:52:23 -04:00
|
|
|
gencallstub(ctxt, 1, stub, r.Sym)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Update the relocation to use the call stub
|
|
|
|
|
r.Sym = stub
|
|
|
|
|
|
2016-03-01 23:21:55 +00:00
|
|
|
// Restore TOC after bl. The compiler put a
|
2015-02-27 22:57:28 -05:00
|
|
|
// nop here for us to overwrite.
|
2016-04-20 14:40:18 -04:00
|
|
|
const o1 = 0xe8410018 // ld r2,24(r1)
|
2016-08-21 13:52:23 -04:00
|
|
|
ctxt.Arch.ByteOrder.PutUint32(s.P[r.Off+4:], o1)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
}
|
2017-03-13 08:24:46 -04:00
|
|
|
// Put call stubs at the beginning (instead of the end).
|
|
|
|
|
// So when resolving the relocations to calls to the stubs,
|
|
|
|
|
// the addresses are known and trampolines can be inserted
|
|
|
|
|
// when necessary.
|
|
|
|
|
ctxt.Textp = append(stubs, ctxt.Textp...)
|
2015-10-16 21:22:20 +13:00
|
|
|
}
|
|
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
func genaddmoduledata(ctxt *ld.Link) {
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
addmoduledata := ctxt.Syms.ROLookup("runtime.addmoduledata", 0)
|
2017-08-15 14:34:53 -04:00
|
|
|
if addmoduledata.Type == ld.STEXT && ld.Buildmode != ld.BuildmodePlugin {
|
2015-10-16 21:22:20 +13:00
|
|
|
return
|
|
|
|
|
}
|
2016-03-02 07:59:49 -05:00
|
|
|
addmoduledata.Attr |= ld.AttrReachable
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
|
2017-04-19 15:15:35 +12:00
|
|
|
initfunc.Type = ld.STEXT
|
2016-03-02 07:59:49 -05:00
|
|
|
initfunc.Attr |= ld.AttrLocal
|
|
|
|
|
initfunc.Attr |= ld.AttrReachable
|
2015-10-16 21:22:20 +13:00
|
|
|
o := func(op uint32) {
|
2017-09-30 15:06:44 +00:00
|
|
|
initfunc.AddUint32(ctxt.Arch, op)
|
2015-10-16 21:22:20 +13:00
|
|
|
}
|
|
|
|
|
// addis r2, r12, .TOC.-func@ha
|
2017-09-30 15:06:44 +00:00
|
|
|
rel := initfunc.AddRel()
|
2015-10-16 21:22:20 +13:00
|
|
|
rel.Off = int32(initfunc.Size)
|
|
|
|
|
rel.Siz = 8
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
rel.Sym = ctxt.Syms.Lookup(".TOC.", 0)
|
2017-08-15 14:34:53 -04:00
|
|
|
rel.Sym.Attr |= ld.AttrReachable
|
2017-04-18 12:53:25 -07:00
|
|
|
rel.Type = objabi.R_ADDRPOWER_PCREL
|
2015-10-16 21:22:20 +13:00
|
|
|
o(0x3c4c0000)
|
|
|
|
|
// addi r2, r2, .TOC.-func@l
|
|
|
|
|
o(0x38420000)
|
|
|
|
|
// mflr r31
|
|
|
|
|
o(0x7c0802a6)
|
|
|
|
|
// stdu r31, -32(r1)
|
|
|
|
|
o(0xf801ffe1)
|
|
|
|
|
// addis r3, r2, local.moduledata@got@ha
|
2017-09-30 15:06:44 +00:00
|
|
|
rel = initfunc.AddRel()
|
2015-10-16 21:22:20 +13:00
|
|
|
rel.Off = int32(initfunc.Size)
|
|
|
|
|
rel.Siz = 8
|
2017-08-15 14:34:53 -04:00
|
|
|
if !ctxt.CanUsePlugins() {
|
|
|
|
|
rel.Sym = ctxt.Syms.Lookup("local.moduledata", 0)
|
|
|
|
|
} else {
|
|
|
|
|
rel.Sym = ctxt.Syms.Lookup("runtime.firstmoduledata", 0)
|
|
|
|
|
}
|
|
|
|
|
rel.Sym.Attr |= ld.AttrReachable
|
|
|
|
|
rel.Sym.Attr |= ld.AttrLocal
|
2017-04-18 12:53:25 -07:00
|
|
|
rel.Type = objabi.R_ADDRPOWER_GOT
|
2015-10-16 21:22:20 +13:00
|
|
|
o(0x3c620000)
|
|
|
|
|
// ld r3, local.moduledata@got@l(r3)
|
|
|
|
|
o(0xe8630000)
|
|
|
|
|
// bl runtime.addmoduledata
|
2017-09-30 15:06:44 +00:00
|
|
|
rel = initfunc.AddRel()
|
2015-10-16 21:22:20 +13:00
|
|
|
rel.Off = int32(initfunc.Size)
|
|
|
|
|
rel.Siz = 4
|
|
|
|
|
rel.Sym = addmoduledata
|
2017-04-18 12:53:25 -07:00
|
|
|
rel.Type = objabi.R_CALLPOWER
|
2015-10-16 21:22:20 +13:00
|
|
|
o(0x48000001)
|
|
|
|
|
// nop
|
|
|
|
|
o(0x60000000)
|
|
|
|
|
// ld r31, 0(r1)
|
|
|
|
|
o(0xe8010000)
|
|
|
|
|
// mtlr r31
|
|
|
|
|
o(0x7c0803a6)
|
|
|
|
|
// addi r1,r1,32
|
|
|
|
|
o(0x38210020)
|
|
|
|
|
// blr
|
|
|
|
|
o(0x4e800020)
|
|
|
|
|
|
2017-08-15 14:34:53 -04:00
|
|
|
if ld.Buildmode == ld.BuildmodePlugin {
|
|
|
|
|
ctxt.Textp = append(ctxt.Textp, addmoduledata)
|
|
|
|
|
}
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
|
2016-10-11 09:26:40 -05:00
|
|
|
ctxt.Textp = append(ctxt.Textp, initfunc)
|
2016-03-02 07:59:49 -05:00
|
|
|
initarray_entry.Attr |= ld.AttrReachable
|
|
|
|
|
initarray_entry.Attr |= ld.AttrLocal
|
2017-04-19 15:15:35 +12:00
|
|
|
initarray_entry.Type = ld.SINITARR
|
2017-09-30 15:06:44 +00:00
|
|
|
initarray_entry.AddAddr(ctxt.Arch, initfunc)
|
2015-10-16 21:22:20 +13:00
|
|
|
}
|
|
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
func gentext(ctxt *ld.Link) {
|
2016-08-25 21:06:10 -04:00
|
|
|
if ctxt.DynlinkingGo() {
|
2016-08-21 13:52:23 -04:00
|
|
|
genaddmoduledata(ctxt)
|
2015-10-16 21:22:20 +13:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ld.Linkmode == ld.LinkInternal {
|
2016-08-21 13:52:23 -04:00
|
|
|
genplt(ctxt)
|
2015-10-16 21:22:20 +13:00
|
|
|
}
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Construct a call stub in stub that calls symbol targ via its PLT
|
|
|
|
|
// entry.
|
2016-08-21 13:52:23 -04:00
|
|
|
func gencallstub(ctxt *ld.Link, abicase int, stub *ld.Symbol, targ *ld.Symbol) {
|
2015-02-27 22:57:28 -05:00
|
|
|
if abicase != 1 {
|
|
|
|
|
// If we see R_PPC64_TOCSAVE or R_PPC64_REL24_NOTOC
|
|
|
|
|
// relocations, we'll need to implement cases 2 and 3.
|
|
|
|
|
log.Fatalf("gencallstub only implements case 1 calls")
|
|
|
|
|
}
|
|
|
|
|
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
plt := ctxt.Syms.Lookup(".plt", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2017-04-19 15:15:35 +12:00
|
|
|
stub.Type = ld.STEXT
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Save TOC pointer in TOC save slot
|
2017-09-30 15:06:44 +00:00
|
|
|
stub.AddUint32(ctxt.Arch, 0xf8410018) // std r2,24(r1)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Load the function pointer from the PLT.
|
2017-09-30 15:06:44 +00:00
|
|
|
r := stub.AddRel()
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
r.Off = int32(stub.Size)
|
|
|
|
|
r.Sym = plt
|
|
|
|
|
r.Add = int64(targ.Plt)
|
|
|
|
|
r.Siz = 2
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Off += int32(r.Siz)
|
|
|
|
|
}
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_HA
|
2017-09-30 15:06:44 +00:00
|
|
|
stub.AddUint32(ctxt.Arch, 0x3d820000) // addis r12,r2,targ@plt@toc@ha
|
|
|
|
|
r = stub.AddRel()
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Off = int32(stub.Size)
|
|
|
|
|
r.Sym = plt
|
|
|
|
|
r.Add = int64(targ.Plt)
|
|
|
|
|
r.Siz = 2
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Off += int32(r.Siz)
|
|
|
|
|
}
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_LO
|
2017-09-30 15:06:44 +00:00
|
|
|
stub.AddUint32(ctxt.Arch, 0xe98c0000) // ld r12,targ@plt@toc@l(r12)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Jump to the loaded pointer
|
2017-09-30 15:06:44 +00:00
|
|
|
stub.AddUint32(ctxt.Arch, 0x7d8903a6) // mtctr r12
|
|
|
|
|
stub.AddUint32(ctxt.Arch, 0x4e800420) // bctr
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2016-09-05 23:49:53 -04:00
|
|
|
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) bool {
|
2015-03-02 12:35:15 -05:00
|
|
|
targ := r.Sym
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
switch r.Type {
|
|
|
|
|
default:
|
|
|
|
|
if r.Type >= 256 {
|
2017-09-30 21:10:49 +00:00
|
|
|
ld.Errorf(s, "unexpected relocation type %d (%s)", r.Type, ld.RelocName(ctxt.Arch, r.Type))
|
2016-09-05 23:49:53 -04:00
|
|
|
return false
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Handle relocations found in ELF object files.
|
|
|
|
|
case 256 + ld.R_PPC64_REL24:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_CALLPOWER
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// This is a local call, so the caller isn't setting
|
|
|
|
|
// up r12 and r2 is the same for the caller and
|
2016-03-01 23:21:55 +00:00
|
|
|
// callee. Hence, we need to go to the local entry
|
2015-02-27 22:57:28 -05:00
|
|
|
// point. (If we don't do this, the callee will try
|
|
|
|
|
// to use r12 to compute r2.)
|
|
|
|
|
r.Add += int64(r.Sym.Localentry) * 4
|
|
|
|
|
|
2017-04-19 15:15:35 +12:00
|
|
|
if targ.Type == ld.SDYNIMPORT {
|
2015-02-27 22:57:28 -05:00
|
|
|
// Should have been handled in elfsetupplt
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "unexpected R_PPC64_REL24 for dyn import")
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2015-11-23 12:55:37 -08:00
|
|
|
case 256 + ld.R_PPC_REL32:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_PCREL
|
2015-11-23 12:55:37 -08:00
|
|
|
r.Add += 4
|
|
|
|
|
|
2017-04-19 15:15:35 +12:00
|
|
|
if targ.Type == ld.SDYNIMPORT {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "unexpected R_PPC_REL32 for dyn import")
|
2015-11-23 12:55:37 -08:00
|
|
|
}
|
|
|
|
|
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-11-23 12:55:37 -08:00
|
|
|
|
2015-02-27 22:57:28 -05:00
|
|
|
case 256 + ld.R_PPC64_ADDR64:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_ADDR
|
2017-04-19 15:15:35 +12:00
|
|
|
if targ.Type == ld.SDYNIMPORT {
|
2015-02-27 22:57:28 -05:00
|
|
|
// These happen in .toc sections
|
2016-08-21 13:52:23 -04:00
|
|
|
ld.Adddynsym(ctxt, targ)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
rela := ctxt.Syms.Lookup(".rela", 0)
|
2017-09-30 15:06:44 +00:00
|
|
|
rela.AddAddrPlus(ctxt.Arch, s, int64(r.Off))
|
|
|
|
|
rela.AddUint64(ctxt.Arch, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_PPC64_ADDR64))
|
|
|
|
|
rela.AddUint64(ctxt.Arch, uint64(r.Add))
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Type = 256 // ignore during relocsym
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_TOC16:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_LO | ld.RV_CHECK_OVERFLOW
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_TOC16_LO:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_LO
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_TOC16_HA:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_HA | ld.RV_CHECK_OVERFLOW
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_TOC16_HI:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_HI | ld.RV_CHECK_OVERFLOW
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_TOC16_DS:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_DS | ld.RV_CHECK_OVERFLOW
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_TOC16_LO_DS:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_POWER_TOC
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_DS
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_REL16_LO:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_PCREL
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_LO
|
|
|
|
|
r.Add += 2 // Compensate for relocation size of 2
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_REL16_HI:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_PCREL
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_HI | ld.RV_CHECK_OVERFLOW
|
|
|
|
|
r.Add += 2
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
case 256 + ld.R_PPC64_REL16_HA:
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_PCREL
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Variant = ld.RV_POWER_HA | ld.RV_CHECK_OVERFLOW
|
|
|
|
|
r.Add += 2
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Handle references to ELF symbols from our own object files.
|
2017-04-19 15:15:35 +12:00
|
|
|
if targ.Type != ld.SDYNIMPORT {
|
2016-09-05 23:49:53 -04:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO(austin): Translate our relocations to ELF
|
|
|
|
|
|
2016-09-05 23:49:53 -04:00
|
|
|
return false
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
func elfreloc1(ctxt *ld.Link, r *ld.Reloc, sectoff int64) bool {
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(uint64(sectoff))
|
2015-09-04 08:30:15 +12:00
|
|
|
|
|
|
|
|
elfsym := r.Xsym.ElfsymForReloc()
|
|
|
|
|
switch r.Type {
|
|
|
|
|
default:
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDR:
|
2015-09-04 08:30:15 +12:00
|
|
|
switch r.Siz {
|
|
|
|
|
case 4:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_ADDR32 | uint64(elfsym)<<32)
|
2015-09-04 08:30:15 +12:00
|
|
|
case 8:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_ADDR64 | uint64(elfsym)<<32)
|
2015-09-04 08:30:15 +12:00
|
|
|
default:
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2015-09-04 08:30:15 +12:00
|
|
|
}
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_POWER_TLS:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_TLS | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_POWER_TLS_LE:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_TPREL16 | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_POWER_TLS_IE:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_GOT_TPREL16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_GOT_TPREL16_LO_DS | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_ADDR16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_ADDR16_LO | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER_DS:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_ADDR16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_ADDR16_LO_DS | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER_GOT:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_GOT16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_GOT16_LO_DS | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER_PCREL:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_REL16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_REL16_LO | uint64(elfsym)<<32)
|
cmd/compile, cmd/link, runtime: on ppc64x, maintain the TOC pointer in R2 when compiling PIC
The PowerPC ISA does not have a PC-relative load instruction, which poses
obvious challenges when generating position-independent code. The way the ELFv2
ABI addresses this is to specify that r2 points to a per "module" (shared
library or executable) TOC pointer. Maintaining this pointer requires
cooperation between codegen and the system linker:
* Non-leaf functions leave space on the stack at r1+24 to save the TOC pointer.
* A call to a function that *might* have to go via a PLT stub must be followed
by a nop instruction that the system linker can replace with "ld r1, 24(r1)"
to restore the TOC pointer (only when dynamically linking Go code).
* When calling a function via a function pointer, the address of the function
must be in r12, and the first couple of instructions (the "global entry
point") of the called function use this to derive the address of the TOC
for the module it is in.
* When calling a function that is implemented in the same module, the system
linker adjusts the call to skip over the instructions mentioned above (the
"local entry point"), assuming that r2 is already correctly set.
So this changeset adds the global entry point instructions, sets the metadata so
the system linker knows where the local entry point is, inserts code to save the
TOC pointer at 24(r1), adds a nop after any call not known to be local and copes
with the odd non-local code transfer in the runtime (e.g. the stuff around
jmpdefer). It does not actually compile PIC yet.
Change-Id: I7522e22bdfd2f891745a900c60254fe9e372c854
Reviewed-on: https://go-review.googlesource.com/15967
Reviewed-by: Russ Cox <rsc@golang.org>
2015-10-16 15:42:09 +13:00
|
|
|
r.Xadd += 4
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER_TOCREL:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_TOC16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_TOC16_LO | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER_TOCREL_DS:
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_TOC16_HA | uint64(elfsym)<<32)
|
|
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
|
|
|
|
ctxt.Out.Write64(uint64(sectoff + 4))
|
|
|
|
|
ctxt.Out.Write64(ld.R_PPC64_TOC16_LO_DS | uint64(elfsym)<<32)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_CALLPOWER:
|
2015-09-04 08:30:15 +12:00
|
|
|
if r.Siz != 4 {
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2015-09-04 08:30:15 +12:00
|
|
|
}
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(ld.R_PPC64_REL24 | uint64(elfsym)<<32)
|
2015-09-04 08:30:15 +12:00
|
|
|
|
|
|
|
|
}
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write64(uint64(r.Xadd))
|
2015-09-04 08:30:15 +12:00
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
func elfsetupplt(ctxt *ld.Link) {
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
plt := ctxt.Syms.Lookup(".plt", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
if plt.Size == 0 {
|
|
|
|
|
// The dynamic linker stores the address of the
|
|
|
|
|
// dynamic resolver and the DSO identifier in the two
|
|
|
|
|
// doublewords at the beginning of the .plt section
|
2016-03-01 23:21:55 +00:00
|
|
|
// before the PLT array. Reserve space for these.
|
2015-02-27 22:57:28 -05:00
|
|
|
plt.Size = 16
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-01 02:37:20 +00:00
|
|
|
func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *ld.Symbol, r *ld.Reloc, sectoff int64) bool {
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Return the value of .TOC. for symbol s
|
2016-08-21 13:52:23 -04:00
|
|
|
func symtoc(ctxt *ld.Link, s *ld.Symbol) int64 {
|
2016-08-19 11:35:54 -04:00
|
|
|
var toc *ld.Symbol
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
if s.Outer != nil {
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
toc = ctxt.Syms.ROLookup(".TOC.", int(s.Outer.Version))
|
2015-02-27 22:57:28 -05:00
|
|
|
} else {
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
toc = ctxt.Syms.ROLookup(".TOC.", int(s.Version))
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if toc == nil {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "TOC-relative relocation in object without .TOC.")
|
2015-02-27 22:57:28 -05:00
|
|
|
return 0
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return toc.Value
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
func archrelocaddr(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, val *int64) bool {
|
2015-09-08 15:21:58 +12:00
|
|
|
var o1, o2 uint32
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-09-08 15:21:58 +12:00
|
|
|
o1 = uint32(*val >> 32)
|
|
|
|
|
o2 = uint32(*val)
|
|
|
|
|
} else {
|
|
|
|
|
o1 = uint32(*val)
|
|
|
|
|
o2 = uint32(*val >> 32)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// We are spreading a 31-bit address across two instructions, putting the
|
|
|
|
|
// high (adjusted) part in the low 16 bits of the first instruction and the
|
|
|
|
|
// low part in the low 16 bits of the second instruction, or, in the DS case,
|
|
|
|
|
// bits 15-2 (inclusive) of the address into bits 15-2 of the second
|
|
|
|
|
// instruction (it is an error in this case if the low 2 bits of the address
|
|
|
|
|
// are non-zero).
|
|
|
|
|
|
2016-09-17 09:39:33 -04:00
|
|
|
t := ld.Symaddr(r.Sym) + r.Add
|
2015-09-08 15:21:58 +12:00
|
|
|
if t < 0 || t >= 1<<31 {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "relocation for %s is too big (>=2G): %d", s.Name, ld.Symaddr(r.Sym))
|
2015-09-08 15:21:58 +12:00
|
|
|
}
|
|
|
|
|
if t&0x8000 != 0 {
|
|
|
|
|
t += 0x10000
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch r.Type {
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER:
|
2015-09-08 15:21:58 +12:00
|
|
|
o1 |= (uint32(t) >> 16) & 0xffff
|
|
|
|
|
o2 |= uint32(t) & 0xffff
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER_DS:
|
2015-09-08 15:21:58 +12:00
|
|
|
o1 |= (uint32(t) >> 16) & 0xffff
|
|
|
|
|
if t&3 != 0 {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "bad DS reloc for %s: %d", s.Name, ld.Symaddr(r.Sym))
|
2015-09-08 15:21:58 +12:00
|
|
|
}
|
|
|
|
|
o2 |= uint32(t) & 0xfffc
|
|
|
|
|
default:
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2015-09-08 15:21:58 +12:00
|
|
|
}
|
|
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-09-08 15:21:58 +12:00
|
|
|
*val = int64(o1)<<32 | int64(o2)
|
|
|
|
|
} else {
|
|
|
|
|
*val = int64(o2)<<32 | int64(o1)
|
|
|
|
|
}
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2015-09-08 15:21:58 +12:00
|
|
|
}
|
|
|
|
|
|
2016-10-11 09:26:40 -05:00
|
|
|
// resolve direct jump relocation r in s, and add trampoline if necessary
|
|
|
|
|
func trampoline(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol) {
|
|
|
|
|
|
2017-06-08 08:26:19 -04:00
|
|
|
// Trampolines are created if the branch offset is too large and the linker cannot insert a call stub to handle it.
|
|
|
|
|
// For internal linking, trampolines are always created for long calls.
|
|
|
|
|
// For external linking, the linker can insert a call stub to handle a long call, but depends on having the TOC address in
|
|
|
|
|
// r2. For those build modes with external linking where the TOC address is not maintained in r2, trampolines must be created.
|
|
|
|
|
if ld.Linkmode == ld.LinkExternal && (ctxt.DynlinkingGo() || ld.Buildmode == ld.BuildmodeCArchive || ld.Buildmode == ld.BuildmodeCShared || ld.Buildmode == ld.BuildmodePIE) {
|
|
|
|
|
// No trampolines needed since r2 contains the TOC
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-11 09:26:40 -05:00
|
|
|
t := ld.Symaddr(r.Sym) + r.Add - (s.Value + int64(r.Off))
|
|
|
|
|
switch r.Type {
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_CALLPOWER:
|
2016-10-11 09:26:40 -05:00
|
|
|
|
|
|
|
|
// If branch offset is too far then create a trampoline.
|
|
|
|
|
|
2017-06-08 08:26:19 -04:00
|
|
|
if (ld.Linkmode == ld.LinkExternal && s.Sect != r.Sym.Sect) || (ld.Linkmode == ld.LinkInternal && int64(int32(t<<6)>>6) != t) || (*ld.FlagDebugTramp > 1 && s.File != r.Sym.File) {
|
2016-10-11 09:26:40 -05:00
|
|
|
var tramp *ld.Symbol
|
|
|
|
|
for i := 0; ; i++ {
|
|
|
|
|
|
|
|
|
|
// Using r.Add as part of the name is significant in functions like duffzero where the call
|
|
|
|
|
// target is at some offset within the function. Calls to duff+8 and duff+256 must appear as
|
|
|
|
|
// distinct trampolines.
|
|
|
|
|
|
|
|
|
|
name := r.Sym.Name
|
|
|
|
|
if r.Add == 0 {
|
|
|
|
|
name = name + fmt.Sprintf("-tramp%d", i)
|
|
|
|
|
} else {
|
|
|
|
|
name = name + fmt.Sprintf("%+x-tramp%d", r.Add, i)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Look up the trampoline in case it already exists
|
|
|
|
|
|
|
|
|
|
tramp = ctxt.Syms.Lookup(name, int(r.Sym.Version))
|
|
|
|
|
if tramp.Value == 0 {
|
|
|
|
|
break
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
t = ld.Symaddr(tramp) + r.Add - (s.Value + int64(r.Off))
|
|
|
|
|
|
2017-06-08 08:26:19 -04:00
|
|
|
// With internal linking, the trampoline can be used if it is not too far.
|
|
|
|
|
// With external linking, the trampoline must be in this section for it to be reused.
|
|
|
|
|
if (ld.Linkmode == ld.LinkInternal && int64(int32(t<<6)>>6) == t) || (ld.Linkmode == ld.LinkExternal && s.Sect == tramp.Sect) {
|
2016-10-11 09:26:40 -05:00
|
|
|
break
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if tramp.Type == 0 {
|
2017-06-08 08:26:19 -04:00
|
|
|
if ctxt.DynlinkingGo() || ld.Buildmode == ld.BuildmodeCArchive || ld.Buildmode == ld.BuildmodeCShared || ld.Buildmode == ld.BuildmodePIE {
|
|
|
|
|
// Should have returned for above cases
|
|
|
|
|
ld.Errorf(s, "unexpected trampoline for shared or dynamic linking\n")
|
|
|
|
|
} else {
|
|
|
|
|
ctxt.AddTramp(tramp)
|
2017-09-30 21:10:49 +00:00
|
|
|
gentramp(ctxt.Arch, tramp, r.Sym, int64(r.Add))
|
2017-06-08 08:26:19 -04:00
|
|
|
}
|
2016-10-11 09:26:40 -05:00
|
|
|
}
|
|
|
|
|
r.Sym = tramp
|
|
|
|
|
r.Add = 0 // This was folded into the trampoline target address
|
2017-08-27 22:00:00 +09:00
|
|
|
r.Done = false
|
2016-10-11 09:26:40 -05:00
|
|
|
}
|
|
|
|
|
default:
|
2017-09-30 21:10:49 +00:00
|
|
|
ld.Errorf(s, "trampoline called with non-jump reloc: %d (%s)", r.Type, ld.RelocName(ctxt.Arch, r.Type))
|
2016-10-11 09:26:40 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-30 21:10:49 +00:00
|
|
|
func gentramp(arch *sys.Arch, tramp, target *ld.Symbol, offset int64) {
|
2017-06-08 08:26:19 -04:00
|
|
|
// Used for default build mode for an executable
|
|
|
|
|
// Address of the call target is generated using
|
|
|
|
|
// relocation and doesn't depend on r2 (TOC).
|
|
|
|
|
tramp.Size = 16 // 4 instructions
|
|
|
|
|
tramp.P = make([]byte, tramp.Size)
|
|
|
|
|
t := ld.Symaddr(target) + offset
|
|
|
|
|
o1 := uint32(0x3fe00000) // lis r31,targetaddr hi
|
|
|
|
|
o2 := uint32(0x3bff0000) // addi r31,targetaddr lo
|
|
|
|
|
// With external linking, the target address must be
|
|
|
|
|
// relocated using LO and HA
|
|
|
|
|
if ld.Linkmode == ld.LinkExternal {
|
2017-09-30 15:06:44 +00:00
|
|
|
tr := tramp.AddRel()
|
2017-06-08 08:26:19 -04:00
|
|
|
tr.Off = 0
|
|
|
|
|
tr.Type = objabi.R_ADDRPOWER
|
|
|
|
|
tr.Siz = 8 // generates 2 relocations: HA + LO
|
|
|
|
|
tr.Sym = target
|
|
|
|
|
tr.Add = offset
|
|
|
|
|
} else {
|
|
|
|
|
// adjustment needed if lo has sign bit set
|
|
|
|
|
// when using addi to compute address
|
|
|
|
|
val := uint32((t & 0xffff0000) >> 16)
|
|
|
|
|
if t&0x8000 != 0 {
|
|
|
|
|
val += 1
|
|
|
|
|
}
|
|
|
|
|
o1 |= val // hi part of addr
|
|
|
|
|
o2 |= uint32(t & 0xffff) // lo part of addr
|
|
|
|
|
}
|
|
|
|
|
o3 := uint32(0x7fe903a6) // mtctr r31
|
|
|
|
|
o4 := uint32(0x4e800420) // bctr
|
2017-09-30 21:10:49 +00:00
|
|
|
arch.ByteOrder.PutUint32(tramp.P, o1)
|
|
|
|
|
arch.ByteOrder.PutUint32(tramp.P[4:], o2)
|
|
|
|
|
arch.ByteOrder.PutUint32(tramp.P[8:], o3)
|
|
|
|
|
arch.ByteOrder.PutUint32(tramp.P[12:], o4)
|
2017-06-08 08:26:19 -04:00
|
|
|
}
|
|
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
func archreloc(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, val *int64) bool {
|
2015-02-27 22:57:28 -05:00
|
|
|
if ld.Linkmode == ld.LinkExternal {
|
2015-09-04 08:30:15 +12:00
|
|
|
switch r.Type {
|
|
|
|
|
default:
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_POWER_TLS, objabi.R_POWER_TLS_LE, objabi.R_POWER_TLS_IE:
|
2017-08-27 22:00:00 +09:00
|
|
|
r.Done = false
|
2015-09-04 08:30:15 +12:00
|
|
|
// check Outer is nil, Type is TLSBSS?
|
|
|
|
|
r.Xadd = r.Add
|
|
|
|
|
r.Xsym = r.Sym
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER,
|
|
|
|
|
objabi.R_ADDRPOWER_DS,
|
|
|
|
|
objabi.R_ADDRPOWER_TOCREL,
|
|
|
|
|
objabi.R_ADDRPOWER_TOCREL_DS,
|
|
|
|
|
objabi.R_ADDRPOWER_GOT,
|
|
|
|
|
objabi.R_ADDRPOWER_PCREL:
|
2017-08-27 22:00:00 +09:00
|
|
|
r.Done = false
|
2015-09-04 08:30:15 +12:00
|
|
|
|
|
|
|
|
// set up addend for eventual relocation via outer symbol.
|
|
|
|
|
rs := r.Sym
|
|
|
|
|
r.Xadd = r.Add
|
|
|
|
|
for rs.Outer != nil {
|
2016-09-17 09:39:33 -04:00
|
|
|
r.Xadd += ld.Symaddr(rs) - ld.Symaddr(rs.Outer)
|
2015-09-04 08:30:15 +12:00
|
|
|
rs = rs.Outer
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-19 15:15:35 +12:00
|
|
|
if rs.Type != ld.SHOSTOBJ && rs.Type != ld.SDYNIMPORT && rs.Sect == nil {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "missing section for %s", rs.Name)
|
2015-09-04 08:30:15 +12:00
|
|
|
}
|
|
|
|
|
r.Xsym = rs
|
|
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_CALLPOWER:
|
2017-08-27 22:00:00 +09:00
|
|
|
r.Done = false
|
2015-09-04 08:30:15 +12:00
|
|
|
r.Xsym = r.Sym
|
|
|
|
|
r.Xadd = r.Add
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2015-09-04 08:30:15 +12:00
|
|
|
}
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch r.Type {
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_CONST:
|
2015-02-27 22:57:28 -05:00
|
|
|
*val = r.Add
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_GOTOFF:
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
*val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_ADDRPOWER, objabi.R_ADDRPOWER_DS:
|
2016-08-21 13:52:23 -04:00
|
|
|
return archrelocaddr(ctxt, r, s, val)
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_CALLPOWER:
|
2015-03-01 13:32:49 -05:00
|
|
|
// Bits 6 through 29 = (S + A - P) >> 2
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2016-09-17 09:39:33 -04:00
|
|
|
t := ld.Symaddr(r.Sym) + r.Add - (s.Value + int64(r.Off))
|
2016-10-11 09:26:40 -05:00
|
|
|
|
2015-02-27 22:57:28 -05:00
|
|
|
if t&3 != 0 {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "relocation for %s+%d is not aligned: %d", r.Sym.Name, r.Off, t)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2016-10-11 09:26:40 -05:00
|
|
|
// If branch offset is too far then create a trampoline.
|
|
|
|
|
|
2015-02-27 22:57:28 -05:00
|
|
|
if int64(int32(t<<6)>>6) != t {
|
2016-10-11 09:26:40 -05:00
|
|
|
ld.Errorf(s, "direct call too far: %s %x", r.Sym.Name, t)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2015-08-31 13:51:37 +12:00
|
|
|
*val |= int64(uint32(t) &^ 0xfc000003)
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_POWER_TOC: // S + A - .TOC.
|
2016-09-17 09:39:33 -04:00
|
|
|
*val = ld.Symaddr(r.Sym) + r.Add - symtoc(ctxt, s)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.R_POWER_TLS_LE:
|
2015-10-30 10:13:13 +13:00
|
|
|
// The thread pointer points 0x7000 bytes after the start of the the
|
|
|
|
|
// thread local storage area as documented in section "3.7.2 TLS
|
|
|
|
|
// Runtime Handling" of "Power Architecture 64-Bit ELF V2 ABI
|
|
|
|
|
// Specification".
|
|
|
|
|
v := r.Sym.Value - 0x7000
|
|
|
|
|
if int64(int16(v)) != v {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "TLS offset out of range %d", v)
|
2015-10-30 10:13:13 +13:00
|
|
|
}
|
|
|
|
|
*val = (*val &^ 0xffff) | (v & 0xffff)
|
2017-08-27 22:00:00 +09:00
|
|
|
return true
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2017-08-27 22:00:00 +09:00
|
|
|
return false
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
func archrelocvariant(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, t int64) int64 {
|
2015-02-27 22:57:28 -05:00
|
|
|
switch r.Variant & ld.RV_TYPE_MASK {
|
|
|
|
|
default:
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "unexpected relocation variant %d", r.Variant)
|
2015-02-27 22:57:28 -05:00
|
|
|
fallthrough
|
|
|
|
|
|
|
|
|
|
case ld.RV_NONE:
|
|
|
|
|
return t
|
|
|
|
|
|
|
|
|
|
case ld.RV_POWER_LO:
|
|
|
|
|
if r.Variant&ld.RV_CHECK_OVERFLOW != 0 {
|
|
|
|
|
// Whether to check for signed or unsigned
|
|
|
|
|
// overflow depends on the instruction
|
2015-03-02 12:35:15 -05:00
|
|
|
var o1 uint32
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-02-27 22:57:28 -05:00
|
|
|
o1 = ld.Be32(s.P[r.Off-2:])
|
|
|
|
|
} else {
|
|
|
|
|
o1 = ld.Le32(s.P[r.Off:])
|
|
|
|
|
}
|
|
|
|
|
switch o1 >> 26 {
|
|
|
|
|
case 24, // ori
|
|
|
|
|
26, // xori
|
|
|
|
|
28: // andi
|
|
|
|
|
if t>>16 != 0 {
|
|
|
|
|
goto overflow
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
if int64(int16(t)) != t {
|
|
|
|
|
goto overflow
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return int64(int16(t))
|
|
|
|
|
|
|
|
|
|
case ld.RV_POWER_HA:
|
|
|
|
|
t += 0x8000
|
|
|
|
|
fallthrough
|
|
|
|
|
|
|
|
|
|
// Fallthrough
|
|
|
|
|
case ld.RV_POWER_HI:
|
|
|
|
|
t >>= 16
|
|
|
|
|
|
|
|
|
|
if r.Variant&ld.RV_CHECK_OVERFLOW != 0 {
|
|
|
|
|
// Whether to check for signed or unsigned
|
|
|
|
|
// overflow depends on the instruction
|
2015-03-02 12:35:15 -05:00
|
|
|
var o1 uint32
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-02-27 22:57:28 -05:00
|
|
|
o1 = ld.Be32(s.P[r.Off-2:])
|
|
|
|
|
} else {
|
|
|
|
|
o1 = ld.Le32(s.P[r.Off:])
|
|
|
|
|
}
|
|
|
|
|
switch o1 >> 26 {
|
|
|
|
|
case 25, // oris
|
|
|
|
|
27, // xoris
|
|
|
|
|
29: // andis
|
|
|
|
|
if t>>16 != 0 {
|
|
|
|
|
goto overflow
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
if int64(int16(t)) != t {
|
|
|
|
|
goto overflow
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return int64(int16(t))
|
|
|
|
|
|
|
|
|
|
case ld.RV_POWER_DS:
|
2015-03-02 12:35:15 -05:00
|
|
|
var o1 uint32
|
2016-08-21 13:52:23 -04:00
|
|
|
if ctxt.Arch.ByteOrder == binary.BigEndian {
|
2015-02-27 22:57:28 -05:00
|
|
|
o1 = uint32(ld.Be16(s.P[r.Off:]))
|
|
|
|
|
} else {
|
|
|
|
|
o1 = uint32(ld.Le16(s.P[r.Off:]))
|
|
|
|
|
}
|
|
|
|
|
if t&3 != 0 {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "relocation for %s+%d is not aligned: %d", r.Sym.Name, r.Off, t)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
if (r.Variant&ld.RV_CHECK_OVERFLOW != 0) && int64(int16(t)) != t {
|
|
|
|
|
goto overflow
|
|
|
|
|
}
|
|
|
|
|
return int64(o1)&0x3 | int64(int16(t))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
overflow:
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "relocation for %s+%d is too big: %d", r.Sym.Name, r.Off, t)
|
2015-02-27 22:57:28 -05:00
|
|
|
return t
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-19 11:35:54 -04:00
|
|
|
func addpltsym(ctxt *ld.Link, s *ld.Symbol) {
|
2015-02-27 22:57:28 -05:00
|
|
|
if s.Plt >= 0 {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-12 15:59:15 +12:00
|
|
|
ld.Adddynsym(ctxt, s)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
if ld.Iself {
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
plt := ctxt.Syms.Lookup(".plt", 0)
|
|
|
|
|
rela := ctxt.Syms.Lookup(".rela.plt", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
if plt.Size == 0 {
|
2016-08-21 13:52:23 -04:00
|
|
|
elfsetupplt(ctxt)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Create the glink resolver if necessary
|
2016-08-21 13:52:23 -04:00
|
|
|
glink := ensureglinkresolver(ctxt)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Write symbol resolver stub (just a branch to the
|
|
|
|
|
// glink resolver stub)
|
2017-09-30 15:06:44 +00:00
|
|
|
r := glink.AddRel()
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
r.Sym = glink
|
|
|
|
|
r.Off = int32(glink.Size)
|
|
|
|
|
r.Siz = 4
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_CALLPOWER
|
2017-09-30 15:06:44 +00:00
|
|
|
glink.AddUint32(ctxt.Arch, 0x48000000) // b .glink
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// In the ppc64 ABI, the dynamic linker is responsible
|
|
|
|
|
// for writing the entire PLT. We just need to
|
|
|
|
|
// reserve 8 bytes for each PLT entry and generate a
|
|
|
|
|
// JMP_SLOT dynamic relocation for it.
|
|
|
|
|
//
|
|
|
|
|
// TODO(austin): ABI v1 is different
|
|
|
|
|
s.Plt = int32(plt.Size)
|
|
|
|
|
|
|
|
|
|
plt.Size += 8
|
|
|
|
|
|
2017-09-30 15:06:44 +00:00
|
|
|
rela.AddAddrPlus(ctxt.Arch, plt, int64(s.Plt))
|
|
|
|
|
rela.AddUint64(ctxt.Arch, ld.ELF64_R_INFO(uint32(s.Dynid), ld.R_PPC64_JMP_SLOT))
|
|
|
|
|
rela.AddUint64(ctxt.Arch, 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
} else {
|
2016-09-17 09:39:33 -04:00
|
|
|
ld.Errorf(s, "addpltsym: unsupported binary format")
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Generate the glink resolver stub if necessary and return the .glink section
|
2016-08-21 13:52:23 -04:00
|
|
|
func ensureglinkresolver(ctxt *ld.Link) *ld.Symbol {
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
glink := ctxt.Syms.Lookup(".glink", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
if glink.Size != 0 {
|
|
|
|
|
return glink
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// This is essentially the resolver from the ppc64 ELF ABI.
|
|
|
|
|
// At entry, r12 holds the address of the symbol resolver stub
|
|
|
|
|
// for the target routine and the argument registers hold the
|
|
|
|
|
// arguments for the target routine.
|
|
|
|
|
//
|
|
|
|
|
// This stub is PIC, so first get the PC of label 1 into r11.
|
|
|
|
|
// Other things will be relative to this.
|
2017-09-30 15:06:44 +00:00
|
|
|
glink.AddUint32(ctxt.Arch, 0x7c0802a6) // mflr r0
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x429f0005) // bcl 20,31,1f
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x7d6802a6) // 1: mflr r11
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x7c0803a6) // mtlf r0
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Compute the .plt array index from the entry point address.
|
|
|
|
|
// Because this is PIC, everything is relative to label 1b (in
|
|
|
|
|
// r11):
|
|
|
|
|
// r0 = ((r12 - r11) - (res_0 - r11)) / 4 = (r12 - res_0) / 4
|
2017-09-30 15:06:44 +00:00
|
|
|
glink.AddUint32(ctxt.Arch, 0x3800ffd0) // li r0,-(res_0-1b)=-48
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x7c006214) // add r0,r0,r12
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x7c0b0050) // sub r0,r0,r11
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x7800f082) // srdi r0,r0,2
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// r11 = address of the first byte of the PLT
|
2017-09-30 15:06:44 +00:00
|
|
|
r := glink.AddRel()
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
r.Off = int32(glink.Size)
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
r.Sym = ctxt.Syms.Lookup(".plt", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
r.Siz = 8
|
2017-04-18 12:53:25 -07:00
|
|
|
r.Type = objabi.R_ADDRPOWER
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2017-09-30 15:06:44 +00:00
|
|
|
glink.AddUint32(ctxt.Arch, 0x3d600000) // addis r11,0,.plt@ha
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x396b0000) // addi r11,r11,.plt@l
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Load r12 = dynamic resolver address and r11 = DSO
|
|
|
|
|
// identifier from the first two doublewords of the PLT.
|
2017-09-30 15:06:44 +00:00
|
|
|
glink.AddUint32(ctxt.Arch, 0xe98b0000) // ld r12,0(r11)
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0xe96b0008) // ld r11,8(r11)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// Jump to the dynamic resolver
|
2017-09-30 15:06:44 +00:00
|
|
|
glink.AddUint32(ctxt.Arch, 0x7d8903a6) // mtctr r12
|
|
|
|
|
glink.AddUint32(ctxt.Arch, 0x4e800420) // bctr
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
// The symbol resolvers must immediately follow.
|
|
|
|
|
// res_0:
|
|
|
|
|
|
|
|
|
|
// Add DT_PPC64_GLINK .dynamic entry, which points to 32 bytes
|
|
|
|
|
// before the first symbol resolver stub.
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
s := ctxt.Syms.Lookup(".dynamic", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2016-08-21 13:52:23 -04:00
|
|
|
ld.Elfwritedynentsymplus(ctxt, s, ld.DT_PPC64_GLINK, glink, glink.Size-32)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
return glink
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-19 22:40:38 -04:00
|
|
|
func asmb(ctxt *ld.Link) {
|
2016-08-21 18:25:28 -04:00
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f asmb\n", ld.Cputime())
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ld.Iself {
|
2016-09-20 15:57:53 +12:00
|
|
|
ld.Asmbelfsetup()
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2017-04-18 21:52:06 +12:00
|
|
|
for _, sect := range ld.Segtext.Sections {
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff))
|
2016-08-25 11:07:33 -05:00
|
|
|
// Handle additional text sections with Codeblk
|
|
|
|
|
if sect.Name == ".text" {
|
|
|
|
|
ld.Codeblk(ctxt, int64(sect.Vaddr), int64(sect.Length))
|
|
|
|
|
} else {
|
|
|
|
|
ld.Datblk(ctxt, int64(sect.Vaddr), int64(sect.Length))
|
|
|
|
|
}
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ld.Segrodata.Filelen > 0 {
|
2016-08-21 18:25:28 -04:00
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f rodatblk\n", ld.Cputime())
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(int64(ld.Segrodata.Fileoff))
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Datblk(ctxt, int64(ld.Segrodata.Vaddr), int64(ld.Segrodata.Filelen))
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2016-09-05 23:29:16 -04:00
|
|
|
if ld.Segrelrodata.Filelen > 0 {
|
|
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f relrodatblk\n", ld.Cputime())
|
2016-09-05 23:29:16 -04:00
|
|
|
}
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(int64(ld.Segrelrodata.Fileoff))
|
2016-09-05 23:29:16 -04:00
|
|
|
ld.Datblk(ctxt, int64(ld.Segrelrodata.Vaddr), int64(ld.Segrelrodata.Filelen))
|
|
|
|
|
}
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2016-08-21 18:25:28 -04:00
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f datblk\n", ld.Cputime())
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(int64(ld.Segdata.Fileoff))
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Datblk(ctxt, int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen))
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(int64(ld.Segdwarf.Fileoff))
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Dwarfblk(ctxt, int64(ld.Segdwarf.Vaddr), int64(ld.Segdwarf.Filelen))
|
2016-03-14 09:23:04 -07:00
|
|
|
|
2015-02-27 22:57:28 -05:00
|
|
|
/* output symbol table */
|
|
|
|
|
ld.Symsize = 0
|
|
|
|
|
|
|
|
|
|
ld.Lcsize = 0
|
2015-03-02 12:35:15 -05:00
|
|
|
symo := uint32(0)
|
2016-08-21 18:34:24 -04:00
|
|
|
if !*ld.FlagS {
|
2015-02-27 22:57:28 -05:00
|
|
|
// TODO: rationalize
|
2016-08-21 18:25:28 -04:00
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f sym\n", ld.Cputime())
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2016-09-09 06:20:44 -04:00
|
|
|
switch ld.Headtype {
|
2015-02-27 22:57:28 -05:00
|
|
|
default:
|
|
|
|
|
if ld.Iself {
|
2016-03-14 09:23:04 -07:00
|
|
|
symo = uint32(ld.Segdwarf.Fileoff + ld.Segdwarf.Filelen)
|
2016-08-21 18:34:24 -04:00
|
|
|
symo = uint32(ld.Rnd(int64(symo), int64(*ld.FlagRound)))
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.Hplan9:
|
2015-02-27 22:57:28 -05:00
|
|
|
symo = uint32(ld.Segdata.Fileoff + ld.Segdata.Filelen)
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(int64(symo))
|
2016-09-09 06:20:44 -04:00
|
|
|
switch ld.Headtype {
|
2015-02-27 22:57:28 -05:00
|
|
|
default:
|
|
|
|
|
if ld.Iself {
|
2016-08-21 18:25:28 -04:00
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f elfsym\n", ld.Cputime())
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Asmelfsym(ctxt)
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Flush()
|
|
|
|
|
ctxt.Out.Write(ld.Elfstrdat)
|
2015-02-27 22:57:28 -05:00
|
|
|
|
|
|
|
|
if ld.Linkmode == ld.LinkExternal {
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Elfemitreloc(ctxt)
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.Hplan9:
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Asmplan9sym(ctxt)
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Flush()
|
2015-02-27 22:57:28 -05:00
|
|
|
|
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same
Done with two eg templates:
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linklookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.Lookup(name, v)
}
package p
import (
"cmd/link/internal/ld"
)
func before(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ld.Linkrlookup(ctxt, name, v)
}
func after(ctxt *ld.Link, name string, v int) *ld.Symbol {
return ctxt.Syms.ROLookup(name, v)
}
Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1
Reviewed-on: https://go-review.googlesource.com/29343
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
|
|
|
sym := ctxt.Syms.Lookup("pclntab", 0)
|
2015-02-27 22:57:28 -05:00
|
|
|
if sym != nil {
|
|
|
|
|
ld.Lcsize = int32(len(sym.P))
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write(sym.P)
|
|
|
|
|
ctxt.Out.Flush()
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-21 18:25:28 -04:00
|
|
|
if ctxt.Debugvlog != 0 {
|
2017-04-18 12:53:25 -07:00
|
|
|
ctxt.Logf("%5.2f header\n", ld.Cputime())
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.SeekSet(0)
|
2016-09-09 06:20:44 -04:00
|
|
|
switch ld.Headtype {
|
2015-02-27 22:57:28 -05:00
|
|
|
default:
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.Hplan9: /* plan 9 */
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Write32(0x647) /* magic */
|
|
|
|
|
ctxt.Out.Write32(uint32(ld.Segtext.Filelen)) /* sizes */
|
|
|
|
|
ctxt.Out.Write32(uint32(ld.Segdata.Filelen))
|
|
|
|
|
ctxt.Out.Write32(uint32(ld.Segdata.Length - ld.Segdata.Filelen))
|
|
|
|
|
ctxt.Out.Write32(uint32(ld.Symsize)) /* nsyms */
|
|
|
|
|
ctxt.Out.Write32(uint32(ld.Entryvalue(ctxt))) /* va of entry */
|
|
|
|
|
ctxt.Out.Write32(0)
|
|
|
|
|
ctxt.Out.Write32(uint32(ld.Lcsize))
|
2015-02-27 22:57:28 -05:00
|
|
|
|
2017-04-18 12:53:25 -07:00
|
|
|
case objabi.Hlinux,
|
|
|
|
|
objabi.Hfreebsd,
|
|
|
|
|
objabi.Hnetbsd,
|
|
|
|
|
objabi.Hopenbsd,
|
|
|
|
|
objabi.Hnacl:
|
2016-08-19 22:40:38 -04:00
|
|
|
ld.Asmbelf(ctxt, int64(symo))
|
2015-02-27 22:57:28 -05:00
|
|
|
}
|
|
|
|
|
|
2017-10-01 02:37:20 +00:00
|
|
|
ctxt.Out.Flush()
|
2016-08-21 18:34:24 -04:00
|
|
|
if *ld.FlagC {
|
2015-02-27 22:57:28 -05:00
|
|
|
fmt.Printf("textsize=%d\n", ld.Segtext.Filelen)
|
|
|
|
|
fmt.Printf("datsize=%d\n", ld.Segdata.Filelen)
|
|
|
|
|
fmt.Printf("bsssize=%d\n", ld.Segdata.Length-ld.Segdata.Filelen)
|
|
|
|
|
fmt.Printf("symsize=%d\n", ld.Symsize)
|
|
|
|
|
fmt.Printf("lcsize=%d\n", ld.Lcsize)
|
|
|
|
|
fmt.Printf("total=%d\n", ld.Segtext.Filelen+ld.Segdata.Length+uint64(ld.Symsize)+uint64(ld.Lcsize))
|
|
|
|
|
}
|
|
|
|
|
}
|