7a9389330e
gcc/: * gcc.c (default_compilers): Add entry for ".go". * common.opt: Add -static-libgo as a driver option. * doc/install.texi (Configuration): Mention libgo as an option for --enable-shared. Mention go as an option for --enable-languages. * doc/invoke.texi (Overall Options): Mention .go as a file name suffix. Mention go as a -x option. * doc/frontends.texi (G++ and GCC): Mention Go as a supported language. * doc/sourcebuild.texi (Top Level): Mention libgo. * doc/standards.texi (Standards): Add section on Go language. Move references for other languages into their own section. * doc/contrib.texi (Contributors): Mention that I contributed the Go frontend. gcc/testsuite/: * lib/go.exp: New file. * lib/go-dg.exp: New file. * lib/go-torture.exp: New file. * lib/target-supports.exp (check_compile): Match // Go. From-SVN: r167407
155 lines
2.7 KiB
Go
155 lines
2.7 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Buffered reading and decoding of DWARF data streams.
|
|
|
|
package dwarf
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"os"
|
|
"strconv"
|
|
)
|
|
|
|
// Data buffer being decoded.
|
|
type buf struct {
|
|
dwarf *Data
|
|
order binary.ByteOrder
|
|
name string
|
|
off Offset
|
|
data []byte
|
|
addrsize int
|
|
err os.Error
|
|
}
|
|
|
|
func makeBuf(d *Data, name string, off Offset, data []byte, addrsize int) buf {
|
|
return buf{d, d.order, name, off, data, addrsize, nil}
|
|
}
|
|
|
|
func (b *buf) uint8() uint8 {
|
|
if len(b.data) < 1 {
|
|
b.error("underflow")
|
|
return 0
|
|
}
|
|
val := b.data[0]
|
|
b.data = b.data[1:]
|
|
b.off++
|
|
return val
|
|
}
|
|
|
|
func (b *buf) bytes(n int) []byte {
|
|
if len(b.data) < n {
|
|
b.error("underflow")
|
|
return nil
|
|
}
|
|
data := b.data[0:n]
|
|
b.data = b.data[n:]
|
|
b.off += Offset(n)
|
|
return data
|
|
}
|
|
|
|
func (b *buf) skip(n int) { b.bytes(n) }
|
|
|
|
func (b *buf) string() string {
|
|
for i := 0; i < len(b.data); i++ {
|
|
if b.data[i] == 0 {
|
|
s := string(b.data[0:i])
|
|
b.data = b.data[i+1:]
|
|
b.off += Offset(i + 1)
|
|
return s
|
|
}
|
|
}
|
|
b.error("underflow")
|
|
return ""
|
|
}
|
|
|
|
func (b *buf) uint16() uint16 {
|
|
a := b.bytes(2)
|
|
if a == nil {
|
|
return 0
|
|
}
|
|
return b.order.Uint16(a)
|
|
}
|
|
|
|
func (b *buf) uint32() uint32 {
|
|
a := b.bytes(4)
|
|
if a == nil {
|
|
return 0
|
|
}
|
|
return b.order.Uint32(a)
|
|
}
|
|
|
|
func (b *buf) uint64() uint64 {
|
|
a := b.bytes(8)
|
|
if a == nil {
|
|
return 0
|
|
}
|
|
return b.order.Uint64(a)
|
|
}
|
|
|
|
// Read a varint, which is 7 bits per byte, little endian.
|
|
// the 0x80 bit means read another byte.
|
|
func (b *buf) varint() (c uint64, bits uint) {
|
|
for i := 0; i < len(b.data); i++ {
|
|
byte := b.data[i]
|
|
c |= uint64(byte&0x7F) << bits
|
|
bits += 7
|
|
if byte&0x80 == 0 {
|
|
b.off += Offset(i + 1)
|
|
b.data = b.data[i+1:]
|
|
return c, bits
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
|
|
// Unsigned int is just a varint.
|
|
func (b *buf) uint() uint64 {
|
|
x, _ := b.varint()
|
|
return x
|
|
}
|
|
|
|
// Signed int is a sign-extended varint.
|
|
func (b *buf) int() int64 {
|
|
ux, bits := b.varint()
|
|
x := int64(ux)
|
|
if x&(1<<(bits-1)) != 0 {
|
|
x |= -1 << bits
|
|
}
|
|
return x
|
|
}
|
|
|
|
// Address-sized uint.
|
|
func (b *buf) addr() uint64 {
|
|
switch b.addrsize {
|
|
case 1:
|
|
return uint64(b.uint8())
|
|
case 2:
|
|
return uint64(b.uint16())
|
|
case 4:
|
|
return uint64(b.uint32())
|
|
case 8:
|
|
return uint64(b.uint64())
|
|
}
|
|
b.error("unknown address size")
|
|
return 0
|
|
}
|
|
|
|
func (b *buf) error(s string) {
|
|
if b.err == nil {
|
|
b.data = nil
|
|
b.err = DecodeError{b.name, b.off, s}
|
|
}
|
|
}
|
|
|
|
type DecodeError struct {
|
|
Name string
|
|
Offset Offset
|
|
Error string
|
|
}
|
|
|
|
func (e DecodeError) String() string {
|
|
return "decoding dwarf section " + e.Name + " at offset 0x" + strconv.Itob64(int64(e.Offset), 16) + ": " + e.Error
|
|
}
|