podman

1
// Copyright 2019 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
package goobj
6

7
import (
8
	"bytes"
9
	"github.com/twitchyliquid64/golang-asm/objabi"
10
	"encoding/binary"
11
)
12

13
// CUFileIndex is used to index the filenames that are stored in the
14
// per-package/per-CU FileList.
15
type CUFileIndex uint32
16

17
// FuncInfo is serialized as a symbol (aux symbol). The symbol data is
18
// the binary encoding of the struct below.
19
//
20
// TODO: make each pcdata a separate symbol?
21
type FuncInfo struct {
22
	Args   uint32
23
	Locals uint32
24
	FuncID objabi.FuncID
25

26
	Pcsp        uint32
27
	Pcfile      uint32
28
	Pcline      uint32
29
	Pcinline    uint32
30
	Pcdata      []uint32
31
	PcdataEnd   uint32
32
	Funcdataoff []uint32
33
	File        []CUFileIndex
34

35
	InlTree []InlTreeNode
36
}
37

38
func (a *FuncInfo) Write(w *bytes.Buffer) {
39
	var b [4]byte
40
	writeUint32 := func(x uint32) {
41
		binary.LittleEndian.PutUint32(b[:], x)
42
		w.Write(b[:])
43
	}
44

45
	writeUint32(a.Args)
46
	writeUint32(a.Locals)
47
	writeUint32(uint32(a.FuncID))
48

49
	writeUint32(a.Pcsp)
50
	writeUint32(a.Pcfile)
51
	writeUint32(a.Pcline)
52
	writeUint32(a.Pcinline)
53
	writeUint32(uint32(len(a.Pcdata)))
54
	for _, x := range a.Pcdata {
55
		writeUint32(x)
56
	}
57
	writeUint32(a.PcdataEnd)
58
	writeUint32(uint32(len(a.Funcdataoff)))
59
	for _, x := range a.Funcdataoff {
60
		writeUint32(x)
61
	}
62
	writeUint32(uint32(len(a.File)))
63
	for _, f := range a.File {
64
		writeUint32(uint32(f))
65
	}
66
	writeUint32(uint32(len(a.InlTree)))
67
	for i := range a.InlTree {
68
		a.InlTree[i].Write(w)
69
	}
70
}
71

72
func (a *FuncInfo) Read(b []byte) {
73
	readUint32 := func() uint32 {
74
		x := binary.LittleEndian.Uint32(b)
75
		b = b[4:]
76
		return x
77
	}
78

79
	a.Args = readUint32()
80
	a.Locals = readUint32()
81
	a.FuncID = objabi.FuncID(readUint32())
82

83
	a.Pcsp = readUint32()
84
	a.Pcfile = readUint32()
85
	a.Pcline = readUint32()
86
	a.Pcinline = readUint32()
87
	pcdatalen := readUint32()
88
	a.Pcdata = make([]uint32, pcdatalen)
89
	for i := range a.Pcdata {
90
		a.Pcdata[i] = readUint32()
91
	}
92
	a.PcdataEnd = readUint32()
93
	funcdataofflen := readUint32()
94
	a.Funcdataoff = make([]uint32, funcdataofflen)
95
	for i := range a.Funcdataoff {
96
		a.Funcdataoff[i] = readUint32()
97
	}
98
	filelen := readUint32()
99
	a.File = make([]CUFileIndex, filelen)
100
	for i := range a.File {
101
		a.File[i] = CUFileIndex(readUint32())
102
	}
103
	inltreelen := readUint32()
104
	a.InlTree = make([]InlTreeNode, inltreelen)
105
	for i := range a.InlTree {
106
		b = a.InlTree[i].Read(b)
107
	}
108
}
109

110
// FuncInfoLengths is a cache containing a roadmap of offsets and
111
// lengths for things within a serialized FuncInfo. Each length field
112
// stores the number of items (e.g. files, inltree nodes, etc), and the
113
// corresponding "off" field stores the byte offset of the start of
114
// the items in question.
115
type FuncInfoLengths struct {
116
	NumPcdata      uint32
117
	PcdataOff      uint32
118
	NumFuncdataoff uint32
119
	FuncdataoffOff uint32
120
	NumFile        uint32
121
	FileOff        uint32
122
	NumInlTree     uint32
123
	InlTreeOff     uint32
124
	Initialized    bool
125
}
126

