diff options
Diffstat (limited to 'parse.py')
| -rwxr-xr-x | parse.py | 1031 |
1 files changed, 1031 insertions, 0 deletions
diff --git a/parse.py b/parse.py new file mode 100755 index 0000000..ff28b8a --- /dev/null +++ b/parse.py @@ -0,0 +1,1031 @@ +#!/bin/python3 + +from __future__ import print_function +import argparse +import sys +import re +from section_structs import * +from utils import * +from opcodes import * +from copy import deepcopy +from init import * +import readline +import code +import signal + +_DBG_ = True + +def SigHandler_SIGINT(signum, frame): + print() + sys.exit(0) + +# we first read the object file and put all the sections in this class +class ParsedStruct: + def __init__(self): + self.version_number = int() + self.section_list = [] + + +# like the above. currently unused +class ParsedStructV2: + def __init__(self, version_number, section_list): + self.version_number = version_number + self.section_list = section_list + + +# @DEVI-Deprecated-convert a bytearray to int +def Conver2Int(little_endian, size, bytelist): + modifier = size - 1 + sum = 0 + + if little_endian: + for bit in reversed(bytelist): + if bit != 0x80: + sum += bit*(pow(16, modifier)) + modifier -= 1 + return(sum) + else: + for bit in reversed(bytelist): + if bit != 0x80: + sum += bit*(pow(16, modifier)) + modifier -= 1 + return(sum) + +# the argparser +class Argparser(object): + def __init__(self): + parser = argparse.ArgumentParser() + parser.add_argument("--wast", type=str, help="path to the wasm text file") + parser.add_argument("--wasm", type=str, nargs='+', help="path to the wasm object file") + parser.add_argument("--asb", type=str, help="path to the wast file to assemble") + parser.add_argument("--dis", type=str, help="path to the wasm file to disassemble") + parser.add_argument("-o", type=str, help="the path to the output file") + parser.add_argument("--dbg", action='store_true', help="print debug info", default=False) + parser.add_argument("--unval", action='store_true', help="skips validation tests", default=False) + parser.add_argument("--memdump", type=int, help="dumps the linear memory") + parser.add_argument("--idxspc", action='store_true', help="print index space data", default=False) + parser.add_argument("--run", action='store_true', help="runs the start function", default=False) + parser.add_argument("--metric", action='store_true', help="print metrics", default=False) + parser.add_argument("--gas", action='store_true', help="print gas usage", default=False) + parser.add_argument("--entry", type=str, help="name of the function that will act as the entry point into execution") + parser.add_argument("--link", type=str, nargs="+", help="link the following wasm modules") + parser.add_argument("--sectiondump", type=str, help="dumps the section provided") + parser.add_argument("--hexdump", type=int, help="dumps all sections") + parser.add_argument("--dbgsection", type=str, help="dumps the parsed section provided", default="") + parser.add_argument("--interactive", action='store_true', help="open in cli mode", default=False) + parser.add_argument("--rawdump", type=int, nargs=2, help="dumps all sections") + self.args = parser.parse_args() + if self.args.wasm is not None and self.args.wast is not None: + raise Exception("the --wast option and the --wasm option cannot\ + be set at the same time. you need to choose one.") + + def getParseFlags(self): + return(ParseFlags(self.args.wast, self.args.wasm, self.args.asb, self.args.dis, + self.args.o, self.args.dbg, self.args.unval, self.args.memdump, + self.args.idxspc, self.args.run, self.args.metric, self.args.gas, self.args.entry)) + +# reads a wasm-obj file, returns a parsedstruct that holds all the sections' +# bytecode, their section type and their length +def ReadWASM(file_path, endianness, is_extended_isa, dbg): + temp_obj_file = [] + wasm_file = open(file_path, "rb") + parsedstruct = ParsedStruct() + # read the magic cookie + byte = wasm_file.read(WASM_OP_Code.uint32) + if byte != WASM_OP_Code.magic_number.to_bytes(WASM_OP_Code.uint32, byteorder=endianness, signed=False): + raise Exception("bad magic cookie") + + # read the version number + byte = wasm_file.read(WASM_OP_Code.uint32) + if byte != WASM_OP_Code.version_number.to_bytes(WASM_OP_Code.uint32, byteorder=endianness, signed=False): + raise Exception("bad version number") + else: + parsedstruct.version_number = byte + + while True: + byte = wasm_file.read(1) + if byte != b'': + temp_obj_file.append(int.from_bytes(byte, byteorder='big', signed=False)) + else: + break + + offset = 0 + loop = True + while loop: + try: + # section_id, offset, dummy = Read(temp_obj_file, offset, 'varuint7') + section_id, offset, dummy = Read(temp_obj_file, offset, 'varuint32') + except IndexError: + break + + payload_length, offset, dummy = Read(temp_obj_file, offset, 'varuint32') + + if section_id == 0: + is_custom_section = True + name_len, offset, dummy = Read(temp_obj_file, offset, 'varuint32') + name = temp_obj_file[offset : offset + name_len] + offset += name_len + if name.find("reloc", 0, 5) == 0: + is_reloc_section = True + reloc_entry_count = Read(temp_obj_file, offset, 'varuint32') + for i in range(0, reloc_entry_count): + reloc_entry, offset, dummy = Read(tmp_obj, offset, 'varuint32') + reloc_entries.append(reloc_entry) + else: + is_custom_section = False + name_len = 0 + name = '' + dummy = 0 + + payload_data = temp_obj_file[offset:offset + payload_length - name_len - dummy] + offset += payload_length - name_len - dummy + + # @DEVI-the second field is for general use. it is unused right + # now so we are filling it with jojo. + parsedstruct.section_list.append([section_id, 'jojo', payload_length, is_custom_section, name_len, name, payload_data]) + + # prints out the sections in the wasm object + for section in parsedstruct.section_list: + pass + #print(section) + wasm_file.close() + return(parsedstruct) + +# Receives a parsedstruct returned from ReadWASM, parses all the sections and +# fills up a module class. the parse method, then can return the module. +# the returned class objects are all defined in section_structs.py. +class ObjReader(object): + def __init__(self, parsedstruct): + self.parsedstruct = parsedstruct + + # we use this method to read the operands of instructions. it's only + # called by ReadCodeSection + def Disassemble(self, section_byte, offset): + # @DEVI-FIXME- not sure why i was using instruction. its a string... + matched = False + read_bytes = 0 + read_bytes_temp = 0 + read_bytes_temp_iter = 0 + instruction = str() + operands = [] + temp_wasm_ins = WASM_Ins() + + # @DEVI-FIXME-for v1.0 opcodes. needs to get fixed for extended + # op-codes. ideally the mosule should hold its version number so we can + # check it here. + byte = format(section_byte[6][offset], '02x') + offset += 1 + read_bytes += 1 + + for op_code in WASM_OP_Code.all_ops: + if op_code[1] == byte: + matched = True + + # br_table has special immediates + # @DEVI-FIXME-this is costing us quite dearly for every opcode + # we read(at least two ticks per opcode). I could have the + # br_table opcode done separately but kinda hurts the codes + # uniformity. anyways. + if op_code[1] == '0e': + matched = True + temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][0]) + instruction += repr(temp) + ' ' + operands.append(repr(temp)) + read_bytes_temp += read_bytes_temp_iter + for target_table in range(0, temp): + temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][1]) + read_bytes_temp += read_bytes_temp_iter + instruction += repr(temp) + ' ' + operands.append(repr(temp)) + temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][2]) + instruction += repr(temp) + ' ' + operands.append(repr(temp)) + read_bytes_temp += read_bytes_temp_iter + elif op_code[2]: + if isinstance(op_code[3], tuple): + for i in range(0, len(op_code [3])): + temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][i]) + read_bytes_temp += read_bytes_temp_iter + instruction += repr(temp) + ' ' + operands.append(repr(temp)) + else: + temp, offset, read_bytes_temp = Read(section_byte[6], offset, op_code[3]) + instruction += repr(temp) + operands.append(repr(temp)) + + temp_wasm_ins.opcode = op_code[0] + temp_wasm_ins.opcodeint = int(byte, 16) + #temp_wasm_ins.operands = instruction + temp_wasm_ins.operands = operands + instruction = str() + operands = [] + break + + read_bytes += read_bytes_temp + return offset, matched, read_bytes, temp_wasm_ins + + # parses the code section. returns a Code_Section class + def ReadCodeSection(self): + offset = 0 + CS = Code_Section() + temp_func_bodies = Func_Body() + temp_local_entry = Local_Entry() + section_exists = False + for whatever in self.parsedstruct.section_list: + # 10 is the code section + if whatever[0] == 10: + code_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + fn_cn, offset, dummy = Read(code_section[6], offset, 'varuint32') + function_cnt = fn_cn + CS.count = function_cnt + + while function_cnt > 0: + function_body_length, offset, dummy = Read(code_section[6], offset, 'varuint32') + temp_func_bodies.body_size = function_body_length + + local_count, offset, dummy = Read(code_section[6], offset, 'varuint32') + temp_func_bodies.local_count = local_count + + # local_count_size will eventually hold how many bytes we will read + # in total because of the local section + local_count_size = dummy + if local_count != 0: + for i in range(0, local_count): + partial_local_count, offset, dummy = Read(code_section[6], offset, 'varuint32') + local_count_size += dummy + partial_local_type, offset, dummy = Read(code_section[6], offset, 'uint8') + local_count_size += dummy + temp_local_entry.count = partial_local_count + temp_local_entry.type = partial_local_type + temp_func_bodies.locals.append(deepcopy(temp_local_entry)) + local_count -= partial_local_count + else: + pass + + read_bytes_so_far = local_count_size + for i in range(0, function_body_length - local_count_size): + offset, matched, read_bytes, temp_wasm_ins = self.Disassemble(code_section, offset) + temp_func_bodies.code.append(deepcopy(temp_wasm_ins)) + + if not matched: + print(Colors.red + 'did not match anything' + Colors.ENDC) + print(Colors.red + 'code section offset: ' + repr(offset) + Colors.ENDC) + print(Colors.red + 'read bytes: ' + repr(read_bytes) + Colors.ENDC) + print(Colors.red + 'wasm ins: ' + repr(temp_wasm_ins.opcode) + Colors.ENDC) + + for iter in temp_func_bodies.code: + print(iter.opcode) + print(iter.operands) + sys.exit(1) + else: + pass + matched = False + read_bytes_so_far += read_bytes + if read_bytes_so_far == function_body_length: + break + + CS.func_bodies.append(deepcopy(temp_func_bodies)) + temp_func_bodies.locals = [] + temp_func_bodies.code = [] + function_cnt -= 1 + return(CS) + + # parsed the data section. returns a Data_Section class + def ReadDataSection(self): + loop = True + section_exists = False + offset = 0 + DS = Data_Section() + temp_data_segment = Data_Segment() + init_expr = [] + for whatever in self.parsedstruct.section_list: + if whatever[0] == 11: + data_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + data_entry_count, offset, dummy = Read(data_section[6], offset, 'varuint32') + DS.count = data_entry_count + + while data_entry_count != 0: + linear_memory_index, offset, dummy = Read(data_section[6], offset, 'varuint32') + temp_data_segment.index = linear_memory_index + + # reading in the init-expr + while loop: + # @DEVI-FIXME-this only works for none extended opcodes + if data_section[6][offset] == 0x0b: + loop = False + data_char, offset, dummy = Read(data_section[6], offset, 'uint8') + init_expr.append(data_char) + + temp_data_segment.offset = init_expr + + data_entry_length, offset, dummy = Read(data_section[6], offset, 'varuint32') + temp_data_segment.size = data_entry_length + + data_itself = data_section[6][offset:offset + data_entry_length] + temp_data_segment.data = data_itself + offset += data_entry_length + + DS.data_segments.append(deepcopy(temp_data_segment)) + + data_entry_count -= 1 + init_expr = [] + loop = True + return(DS) + + # parses the import section. returns an Import_Section class + def ReadImportSection(self): + offset = 0 + section_exists = False + module_name = [] + field_name = [] + IS = Import_Section() + temp_import_entry = Import_Entry() + for whatever in self.parsedstruct.section_list: + if whatever[0] == 2: + import_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + import_cnt, offset, dummy = Read(import_section[6], offset, 'varuint32') + IS.count = import_cnt + + while import_cnt != 0: + module_length, offset, dummy = Read(import_section[6], offset, 'varuint32') + temp_import_entry.module_len = module_length + + for i in range(0, module_length): + module_name.append(import_section[6][offset + i]) + temp_import_entry.module_str = module_name + offset += module_length + + field_length, offset, dummy = Read(import_section[6], offset, 'varuint32') + temp_import_entry.field_len = field_length + for i in range(0, field_length): + field_name.append(import_section[6][offset + i]) + temp_import_entry.field_str = field_name + offset += field_length + + kind, offset, dummy = Read(import_section[6], offset, 'uint8') + temp_import_entry.kind = kind + + # function type + if kind == 0: + import_type, offset, dummy = Read(import_section[6], offset, 'varuint32') + temp_import_entry.type = import_type + # table type + elif kind == 1: + table_type = Table_Type() + table_type.elemet_type, offset, dummy = Read(import_section[6], offset, 'varint7') + rsz_limits = Resizable_Limits() + rsz_limits.flags, offset, dummy = Read(import_section[6], offset, 'varuint1') + rsz_limits.initial, offset, dummy = Read(import_section[6], offset, 'varuint32') + if rsz_limits.flags: + rsz_limits.maximum, offset, dummy = Read(import_section[6], offset, 'varuint32') + table_type.limit = rsz_limits + temp_import_entry.type = table_type + elif kind == 2: + memory_type = Memory_Type() + rsz_limits = Resizable_Limits() + rsz_limits.flags, offset, dummy = Read(import_section[6], offset, 'varuint1') + rsz_limits.initial, offset, dummy = Read(import_section[6], offset, 'varuint32') + if rsz_limits.flags: + rsz_limits.maximum, offset, dummy = Read(import_section[6], offset, 'varuint32') + memory_type.limits = rsz_limits + temp_import_entry.type = memory_type + elif kind == 3: + global_type = Global_Type() + global_type.content_type, offset, dummy = Read(import_section[6], offset, 'uint8') + global_type.mutability, offset, dummy = Read(import_section[6], offset, 'varuint1') + temp_import_entry.type = global_type + + IS.import_entry.append(deepcopy(temp_import_entry)) + + import_cnt -= 1 + module_name = [] + field_name = [] + return(IS) + + # parses the export section, returns an Export_Section class + def ReadExportSection(self): + offset = 0 + section_exists = False + field_name = [] + ES = Export_Section() + temp_export_entry = Export_Entry() + for whatever in self.parsedstruct.section_list: + if whatever[0] == 7: + export_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + export_entry_cnt, offset, dummy = Read(export_section[6], offset, 'varuint32') + ES.count = export_entry_cnt + + while export_entry_cnt != 0: + field_length, offset, dummy = Read(export_section[6], offset, 'varuint32') + temp_export_entry.field_len = field_length + + for i in range(0, field_length): + field_name.append(export_section[6][offset + i]) + temp_export_entry.fiels_str = field_name + offset += field_length + + kind, offset, dummy = Read(export_section[6], offset, 'uint8') + temp_export_entry.kind = kind + + index, offset, dummy = Read(export_section[6], offset, 'varuint32') + temp_export_entry.index = index + + ES.export_entries.append(deepcopy(temp_export_entry)) + + export_entry_cnt -= 1 + field_name = [] + return(ES) + + # parses the type section, returns a Type_Section class + def ReadTypeSection(self): + offset = 0 + section_exists = False + param_list = [] + return_list = [] + TS = Type_Section() + temp_func_type = Func_Type() + for whatever in self.parsedstruct.section_list: + if whatever[0] == 1: + type_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + type_entry_count, offset, dummy = Read(type_section[6], offset, 'varuint32') + TS.count = type_entry_count + + while type_entry_count != 0: + form, offset, dummy = Read(type_section[6], offset, 'varint7') + temp_func_type.form = form + + param_count, offset, dummy = Read(type_section[6], offset, 'varuint32') + temp_func_type.param_cnt = param_count + + for i in range(0, param_count): + param_list.append(type_section[6][offset + i]) + temp_func_type.param_types = param_list + offset += param_count + + # @DEVI-FIXME- only works for MVP || single return value + return_count, offset, dummy = Read(type_section[6], offset, 'varuint1') + temp_func_type.return_cnt = return_count + + for i in range(0, return_count): + return_list.append(type_section[6][offset + i]) + temp_func_type.return_type = return_list + offset += return_count + + TS.func_types.append(deepcopy(temp_func_type)) + + type_entry_count -= 1 + param_list = [] + return_list = [] + return(TS) + + # parses the function section, returns a Function_section class + def ReadFunctionSection(self): + offset = 0 + section_exists = False + index_to_type = [] + FS = Function_Section() + for whatever in self.parsedstruct.section_list: + if whatever[0] == 3: + function_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + function_entry_count, offset, dummy = Read(function_section[6], offset, 'varuint32') + FS.count = function_entry_count + + for i in range(0, function_entry_count): + index, offset, dummy = Read(function_section[6], offset, 'varuint32') + index_to_type.append(index) + FS.type_section_index = index_to_type + offset += function_entry_count + return(FS) + + # parses the element secction, returns an Element_Section class + def ReadElementSection(self): + offset = 0 + section_exists = False + init_expr = [] + loop = True + function_indices = [] + ES = Element_Section() + temp_elem_segment = Elem_Segment() + + for whatever in self.parsedstruct.section_list: + if whatever[0] == 9: + element_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + element_entry_count, offset, dummy = Read(element_section[6], offset, 'varuint32') + ES.count = element_entry_count + + while element_entry_count != 0: + table_index, offset, dummy = Read(element_section[6], offset, 'varuint32') + temp_elem_segment.index = table_index + + # @DEVI-FIXME-only works for non-extneded opcodes + while loop: + if element_section[6][offset] == 0x0b: + loop = False + init_expr.append(element_section[6][offset]) + offset += 1 + temp_elem_segment.offset = init_expr + + num_elements, offset, dummy = Read(element_section[6], offset, 'varuint32') + temp_elem_segment.num_elem = num_elements + + for i in range(0, num_elements): + index, offset, dummy = Read(element_section[6], offset, 'varuint32') + function_indices.append(index) + temp_elem_segment.elems = function_indices + offset += num_elements + + ES.elem_segments.append(deepcopy(temp_elem_segment)) + + loop = True + init_expr = [] + function_indices = [] + element_entry_count -= 1 + return(ES) + + # parses the memory section, returns a Memory_Section class + def ReadMemorySection(self): + offset = 0 + section_exists = False + MS = Memory_Section() + temp_rsz_limits = Resizable_Limits() + + for whatever in self.parsedstruct.section_list: + if whatever[0] == 5: + memory_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + num_linear_mems, offset, dummy = Read(memory_section[6], offset, 'varuint32') + MS.count = num_linear_mems + + while num_linear_mems != 0: + flag, offset, dummy = Read(memory_section[6], offset, 'varuint1') + temp_rsz_limits.flags = flag + + initial,offset, dummy = Read(memory_section[6], offset, 'varuint32') + temp_rsz_limits.initial = initial + + if flag: + maximum, offset, dummy = Read(memory_section[6], offset, 'varuint32') + temp_rsz_limits.maximum = maximum + + MS.memory_types.append(deepcopy(temp_rsz_limits)) + num_linear_mems -= 1 + return(MS) + + # parses the table section, returns a Table_Section class + def ReadTableSection(self): + offset = 0 + section_exists = False + TS = Table_Section() + temp_table_type = Table_Type() + temp_rsz_limits = Resizable_Limits() + + for whatever in self.parsedstruct.section_list: + if whatever[0] == 4: + table_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + table_count, offset, dummy = Read(table_section[6], offset, 'varuint32') + TS.count = table_count + + while table_count != 0: + element_type, offset, dummy = Read(table_section[6], offset, 'varint7') + temp_table_type.element_type = element_type + + flag, offset, dummy = Read(table_section[6], offset, 'varuint1') + temp_rsz_limits.flags = flag + + initial, offset, dummy = Read(table_section[6], offset, 'varuint32') + temp_rsz_limits.initial = initial + + if flag: + maximum, offset, dummy = Read(table_section[6], offset, 'varuint32') + temp_rsz_limits.maximum = maximum + + temp_table_type.limit = temp_rsz_limits + TS.table_types.append(deepcopy(temp_table_type)) + + table_count -= 1 + return(TS) + + # parses the global section, returns a Global_Section class + def ReadGlobalSection(self): + offset = 0 + loop = True + section_exists = False + init_expr = [] + GS = Global_Section() + temp_gl_var = Global_Variable() + temp_gl_type = Global_Type() + + for whatever in self.parsedstruct.section_list: + if whatever[0] == 6: + global_section = whatever.copy() + section_exists = True + + if not section_exists: + return None + + count, offset, dummy = Read(global_section[6], offset, 'varuint32') + GS.count = count + + while count != 0: + content_type, offset, dummy = Read(global_section[6], offset, 'uint8') + temp_gl_type.content_type = content_type + + mutability, offset, dummy = Read(global_section[6], offset, 'varuint1') + temp_gl_type.mutability = mutability + + # @DEVI-FIXME-only works for non-extended opcodes + while loop: + if global_section[6][offset] == 0x0b: + loop = False + init_expr.append(global_section[6][offset]) + offset += 1 + temp_gl_var.init_expr = init_expr + + temp_gl_var.global_type = temp_gl_type + GS.global_variables.append(deepcopy(temp_gl_var)) + + + count -= 1 + loop = True + init_expr = [] + return(GS) + + # parses the start section, returns a Start_Section + def ReadStartSection(self): + offset = 0 + section_exists = False + SS = Start_Section() + + for whatever in self.parsedstruct.section_list: + if whatever[0] == 8: + start_section = whatever.copy() + section_exists = True + if not section_exists: + return None + + function_index, offset, dummy = Read(start_section[6], offset, 'varuint32') + SS.function_section_index = function_index + return(SS) + + def ReadRelocationSection(self): + offset = 0 + section_exists = False + RS = Relocation_Section() + for whatever in self.parsedstruct.section_list: + if whatever[0] == 0 and whatever[1] == "reloc": + reloc_section = whatever.copy() + section_exists = True + if not section_exists: + return None + return(RS) + + def ReadNameSection(self): + offset = 0 + section_exists = False + NS = Name_Section() + for whatever in self.parsedstruct.section_list: + if whatever[0] == 0 and whatever[1] == "name": + name_section = whatever.copy() + section_exists = True + if not section_exists: + return None + return(NS) + + def ReadLinkingSection(self): + pass + + def ReadLinkingDotSections(self): + pass + + # unused-returns the cursor location in the object file + def getCursorLocation(self): + return(self.wasm_file.tell()) + + # a convinience method-builds a module class and returns it + def parse(self): + return(Module(self.ReadTypeSection(), self.ReadImportSection(), + self.ReadFunctionSection(), self.ReadTableSection(), + self.ReadMemorySection(), self.ReadGlobalSection(), + self.ReadExportSection(), self.ReadStartSection(), + self.ReadElementSection(), self.ReadCodeSection(), + self.ReadDataSection())) + + +# WIP-basically how the assembler is constructed +class ParserV1(object): + def __init__(self, path): + self.path = path + + def run(self): + wasmtobj = WASMText(self.path) + # wasmtobj.test_print() + wasmtobj.RegExSearch() + wasmtobj.PrintTypeDict() + wasmtobj.PrintImportDict() + wasmtobj.PrintTableDict() + wasmtobj.PrintElemDict() + wasmtobj.PrintMemoryDict() + wasmtobj.PrintDataDict() + wasmtobj.PrintExportDict() + wasmtobj.PrintFuncDict() + wasmtobj.PrintElemDict() + wasmtobj.FuncParser() + wasmtobj.FuncParserTest() + + funcbodyparser = FuncBodyParser(wasmtobj.getFuncBodies()) + headerparser = FuncBodyParser(wasmtobj.getTypeHeader()) + + expr_stack = funcbodyparser.ParseBodyV3(False) + header_stack = headerparser.ParseBodyV3(True) + + wasm_codeemitter = WASM_CodeEmitter(expr_stack) + #wasm_codeemitter.Obj_Header_32() + #wasm_codeemitter.Dump_Obj_STDOUT() + + #wasm_codeemitter.SetNewStack(header_stack) + #wasm_codeemitter.EmitTypeHeader() + #wasm_codeemitter.PrintTypeHeaderObj() + + +# our interpreter class +class PythonInterpreter(object): + def __init__(self): + self.modules = [] + self.sections = [] + + # appends a module to the module list that PythonInterpreter has + def appendmodule(self, module): + self.modules.append(module) + + # returns the list of modules that we have parsed so far + def getmodules(self): + return(self.modules) + + def appendsection(self, section): + self.sections.append(section) + + def getsections(self): + return self.sections + + # convinience method.calls the ObjReader to parse a wasm obj file. + # returns a module class. + def parse(self, file_path): + section = ReadWASM(file_path, 'little', False, True) + self.appendsection(section) + parser = ObjReader(section) + return(parser.parse()) + + # dumps the object sections' info to stdout. pretty print. + def dump_sections(self, module, dbgsection): + all = False + if dbgsection == "": + all = True + print(Colors.blue + Colors.BOLD + + 'BEGENNING OF MODULE' + Colors.ENDC) + + # type_section + if module.type_section is not None and (dbgsection == "type" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Type Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.type_section.count)) + for iter in module.type_section.func_types: + print(Colors.cyan + 'form: ' + repr(iter.form) + Colors.ENDC) + print(Colors.green + 'param count: ' + repr(iter.param_cnt) + Colors.ENDC) + print(Colors.red + 'param types: ' + repr(iter.param_types) + Colors.ENDC) + print(Colors.purple + 'return count: ' + repr(iter.return_cnt) + Colors.ENDC) + print(Colors.yellow + 'return type: ' + repr(iter.return_type) + Colors.ENDC) + + # import_section + if module.import_section is not None and (dbgsection == "import" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Import Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.import_section.count)) + for iter in module.import_section.import_entry: + print(Colors.cyan + 'module length: ' + repr(iter.module_len) + Colors.ENDC) + print(Colors.green + 'module str: ' + repr(iter.module_str) + Colors.ENDC) + print(Colors.red + 'field length: ' + repr(iter.field_len) + Colors.ENDC) + print(Colors.purple + 'field str: ' + repr(iter.field_str) + Colors.ENDC) + print(Colors.yellow + 'kind: ' + repr(iter.kind) + Colors.ENDC) + print(Colors.grey + 'type: ' + repr(iter.type) + Colors.ENDC) + + # function_section + if module.function_section is not None and (dbgsection == "function" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Function Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.function_section.count)) + for iter in module.function_section.type_section_index: + print(Colors.cyan + 'type section index: ' + repr(iter) + Colors.ENDC) + + # table_section + if module.table_section is not None and (dbgsection == "table" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Table Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.table_section.count)) + for iter in module.table_section.table_types: + print(Colors.cyan + 'element type: ' + repr(iter.element_type) + Colors.ENDC) + print(Colors.green + 'Resizable_Limits:flags: ' + repr(iter.limit.flags) + Colors.ENDC) + print(Colors.red + 'Resizable_Limits:initial: ' + repr(iter.limit.initial) + Colors.ENDC) + print(Colors.purple + 'Resizable_Limits:maximum: ' + repr(iter.limit.maximum) + Colors.ENDC) + + # memory_section + if module.memory_section is not None and (dbgsection == "memory" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Memory Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.memory_section.count)) + for iter in module.memory_section.memory_types: + print(Colors.green + 'Resizable_Limits:flags: ' + repr(iter.flags) + Colors.ENDC) + print(Colors.red + 'Resizable_Limits:initial: ' + repr(iter.initial) + Colors.ENDC) + print(Colors.purple + 'Resizable_Limits:maximum: ' + repr(iter.maximum) + Colors.ENDC) + + # global_section + if module.global_section is not None and (dbgsection == "global" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Global Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.global_section.count)) + for iter in module.global_section.global_variables: + print(Colors.green + 'global type: ' + repr(iter.global_type) + Colors.ENDC) + print(Colors.red + 'init expr: ' + repr(iter.init_expr) + Colors.ENDC) + + # export_section + if module.export_section is not None and (dbgsection == "export" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Export Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.export_section.count)) + for iter in module.export_section.export_entries: + print(Colors.green + 'field length: ' + repr(iter.field_len) + Colors.ENDC) + print(Colors.red + 'field str: ' + repr(iter.field_str) + Colors.ENDC) + print(Colors.purple + 'kind: ' + repr(iter.kind) + Colors.ENDC) + print(Colors.cyan + 'index: ' + repr(iter.index) + Colors.ENDC) + + # start_section + if module.start_section is not None and (dbgsection == "start" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Start Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('start function index: ' + repr(module.start_section.function_section_index)) + + # element_section + if module.element_section is not None and (dbgsection == "element" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Element Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.element_section.count)) + for iter in module.element_section.elem_segments: + print(Colors.green + 'index: ' + repr(iter.index) + Colors.ENDC) + print(Colors.red + 'offset: ' + repr(iter.offset) + Colors.ENDC) + print(Colors.purple + 'num_elem: ' + repr(iter.num_elem) + Colors.ENDC) + print(Colors.cyan + 'elemes:' + repr(iter.elems) + Colors.ENDC) + + # code_section + if module.code_section is not None and (dbgsection == "code" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Code Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.code_section.count)) + for iter in module.code_section.func_bodies: + print(Colors.green + 'body size: ' + repr(iter.body_size) + Colors.ENDC) + print(Colors.red + 'local enrty count: ' + repr(iter.local_count) + Colors.ENDC) + for iterer in iter.locals: + print(Colors.blue + 'local count: ' + repr(iterer.count) + Colors.ENDC) + print(Colors.blue + 'local type: ' + repr(iterer.type) + Colors.ENDC) + for iterer in iter.code: + instruction = iterer.opcode + ' ' + repr(iterer.operands) + print(Colors.yellow + instruction + Colors.ENDC, end="") + print("\t", end="") + print(Colors.cyan + 'opcode: ' + repr(iterer.opcode) + Colors.ENDC, end="") + print("\t", end="") + print(Colors.grey + 'immediate: ' + repr(iterer.operands) + Colors.ENDC, end="") + print("\t", end="") + print(Colors.UNDERLINE + "num of operands: " + repr(len(iterer.operands)) + Colors.ENDC) + + # data_section + if module.data_section is not None and (dbgsection == "data" or all): + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print(Colors.blue + Colors.BOLD + 'Data Section:' + Colors.ENDC) + print(Colors.blue + '------------------------------------------------------' + Colors.ENDC) + print('count: ' + repr(module.data_section.count)) + for iter in module.data_section.data_segments: + print(Colors.green + 'index: ' + repr(iter.index) + Colors.ENDC) + print(Colors.red + 'offset: ' + repr(iter.offset) + Colors.ENDC) + print(Colors.purple + 'size: ' + repr(iter.size) + Colors.ENDC) + print(Colors.cyan + 'data:' + repr(iter.data) + Colors.ENDC) + + # palceholder for the validation tests + def runValidations(self): + modulevalidation = ModuleValidation(self.modules[0]) + return(modulevalidation.ValidateAll()) + +def premain(argparser): + interpreter = PythonInterpreter() + if argparser.args.wasm: + for file_path in argparser.args.wasm: + module = interpreter.parse(file_path) + print(type(module)) + interpreter.appendmodule(module) + if argparser.args.dbg or argparser.args.dbgsection: + interpreter.dump_sections(module, argparser.args.dbgsection) + if interpreter.runValidations(): + print(Colors.red + "validations are not implemented yet" + Colors.ENDC) + pass + else: + print(Colors.red + 'failed validation tests' + Colors.ENDC) + vm = VM(interpreter.getmodules()) + vm.setFlags(argparser.getParseFlags()) + ms = vm.getState() + if argparser.args.idxspc: + DumpIndexSpaces(ms) + if argparser.args.memdump: + DumpLinearMems(ms.Linear_Memory, argparser.getMEMDUMP()) + if argparser.args.run: + vm.run() + # merklizer = Merklizer(ms.Linear_Memory[0][0:512], module) + # treelength, hashtree = merklizer.run() + + if argparser.args.interactive: + variables = globals().copy() + variables.update(locals()) + shell = code.InteractiveConsole(variables) + shell.interact(banner="WASM python REPL") + if argparser.args.hexdump: + dumpprettysections(interpreter.getsections(), argparser.args.hexdump, "") + if argparser.args.sectiondump is not None: + dumpprettysections(interpreter.getsections(), 24, argparser.args.sectiondump) + if argparser.args.wast: + #print(argparser.getWASTPath()) + parser = ParserV1(argparser.getWASTPath()) + parser.run() + # WIP-the assmebler + if argparser.args.asb: + print("not implemented yet") + sys.exit(1) + # WIP-the disassmebler + if argparser.args.dis: + print("not implemented yet") + sys.exit(1) + +def main(): + argparser = Argparser() + if argparser.args.dbg: + try: + premain(argparser) + except Exception: + variables = globals().copy() + variables.update(locals()) + shell = code.InteractiveConsole(variables) + shell.interact(banner="DEVIWASM REPL") + else: + premain(argparser) + +if __name__ == "__main__": + main() |