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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
# SPDX-License-Identifier: MIT
from contextlib import contextmanager, ExitStack
import sys, pathlib, os
import subprocess
import tempfile
import bisect
from .asm import NM, LD, OBJCOPY, ARMAsm
__all__ = ["LinkedProgram"]
def tool_output_lines(progname, *args):
with subprocess.Popen([progname.replace("%ARCH", ARMAsm.ARCH)] + list(args),
stdout=subprocess.PIPE) as proc:
for line in proc.stdout:
yield line.decode("ascii")
proc.wait()
if proc.returncode:
raise Exception(f"{progname} (args: {args}) exited with status {proc.returncode}")
def run_tool(progname, *args, silent=False):
subprocess.check_call([progname.replace("%ARCH", ARMAsm.ARCH)] + list(args),
stdout=subprocess.DEVNULL if silent else None)
class LinkedProgram:
SOURCE_ROOT = str(pathlib.Path(__file__).resolve().parents[2])
def __init__(self, u, base_object=None):
self.u = u
self.symbols = []
self.symaddrs = dict()
self.base_object = base_object
self._alloced_bases = []
self._attrs_to_clear = []
self._load_base_symbols()
def _load_base_symbols(self):
if self.base_object is None:
suffix = "-raw" if not self.m1n1_is_macho() else ""
self.base_object = f"build/m1n1{suffix}.elf"
addrs = self._load_elf_symbols(self.base_object, self.u.proxy.get_base())
# sanity check: compare the .rela table between ELF and m1n1 image on target
rela_base = addrs["_rela_start"]
rela_length = addrs["_rela_end"] - rela_base
rela_target = self.u.iface.readmem(rela_base, rela_length)
tmp = os.path.join(tempfile.mkdtemp(), "bin")
path = os.path.join(self.SOURCE_ROOT, self.base_object)
run_tool(OBJCOPY, "-O", "binary", path, tmp, "--only-section=.rela.dyn")
rela_objfile = open(tmp, "rb").read()
if rela_objfile[:len(rela_target)] != rela_target:
raise Exception(f"Mismatch between {self.base_object} and image on target")
def m1n1_is_macho(self):
p = self.u.proxy
return p.read32(p.get_base()) == 0xfeedfacf
def _load_elf_symbols(self, relpath, offset=0,
objname=None, ignore=""):
path = pathlib.Path(self.SOURCE_ROOT, relpath)
symaddrs = dict()
for line in tool_output_lines(NM, "-g", path):
addr_str, t, name = line.split()
addr = int(addr_str, 16) + offset
if t in ignore:
continue
self.symbols.append((addr, name, objname))
symaddrs[name] = addr
if t in "T" and not hasattr(self, name):
setattr(self, name, self._wrap_call_to(addr))
if relpath != self.base_object:
self._attrs_to_clear.append(name)
self.symbols.sort()
return symaddrs
def load_obj(self, objfile, base=None):
ALLOC_SIZE = 16*4096
if base is None:
base = self.u.heap.memalign(0x4000, ALLOC_SIZE)
self._alloced_bases.append(base)
objfile = os.path.join(self.SOURCE_ROOT, objfile)
tmp = tempfile.mkdtemp() + os.sep
elffile = tmp + "elf"
ld_script = tmp + "ld"
binfile = tmp + "bin"
with open(ld_script, "w") as f:
f.write("SECTIONS {\n")
f.write(f". = 0x{base:x};\n")
f.write(".text : { *(.text .text.*) }\n")
f.write(".data : { *(.got .data .data.* .rodata .rodata.* .bss .bss.*) }\n")
f.write("}\n")
for sym in self.symbols:
f.write(f"{sym[1]} = 0x{sym[0]:x};\n")
run_tool(LD, "-EL", "-maarch64elf", "-T", ld_script, "-o", elffile, objfile)
run_tool(OBJCOPY, "-O", "binary", elffile, binfile)
#run_tool("objdump", "-d", elffile)
self._load_elf_symbols(elffile, ignore="A")
with open(binfile, "rb") as f:
buf = f.read()
assert len(buf) <= ALLOC_SIZE
self.u.iface.writemem(base, buf)
self.u.proxy.dc_cvau(base, len(buf))
self.u.proxy.ic_ivau(base, len(buf))
def clear_objs(self):
for name in self._attrs_to_clear:
delattr(self, name)
self._attrs_to_clear = []
for base in self._alloced_bases:
self.u.free(base)
self._alloced_bases = []
self.symbols = [(a, b, objname) for (a, b, objname) \
in self.symbols if objname == self.base_object]
@contextmanager
def _copy_args_to_target(self, args):
heap = self.u.heap
with ExitStack() as stack:
args_copied = []
for arg in args:
if type(arg) is str:
arg = arg.encode("ascii")
# fallthrough
if type(arg) is bytes:
p = stack.enter_context(heap.guarded_malloc(len(arg) + 1))
self.u.iface.writemem(p, arg + b"\0")
args_copied.append(p)
elif type(arg) is int:
args_copied.append(arg)
else:
raise NotImplementedError(type(arg))
yield args_copied
def _wrap_call_to(self, addr):
def call_symbol(*args, call=self.u.proxy.call):
with self._copy_args_to_target(args) as args_copied:
return call(addr, *args_copied)
return call_symbol
def lookup(self, addr):
idx = bisect.bisect_left(self.symbols, (addr + 1, "", "")) - 1
if idx < 0 or idx >= len(self.symbols):
return None, None
return self.symbols[idx]
def load_inline_c(self, source):
tmp = tempfile.mkdtemp()
cfile = tmp + ".c"
objfile = tmp + ".o"
with open(cfile, "w") as f:
f.write(source)
run_tool("make", "-C", self.SOURCE_ROOT, "invoke_cc",
f"OBJFILE={objfile}", f"CFILE={cfile}", silent=True)
self.load_obj(objfile)
if __name__ == "__main__":
from m1n1.setup import *
lp = LinkedProgram(u)
lp.debug_printf("hello from the other side! (%d)\n", 42)
lp.load_inline_c('''
#include "utils.h"
int add(int a, int b) {
debug_printf("adding %d and %d\\n", a, b);
return a + b;
}
''')
print(f"1 + 2 = {lp.add(1, 2)}")
|