127
func (*FuncInfo) ReadFuncInfoLengths(b []byte) FuncInfoLengths {
128
	var result FuncInfoLengths
129

130
	const numpcdataOff = 28
131
	result.NumPcdata = binary.LittleEndian.Uint32(b[numpcdataOff:])
132
	result.PcdataOff = numpcdataOff + 4
133

134
	numfuncdataoffOff := result.PcdataOff + 4*(result.NumPcdata+1)
135
	result.NumFuncdataoff = binary.LittleEndian.Uint32(b[numfuncdataoffOff:])
136
	result.FuncdataoffOff = numfuncdataoffOff + 4
137

138
	numfileOff := result.FuncdataoffOff + 4*result.NumFuncdataoff
139
	result.NumFile = binary.LittleEndian.Uint32(b[numfileOff:])
140
	result.FileOff = numfileOff + 4
141

142
	numinltreeOff := result.FileOff + 4*result.NumFile
143
	result.NumInlTree = binary.LittleEndian.Uint32(b[numinltreeOff:])
144
	result.InlTreeOff = numinltreeOff + 4
145

146
	result.Initialized = true
147

148
	return result
149
}
150

151
func (*FuncInfo) ReadArgs(b []byte) uint32 { return binary.LittleEndian.Uint32(b) }
152

153
func (*FuncInfo) ReadLocals(b []byte) uint32 { return binary.LittleEndian.Uint32(b[4:]) }
154

155
func (*FuncInfo) ReadFuncID(b []byte) uint32 { return binary.LittleEndian.Uint32(b[8:]) }
156

157
// return start and end offsets.
158
func (*FuncInfo) ReadPcsp(b []byte) (uint32, uint32) {
159
	return binary.LittleEndian.Uint32(b[12:]), binary.LittleEndian.Uint32(b[16:])
160
}
161

162
// return start and end offsets.
163
func (*FuncInfo) ReadPcfile(b []byte) (uint32, uint32) {
164
	return binary.LittleEndian.Uint32(b[16:]), binary.LittleEndian.Uint32(b[20:])
165
}
166

167
// return start and end offsets.
168
func (*FuncInfo) ReadPcline(b []byte) (uint32, uint32) {
169
	return binary.LittleEndian.Uint32(b[20:]), binary.LittleEndian.Uint32(b[24:])
170
}
171

172
// return start and end offsets.
173
func (*FuncInfo) ReadPcinline(b []byte, pcdataoffset uint32) (uint32, uint32) {
174
	return binary.LittleEndian.Uint32(b[24:]), binary.LittleEndian.Uint32(b[pcdataoffset:])
175
}
176

177
// return start and end offsets.
178
func (*FuncInfo) ReadPcdata(b []byte, pcdataoffset uint32, k uint32) (uint32, uint32) {
179
	return binary.LittleEndian.Uint32(b[pcdataoffset+4*k:]), binary.LittleEndian.Uint32(b[pcdataoffset+4+4*k:])
180
}
181

182
func (*FuncInfo) ReadFuncdataoff(b []byte, funcdataofffoff uint32, k uint32) int64 {
183
	return int64(binary.LittleEndian.Uint32(b[funcdataofffoff+4*k:]))
184
}
185

186
func (*FuncInfo) ReadFile(b []byte, filesoff uint32, k uint32) CUFileIndex {
187
	return CUFileIndex(binary.LittleEndian.Uint32(b[filesoff+4*k:]))
188
}
189

190
func (*FuncInfo) ReadInlTree(b []byte, inltreeoff uint32, k uint32) InlTreeNode {
191
	const inlTreeNodeSize = 4 * 6
192
	var result InlTreeNode
193
	result.Read(b[inltreeoff+k*inlTreeNodeSize:])
194
	return result
195
}
196

197
// InlTreeNode is the serialized form of FileInfo.InlTree.
198
type InlTreeNode struct {
199
	Parent   int32
200
	File     CUFileIndex
201
	Line     int32
202
	Func     SymRef
203
	ParentPC int32
204
}
205

206
func (inl *InlTreeNode) Write(w *bytes.Buffer) {
207
	var b [4]byte
208
	writeUint32 := func(x uint32) {
209
		binary.LittleEndian.PutUint32(b[:], x)
210
		w.Write(b[:])
211
	}
212
	writeUint32(uint32(inl.Parent))
213
	writeUint32(uint32(inl.File))
214
	writeUint32(uint32(inl.Line))
215
	writeUint32(inl.Func.PkgIdx)
216
	writeUint32(inl.Func.SymIdx)
217
	writeUint32(uint32(inl.ParentPC))
218
}
219

220
// Read an InlTreeNode from b, return the remaining bytes.
221
func (inl *InlTreeNode) Read(b []byte) []byte {
222
	readUint32 := func() uint32 {
223
		x := binary.LittleEndian.Uint32(b)
224
		b = b[4:]
225
		return x
226
	}
227
	inl.Parent = int32(readUint32())
228
	inl.File = CUFileIndex(readUint32())
229
	inl.Line = int32(readUint32())
230
	inl.Func = SymRef{readUint32(), readUint32()}
231
	inl.ParentPC = int32(readUint32())
232
	return b
233
}
234