OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [debug/] [dwarf/] [buf.go] - Blame information for rev 747

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// Copyright 2009 The Go Authors.  All rights reserved.
2 
// Use of this source code is governed by a BSD-style
3 
// license that can be found in the LICENSE file.
4 
 
5 
// Buffered reading and decoding of DWARF data streams.
6 
 
7 
package dwarf
8 
 
9 
import (
10 
        "encoding/binary"
11 
        "strconv"
12 
)
13 
 
14 
// Data buffer being decoded.
15 
type buf struct {
16 
        dwarf    *Data
17 
        order    binary.ByteOrder
18 
        name     string
19 
        off      Offset
20 
        data     []byte
21 
        addrsize int
22 
        err      error
23 
}
24 
 
25 
func makeBuf(d *Data, name string, off Offset, data []byte, addrsize int) buf {
26 
        return buf{d, d.order, name, off, data, addrsize, nil}
27 
}
28 
 
29 
func (b *buf) uint8() uint8 {
30 
        if len(b.data) < 1 {
31 
                b.error("underflow")
32 
                return 0
33 
        }
34 
        val := b.data[0]
35 
        b.data = b.data[1:]
36 
        b.off++
37 
        return val
38 
}
39 
 
40 
func (b *buf) bytes(n int) []byte {
41 
        if len(b.data) < n {
42 
                b.error("underflow")
43 
                return nil
44 
        }
45 
        data := b.data[0:n]
46 
        b.data = b.data[n:]
47 
        b.off += Offset(n)
48 
        return data
49 
}
50 
 
51 
func (b *buf) skip(n int) { b.bytes(n) }
52 
 
53 
func (b *buf) string() string {
54 
        for i := 0; i < len(b.data); i++ {
55 
                if b.data[i] == 0 {
56 
                        s := string(b.data[0:i])
57 
                        b.data = b.data[i+1:]
58 
                        b.off += Offset(i + 1)
59 
                        return s
60 
                }
61 
        }
62 
        b.error("underflow")
63 
        return ""
64 
}
65 
 
66 
func (b *buf) uint16() uint16 {
67 
        a := b.bytes(2)
68 
        if a == nil {
69 
                return 0
70 
        }
71 
        return b.order.Uint16(a)
72 
}
73 
 
74 
func (b *buf) uint32() uint32 {
75 
        a := b.bytes(4)
76 
        if a == nil {
77 
                return 0
78 
        }
79 
        return b.order.Uint32(a)
80 
}
81 
 
82 
func (b *buf) uint64() uint64 {
83 
        a := b.bytes(8)
84 
        if a == nil {
85 
                return 0
86 
        }
87 
        return b.order.Uint64(a)
88 
}
89 
 
90 
// Read a varint, which is 7 bits per byte, little endian.
91 
// the 0x80 bit means read another byte.
92 
func (b *buf) varint() (c uint64, bits uint) {
93 
        for i := 0; i < len(b.data); i++ {
94 
                byte := b.data[i]
95 
                c |= uint64(byte&0x7F) << bits
96 
                bits += 7
97 
                if byte&0x80 == 0 {
98 
                        b.off += Offset(i + 1)
99 
                        b.data = b.data[i+1:]
100 
                        return c, bits
101 
                }
102 
        }
103 
        return 0, 0
104 
}
105 
 
106 
// Unsigned int is just a varint.
107 
func (b *buf) uint() uint64 {
108 
        x, _ := b.varint()
109 
        return x
110 
}
111 
 
112 
// Signed int is a sign-extended varint.
113 
func (b *buf) int() int64 {
114 
        ux, bits := b.varint()
115 
        x := int64(ux)
116 
        if x&(1<<(bits-1)) != 0 {
117 
                x |= -1 << bits
118 
        }
119 
        return x
120 
}
121 
 
122 
// Address-sized uint.
123 
func (b *buf) addr() uint64 {
124 
        switch b.addrsize {
125 
        case 1:
126 
                return uint64(b.uint8())
127 
        case 2:
128 
                return uint64(b.uint16())
129 
        case 4:
130 
                return uint64(b.uint32())
131 
        case 8:
132 
                return uint64(b.uint64())
133 
        }
134 
        b.error("unknown address size")
135 
        return 0
136 
}
137 
 
138 
func (b *buf) error(s string) {
139 
        if b.err == nil {
140 
                b.data = nil
141 
                b.err = DecodeError{b.name, b.off, s}
142 
        }
143 
}
144 
 
145 
type DecodeError struct {
146 
        Name   string
147 
        Offset Offset
148 
        Err    string
149 
}
150 
 
151 
func (e DecodeError) Error() string {
152 
        return "decoding dwarf section " + e.Name + " at offset 0x" + strconv.FormatInt(int64(e.Offset), 16) + ": " + e.Err
153 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.