mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
239dbd7dba
For FIPS init-time code+data verification, we need to arrange to put the FIPS symbols into contiguous regions of the executable and then record those sections along with the expected checksum. The cmd/internal/obj changes identify the FIPS symbols and give them distinguished types, which the linker then places in contiguous regions. The linker also writes out information to use at run time to find the FIPS sections, along with the expected hash. See cmd/internal/obj/fips.go and cmd/link/internal/ld/fips.go for more details. The code is disabled in this commit. CL 625998 and 625999 adds tests. CL 626000 enables the code. For #69536. Change-Id: I48da6db94bc0bea7428c43d4abcf999527bccfcd Reviewed-on: https://go-review.googlesource.com/c/go/+/625997 Auto-Submit: Russ Cox <rsc@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
212 lines
6.8 KiB
Go
212 lines
6.8 KiB
Go
// Derived from Inferno utils/6l/obj.c and utils/6l/span.c
|
|
// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/obj.c
|
|
// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/span.c
|
|
//
|
|
// 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
|
|
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
|
//
|
|
// 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.
|
|
|
|
package obj
|
|
|
|
import (
|
|
"cmd/internal/objabi"
|
|
"log"
|
|
"math"
|
|
)
|
|
|
|
// Grow increases the length of s.P to lsiz.
|
|
func (s *LSym) Grow(lsiz int64) {
|
|
siz := int(lsiz)
|
|
if int64(siz) != lsiz {
|
|
log.Fatalf("LSym.Grow size %d too long", lsiz)
|
|
}
|
|
if len(s.P) >= siz {
|
|
return
|
|
}
|
|
s.P = append(s.P, make([]byte, siz-len(s.P))...)
|
|
}
|
|
|
|
// GrowCap increases the capacity of s.P to c.
|
|
func (s *LSym) GrowCap(c int64) {
|
|
if int64(cap(s.P)) >= c {
|
|
return
|
|
}
|
|
if s.P == nil {
|
|
s.P = make([]byte, 0, c)
|
|
return
|
|
}
|
|
b := make([]byte, len(s.P), c)
|
|
copy(b, s.P)
|
|
s.P = b
|
|
}
|
|
|
|
// prepwrite prepares to write data of size siz into s at offset off.
|
|
func (s *LSym) prepwrite(ctxt *Link, off int64, siz int) {
|
|
if off < 0 || siz < 0 || off >= 1<<30 {
|
|
ctxt.Diag("prepwrite: bad off=%d siz=%d s=%v", off, siz, s)
|
|
}
|
|
switch s.Type {
|
|
case objabi.Sxxx, objabi.SBSS:
|
|
s.Type = objabi.SDATA
|
|
s.setFIPSType(ctxt)
|
|
case objabi.SNOPTRBSS:
|
|
s.Type = objabi.SNOPTRDATA
|
|
s.setFIPSType(ctxt)
|
|
case objabi.STLSBSS:
|
|
ctxt.Diag("cannot supply data for %v var %v", s.Type, s.Name)
|
|
}
|
|
l := off + int64(siz)
|
|
s.Grow(l)
|
|
if l > s.Size {
|
|
s.Size = l
|
|
}
|
|
}
|
|
|
|
// WriteFloat32 writes f into s at offset off.
|
|
func (s *LSym) WriteFloat32(ctxt *Link, off int64, f float32) {
|
|
s.prepwrite(ctxt, off, 4)
|
|
ctxt.Arch.ByteOrder.PutUint32(s.P[off:], math.Float32bits(f))
|
|
}
|
|
|
|
// WriteFloat64 writes f into s at offset off.
|
|
func (s *LSym) WriteFloat64(ctxt *Link, off int64, f float64) {
|
|
s.prepwrite(ctxt, off, 8)
|
|
ctxt.Arch.ByteOrder.PutUint64(s.P[off:], math.Float64bits(f))
|
|
}
|
|
|
|
// WriteInt writes an integer i of size siz into s at offset off.
|
|
func (s *LSym) WriteInt(ctxt *Link, off int64, siz int, i int64) {
|
|
s.prepwrite(ctxt, off, siz)
|
|
switch siz {
|
|
default:
|
|
ctxt.Diag("WriteInt: bad integer size: %d", siz)
|
|
case 1:
|
|
s.P[off] = byte(i)
|
|
case 2:
|
|
ctxt.Arch.ByteOrder.PutUint16(s.P[off:], uint16(i))
|
|
case 4:
|
|
ctxt.Arch.ByteOrder.PutUint32(s.P[off:], uint32(i))
|
|
case 8:
|
|
ctxt.Arch.ByteOrder.PutUint64(s.P[off:], uint64(i))
|
|
}
|
|
}
|
|
|
|
func (s *LSym) writeAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64, rtype objabi.RelocType) {
|
|
// Allow 4-byte addresses for DWARF.
|
|
if siz != ctxt.Arch.PtrSize && siz != 4 {
|
|
ctxt.Diag("WriteAddr: bad address size %d in %s", siz, s.Name)
|
|
}
|
|
s.prepwrite(ctxt, off, siz)
|
|
if int64(int32(off)) != off {
|
|
ctxt.Diag("WriteAddr: off overflow %d in %s", off, s.Name)
|
|
}
|
|
s.AddRel(ctxt, Reloc{
|
|
Type: rtype,
|
|
Off: int32(off),
|
|
Siz: uint8(siz),
|
|
Sym: rsym,
|
|
Add: roff,
|
|
})
|
|
}
|
|
|
|
// WriteAddr writes an address of size siz into s at offset off.
|
|
// rsym and roff specify the relocation for the address.
|
|
func (s *LSym) WriteAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64) {
|
|
s.writeAddr(ctxt, off, siz, rsym, roff, objabi.R_ADDR)
|
|
}
|
|
|
|
// WriteWeakAddr writes an address of size siz into s at offset off.
|
|
// rsym and roff specify the relocation for the address.
|
|
// This is a weak reference.
|
|
func (s *LSym) WriteWeakAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64) {
|
|
s.writeAddr(ctxt, off, siz, rsym, roff, objabi.R_WEAKADDR)
|
|
}
|
|
|
|
// WriteCURelativeAddr writes a pointer-sized address into s at offset off.
|
|
// rsym and roff specify the relocation for the address which will be
|
|
// resolved by the linker to an offset from the DW_AT_low_pc attribute of
|
|
// the DWARF Compile Unit of rsym.
|
|
func (s *LSym) WriteCURelativeAddr(ctxt *Link, off int64, rsym *LSym, roff int64) {
|
|
s.writeAddr(ctxt, off, ctxt.Arch.PtrSize, rsym, roff, objabi.R_ADDRCUOFF)
|
|
}
|
|
|
|
// WriteOff writes a 4 byte offset to rsym+roff into s at offset off.
|
|
// After linking the 4 bytes stored at s+off will be
|
|
// rsym+roff-(start of section that s is in).
|
|
func (s *LSym) WriteOff(ctxt *Link, off int64, rsym *LSym, roff int64) {
|
|
s.prepwrite(ctxt, off, 4)
|
|
if int64(int32(off)) != off {
|
|
ctxt.Diag("WriteOff: off overflow %d in %s", off, s.Name)
|
|
}
|
|
s.AddRel(ctxt, Reloc{
|
|
Type: objabi.R_ADDROFF,
|
|
Off: int32(off),
|
|
Siz: 4,
|
|
Sym: rsym,
|
|
Add: roff,
|
|
})
|
|
}
|
|
|
|
// WriteWeakOff writes a weak 4 byte offset to rsym+roff into s at offset off.
|
|
// After linking the 4 bytes stored at s+off will be
|
|
// rsym+roff-(start of section that s is in).
|
|
func (s *LSym) WriteWeakOff(ctxt *Link, off int64, rsym *LSym, roff int64) {
|
|
s.prepwrite(ctxt, off, 4)
|
|
if int64(int32(off)) != off {
|
|
ctxt.Diag("WriteWeakOff: off overflow %d in %s", off, s.Name)
|
|
}
|
|
s.AddRel(ctxt, Reloc{
|
|
Type: objabi.R_WEAKADDROFF,
|
|
Off: int32(off),
|
|
Siz: 4,
|
|
Sym: rsym,
|
|
Add: roff,
|
|
})
|
|
}
|
|
|
|
// WriteString writes a string of size siz into s at offset off.
|
|
func (s *LSym) WriteString(ctxt *Link, off int64, siz int, str string) {
|
|
if siz < len(str) {
|
|
ctxt.Diag("WriteString: bad string size: %d < %d", siz, len(str))
|
|
}
|
|
s.prepwrite(ctxt, off, siz)
|
|
copy(s.P[off:off+int64(siz)], str)
|
|
}
|
|
|
|
// WriteBytes writes a slice of bytes into s at offset off.
|
|
func (s *LSym) WriteBytes(ctxt *Link, off int64, b []byte) int64 {
|
|
s.prepwrite(ctxt, off, len(b))
|
|
copy(s.P[off:], b)
|
|
return off + int64(len(b))
|
|
}
|
|
|
|
// AddRel adds the relocation rel to s.
|
|
func (s *LSym) AddRel(ctxt *Link, rel Reloc) {
|
|
if s.Type.IsFIPS() {
|
|
s.checkFIPSReloc(ctxt, rel)
|
|
}
|
|
s.R = append(s.R, rel)
|
|
}
|