// Open a CDataFile
func OpenRawDataFile(name string, readOnly bool, byteOrder binary.ByteOrder, byteAlignment uint64, valueSize int) (*RawDataFile, error) {
flag := os.O_RDWR
if readOnly {
flag = os.O_RDONLY
}
file, err := os.OpenFile(name, flag, 0644)
if err != nil {
return nil, err
}
var univalToBytes func([]byte, unival)
var bytesToUnival func([]byte) unival
switch valueSize {
case 8:
univalToBytes = func(dst []byte, src unival) {
byteOrder.PutUint64(dst, src.AsUnsignedLong())
}
bytesToUnival = func(src []byte) unival {
return unival(byteOrder.Uint64(src))
}
default:
return nil, errors.Errorf("Invalid value size %d", valueSize)
}
return &RawDataFile{
file: file,
// byteOrder: byteOrder,
byteAlignment: byteAlignment,
valueSize: valueSize,
univalToBytes: univalToBytes,
bytesToUnival: bytesToUnival,
}, nil
}
func (b *Buffer) ReadUint64(order binary.ByteOrder) (uint64, error) {
if b.readPos >= len(b.Buf)-8 {
return 0, io.EOF
}
u := order.Uint64(b.Buf[b.readPos:])
b.readPos += 8
return u, nil
}
// Uint64 reads eight bytes from the provided reader using a buffer from the
// free list, converts it to a number using the provided byte order, and returns
// the resulting uint64.
func (l binaryFreeList) Uint64(r io.Reader, byteOrder binary.ByteOrder) (uint64, error) {
buf := l.Borrow()[:8]
if _, err := io.ReadFull(r, buf); err != nil {
l.Return(buf)
return 0, err
}
rv := byteOrder.Uint64(buf)
l.Return(buf)
return rv, nil
}
func walksymtab(data []byte, ptrsz int, fn func(sym) error) error {
var order binary.ByteOrder = binary.BigEndian
var s sym
p := data
for len(p) >= 4 {
// Symbol type, value.
if len(p) < ptrsz {
return &formatError{len(data), "unexpected EOF", nil}
}
// fixed-width value
if ptrsz == 8 {
s.value = order.Uint64(p[0:8])
p = p[8:]
} else {
s.value = uint64(order.Uint32(p[0:4]))
p = p[4:]
}
var typ byte
typ = p[0] & 0x7F
s.typ = typ
p = p[1:]
// Name.
var i int
var nnul int
for i = 0; i < len(p); i++ {
if p[i] == 0 {
nnul = 1
break
}
}
switch typ {
case 'z', 'Z':
p = p[i+nnul:]
for i = 0; i+2 <= len(p); i += 2 {
if p[i] == 0 && p[i+1] == 0 {
nnul = 2
break
}
}
}
if len(p) < i+nnul {
return &formatError{len(data), "unexpected EOF", nil}
}
s.name = p[0:i]
i += nnul
p = p[i:]
fn(s)
}
return nil
}
func newSimpleProtocol(n int, byteOrder binary.ByteOrder) *simpleProtocol {
protocol := &simpleProtocol{
n: n,
bo: byteOrder,
}
switch n {
case 1:
protocol.encodeHead = func(buffer []byte) {
buffer[0] = byte(len(buffer) - n)
}
protocol.decodeHead = func(buffer []byte) int {
return int(buffer[0])
}
case 2:
protocol.encodeHead = func(buffer []byte) {
byteOrder.PutUint16(buffer, uint16(len(buffer)-n))
}
protocol.decodeHead = func(buffer []byte) int {
return int(byteOrder.Uint16(buffer))
}
case 4:
protocol.encodeHead = func(buffer []byte) {
byteOrder.PutUint32(buffer, uint32(len(buffer)-n))
}
protocol.decodeHead = func(buffer []byte) int {
return int(byteOrder.Uint32(buffer))
}
case 8:
protocol.encodeHead = func(buffer []byte) {
byteOrder.PutUint64(buffer, uint64(len(buffer)-n))
}
protocol.decodeHead = func(buffer []byte) int {
return int(byteOrder.Uint64(buffer))
}
default:
panic("unsupported packet head size")
}
return protocol
}
func walksymtab(data []byte, fn func(sym) error) error {
if len(data) == 0 { // missing symtab is okay
return nil
}
var order binary.ByteOrder = binary.BigEndian
newTable := false
switch {
case bytes.HasPrefix(data, oldLittleEndianSymtab):
// Same as Go 1.0, but little endian.
// Format was used during interim development between Go 1.0 and Go 1.1.
// Should not be widespread, but easy to support.
data = data[6:]
order = binary.LittleEndian
case bytes.HasPrefix(data, bigEndianSymtab):
newTable = true
case bytes.HasPrefix(data, littleEndianSymtab):
newTable = true
order = binary.LittleEndian
}
var ptrsz int
if newTable {
if len(data) < 8 {
return &DecodingError{len(data), "unexpected EOF", nil}
}
ptrsz = int(data[7])
if ptrsz != 4 && ptrsz != 8 {
return &DecodingError{7, "invalid pointer size", ptrsz}
}
data = data[8:]
}
var s sym
p := data
for len(p) >= 4 {
var typ byte
if newTable {
// Symbol type, value, Go type.
typ = p[0] & 0x3F
wideValue := p[0]&0x40 != 0
goType := p[0]&0x80 != 0
if typ < 26 {
typ += 'A'
} else {
typ += 'a' - 26
}
s.typ = typ
p = p[1:]
if wideValue {
if len(p) < ptrsz {
return &DecodingError{len(data), "unexpected EOF", nil}
}
// fixed-width value
if ptrsz == 8 {
s.value = order.Uint64(p[0:8])
p = p[8:]
} else {
s.value = uint64(order.Uint32(p[0:4]))
p = p[4:]
}
} else {
// varint value
s.value = 0
shift := uint(0)
for len(p) > 0 && p[0]&0x80 != 0 {
s.value |= uint64(p[0]&0x7F) << shift
shift += 7
p = p[1:]
}
if len(p) == 0 {
return &DecodingError{len(data), "unexpected EOF", nil}
}
s.value |= uint64(p[0]) << shift
p = p[1:]
}
if goType {
if len(p) < ptrsz {
return &DecodingError{len(data), "unexpected EOF", nil}
}
// fixed-width go type
if ptrsz == 8 {
s.gotype = order.Uint64(p[0:8])
p = p[8:]
} else {
s.gotype = uint64(order.Uint32(p[0:4]))
p = p[4:]
}
}
} else {
// Value, symbol type.
s.value = uint64(order.Uint32(p[0:4]))
if len(p) < 5 {
return &DecodingError{len(data), "unexpected EOF", nil}
}
typ = p[4]
if typ&0x80 == 0 {
return &DecodingError{len(data) - len(p) + 4, "bad symbol type", typ}
}
typ &^= 0x80
s.typ = typ
p = p[5:]
}
// Name.
var i int
var nnul int
for i = 0; i < len(p); i++ {
if p[i] == 0 {
nnul = 1
break
}
}
switch typ {
case 'z', 'Z':
p = p[i+nnul:]
for i = 0; i+2 <= len(p); i += 2 {
if p[i] == 0 && p[i+1] == 0 {
nnul = 2
break
}
}
}
if len(p) < i+nnul {
return &DecodingError{len(data), "unexpected EOF", nil}
}
s.name = p[0:i]
i += nnul
p = p[i:]
if !newTable {
if len(p) < 4 {
return &DecodingError{len(data), "unexpected EOF", nil}
}
// Go type.
s.gotype = uint64(order.Uint32(p[:4]))
p = p[4:]
}
fn(s)
}
return nil
}
func (s *Stream) readSectionHeaderBlockBody(headerData []byte) (header *SectionHeaderBlock, err error) {
//
// read byte-order magic, version and section length
//
bodyData, err := s.read(16)
if err != nil {
return nil, err
}
//
// read byte-order magic
//
var byteOrder binary.ByteOrder
if bodyData[0] == 0x1A && bodyData[1] == 0x2B && bodyData[2] == 0x3C && bodyData[3] == 0x4D {
byteOrder = binary.BigEndian
} else if bodyData[3] == 0x1A && bodyData[2] == 0x2B && bodyData[1] == 0x3C && bodyData[0] == 0x4D {
byteOrder = binary.LittleEndian
} else {
return nil, errors.New("invalid byte order mark")
}
//
// read other fields
//
versionMajor := byteOrder.Uint16(bodyData[4:6])
versionMinor := byteOrder.Uint16(bodyData[6:8])
sectionLength := int64(byteOrder.Uint64(bodyData[8:16]))
//
// Read options
//
totalLength := byteOrder.Uint32(headerData[4:8])
optsLen := totalLength - 28
rawOpts, err := s.readOptions(optsLen, byteOrder)
if err != nil {
return nil, err
}
opts, err := parseSectionHeaderOptions(rawOpts)
if err != nil {
return nil, err
}
//
// Read last block total length
//
_, err = s.readExactly(4)
if err != nil {
return nil, err
}
retval := &SectionHeaderBlock{
totalLength: totalLength,
ByteOrder: byteOrder,
VersionMajor: versionMajor,
VersionMinor: versionMinor,
SectionLength: sectionLength,
RawOptions: rawOpts,
Options: opts,
}
s.sectionHeader = retval
return retval, nil
}
// Convert raw image data into a 2d array of 64-bit labels
func (d *Data) convertTo64bit(geom dvid.Geometry, data []uint8, bytesPerVoxel, stride int) ([]byte, error) {
nx := int(geom.Size().Value(0))
ny := int(geom.Size().Value(1))
numBytes := nx * ny * 8
data64 := make([]byte, numBytes, numBytes)
var byteOrder binary.ByteOrder
if geom.DataShape().ShapeDimensions() == 2 {
byteOrder = binary.BigEndian // This is the default for PNG
} else {
byteOrder = binary.LittleEndian
}
switch bytesPerVoxel {
case 1:
dstI := 0
for y := 0; y < ny; y++ {
srcI := y * stride
for x := 0; x < nx; x++ {
binary.LittleEndian.PutUint64(data64[dstI:dstI+8], uint64(data[srcI]))
srcI++
dstI += 8
}
}
case 2:
dstI := 0
for y := 0; y < ny; y++ {
srcI := y * stride
for x := 0; x < nx; x++ {
value := byteOrder.Uint16(data[srcI : srcI+2])
binary.LittleEndian.PutUint64(data64[dstI:dstI+8], uint64(value))
srcI += 2
dstI += 8
}
}
case 4:
dstI := 0
for y := 0; y < ny; y++ {
srcI := y * stride
for x := 0; x < nx; x++ {
value := byteOrder.Uint32(data[srcI : srcI+4])
binary.LittleEndian.PutUint64(data64[dstI:dstI+8], uint64(value))
srcI += 4
dstI += 8
}
}
case 8:
dstI := 0
for y := 0; y < ny; y++ {
srcI := y * stride
for x := 0; x < nx; x++ {
value := byteOrder.Uint64(data[srcI : srcI+8])
binary.LittleEndian.PutUint64(data64[dstI:dstI+8], uint64(value))
srcI += 8
dstI += 8
}
}
default:
return nil, fmt.Errorf("could not convert to 64-bit label given %d bytes/voxel", bytesPerVoxel)
}
return data64, nil
}
func reprDouble(in []byte, bo binary.ByteOrder) string {
return fmt.Sprintf("%f", math.Float64frombits(bo.Uint64(in)))
}
func rvalSLong8(in []byte, bo binary.ByteOrder) reflect.Value {
return reflect.ValueOf(int64(bo.Uint64(in)))
}
func reprSLong8(in []byte, bo binary.ByteOrder) string { return fmt.Sprintf("%d", int64(bo.Uint64(in))) }
// decodeNumeric decodes a simple stream of numeric or character data
func decodeNumeric(de dataElement, bo binary.ByteOrder) (interface{}, error) {
var b [8]byte
var bs []byte
if int(de.nBytes) > len(b) {
bs = make([]byte, de.nBytes)
} else {
bs = b[:de.nBytes]
}
_, err := de.r.ReadAt(bs, 0)
if err != nil {
return nil, err
}
switch de.dataType {
case miINT8:
val := make([]int8, de.nBytes)
for i, x := range bs {
val[i] = int8(x)
}
return val, nil
case miUINT8:
val := make([]uint8, de.nBytes)
copy(val, bs)
return val, nil
case miINT16:
val := make([]int16, de.nBytes/2)
for i := range bs {
val[i] = int16(bo.Uint16(bs[2*i:]))
}
return val, nil
case miUINT16:
val := make([]uint16, de.nBytes/2)
for i := range bs {
val[i] = bo.Uint16(bs[2*i:])
}
return val, nil
case miINT32:
val := make([]int32, de.nBytes/4)
for i := range bs {
val[i] = int32(bo.Uint32(bs[4*i:]))
}
return val, nil
case miUINT32:
val := make([]uint32, de.nBytes/4)
for i := range bs {
val[i] = bo.Uint32(bs[4*i:])
}
return val, nil
case miINT64:
val := make([]int64, de.nBytes/8)
for i := range bs {
val[i] = int64(bo.Uint64(bs[8*i:]))
}
return val, nil
case miUINT64:
val := make([]uint64, de.nBytes/8)
for i := range bs {
val[i] = bo.Uint64(bs[8*i:])
}
return val, nil
case miSINGLE:
val := make([]float32, de.nBytes/4)
for i := range bs {
val[i] = math.Float32frombits(bo.Uint32(bs[4*i:]))
}
return val, nil
case miDOUBLE:
val := make([]float64, de.nBytes/8)
for i := range bs {
val[i] = math.Float64frombits(bo.Uint64(bs[8*i:]))
}
return val, nil
case miUTF8:
return string(bs), nil
case miUTF16:
x := make([]uint16, de.nBytes/2)
for i := range bs {
x[i] = bo.Uint16(bs[2*i:])
}
return string(utf16.Decode(x)), nil
case miUTF32:
runes := make([]rune, de.nBytes/4)
for i := range runes {
runes[i] = rune(bo.Uint32(bs[4*i:]))
}
return string(runes), nil
}
return nil, nil
}
func readFloat(buf []byte, byteOrder binary.ByteOrder) float64 {
u := byteOrder.Uint64(buf)
return math.Float64frombits(u)
}
func NewCpuProfParser(r io.Reader) (*CpuProfParser, error) {
b := bufio.NewReader(r)
chunk, err := b.Peek(16)
if err != nil {
return nil, err
}
// A CPU profile starts with integers 0, and 3, with program's
// word size and endianness.
size := 32
first := binary.LittleEndian.Uint64(chunk[:8])
if first == 0 {
size = 64
}
var order binary.ByteOrder
if size == 32 {
n := binary.LittleEndian.Uint32(chunk[4:8])
if n == 3 {
order = binary.LittleEndian
} else {
order = binary.BigEndian
}
} else {
n := binary.LittleEndian.Uint64(chunk[8:16])
if n == 3 {
order = binary.LittleEndian
} else {
order = binary.BigEndian
}
}
p := &CpuProfParser{R: b, Order: order, Size: size}
if size == 32 {
p.read = func() (n uint64, err error) {
s, err := b.Peek(4)
if err == nil {
n = uint64(order.Uint32(s[:]))
}
b.Read(s)
return
}
} else {
p.read = func() (n uint64, err error) {
s, err := b.Peek(8)
if err == nil {
n = order.Uint64(s)
}
b.Read(s)
return
}
}
headerCount, _ := p.read()
headerWords, _ := p.read()
version, _ := p.read()
period, _ := p.read()
padding, err := p.read()
if err != nil {
return nil, err
}
if headerCount != 0 || headerWords != 3 || version != 0 || padding != 0 {
return nil, errBadProfileHeader
}
p.Period = period
return p, nil
}
func rvalDouble(in []byte, bo binary.ByteOrder) reflect.Value {
return reflect.ValueOf(math.Float64frombits(bo.Uint64(in)))
}
func ldelf(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
if ctxt.Debugvlog != 0 {
ctxt.Logf("%5.2f ldelf %s\n", obj.Cputime(), pn)
}
localSymVersion := ctxt.Syms.IncVersion()
base := f.Offset()
var add uint64
var e binary.ByteOrder
var elfobj *ElfObj
var err error
var flag int
var hdr *ElfHdrBytes
var hdrbuf [64]uint8
var info uint64
var is64 int
var j int
var n int
var name string
var p []byte
var r []Reloc
var rela int
var rp *Reloc
var rsect *ElfSect
var s *Symbol
var sect *ElfSect
var sym ElfSym
var symbols []*Symbol
if _, err := io.ReadFull(f, hdrbuf[:]); err != nil {
goto bad
}
hdr = new(ElfHdrBytes)
binary.Read(bytes.NewReader(hdrbuf[:]), binary.BigEndian, hdr) // only byte arrays; byte order doesn't matter
if string(hdr.Ident[:4]) != "\x7FELF" {
goto bad
}
switch hdr.Ident[5] {
case ElfDataLsb:
e = binary.LittleEndian
case ElfDataMsb:
e = binary.BigEndian
default:
goto bad
}
// read header
elfobj = new(ElfObj)
elfobj.e = e
elfobj.f = f
elfobj.base = base
elfobj.length = length
elfobj.name = pn
is64 = 0
if hdr.Ident[4] == ElfClass64 {
is64 = 1
hdr := new(ElfHdrBytes64)
binary.Read(bytes.NewReader(hdrbuf[:]), binary.BigEndian, hdr) // only byte arrays; byte order doesn't matter
elfobj.type_ = uint32(e.Uint16(hdr.Type[:]))
elfobj.machine = uint32(e.Uint16(hdr.Machine[:]))
elfobj.version = e.Uint32(hdr.Version[:])
elfobj.phoff = e.Uint64(hdr.Phoff[:])
elfobj.shoff = e.Uint64(hdr.Shoff[:])
elfobj.flags = e.Uint32(hdr.Flags[:])
elfobj.ehsize = uint32(e.Uint16(hdr.Ehsize[:]))
elfobj.phentsize = uint32(e.Uint16(hdr.Phentsize[:]))
elfobj.phnum = uint32(e.Uint16(hdr.Phnum[:]))
elfobj.shentsize = uint32(e.Uint16(hdr.Shentsize[:]))
elfobj.shnum = uint32(e.Uint16(hdr.Shnum[:]))
elfobj.shstrndx = uint32(e.Uint16(hdr.Shstrndx[:]))
} else {
elfobj.type_ = uint32(e.Uint16(hdr.Type[:]))
elfobj.machine = uint32(e.Uint16(hdr.Machine[:]))
elfobj.version = e.Uint32(hdr.Version[:])
elfobj.entry = uint64(e.Uint32(hdr.Entry[:]))
elfobj.phoff = uint64(e.Uint32(hdr.Phoff[:]))
elfobj.shoff = uint64(e.Uint32(hdr.Shoff[:]))
elfobj.flags = e.Uint32(hdr.Flags[:])
elfobj.ehsize = uint32(e.Uint16(hdr.Ehsize[:]))
elfobj.phentsize = uint32(e.Uint16(hdr.Phentsize[:]))
elfobj.phnum = uint32(e.Uint16(hdr.Phnum[:]))
elfobj.shentsize = uint32(e.Uint16(hdr.Shentsize[:]))
elfobj.shnum = uint32(e.Uint16(hdr.Shnum[:]))
elfobj.shstrndx = uint32(e.Uint16(hdr.Shstrndx[:]))
}
elfobj.is64 = is64
if uint32(hdr.Ident[6]) != elfobj.version {
goto bad
}
if e.Uint16(hdr.Type[:]) != ElfTypeRelocatable {
Errorf(nil, "%s: elf but not elf relocatable object", pn)
return
}
switch SysArch.Family {
default:
Errorf(nil, "%s: elf %s unimplemented", pn, SysArch.Name)
return
case sys.MIPS64:
if elfobj.machine != ElfMachMips || hdr.Ident[4] != ElfClass64 {
Errorf(nil, "%s: elf object but not mips64", pn)
return
}
case sys.ARM:
if e != binary.LittleEndian || elfobj.machine != ElfMachArm || hdr.Ident[4] != ElfClass32 {
Errorf(nil, "%s: elf object but not arm", pn)
return
}
case sys.AMD64:
if e != binary.LittleEndian || elfobj.machine != ElfMachAmd64 || hdr.Ident[4] != ElfClass64 {
Errorf(nil, "%s: elf object but not amd64", pn)
return
}
case sys.ARM64:
if e != binary.LittleEndian || elfobj.machine != ElfMachArm64 || hdr.Ident[4] != ElfClass64 {
Errorf(nil, "%s: elf object but not arm64", pn)
return
}
case sys.I386:
if e != binary.LittleEndian || elfobj.machine != ElfMach386 || hdr.Ident[4] != ElfClass32 {
Errorf(nil, "%s: elf object but not 386", pn)
return
}
case sys.PPC64:
if elfobj.machine != ElfMachPower64 || hdr.Ident[4] != ElfClass64 {
Errorf(nil, "%s: elf object but not ppc64", pn)
return
}
case sys.S390X:
if elfobj.machine != ElfMachS390 || hdr.Ident[4] != ElfClass64 {
Errorf(nil, "%s: elf object but not s390x", pn)
return
}
}
// load section list into memory.
elfobj.sect = make([]ElfSect, elfobj.shnum)
elfobj.nsect = uint(elfobj.shnum)
for i := 0; uint(i) < elfobj.nsect; i++ {
if f.Seek(int64(uint64(base)+elfobj.shoff+uint64(int64(i)*int64(elfobj.shentsize))), 0) < 0 {
goto bad
}
sect = &elfobj.sect[i]
if is64 != 0 {
var b ElfSectBytes64
if err = binary.Read(f, e, &b); err != nil {
goto bad
}
sect.nameoff = e.Uint32(b.Name[:])
sect.type_ = e.Uint32(b.Type[:])
sect.flags = e.Uint64(b.Flags[:])
sect.addr = e.Uint64(b.Addr[:])
sect.off = e.Uint64(b.Off[:])
sect.size = e.Uint64(b.Size[:])
sect.link = e.Uint32(b.Link[:])
sect.info = e.Uint32(b.Info[:])
sect.align = e.Uint64(b.Align[:])
sect.entsize = e.Uint64(b.Entsize[:])
} else {
var b ElfSectBytes
if err = binary.Read(f, e, &b); err != nil {
goto bad
}
sect.nameoff = e.Uint32(b.Name[:])
sect.type_ = e.Uint32(b.Type[:])
sect.flags = uint64(e.Uint32(b.Flags[:]))
sect.addr = uint64(e.Uint32(b.Addr[:]))
sect.off = uint64(e.Uint32(b.Off[:]))
sect.size = uint64(e.Uint32(b.Size[:]))
sect.link = e.Uint32(b.Link[:])
sect.info = e.Uint32(b.Info[:])
sect.align = uint64(e.Uint32(b.Align[:]))
sect.entsize = uint64(e.Uint32(b.Entsize[:]))
}
}
// read section string table and translate names
if elfobj.shstrndx >= uint32(elfobj.nsect) {
err = fmt.Errorf("shstrndx out of range %d >= %d", elfobj.shstrndx, elfobj.nsect)
goto bad
}
sect = &elfobj.sect[elfobj.shstrndx]
if err = elfmap(elfobj, sect); err != nil {
goto bad
}
for i := 0; uint(i) < elfobj.nsect; i++ {
if elfobj.sect[i].nameoff != 0 {
elfobj.sect[i].name = cstring(sect.base[elfobj.sect[i].nameoff:])
}
}
// load string table for symbols into memory.
elfobj.symtab = section(elfobj, ".symtab")
if elfobj.symtab == nil {
// our work is done here - no symbols means nothing can refer to this file
return
}
if elfobj.symtab.link <= 0 || elfobj.symtab.link >= uint32(elfobj.nsect) {
Errorf(nil, "%s: elf object has symbol table with invalid string table link", pn)
return
}
elfobj.symstr = &elfobj.sect[elfobj.symtab.link]
if is64 != 0 {
elfobj.nsymtab = int(elfobj.symtab.size / ELF64SYMSIZE)
} else {
elfobj.nsymtab = int(elfobj.symtab.size / ELF32SYMSIZE)
}
if err = elfmap(elfobj, elfobj.symtab); err != nil {
goto bad
}
if err = elfmap(elfobj, elfobj.symstr); err != nil {
goto bad
}
// load text and data segments into memory.
// they are not as small as the section lists, but we'll need
// the memory anyway for the symbol images, so we might
// as well use one large chunk.
// create symbols for elfmapped sections
for i := 0; uint(i) < elfobj.nsect; i++ {
sect = &elfobj.sect[i]
if sect.type_ == SHT_ARM_ATTRIBUTES && sect.name == ".ARM.attributes" {
if err = elfmap(elfobj, sect); err != nil {
goto bad
}
parseArmAttributes(ctxt, e, sect.base[:sect.size])
}
if (sect.type_ != ElfSectProgbits && sect.type_ != ElfSectNobits) || sect.flags&ElfSectFlagAlloc == 0 {
continue
}
if sect.type_ != ElfSectNobits {
if err = elfmap(elfobj, sect); err != nil {
goto bad
}
}
name = fmt.Sprintf("%s(%s)", pkg, sect.name)
s = ctxt.Syms.Lookup(name, localSymVersion)
switch int(sect.flags) & (ElfSectFlagAlloc | ElfSectFlagWrite | ElfSectFlagExec) {
default:
err = fmt.Errorf("unexpected flags for ELF section %s", sect.name)
goto bad
case ElfSectFlagAlloc:
s.Type = obj.SRODATA
case ElfSectFlagAlloc + ElfSectFlagWrite:
if sect.type_ == ElfSectNobits {
s.Type = obj.SNOPTRBSS
} else {
s.Type = obj.SNOPTRDATA
}
case ElfSectFlagAlloc + ElfSectFlagExec:
s.Type = obj.STEXT
}
if sect.name == ".got" || sect.name == ".toc" {
s.Type = obj.SELFGOT
}
if sect.type_ == ElfSectProgbits {
s.P = sect.base
s.P = s.P[:sect.size]
}
s.Size = int64(sect.size)
s.Align = int32(sect.align)
sect.sym = s
}
// enter sub-symbols into symbol table.
// symbol 0 is the null symbol.
symbols = make([]*Symbol, elfobj.nsymtab)
for i := 1; i < elfobj.nsymtab; i++ {
if err = readelfsym(ctxt, elfobj, i, &sym, 1, localSymVersion); err != nil {
goto bad
}
symbols[i] = sym.sym
if sym.type_ != ElfSymTypeFunc && sym.type_ != ElfSymTypeObject && sym.type_ != ElfSymTypeNone {
continue
}
if sym.shndx == ElfSymShnCommon {
s = sym.sym
if uint64(s.Size) < sym.size {
s.Size = int64(sym.size)
}
if s.Type == 0 || s.Type == obj.SXREF {
s.Type = obj.SNOPTRBSS
}
continue
}
if uint(sym.shndx) >= elfobj.nsect || sym.shndx == 0 {
continue
}
// even when we pass needSym == 1 to readelfsym, it might still return nil to skip some unwanted symbols
if sym.sym == nil {
continue
}
sect = &elfobj.sect[sym.shndx]
if sect.sym == nil {
if strings.HasPrefix(sym.name, ".Linfo_string") { // clang does this
continue
}
if sym.name == "" && sym.type_ == 0 && sect.name == ".debug_str" {
// This reportedly happens with clang 3.7 on ARM.
// See issue 13139.
continue
}
if strings.HasPrefix(sym.name, ".LASF") { // gcc on s390x does this
continue
}
Errorf(sym.sym, "%s: sym#%d: ignoring symbol in section %d (type %d)", pn, i, sym.shndx, sym.type_)
continue
}
s = sym.sym
if s.Outer != nil {
if s.Attr.DuplicateOK() {
continue
}
Exitf("%s: duplicate symbol reference: %s in both %s and %s", pn, s.Name, s.Outer.Name, sect.sym.Name)
}
s.Sub = sect.sym.Sub
sect.sym.Sub = s
s.Type = sect.sym.Type | s.Type&^obj.SMASK | obj.SSUB
if !s.Attr.CgoExportDynamic() {
s.Dynimplib = "" // satisfy dynimport
}
s.Value = int64(sym.value)
s.Size = int64(sym.size)
s.Outer = sect.sym
if sect.sym.Type == obj.STEXT {
if s.Attr.External() && !s.Attr.DuplicateOK() {
Errorf(s, "%s: duplicate symbol definition", pn)
}
s.Attr |= AttrExternal
}
if elfobj.machine == ElfMachPower64 {
flag = int(sym.other) >> 5
if 2 <= flag && flag <= 6 {
s.Localentry = 1 << uint(flag-2)
} else if flag == 7 {
Errorf(s, "%s: invalid sym.other 0x%x", pn, sym.other)
}
}
}
// Sort outer lists by address, adding to textp.
// This keeps textp in increasing address order.
for i := 0; uint(i) < elfobj.nsect; i++ {
s = elfobj.sect[i].sym
if s == nil {
continue
}
if s.Sub != nil {
s.Sub = listsort(s.Sub)
}
if s.Type == obj.STEXT {
if s.Attr.OnList() {
log.Fatalf("symbol %s listed multiple times", s.Name)
}
s.Attr |= AttrOnList
ctxt.Textp = append(ctxt.Textp, s)
for s = s.Sub; s != nil; s = s.Sub {
if s.Attr.OnList() {
log.Fatalf("symbol %s listed multiple times", s.Name)
}
s.Attr |= AttrOnList
ctxt.Textp = append(ctxt.Textp, s)
}
}
}
// load relocations
for i := 0; uint(i) < elfobj.nsect; i++ {
rsect = &elfobj.sect[i]
if rsect.type_ != ElfSectRela && rsect.type_ != ElfSectRel {
continue
}
if rsect.info >= uint32(elfobj.nsect) || elfobj.sect[rsect.info].base == nil {
continue
}
sect = &elfobj.sect[rsect.info]
if err = elfmap(elfobj, rsect); err != nil {
goto bad
}
rela = 0
if rsect.type_ == ElfSectRela {
rela = 1
}
n = int(rsect.size / uint64(4+4*is64) / uint64(2+rela))
r = make([]Reloc, n)
p = rsect.base
for j = 0; j < n; j++ {
add = 0
rp = &r[j]
if is64 != 0 {
// 64-bit rel/rela
rp.Off = int32(e.Uint64(p))
p = p[8:]
info = e.Uint64(p)
p = p[8:]
if rela != 0 {
add = e.Uint64(p)
p = p[8:]
}
} else {
// 32-bit rel/rela
rp.Off = int32(e.Uint32(p))
p = p[4:]
info = uint64(e.Uint32(p))
info = info>>8<<32 | info&0xff // convert to 64-bit info
p = p[4:]
if rela != 0 {
add = uint64(e.Uint32(p))
p = p[4:]
}
}
if info&0xffffffff == 0 { // skip R_*_NONE relocation
j--
n--
continue
}
if info>>32 == 0 { // absolute relocation, don't bother reading the null symbol
rp.Sym = nil
} else {
if err = readelfsym(ctxt, elfobj, int(info>>32), &sym, 0, 0); err != nil {
goto bad
}
sym.sym = symbols[info>>32]
if sym.sym == nil {
err = fmt.Errorf("%s#%d: reloc of invalid sym #%d %s shndx=%d type=%d", sect.sym.Name, j, int(info>>32), sym.name, sym.shndx, sym.type_)
goto bad
}
rp.Sym = sym.sym
}
rp.Type = 256 + obj.RelocType(info)
rp.Siz = relSize(ctxt, pn, uint32(info))
if rela != 0 {
rp.Add = int64(add)
} else {
// load addend from image
if rp.Siz == 4 {
rp.Add = int64(e.Uint32(sect.base[rp.Off:]))
} else if rp.Siz == 8 {
rp.Add = int64(e.Uint64(sect.base[rp.Off:]))
} else {
Errorf(nil, "invalid rela size %d", rp.Siz)
}
}
if rp.Siz == 2 {
rp.Add = int64(int16(rp.Add))
}
if rp.Siz == 4 {
rp.Add = int64(int32(rp.Add))
}
}
//print("rel %s %d %d %s %#llx\n", sect->sym->name, rp->type, rp->siz, rp->sym->name, rp->add);
sort.Sort(rbyoff(r[:n]))
// just in case
s = sect.sym
s.R = r
s.R = s.R[:n]
}
return
bad:
Errorf(nil, "%s: malformed elf file: %v", pn, err)
}
func ldelf(f *Biobuf, pkg string, length int64, pn string) {
if Debug['v'] != 0 {
fmt.Fprintf(&Bso, "%5.2f ldelf %s\n", obj.Cputime(), pn)
}
Ctxt.Version++
base := int32(Boffset(f))
var add uint64
var e binary.ByteOrder
var elfobj *ElfObj
var err error
var flag int
var hdr *ElfHdrBytes
var hdrbuf [64]uint8
var info uint64
var is64 int
var j int
var n int
var name string
var p []byte
var r []Reloc
var rela int
var rp *Reloc
var rsect *ElfSect
var s *LSym
var sect *ElfSect
var sym ElfSym
var symbols []*LSym
if Bread(f, hdrbuf[:]) != len(hdrbuf) {
goto bad
}
hdr = new(ElfHdrBytes)
binary.Read(bytes.NewReader(hdrbuf[:]), binary.BigEndian, hdr) // only byte arrays; byte order doesn't matter
if string(hdr.Ident[:4]) != "\x7FELF" {
goto bad
}
switch hdr.Ident[5] {
case ElfDataLsb:
e = binary.LittleEndian
case ElfDataMsb:
e = binary.BigEndian
default:
goto bad
}
// read header
elfobj = new(ElfObj)
elfobj.e = e
elfobj.f = f
elfobj.base = int64(base)
elfobj.length = length
elfobj.name = pn
is64 = 0
if hdr.Ident[4] == ElfClass64 {
is64 = 1
hdr := new(ElfHdrBytes64)
binary.Read(bytes.NewReader(hdrbuf[:]), binary.BigEndian, hdr) // only byte arrays; byte order doesn't matter
elfobj.type_ = uint32(e.Uint16(hdr.Type[:]))
elfobj.machine = uint32(e.Uint16(hdr.Machine[:]))
elfobj.version = e.Uint32(hdr.Version[:])
elfobj.phoff = e.Uint64(hdr.Phoff[:])
elfobj.shoff = e.Uint64(hdr.Shoff[:])
elfobj.flags = e.Uint32(hdr.Flags[:])
elfobj.ehsize = uint32(e.Uint16(hdr.Ehsize[:]))
elfobj.phentsize = uint32(e.Uint16(hdr.Phentsize[:]))
elfobj.phnum = uint32(e.Uint16(hdr.Phnum[:]))
elfobj.shentsize = uint32(e.Uint16(hdr.Shentsize[:]))
elfobj.shnum = uint32(e.Uint16(hdr.Shnum[:]))
elfobj.shstrndx = uint32(e.Uint16(hdr.Shstrndx[:]))
} else {
elfobj.type_ = uint32(e.Uint16(hdr.Type[:]))
elfobj.machine = uint32(e.Uint16(hdr.Machine[:]))
elfobj.version = e.Uint32(hdr.Version[:])
elfobj.entry = uint64(e.Uint32(hdr.Entry[:]))
elfobj.phoff = uint64(e.Uint32(hdr.Phoff[:]))
elfobj.shoff = uint64(e.Uint32(hdr.Shoff[:]))
elfobj.flags = e.Uint32(hdr.Flags[:])
elfobj.ehsize = uint32(e.Uint16(hdr.Ehsize[:]))
elfobj.phentsize = uint32(e.Uint16(hdr.Phentsize[:]))
elfobj.phnum = uint32(e.Uint16(hdr.Phnum[:]))
elfobj.shentsize = uint32(e.Uint16(hdr.Shentsize[:]))
elfobj.shnum = uint32(e.Uint16(hdr.Shnum[:]))
elfobj.shstrndx = uint32(e.Uint16(hdr.Shstrndx[:]))
}
elfobj.is64 = is64
if uint32(hdr.Ident[6]) != elfobj.version {
goto bad
}
if e.Uint16(hdr.Type[:]) != ElfTypeRelocatable {
Diag("%s: elf but not elf relocatable object", pn)
return
}
switch Thearch.Thechar {
default:
Diag("%s: elf %s unimplemented", pn, Thestring)
return
case '5':
if e != binary.LittleEndian || elfobj.machine != ElfMachArm || hdr.Ident[4] != ElfClass32 {
Diag("%s: elf object but not arm", pn)
return
}
case '6':
if e != binary.LittleEndian || elfobj.machine != ElfMachAmd64 || hdr.Ident[4] != ElfClass64 {
Diag("%s: elf object but not amd64", pn)
return
}
case '7':
if e != binary.LittleEndian || elfobj.machine != ElfMachArm64 || hdr.Ident[4] != ElfClass64 {
Diag("%s: elf object but not arm64", pn)
return
}
case '8':
if e != binary.LittleEndian || elfobj.machine != ElfMach386 || hdr.Ident[4] != ElfClass32 {
Diag("%s: elf object but not 386", pn)
return
}
case '9':
if elfobj.machine != ElfMachPower64 || hdr.Ident[4] != ElfClass64 {
Diag("%s: elf object but not ppc64", pn)
return
}
}
// load section list into memory.
elfobj.sect = make([]ElfSect, elfobj.shnum)
elfobj.nsect = uint(elfobj.shnum)
for i := 0; uint(i) < elfobj.nsect; i++ {
if Bseek(f, int64(uint64(base)+elfobj.shoff+uint64(int64(i)*int64(elfobj.shentsize))), 0) < 0 {
goto bad
}
sect = &elfobj.sect[i]
if is64 != 0 {
var b ElfSectBytes64
if err = binary.Read(f, e, &b); err != nil {
goto bad
}
sect.nameoff = uint32(e.Uint32(b.Name[:]))
sect.type_ = e.Uint32(b.Type[:])
sect.flags = e.Uint64(b.Flags[:])
sect.addr = e.Uint64(b.Addr[:])
sect.off = e.Uint64(b.Off[:])
sect.size = e.Uint64(b.Size[:])
sect.link = e.Uint32(b.Link[:])
sect.info = e.Uint32(b.Info[:])
sect.align = e.Uint64(b.Align[:])
sect.entsize = e.Uint64(b.Entsize[:])
} else {
var b ElfSectBytes
if err = binary.Read(f, e, &b); err != nil {
goto bad
}
sect.nameoff = uint32(e.Uint32(b.Name[:]))
sect.type_ = e.Uint32(b.Type[:])
sect.flags = uint64(e.Uint32(b.Flags[:]))
sect.addr = uint64(e.Uint32(b.Addr[:]))
sect.off = uint64(e.Uint32(b.Off[:]))
sect.size = uint64(e.Uint32(b.Size[:]))
sect.link = e.Uint32(b.Link[:])
sect.info = e.Uint32(b.Info[:])
sect.align = uint64(e.Uint32(b.Align[:]))
sect.entsize = uint64(e.Uint32(b.Entsize[:]))
}
}
// read section string table and translate names
if elfobj.shstrndx >= uint32(elfobj.nsect) {
err = fmt.Errorf("shstrndx out of range %d >= %d", elfobj.shstrndx, elfobj.nsect)
goto bad
}
sect = &elfobj.sect[elfobj.shstrndx]
if err = elfmap(elfobj, sect); err != nil {
goto bad
}
for i := 0; uint(i) < elfobj.nsect; i++ {
if elfobj.sect[i].nameoff != 0 {
elfobj.sect[i].name = cstring(sect.base[elfobj.sect[i].nameoff:])
}
}
// load string table for symbols into memory.
elfobj.symtab = section(elfobj, ".symtab")
if elfobj.symtab == nil {
// our work is done here - no symbols means nothing can refer to this file
return
}
if elfobj.symtab.link <= 0 || elfobj.symtab.link >= uint32(elfobj.nsect) {
Diag("%s: elf object has symbol table with invalid string table link", pn)
return
}
elfobj.symstr = &elfobj.sect[elfobj.symtab.link]
if is64 != 0 {
elfobj.nsymtab = int(elfobj.symtab.size / ELF64SYMSIZE)
} else {
elfobj.nsymtab = int(elfobj.symtab.size / ELF32SYMSIZE)
}
if err = elfmap(elfobj, elfobj.symtab); err != nil {
goto bad
}
if err = elfmap(elfobj, elfobj.symstr); err != nil {
goto bad
}
// load text and data segments into memory.
// they are not as small as the section lists, but we'll need
// the memory anyway for the symbol images, so we might
// as well use one large chunk.
// create symbols for elfmapped sections
for i := 0; uint(i) < elfobj.nsect; i++ {
sect = &elfobj.sect[i]
if (sect.type_ != ElfSectProgbits && sect.type_ != ElfSectNobits) || sect.flags&ElfSectFlagAlloc == 0 {
continue
}
if sect.type_ != ElfSectNobits {
if err = elfmap(elfobj, sect); err != nil {
goto bad
}
}
name = fmt.Sprintf("%s(%s)", pkg, sect.name)
s = Linklookup(Ctxt, name, Ctxt.Version)
switch int(sect.flags) & (ElfSectFlagAlloc | ElfSectFlagWrite | ElfSectFlagExec) {
default:
err = fmt.Errorf("unexpected flags for ELF section %s", sect.name)
goto bad
case ElfSectFlagAlloc:
s.Type = SRODATA
case ElfSectFlagAlloc + ElfSectFlagWrite:
if sect.type_ == ElfSectNobits {
s.Type = SNOPTRBSS
} else {
s.Type = SNOPTRDATA
}
case ElfSectFlagAlloc + ElfSectFlagExec:
s.Type = STEXT
}
if sect.name == ".got" || sect.name == ".toc" {
s.Type = SELFGOT
}
if sect.type_ == ElfSectProgbits {
s.P = sect.base
s.P = s.P[:sect.size]
}
s.Size = int64(sect.size)
s.Align = int32(sect.align)
sect.sym = s
}
// enter sub-symbols into symbol table.
// symbol 0 is the null symbol.
symbols = make([]*LSym, elfobj.nsymtab)
if symbols == nil {
Diag("out of memory")
Errorexit()
}
for i := 1; i < elfobj.nsymtab; i++ {
if err = readelfsym(elfobj, i, &sym, 1); err != nil {
goto bad
}
symbols[i] = sym.sym
if sym.type_ != ElfSymTypeFunc && sym.type_ != ElfSymTypeObject && sym.type_ != ElfSymTypeNone {
continue
}
if sym.shndx == ElfSymShnCommon {
s = sym.sym
if uint64(s.Size) < sym.size {
s.Size = int64(sym.size)
}
if s.Type == 0 || s.Type == SXREF {
s.Type = SNOPTRBSS
}
continue
}
if uint(sym.shndx) >= elfobj.nsect || sym.shndx == 0 {
continue
}
// even when we pass needSym == 1 to readelfsym, it might still return nil to skip some unwanted symbols
if sym.sym == nil {
continue
}
sect = &elfobj.sect[sym.shndx:][0]
if sect.sym == nil {
if strings.HasPrefix(sym.name, ".Linfo_string") { // clang does this
continue
}
Diag("%s: sym#%d: ignoring %s in section %d (type %d)", pn, i, sym.name, sym.shndx, sym.type_)
continue
}
s = sym.sym
if s.Outer != nil {
if s.Dupok != 0 {
continue
}
Diag("%s: duplicate symbol reference: %s in both %s and %s", pn, s.Name, s.Outer.Name, sect.sym.Name)
Errorexit()
}
s.Sub = sect.sym.Sub
sect.sym.Sub = s
s.Type = sect.sym.Type | s.Type&^SMASK | SSUB
if s.Cgoexport&CgoExportDynamic == 0 {
s.Dynimplib = "" // satisfy dynimport
}
s.Value = int64(sym.value)
s.Size = int64(sym.size)
s.Outer = sect.sym
if sect.sym.Type == STEXT {
if s.External != 0 && s.Dupok == 0 {
Diag("%s: duplicate definition of %s", pn, s.Name)
}
s.External = 1
}
if elfobj.machine == ElfMachPower64 {
flag = int(sym.other) >> 5
if 2 <= flag && flag <= 6 {
s.Localentry = 1 << uint(flag-2)
} else if flag == 7 {
Diag("%s: invalid sym.other 0x%x for %s", pn, sym.other, s.Name)
}
}
}
// Sort outer lists by address, adding to textp.
// This keeps textp in increasing address order.
for i := 0; uint(i) < elfobj.nsect; i++ {
s = elfobj.sect[i].sym
if s == nil {
continue
}
if s.Sub != nil {
s.Sub = listsort(s.Sub, valuecmp, listsubp)
}
if s.Type == STEXT {
if s.Onlist != 0 {
log.Fatalf("symbol %s listed multiple times", s.Name)
}
s.Onlist = 1
if Ctxt.Etextp != nil {
Ctxt.Etextp.Next = s
} else {
Ctxt.Textp = s
}
Ctxt.Etextp = s
for s = s.Sub; s != nil; s = s.Sub {
if s.Onlist != 0 {
log.Fatalf("symbol %s listed multiple times", s.Name)
}
s.Onlist = 1
Ctxt.Etextp.Next = s
Ctxt.Etextp = s
}
}
}
// load relocations
for i := 0; uint(i) < elfobj.nsect; i++ {
rsect = &elfobj.sect[i]
if rsect.type_ != ElfSectRela && rsect.type_ != ElfSectRel {
continue
}
if rsect.info >= uint32(elfobj.nsect) || elfobj.sect[rsect.info].base == nil {
continue
}
sect = &elfobj.sect[rsect.info]
if err = elfmap(elfobj, rsect); err != nil {
goto bad
}
rela = 0
if rsect.type_ == ElfSectRela {
rela = 1
}
n = int(rsect.size / uint64(4+4*is64) / uint64(2+rela))
r = make([]Reloc, n)
p = rsect.base
for j = 0; j < n; j++ {
add = 0
rp = &r[j]
if is64 != 0 {
// 64-bit rel/rela
rp.Off = int32(e.Uint64(p))
p = p[8:]
info = e.Uint64(p)
p = p[8:]
if rela != 0 {
add = e.Uint64(p)
p = p[8:]
}
} else {
// 32-bit rel/rela
rp.Off = int32(e.Uint32(p))
p = p[4:]
info = uint64(e.Uint32(p))
info = info>>8<<32 | info&0xff // convert to 64-bit info
p = p[4:]
if rela != 0 {
add = uint64(e.Uint32(p))
p = p[4:]
}
}
if info&0xffffffff == 0 { // skip R_*_NONE relocation
j--
n--
continue
}
if info>>32 == 0 { // absolute relocation, don't bother reading the null symbol
rp.Sym = nil
} else {
if err = readelfsym(elfobj, int(info>>32), &sym, 0); err != nil {
goto bad
}
sym.sym = symbols[info>>32]
if sym.sym == nil {
err = fmt.Errorf("%s#%d: reloc of invalid sym #%d %s shndx=%d type=%d", sect.sym.Name, j, int(info>>32), sym.name, sym.shndx, sym.type_)
goto bad
}
rp.Sym = sym.sym
}
rp.Type = int32(reltype(pn, int(uint32(info)), &rp.Siz))
if rela != 0 {
rp.Add = int64(add)
} else {
// load addend from image
if rp.Siz == 4 {
rp.Add = int64(e.Uint32(sect.base[rp.Off:]))
} else if rp.Siz == 8 {
rp.Add = int64(e.Uint64(sect.base[rp.Off:]))
} else {
Diag("invalid rela size %d", rp.Siz)
}
}
if rp.Siz == 2 {
rp.Add = int64(int16(rp.Add))
}
if rp.Siz == 4 {
rp.Add = int64(int32(rp.Add))
}
}
//print("rel %s %d %d %s %#llx\n", sect->sym->name, rp->type, rp->siz, rp->sym->name, rp->add);
sort.Sort(rbyoff(r[:n]))
// just in case
s = sect.sym
s.R = r
s.R = s.R[:n]
}
return
bad:
Diag("%s: malformed elf file: %v", pn, err)
}
func getFloat64(b []byte, byteOrder binary.ByteOrder) (float64, int) {
return math.Float64frombits(byteOrder.Uint64(b)), 8
}