From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001
From: upstream source tree <ports@midipix.org>
Date: Sun, 15 Mar 2015 20:14:05 -0400
Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified
 gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream
 tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.
---
 libgo/go/debug/dwarf/buf.go | 154 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 libgo/go/debug/dwarf/buf.go

(limited to 'libgo/go/debug/dwarf/buf.go')

diff --git a/libgo/go/debug/dwarf/buf.go b/libgo/go/debug/dwarf/buf.go
new file mode 100644
index 000000000..2d29cebdd
--- /dev/null
+++ b/libgo/go/debug/dwarf/buf.go
@@ -0,0 +1,154 @@
+// 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
+}
-- 
cgit v1.2.3