├── LICENSE
├── subasm.py
├── subasm.spec
└── subleq.rop


/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2019 Ryan Hileman
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/subasm.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | 
  3 | ## var
  4 | # x
  5 | # x[0]
  6 | # x[x]
  7 | 
  8 | ## immediates
  9 | # 0
 10 | # 0x1
 11 | # -1
 12 | # 'a'
 13 | # [0, 1, 2, 3] # global array of 32-bit imms
 14 | # [aaaaaaa]    # global array of 32-bit chars
 15 | 
 16 | ## operators
 17 | # + - * / %
 18 | 
 19 | ## labels
 20 | # label:
 21 | 
 22 | ## jumps
 23 | # jmp label
 24 | # jmp label if var <conditional> var_or_imm
 25 | 
 26 | ## conditionals
 27 | # == != < > <= >=
 28 | 
 29 | # var parsing
 30 | var_embed = r'\w+(\[[^\]]+\])?'
 31 | imm_embed = r"(-?(0x[0-9a-fA-F]+|[0-9]+|'[a-z]')|len\(\w+\))"
 32 | var_imm_embed = r'({}|{})'.format(var_embed, imm_embed)
 33 | 
 34 | array_embed = r"\[([a-z]+|{}(,\s*{})*)\]".format(imm_embed, imm_embed)
 35 | 
 36 | var_re = re.compile(r'^((?P<name>\w+?)(?P<index>\[[^\]]+\])?)$')
 37 | imm_re = re.compile(r"^((?P<numeric>-?(0x[0-9a-fA-F]+|[0-9]+))|'(?P<char>[a-z])')$")
 38 | array_re = re.compile(r"\[((?P<chars>[a-z]+)|(?P<elements>[^]]+))\]")
 39 | 
 40 | ops = '-=+*/%'
 41 | op_embed = '(' + ('|'.join([re.escape(o) for o in ops])) + ')'
 42 | conds = ['==', '!=', '<', '<=', '>=']
 43 | cond_embed = '(' + ('|'.join([re.escape(o) for o in conds])) + ')'
 44 | 
 45 | label_re = re.compile(r'^(?P<name>\w+):$')
 46 | assign_line_re = re.compile(r'^(?P<dst>{})\s*=\s*(?P<src>{}|{})$'.format(var_embed, var_imm_embed, array_embed))
 47 | expr_line_re = re.compile(r'^(?P<dst>{})\s*=\s*(?P<src_a>{})\s*(?P<op>{})\s*(?P<src_b>{})$'.format(var_embed, var_imm_embed, op_embed, var_imm_embed))
 48 | jump_line_re = re.compile(r'^jmp\s*(?P<label>\w+)(\s*if\s*(?P<var>{})\s*(?P<cond>{})\s*(?P<cmpto>{}))?$'.format(var_embed, cond_embed, var_imm_embed))
 49 | 
 50 | def test_regexes():
 51 |     for test in ['x', 'x[0]', 'x[x]']:
 52 |         match = var_re.match(test)
 53 |         print(test, match.groups())
 54 | 
 55 |     lines = r'''
 56 |     a = 1
 57 |     a = a * 1
 58 |     a[0] = 2
 59 |     a = a[1]
 60 |     1:
 61 |     qqqqqq:
 62 |     jmp 1
 63 |     jmp 1 if a == 2
 64 |     '''.split('\n')
 65 |     for line in lines:
 66 |         line = line.strip()
 67 |         if not line:
 68 |             continue
 69 |         print(line)
 70 |         match = label_re.match(line)
 71 |         if match: print('label', match.groupdict())
 72 |         match = assign_line_re.match(line)
 73 |         if match: print('assign', match.groupdict())
 74 |         match = expr_line_re.match(line)
 75 |         if match: print('expr', match.groupdict())
 76 |         match = jump_line_re.match(line)
 77 |         if match: print('jump', match.groupdict())
 78 |         print()
 79 | 
 80 | class Assign:
 81 |     def __init__(self, lineno, dst, src):
 82 |         self.lineno = lineno
 83 |         self.dst = dst
 84 |         self.src = src
 85 | 
 86 |     def __repr__(self):
 87 |         return "{} = {}".format(self.dst, self.src)
 88 | 
 89 | class Expr:
 90 |     def __init__(self, lineno, dst, src_a, op, src_b):
 91 |         self.lineno = lineno
 92 |         self.dst = dst
 93 |         self.src_a = src_a
 94 |         self.op = op
 95 |         self.src_b = src_b
 96 | 
 97 |     def __repr__(self):
 98 |         return "{} = {} {} {}".format(self.dst, self.src_a, self.op, self.src_b)
 99 | 
