1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// 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.
package ogle
import (
"debug/proc";
"math";
)
type Arch interface {
// ToWord converts an array of up to 8 bytes in memory order
// to a word.
ToWord(data []byte) proc.Word;
// FromWord converts a word to an array of up to 8 bytes in
// memory order.
FromWord(v proc.Word, out []byte);
// ToFloat32 converts a word to a float. The order of this
// word will be the order returned by ToWord on the memory
// representation of a float, and thus may require reversing.
ToFloat32(bits uint32) float32;
// FromFloat32 converts a float to a word. This should return
// a word that can be passed to FromWord to get the memory
// representation of a float on this architecture.
FromFloat32(f float32) uint32;
// ToFloat64 is to float64 as ToFloat32 is to float32.
ToFloat64(bits uint64) float64;
// FromFloat64 is to float64 as FromFloat32 is to float32.
FromFloat64(f float64) uint64;
// IntSize returns the number of bytes in an 'int'.
IntSize() int;
// PtrSize returns the number of bytes in a 'uintptr'.
PtrSize() int;
// FloatSize returns the number of bytes in a 'float'.
FloatSize() int;
// Align rounds offset up to the appropriate offset for a
// basic type with the given width.
Align(offset, width int) int;
// G returns the current G pointer.
G(regs proc.Regs) proc.Word;
// ClosureSize returns the number of bytes expected by
// ParseClosure.
ClosureSize() int;
// ParseClosure takes ClosureSize bytes read from a return PC
// in a remote process, determines if the code is a closure,
// and returns the frame size of the closure if it is.
ParseClosure(data []byte) (frame int, ok bool);
}
type ArchLSB struct{}
func (ArchLSB) ToWord(data []byte) proc.Word {
var v proc.Word;
for i, b := range data {
v |= proc.Word(b) << (uint(i)*8);
}
return v;
}
func (ArchLSB) FromWord(v proc.Word, out []byte) {
for i := range out {
out[i] = byte(v);
v >>= 8;
}
}
func (ArchLSB) ToFloat32(bits uint32) float32 {
// TODO(austin) Do these definitions depend on my current
// architecture?
return math.Float32frombits(bits);
}
func (ArchLSB) FromFloat32(f float32) uint32 {
return math.Float32bits(f);
}
func (ArchLSB) ToFloat64(bits uint64) float64 {
return math.Float64frombits(bits);
}
func (ArchLSB) FromFloat64(f float64) uint64 {
return math.Float64bits(f);
}
type ArchAlignedMultiple struct{}
func (ArchAlignedMultiple) Align(offset, width int) int {
return ((offset-1)|(width-1))+1;
}
type amd64 struct {
ArchLSB;
ArchAlignedMultiple;
gReg int;
}
func (a *amd64) IntSize() int {
return 4;
}
func (a *amd64) PtrSize() int {
return 8;
}
func (a *amd64) FloatSize() int {
return 4;
}
func (a *amd64) G(regs proc.Regs) proc.Word {
// See src/pkg/runtime/mkasmh
if a.gReg == -1 {
ns := regs.Names();
for i, n := range ns {
if n == "r15" {
a.gReg = i;
break;
}
}
}
return regs.Get(a.gReg);
}
func (a *amd64) ClosureSize() int {
return 8;
}
func (a *amd64) ParseClosure(data []byte) (int, bool) {
if data[0] == 0x48 && data[1] == 0x81 && data[2] == 0xc4 && data[7] == 0xc3 {
return int(a.ToWord(data[3:7]) + 8), true;
}
return 0, false;
}
var Amd64 = &amd64{gReg: -1}
|
