def disassemble(self, rv, formatter=Formatter()): """Disassemble the cubin instructions in this kernel""" # Phase 1 -- decode instructions ptr = 0 disa = Disassembler() instructions = [] while ptr < len(self.bincode): base = ptr*4 inst = [self.bincode[ptr]] ptr += 1 if inst[0] & 1: inst.append(self.bincode[ptr]) ptr += 1 instructions.append(disa.decode(base, inst)) # Phase 2 -- labels, sort in order of address label_set = set() for i in instructions: for o in i.dst_operands: if o.indirection == OP_INDIRECTION_CODE and o.source == OP_SOURCE_IMMEDIATE: label_set.add(o.value) labels = list(label_set) labels.sort() label_map = dict([(l, "label%i" % x) for x,l in enumerate(labels)]) # Phase 3 -- fill in labels in program arguments for i in instructions: for o in i.dst_operands: if o.indirection == OP_INDIRECTION_CODE and o.source == OP_SOURCE_IMMEDIATE: o.label = label_map[o.value] # Phase 4 -- print for i in instructions: formatter.address(rv, i.address) formatter.bincode(rv, (" ".join(["%08x" % x for x in i.inst]))) if i.address in label_map: formatter.label(rv, label_map[i.address]) i.dump(rv, formatter) formatter.newline(rv) # Phase 5 -- print constants for seg in self.const: formatter.const_hdr(rv, seg.segname, seg.segnum, seg.offset, seg.bytes) formatter.const_data(rv, seg.mem)
def _rule_test_helper(self, rule): """ Helper function to test a rule """ rule_dir = 'rules' if os.path.exists("test") and os.path.isdir("test"): if os.path.exists(os.path.join("test", rule_dir)) and os.path.isdir( os.path.join("test", rule_dir)): rule_dir = os.path.join('test', rule_dir) rule_path = os.path.join(rule_dir, rule) data_dir = 'data' if os.path.exists("test") and os.path.isdir("test"): if os.path.exists(os.path.join("test", data_dir)) and os.path.isdir( os.path.join("test", data_dir)): data_dir = os.path.join('test', data_dir) input_fname = rule + '.xlsx' input_path = os.path.join(data_dir, input_fname) input_fname_prefix, input_type = os.path.splitext(input_fname) actual_path = os.path.join(data_dir, input_fname_prefix + '_formatted.xlsx') expected_path = os.path.join(data_dir, input_fname_prefix + '_expected.xlsx') Formatter(FormatterOptions(rule_path, input_path)).run() actual_SR = SpreadsheetReader(actual_path) expected_SR = SpreadsheetReader(expected_path) actual_file_data = actual_SR.get_rows() expected_file_data = expected_SR.get_rows() try: self.assertEqual(actual_file_data, expected_file_data) except Exception as e: print('Expected:\n', expected_file_data) print('Actual:\n', actual_file_data) print(e)
def dump(self, rv, fmt=Formatter()): # Predication # Condition code # What do these mean? # do we have a zero bit, sign bit? # self.pred_op&3 seems straightforward enough # but what is self.pred_op>>2 ? if not self.predicated or self.pred_op == 15 or self.pred_op == None: pass # No self.pred else: fmt.pred(rv, "@$p%i.%s" % (self.pred, condition_codes[self.pred_op])) #elif self.pred_op == 2: # 0010 # # Execute on false, not on true # fmt.pred(rv, "@!$p%i" % self.pred) #elif self.pred_op == 5: # 0101 # # Execute on true, not on false # fmt.pred(rv, "@$p%i" % self.pred) #elif (self.pred_op&3)==2: # xx10 -- seems to be @!$p%i # fmt.pred(rv, "@!$p%i" % (self.pred)) # self.warnings.append("cc is %s" % condition_codes[self.pred_op]) #elif (self.pred_op&3)==1: # xx01 -- seems to be @p%i # fmt.pred(rv, "@$p%i" % (self.pred)) # self.warnings.append("cc is %s" % condition_codes[self.pred_op]) #elif logic_ops.has_key(self.pred_op): # # unsigned version # fmt.pred(rv, "@$p%i%s.u" % (self.pred,logic_ops[self.pred_op])) #elif (self.pred_op>=8 and self.pred_op<16) and logic_ops.has_key(self.pred_op-8): # # signed version # fmt.pred(rv, "@$p%i%s.s" % (self.pred,logic_ops[self.pred_op-8])) #else: # fmt.pred(rv, "@$p%i.%i" % (self.pred, self.pred_op)) # self.warnings.append("cc is %s" % condition_codes[self.pred_op]) # Base if self.base: fmt.base(rv, self.base) elif self.system: fmt.base(rv, "sop.%01x" % (self.op)) else: fmt.base(rv, "op.%01x%01x" % (self.op, self.subop)) # Add instruction modifiers for m in self.modifiers: fmt.modifier(rv, m) # Operand types # collapse if all are the same #optypes.extend([x.typestr() for x in self.dst_operands]) # Promote sign of source operands srco = self.dst_operands + self.src_operands srco = [x.clone() for x in srco] sign = OP_SIGN_NONE for o in srco: if o.sign != OP_SIGN_NONE: sign = o.sign for o in srco: if o.sign == OP_SIGN_NONE: o.sign = sign # Add to operand list optypes = [] optypes.extend([x.typestr() for x in srco]) optypes = [x for x in optypes if x != ""] # Filter empty types (predicates) oset = set(optypes) if len(oset) == 1: # There is only one type fmt.types(rv, optypes[0]) else: # Show all types fmt.types(rv, "".join(optypes)) # Destination operands dst_operands = self.dst_operands[:] #if self.ignore_result: # # When ignoring result, only pred register output # dst_operands = [x for x in dst_operands if x.source==OP_SOURCE_PRED_REGISTER] # output register 0x7f = bit bucket # dst_operands = [x for x in dst_operands if not (x.source==OP_SOURCE_OUTPUT_REGISTER and x.value==0x7f)] if len(dst_operands): operands_str = [x.__repr__() for x in dst_operands] fmt.dest_operands(rv, "|".join(operands_str)) # Source operands if len(self.src_operands): pre = "" if len(self.dst_operands): pre = ", " operands_str = [x.__repr__() for x in self.src_operands] fmt.src_operands(rv, pre + (", ".join(operands_str))) # Disassembler warnings if self.inst != None and self.visited != None: unk0 = self.inst[0] & ~(self.visited[0]) if len(self.inst) == 2: unk1 = self.inst[1] & ~(self.visited[1]) else: unk1 = 0 if unk0: fmt.warning(rv, "unk0 %08x" % (unk0)) if unk1: fmt.warning(rv, "unk1 %08x" % (unk1)) for warn in self.warnings: fmt.warning(rv, warn)
def parse_args_and_file(): args = get_args() global num_variants num_variants = args.num_variants print(args.input) problems = [] formatter = Formatter.Formatter() with open(args.input, "r") as file: problem= None preamble_passed = False lines = file.readlines() for line in lines: if (line == '=====\n' or (line == '=====' and line is lines[-1])): preamble_passed = True print('created problem') if(problem is not None): problems.append(problem) # Bug : doesn't execute if =====\n is on the last line problem = Problem_Modifier.Problem_Specs() continue data = line.split() if(not preamble_passed): if(data[0] == 'NONUMBER'): formatter.has_numbebered_pages(False) elif(data[0] == 'TITLEPAGE'): formatter.has_title_page(True) elif(data[0] == 'TITLETEXT'): text = ' '.join(data[1:]) formatter.set_title_text(text) elif(data[0] == 'MARKTOTAL'): total_marks = int(data[1]) formatter.set_mark_total(total_marks) elif(data[0] == 'HEADER_L'): text = ' '.join(data[1:]) formatter.set_left_header(text) elif(data[0] == 'HEADER_R'): text = ' '.join(data[1:]) formatter.set_right_header(text) elif(data[0] == 'FOOTER_L'): text = ' '.join(data[1:]) formatter.set_left_footer(text) elif(data[0] == 'FOOTER_R'): text = ' '.join(data[1:]) formatter.set_right_footer(text) continue if(data[0] == 'VAR'): parse_variable_line(problem, data) elif (data[0] == 'TOSIM'): if(len(data[1:])< 2): raise ValueError('TOSIM had too few arguments') problem.to_sim(data[1], data[2]) elif (data[0] == 'IMAGE'): file_path = data[1] display = Displays.Image(file_path) elif (data[0] == 'SCHEMATIC'): file_path = data[1] show = True if(len(data[1:]) == 2): show = bool(data[2]) display = Displays.Schematic(file_path, show) problem.add_soldisplay_to_problem(display) elif (data[0] == 'TEXT'): text = ' '.join(data[1:]) display = Displays.Text(text) problem.add_display_to_problem(display) elif (data[0] == 'SOLTEXT'): text = ' '.join(data[1:]) display = Displays.Text(text) problem.add_soldisplay_to_problem(display) elif (data[0] == 'SOLDISPLAY'): problem.show_solution_all_params(True) elif (data[0] == 'TITLE'): title = data[1] problem.set_title(title) elif (data[0] == 'MARKS'): marks = int(data[1]) problem.set_marks(marks) Contain = Problem_Modifier.Container(problems,formatter) return Contain
sys.exit(1) if not os.path.isfile(sys.argv[1]): print("***file not found") sys.exit(1) file = open(sys.argv[1], "r") variable_dictionary = {} format_dictionary = { "FLOW": "YES", "LM": "1", "RM": "80", "JUST": "LEFT", "BULLET": "o" } f = Formatter(" ", format_dictionary) # noinspection PySimplifyBooleanCheck,PyGlobalUndefined def readCommands(file): """ :param file: text file to be parsed :return: N/A """ for input_line in file.readlines(): input_line = input_line.rstrip('\n') # removes newline if input_line == "": f.getformattedLine(input_line) token_list = input_line.split()