100 | class Jump:
101 |     def __init__(self, lineno, label, var=None, cond=None, cmpto=None):
102 |         self.lineno = lineno
103 |         self.label = label
104 |         self.var = var
105 |         self.cond = cond
106 |         self.cmpto = cmpto
107 | 
108 |     def __repr__(self):
109 |         if self.var and self.cond and self.cmpto:
110 |             return "jmp {} if {} {} {}".format(self.label, self.var, self.cond, self.cmpto)
111 |         else:
112 |             return "jmp {}".format(self.label)
113 | 
114 | class Label:
115 |     def __init__(self, lineno, name):
116 |         self.lineno = lineno
117 |         self.name = name
118 | 
119 |     def __repr__(self):
120 |         return "{}:".format(self.name)
121 | 
122 | def parse(source):
123 |     lines = source.split('\n')
124 |     parsed = []
125 |     for lineno, line in enumerate(lines):
126 |         line = line.strip()
127 |         if not line or line.startswith('#'):
128 |             continue
129 | 
130 |         massign = assign_line_re.match(line)
131 |         mexpr   = expr_line_re.match(line)
132 |         mjump   = jump_line_re.match(line)
133 |         mlabel  = label_re.match(line)
134 |         if massign:
135 |             parsed.append(Assign(lineno, **massign.groupdict()))
136 |         elif mexpr:
137 |             parsed.append(Expr(lineno, **mexpr.groupdict()))
138 |         elif mjump:
139 |             parsed.append(Jump(lineno, **mjump.groupdict()))
140 |         elif mlabel:
141 |             parsed.append(Label(lineno, **mlabel.groupdict()))
142 |         else:
143 |             raise Exception("Couldn't parse line {}: {}".format(lineno, line))
144 |     return parsed
145 | 
146 | class Var:
147 |     def __init__(self, name=None, index=None):
148 |         self.name = name
149 |         self.index = index
150 | 
151 |     def __repr__(self):
152 |         name = self.name
153 |         if self.index:
154 |             name = name + self.index
155 |         return name
156 | 
157 | class Immediate:
158 |     def __init__(self, numeric=0, char=None):
159 |         value = numeric
160 |         if char is not None:
161 |             value = ord(char)
162 |         else:
163 |             value = int(value, 0)
164 |         self.value = value
165 | 
166 |     def __repr__(self):
167 |         return str(self.value)
168 | 
169 | class Array:
170 |     def __init__(self, chars=None, elements=()):
171 |         if chars is not None:
172 |             elements = [ord(c) for c in chars]
173 |         self.values = elements
174 | 
175 |     def __repr__(self):
176 |         return repr(list(self.values))
177 | 
178 | def get_var(s):
179 |     mvar = var_re.match(s)
180 |     if mvar:
181 |         return Var(**mvar.groupdict())
182 |     else:
183 |         raise Exception("failed to parse var: {}".format(s))
184 | 
185 | def get_var_imm(s):
186 |     mvar = var_re.match(s)
187 |     mimm = imm_re.match(s)
188 |     marray = array_re.match(s)
189 |     if mimm: return Immediate(**mimm.groupdict())
190 |     elif marray: return Array(**marray.groupdict())
191 |     elif mvar: return Var(**mvar.groupdict())
192 |     else:
193 |         raise Exception("failed to parse var or imm: {}".format(s))
194 | 
195 | class Program:
196 |     def __init__(self, code_base=0x30200000, data_base=0x30400000):
197 |         self.code_base = code_base
198 |         self.data_base = data_base
199 |         self.pc = code_base
200 |         self.bump_alloc = data_base
201 | 
202 |         self.code = []
203 |         self.current_element = None
204 |         self.label_backpatch = []
205 |         self.labels = {}
206 |         self.memory = []
207 |         self.sourcemap = {}
208 |         self.variables = {}
209 |         self.constants = {}
210 | 
211 |     def ins(self, a, b, c=None):
212 |         self.sourcemap[self.pc] = self.current_element
213 |         if c is None:
214 |             c = self.pc + 12
215 |         self.code += [a, b, c]
216 |         self.pc += 12
217 | 
218 |     def alloc(self, value=0):
219 |         ret = self.bump_alloc
220 |         self.bump_alloc += 4
221 |         self.memory += [value]
222 |         return ret
223 | 
224 |     def calloc(self):
225 |         tmp = self.alloc()
226 |         self.ins(tmp, tmp)
227 |         return tmp
228 | 
229 |     def var_addr(self, name):
230 |         if not name in self.variables:
231 |             self.variables[name] = self.alloc()
232 |         return self.variables[name]
233 | 
234 |     def imm_addr(self, imm):
235 |         if isinstance(imm, Immediate):
236 |             imm = imm.value
237 | 
238 |         if isinstance(imm, int):
239 |             if not imm in self.constants:
240 |                 tmp = self.alloc(value=imm)
241 |                 self.constants[imm] = tmp
242 |                 return tmp
243 |             return self.constants[imm]
244 |         elif isinstance(imm, Array):
245 |             addr = self.alloc(value=self.bump_alloc + 4)
246 |             for n in imm.values:
247 |                 self.alloc(value=n)
248 |             return addr
249 |         elif isinstance(imm, Var):
250 |             addr = self.var_addr(imm.name)
251 |             if imm.index:
252 |                 # when reading an index (pointer), JIT a copy operation into a temporary variable
253 |                 return self.copy_index(addr, imm.index)
254 |             return addr
255 |         else:
256 |             raise Exception("invalid immediate type: {}".format(imm))
257 | 
258 |     def copy(self, src):
259 |         # tmp = -src; dst = -tmp
260 |         tmp = self.calloc()
261 |         dst = self.calloc()
262 |         self.ins(src, tmp)
263 |         self.ins(tmp, dst)
264 |         return dst
265 | 
266 |     def assign(self, dst, src):
267 |         if src == self.constants.get(0):
268 |             self.ins(dst, dst)
269 |             return
270 |         # tmp = -src; dst = 0; dst -= src
271 |         tmp = self.calloc()
272 |         self.ins(src, tmp)
273 |         self.ins(dst, dst)
274 |         self.ins(tmp, dst)
275 | 
276 |     def get_index_addr(self, addr, index):
277 |         index = index.strip('[]')
278 |         if index.lstrip('-').isdigit():
279 |             index = int(index) * 4
280 |             index_addr = self.imm_addr(index)
281 |         else:
282 |             index = str(index)
283 |             if not index in self.variables:
284 |                 raise Exception('index variable [{}] not defined before use'.format(index))
285 |             index_var_addr = self.variables[index]
286 |             four = self.imm_addr(4)
287 |             index_addr = self.calloc()
288 |             self.mul(index_addr, index_var_addr, four)
289 |         tmp = self.calloc()
290 |         self.add(tmp, addr, index_addr)
291 |         return tmp
292 | 
293 |     def copy_index(self, src, index):
294 |         neg_dst = self.calloc()
295 |         index_addr = self.get_index_addr(src, index)
296 |         neg_src = self.calloc()
297 |         self.ins(index_addr, neg_src)
298 | 
299 |         # need self-modifying code to read index...
300 |         jit_slot2 = self.pc + 12 * 2
301 | 
302 |         self.ins(jit_slot2, jit_slot2)
303 |         self.ins(neg_src, jit_slot2)
304 |         self.ins(0, neg_dst)
305 | 
306 |         dst = self.calloc()
307 |         self.ins(neg_dst, dst)
308 |         return dst
309 | 
310 |     def assign_index(self, dst, src, index):
311 |         index_addr = self.get_index_addr(dst, index)
312 | 
313 |         neg_src = self.calloc()
314 |         self.ins(src, neg_src)
315 |         neg_dst = self.calloc()
316 |         self.ins(index_addr, neg_dst)
317 |         # print('neg_src', hex(neg_src), 'neg_dst', hex(neg_dst))
318 | 
319 |         # need self-modifying code to write index...
320 |         dst1_slot1 = self.pc + 12 * 6
321 |         dst1_slot2 = dst1_slot1 + 4
322 |         dst2_slot2 = self.pc + 12 * 7 + 4
323 | 
324 |         self.ins(dst1_slot1, dst1_slot1)
325 |         self.ins(dst1_slot2, dst1_slot2)
326 |         self.ins(dst2_slot2, dst2_slot2)
327 |         self.ins(neg_dst, dst1_slot1)
328 |         self.ins(neg_dst, dst1_slot2)
329 |         self.ins(neg_dst, dst2_slot2)
330 |         self.ins(0, 0)
331 |         self.ins(neg_src, 0)
332 | 
333 |     def sub(self, dst, a, b):
334 |         if a == dst:
335 |             self.ins(b, dst)
336 |             return
337 |         tmp = self.copy(b)
338 |         self.assign(dst, a)
339 |         self.ins(tmp, dst)
340 | 
341 |     def add(self, dst, a, b):
342 |         if a == dst:
343 |             tmp = self.calloc()
344 |             self.ins(b, tmp)
345 |             self.ins(tmp, dst)
346 |             return
347 |         tmp1 = self.calloc()
348 |         tmp2 = self.calloc()
349 |         self.ins(a, tmp1)
350 |         self.ins(b, tmp2)
351 |         self.ins(dst, dst)
352 |         self.ins(tmp1, dst)
353 |         self.ins(tmp2, dst)
354 | 
355 |     def mul(self, dst, a, b):
356 |         i = self.calloc()
357 |         acc = self.calloc()
358 |         neg_one = self.imm_addr(-1)
359 |         # loop B times, adding A each time
360 |         # i = -b - -1
361 |         # while i < 0
362 |         #   acc -= a
363 |         # i -= -1
364 |         # dst = -acc
365 |         self.ins(b, i)
366 |         self.ins(neg_one, i)
367 |         loop = self.pc
368 |         self.ins(a, acc)
369 |         self.ins(neg_one, i, loop)
370 |         # dst = 0; dst -= acc
371 |         self.ins(dst, dst)
372 |         self.ins(acc, dst)
373 | 
374 |     def div(self, dst, a, b):
375 |         # loop, subtracting B from A and incrementing ACC each time, until A < 0
376 |         A = self.calloc()
377 |         B = self.calloc()
378 |         ACC = self.calloc()
379 |         one = self.imm_addr(1)
380 |         neg_one = self.imm_addr(-1)
381 |         # set acc to 1, so the first dec sets acc to 0
382 |         self.ins(neg_one, ACC)
383 |         self.ins(a, A)
384 |         self.ins(b, B)
385 | 
386 |         loop = self.pc
387 |         self.ins(one, ACC)
388 |         self.ins(B, A, loop)
389 |         # dst = 0; dest -= ACC
390 |         self.ins(dst, dst)
391 |         self.ins(ACC, dst)
392 | 
393 |     def mod(self, dst, a, b):
394 |         # loop, subtracting B from A, until A < 0
395 |         # then add B to A and the result is the modulo
396 |         A = self.calloc()
397 |         B = self.calloc()
398 |         self.ins(a, A)
399 |         self.ins(b, B)
400 |         loop = self.pc
401 |         self.ins(B, A, loop)
402 |         self.ins(b, A)
403 |         # dst = 0; dest -= ACC
404 |         self.ins(dst, dst)
405 |         self.ins(A, dst)
406 | 
407 |     def assemble(self, code):
408 |         neg1_addr = self.imm_addr(-1)
409 |         zero_addr = self.imm_addr(0)
410 |         elements = parse(code)
411 |         for el in elements:
412 |             self.current_element = el
413 |             if isinstance(el, Assign):
414 |                 dst_var = get_var(el.dst)
415 |                 dst = self.var_addr(dst_var.name)
416 |                 src = self.imm_addr(get_var_imm(el.src))
417 |                 if dst_var.index:
418 |                     self.assign_index(dst, src, dst_var.index)
419 |                 else:
420 |                     self.assign(dst, src)
421 |             elif isinstance(el, Expr):
422 |                 # + - * / %
423 |                 dst_var = get_var(el.dst)
424 |                 src_a = self.imm_addr(get_var_imm(el.src_a))
425 |                 src_b = self.imm_addr(get_var_imm(el.src_b))
426 | 
427 |                 # if we're assigning to an index (pointer)
428 |                 # for simplicity, store to a temporary first then use assign_index()
429 |                 if dst_var.index:
430 |                     dst = self.calloc()
431 |                 else:
432 |                     dst = self.imm_addr(dst_var)
433 | 
434 |                 op = el.op
435 |                 if op == '-':
436 |                     self.sub(dst, src_a, src_b)
437 |                 elif op == '+':
438 |                     self.add(dst, src_a, src_b)
439 |                 elif op == '*':
440 |                     self.mul(dst, src_a, src_b)
441 |                 elif op == '/':
442 |                     self.div(dst, src_a, src_b)
443 |                 elif op == '%':
444 |                     self.mod(dst, src_a, src_b)
445 |                 else:
446 |                     raise Exception("unknown op: {}".format(op))
447 | 
448 |                 if dst_var.index:
449 |                     self.assign_index(self.var_addr(dst_var.name), dst)
450 |             elif isinstance(el, Jump):
451 |                 if el.cond and el.cmpto:
452 |                     var = self.imm_addr(get_var(el.var))
453 |                     cmpto = self.imm_addr(get_var_imm(el.cmpto))
454 |                     cond = el.cond
455 |                     if cond == '==':
456 |                         # TODO
457 |                         # self.sub(tmp, var, cmpto)
458 |                         # self.sub(tmp2, cmpto, var)
459 |                         raise Exception("Unsupported jump cond type: {}".format(cond))
460 |                     elif cond == '!=':
461 |                         # TODO
462 |                         raise Exception("Unsupported jump cond type: {}".format(cond))
463 |                     elif cond == '<':
464 |                         tmp = self.calloc()
465 |                         self.sub(tmp, var, cmpto)
466 |                         neg_one = self.imm_addr(-1)
467 |                         self.ins(neg_one, tmp, 0)
468 |                     elif cond == '>':
469 |                         tmp = self.calloc()
470 |                         self.sub(tmp, cmpto, var)
471 |                         neg_one = self.imm_addr(-1)
472 |                         self.ins(neg_one, tmp, 0)
473 |                     elif cond == '<=':
474 |                         tmp = self.copy(var)
475 |                         self.ins(cmpto, tmp, 0)
476 |                     elif cond == '>=':
477 |                         tmp = self.copy(cmpto)
478 |                         self.ins(var, tmp, 0)
479 |                     else:
480 |                         raise Exception("Unknown jump cond type: {}".format(cond))
481 |                 else:
482 |                     # unconditional jump
483 |                     self.ins(zero_addr, neg1_addr, 0)
484 | 
485 |                 backpatch = self.pc - 4
486 |                 self.label_backpatch.append((el.label, backpatch))
487 |             elif isinstance(el, Label):
488 |                 self.labels[el.name] = self.pc
489 |             else:
490 |                 raise Exception("Unknown element: {}".format(el))
491 | 
492 |         for label, pc in self.label_backpatch:
493 |             self.code[(pc - self.code_base) // 4] = self.labels[label]
494 | 
495 |         # print([hex(n) for n in self.code])
496 |         # print([hex(n) for n in self.memory])
497 |         # print({k: hex(v) for k, v in self.variables.items()})
498 | 
499 | def sim(prog):
500 |     mem = prog.memory
501 |     code = prog.code
502 |     sourcemap = prog.sourcemap
503 |     variables = prog.variables
504 |     rvars = {v: k for k, v in variables.items()}
505 | 
506 |     CODE_ADDR = 0x30200000
507 |     MEM_ADDR  = 0x30400000
508 |     HEAP_ADDR = 0x40000000
509 | 
510 |     heap = [0] * 1024
511 | 
512 |     def read(addr):
513 |         # print('read {:x}'.format(addr))
514 |         if CODE_ADDR <= addr < CODE_ADDR + len(code) * 4:
515 |             return code[(addr - CODE_ADDR) // 4]
516 |         elif MEM_ADDR <= addr < MEM_ADDR + len(mem) * 4:
517 |             return mem[(addr - MEM_ADDR) // 4]
518 |         elif HEAP_ADDR <= addr < HEAP_ADDR + len(heap) * 4:
519 |             return heap[(addr - HEAP_ADDR) // 4]
520 |         else:
521 |             raise Exception('segfault read at {:#x}'.format(addr))
522 | 
523 |     def write(addr, value):
524 |         # print('write {:x} = {:x}'.format(addr, value))
525 |         if CODE_ADDR <= addr < CODE_ADDR + len(code) * 4:
526 |             code[(addr - CODE_ADDR) // 4] = value
527 |         elif MEM_ADDR <= addr < MEM_ADDR + len(mem) * 4:
528 |             mem[(addr - MEM_ADDR) // 4] = value
529 |         elif HEAP_ADDR <= addr < HEAP_ADDR + len(heap) * 4:
530 |             heap[(addr - HEAP_ADDR) // 4] = value
531 |         else:
532 |             raise Exception('segfault write at {:#x}'.format(addr))
533 | 
534 |     ip = CODE_ADDR
535 |     last_element = None
536 |     try:
537 |         while True:
538 |             element = sourcemap.get(ip, None)
539 |             if element and element != last_element:
540 |                 print('[+] {}'.format(element))
541 |                 last_element = element
542 |             next_ip = ip + 12
543 |             try:
544 |                 a = read(ip)
545 |                 b = read(ip + 4)
546 |                 c = read(ip + 8)
547 |             except Exception:
548 |                 break
549 |             print('  ip = {:x}, a={:x}, b={:x}, c={:x}'.format(ip, a, b, c), end='')
550 | 
551 |             val = read(b) - read(a)
552 |             write(b, val)
553 | 
554 |             if b in rvars:
555 |                 print(' | {} = {:#x}'.format(rvars[b], val))
556 |             else:
557 |                 print(' | {:#x}'.format(val))
558 |             if val <= 0 and c != next_ip:
559 |                 print('  jmp {:x}'.format(c))
560 |                 next_ip = c
561 |             ip = next_ip
562 |             # print('mem:  ' + ' '.join([hex(n) for n in mem]))
563 |             # print('heap: ' +' '.join([hex(n) for n in heap[:8]]))
564 |     except Exception as e:
565 |         print()
566 |         print(e)
567 |     print()
568 |     print('heap: ' +' '.join([hex(n) for n in heap[:8]]))
569 |     print('variables:')
570 |     for name, addr in variables.items():
571 |         print('  {} = {:x}'.format(name, read(addr)))
572 | 
573 | if __name__ == '__main__':
574 |     prog1 = '''
575 |     HEAP = 0x40000000
576 |     a = 1
577 |     b = a + 1
578 |     HEAP[0] = a
579 |     '''
580 | 
581 |     prog2 = '''
582 |     a = 2
583 |     b = 2
584 |     c = a * b
585 |     '''
586 |     
587 |     prog3 = '''
588 |     moves = ['n', 'n', 'a', 's', 'l']
589 |     moves = [nnasl]
590 |     tick = HEAP[2]
591 |     move = tick % 5
592 |     HEAP[0] = moves[move]
593 |     jmp label
594 |     '''
595 | 
596 |     prog4 = '''
597 |     HEAP = 0x40000000
598 |     a = 5
599 |     b = 0
600 |     label:
601 |         a = a - 1
602 |         b = b + 1
603 |     jmp label if a >= 0
604 | 
605 |     HEAP[0] = b
606 |     '''
607 | 
608 |     prog5 = '''
609 |     HEAP = 0x40000000
610 |     HEAP[2] = 1
611 | 
612 |     tick = HEAP[2]
613 |     tick_mod = tick % 2
614 | 
615 |     jmp move1 if tick_mod < 1
616 |     jmp move2
617 | 
618 |     move1:
619 |     HEAP[0] = 'n'
620 |     jmp exit
621 | 
622 |     move2:
623 |     HEAP[0] = 'l'
624 |     jmp exit
625 | 
626 |     exit:
627 |     ZERO = 0
628 |     ZERO[0] = 0
629 |     '''
630 | 
631 |     prog6 = '''
632 |     HEAP = 0x40000000
633 |     HEAP[2] = 0
634 | 
635 |     moves = [abcdef]
636 |     tick = HEAP[2]
637 | 
638 | loop:
639 |     tick = tick + 1
640 |     move = tick % 2
641 | 
642 |     c = moves[move]
643 |     HEAP[0] = c
644 |     jmp loop if tick < 6
645 | 
646 | exit:
647 |     ZERO = 0
648 |     ZERO[0] = 0
649 |     '''
650 | 
651 |     prog7 = '''
652 |     HEAP = 0x40000000
653 |     HEAP[2] = 1
654 | 
655 |     moves = [lrla]
656 |     tick = HEAP[2] % 4
657 | 
658 |     move = moves[tick]
659 |     HEAP[0] = move
660 |     '''
661 | 
662 |     prog = prog6
663 |     print('Program:')
664 |     print(prog)
665 |     print()
666 |     p = Program()
667 |     p.assemble(prog)
668 |     sim(p)
669 | 


--------------------------------------------------------------------------------
/subasm.spec:
--------------------------------------------------------------------------------
 1 | a = 1
 2 | a = 0
 3 | a = 'a'
 4 | a = 0x00000000
 5 | a = 1
 6 | a = -1
 7 | asdfhjklasdf = 1
 8 | 
 9 | a = HEAP
10 | a[0] = 'n'
11 | 
12 | moves = [nnasl]
13 | tick = HEAP[2]
14 | tick = HEAP + 8
15 | tick = tick[0]
16 | 
17 | move = tick % len(array)
18 | HEAP[0] = moves[move]
19 | 
20 | label:
21 |     HEAP = 0
22 |     STACK = 0
23 |     
24 |     a = 1 
25 |     a = a + 1
26 |     a = a * 4 
27 |     jmp label 
28 |     jmp label if a == 1
29 |     
30 |     if a != 1
31 |     if a == 1
32 |     if a < b
33 |     if a <= b
34 |     if a > b
35 |     if a >= b
36 | 


--------------------------------------------------------------------------------
/subleq.rop:
--------------------------------------------------------------------------------
 1 | ; while(1) {
 2 | ;     nextIP = ip + 3;
 3 | ;     a = code[ip];
 4 | ;     b = code[ip+1];
 5 | ;     c = code[ip+2];
 6 | ; 
 7 | ;     code[b] -= code[a]
 8 | ;     if (code[b] <= 0)
 9 | ;         nextIP = c
10 | ;     ip = nextIP
11 | ; }
12 | ; a  = eax
13 | ; b  = ebx
14 | ; c  = ecx
15 | ; ip = esi
16 | ; 
17 | ; base = esi = 0x30000000 (+ size of interpreter)
18 | ; ebp  = scratch register
19 | ; edi  = nextIP
20 | ; a = code[ip]
21 | ; b = code[ip+1]
22 | ; c = code[ip+2]
23 | ; nextIP = ip + 3
24 | 
25 | init:
26 | ; 0x30000000
27 | mov esi, esp
28 | inc eax
29 | add eax, eax
30 | add eax, eax
31 | add eax, eax
32 | add eax, eax
33 | add eax, eax
34 | add eax, eax
35 | add eax, eax
36 | add eax, eax
37 | add eax, eax
38 | add eax, eax
39 | add eax, eax
40 | add eax, eax
41 | add esi, eax   ; 0x30001008
42 | 
43 | interp:
44 | ; 0x30000078
45 | lodsd
46 | mov ebp, eax
47 | lodsd
48 | mov ebx, eax
49 | lodsd
50 | mov ecx, eax
51 | mov eax, ebp
52 | 
53 | ; code[b] -= code[a]
54 | mov ebp, [rbx]
55 | sub ebp, [rax]
56 | mov [rbx], ebp
57 | 
58 | ;; if (code[b] <= 0) nextIP = c
59 | ; c -= nextIP
60 | ; c *= (code[b] < 0)
61 | ; c *= (code[b] == 0)
62 | ; ip = nextIP + c
63 | ; c -= nextIP
64 | sub ecx, esi
65 | 
66 | ; c *= (code[b] < 0)
67 | ; edi = code[b] == 0
68 | mov ebp, [rbx]
69 | xor eax, eax
70 | neg ebp          ; C == 0 if b == 0
71 | cmc              ; C == 1 if b == 0
72 | adc eax, eax     ; eax == 1 if b == 0
73 | xor edx, edx     
74 | sub edx, eax     ; edx == -1 if b == 0, else edx == 0
75 | 
76 | ; c *= (code[b] == 0)
77 | ; edi = code[b] < 0
78 | mov ebp, [rbx]
79 | xor eax, eax
80 | sal ebp, 1
81 | adc eax, eax      ; eax == 1 if b < 0
82 | xor ebp, ebp
83 | sub ebp, eax      ; ebp == -1 if b < 0
84 | or  ebp, edx      ; combine masks  b < 0 || b == 0 
85 | and ecx, ebp      ; ecx unchanged if b < 0
86 | 
87 | ; ip = c + nextIP
88 | add esi, ecx      ; ecx = b <= 0 ? c : 0
89 | 
90 | pop rsp ; we need to put the stack start addr here
91 | 


--------------------------------------------------------------------------------