def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 2) ops[0].set_val(ops[1].get_val()) if isinstance(ops[0], Register): vm.changes.add(ops[0].get_nm()) elif isinstance(ops[0], Address): vm.changes.add(f'MEM{ops[0].get_mem_addr()}')
def get_three_ops_imm(instr, ops): ''' Same concept as the function above. ''' check_num_args(instr, ops, 3) check_immediate_three(instr, ops) return (ops[0], ops[1], ops[2])
def get_two_op_imm(instr, ops): """ Again, same as above, except for reg, imm format """ check_num_args(instr, ops, 2) check_immediate_two(instr, ops) return (ops[0], ops[1])
def fhook(self, ops, vm): check_num_args("CALL", ops, 1) vm.dec_sp() vm.stack[hex(vm.get_sp() + 1).split('x')[-1].upper()] = vm.get_ip() target = get_one_op(self.get_nm(), ops) vm.c_stack.append(vm.get_ip()) raise Jump(target.name)
def fhook(self, ops, vm): check_num_args(self.name, ops, 3) check_reg_only(self.name, ops) ops[0].set_val( check_overflow( opfunc.mod(abs(ops[1].get_val()), abs(ops[2].get_val())), vm)) vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.name, ops, 3) check_reg_only(self.name, ops) fixed_op2 = ops[2].get_val() % 32 ops[0].set_val( check_overflow(opfunc.lshift(ops[1].get_val(), fixed_op2), vm)) vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.name, ops, 1) if not isinstance(ops[0], Register): raise InvalidArgument(ops[0].get_nm()) ops[0].set_val(vm.registers['LO']) vm.changes.add(ops[0].get_nm()) return ''
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 1) if isinstance(ops[0], NewSymbol): vm.locals[ops[0].get_nm()] = ops[0].get_val() vm.changes.add(f'LOCALVAR{ops[0].get_nm()}') else: raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 1) if vm.is_FP_stack_full(): raise StackFull() # if isinstance(ops[0], FloatTok): # vm.push_to_Float_Stack(ops[0].get_val()) vm.push_to_Float_Stack(ops[0].get_val())
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 2, type_ins=1) if isinstance(ops[0], Register): checkEven(ops[0]) if isinstance(ops[1], RegAddress): reg_number = int(ops[0].get_nm()[1:]) curr_reg = "F" + str(reg_number + 0) next_reg = "F" + str(reg_number + 1) first_half = vm.registers[curr_reg] second_half = vm.registers[next_reg] full_b = first_half + second_half v = b_to_f64(full_b) ops[1].set_val(v) # deprecated code below # print(ops[0]) # first_half = ops[0].get_val() # reg_name = "F" + str(int(ops[0].get_nm()[1:])) # second_half = vm.registers[reg_name] # full_b = first_half + second_half # print("full_b", full_b) # v = b_to_f64(full_b) # ops[1].set_val(v) else: InvalidArgument(ops[1].get_nm()) else: raise InvalidArgument(ops[0].get_nm())
def two_op_arith(ops, vm, instr, operator): """ operator: this is the functional version of Python's +, -, *, etc. """ check_num_args(instr, ops, 2) ops[0].set_val(checkflag(operator(ops[0].get_val(), ops[1].get_val()), vm)) vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 2) if isinstance(ops[0], Register): if isinstance(ops[1], RegAddress): ops[1].set_val(ops[0].get_val()) else: InvalidArgument(ops[1].get_nm()) else: raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args("RET", ops, 0) vm.inc_sp() vm.set_ip(int(vm.stack[hex(vm.get_sp()).split('x')[-1].upper()])) vm.stack[hex(vm.get_sp()).split('x')[-1].upper()] = vm.empty_cell() while not isinstance(vm.c_stack[-1], int): vm.c_stack.pop() if isinstance(vm.c_stack[-1], int): vm.c_stack.pop()
def get_three_ops(instr, ops): ''' Function to grab the values in registers. Put in a separate so that we don't have to write out the checks all the time. ''' check_num_args(instr, ops, 3) check_reg_only(instr, ops) return (ops[0], ops[1], ops[2])
def one_op_arith(ops, vm, instr, operator): """ operator: this is the functional version of Python's +, -, *, etc. """ check_num_args(instr, ops, 1) if operator.__name__ == 'div' and ops[0].get_val() == 0.0: raise DivisionZero() else: vm.registers["ST0"] = operator(vm.registers["ST0"], ops[0].get_val())
def three_op_arith_immediate(ops, vm, instr, operator): """ operator: this is the functional version of Python's +, -, *, etc. """ check_num_args(instr, ops, 3) check_immediate_three(instr, ops) ops[0].set_val( check_overflow(operator(ops[1].get_val(), ops[2].get_val()), vm)) vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 1) if type(ops[0]) != IntegerTok: raise InvalidOperand(str(ops[0])) try: interrupt_class = int_vectors[ops[0].get_val()] interrupt_handler = interrupt_class[int(vm.registers[EAX])] except KeyError: raise UnknownInt(str(ops[0].get_val()) + ": " + vm.registers[EAX]) c = interrupt_handler(vm, self.get_nm()) return str(c)
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 1) if isinstance(ops[0], IntegerTok): try: stack_loc = hex(vm.get_sp()).split('x')[-1].upper() vm.stack[stack_loc] = ops[0].get_val() vm.inc_sp() except Exception: raise InvalidArgument(ops[0].get_nm()) else: raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 1) if isinstance(ops[0], NewSymbol): if ops[0].get_nm() in vm.locals: stack_loc = hex(vm.get_sp()).split('x')[-1].upper() vm.stack[stack_loc] = vm.locals[ops[0].get_nm()] vm.inc_sp() else: raise InvalidArgument(ops[0].get_nm()) else: raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 2) if isinstance(ops[0], Register): checkEven(ops[0]) if isinstance(ops[1], RegAddress): # if (float(ops[0].get_val()) > float(2 ** 22)): # raise TooBigForSingle(str(float(ops[0].get_val()))) ops[1].set_val(float(ops[0].get_val())) else: InvalidArgument(ops[1].get_nm()) else: raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.name, ops, 2) check_reg_only(self.name, ops) result = ops[0].get_val() * ops[1].get_val() if result > 2**32 - 1: vm.registers['LO'] = opfunc.lshift(result, 32) vm.registers['HI'] = opfunc.rshift(result, 32) else: vm.registers['LO'] = result vm.registers['HI'] = 0 vm.changes.add('LO') vm.changes.add('HI') return ''
def fhook(self, ops, vm): check_num_args(self.name, ops, 2) check_reg_only(self.name, ops) if ops[1].get_val() == 0: raise DivisionZero() quotient = ops[0].get_val() // ops[1].get_val() remainder = ops[0].get_val() % ops[1].get_val() vm.registers['LO'] = quotient vm.registers['HI'] = remainder vm.changes.add('LO') vm.changes.add('HI') return ''
def fhook(self, ops, vm): check_num_args(self.get_nm(), ops, 1) if isinstance(ops[0], NewSymbol): if ops[0].get_nm() in vm.globals: vm.dec_sp() stack_loc = hex(vm.get_sp()).split('x')[-1].upper() vm.globals[ops[0].get_nm()] = vm.stack[stack_loc] vm.inc_sp() vm.changes.add(f'GLOBALVAR{ops[0].get_nm()}') else: raise InvalidArgument(ops[0].get_nm()) else: raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm): check_num_args(self.name, ops, 1) hireg = int(vm.registers['EDX']) << 32 lowreg = int(vm.registers['EAX']) dividend = hireg + lowreg if ops[0].get_val() == 0: raise DivisionZero() vm.registers['EAX'] = dividend // ops[0].get_val() vm.registers['EDX'] = dividend % ops[0].get_val() vm.changes.add('EAX') vm.changes.add('EDX') return ''
def pop_arith(ops, vm, instr, operator): check_num_args(instr, ops, 2) reg_one, reg_two = [int(x.get_nm()[-1]) for x in ops] # first_reg = vm.get_float_stack_register_at_offset(offset1) # second_reg = vm.get_float_stack_register_at_offset(offset2) # r1 = vm.fp_stack_registers[first_reg] # r2 = vm.fp_stack_registers[second_reg] # vm.fp_stack_registers[first_reg] = checkflag(operator(r1, r2), vm) if reg_two != 0: raise InvalidOperand(f'ST{reg_two}') r1 = vm.registers[f'ST{reg_one}'] r2 = vm.registers[f'ST{reg_two}'] vm.registers[f'ST{reg_one}'] = checkflag(float(operator(r1, r2)), vm)
def fhook(self, ops, vm): check_num_args(self.name, ops, 3, type_ins=1) check_reg_only(self.name, ops) if ops[2].get_val() == 0: raise DivisionZero() result = ops[1].get_val() / ops[2].get_val() # this is the single version of div for floats # so we don't want to be bigger than max single if (result > 2**22): raise TooBigForSingle(str(result)) ops[0].set_val(result) vm.changes.add(ops[0].get_nm()) return ''
def fhook(self, ops, vmachine): check_num_args(self.name, ops, 2) num = ops[1].get_val() if num == 0: vmachine.flags["ZF"] = 1 else: vmachine.flags["ZF"] = 0 if ops[1].get_val().bit_length() <= 16: bit_size = 16 else: bit_size = 32 binStr = str(bin(num))[2:].zfill(bit_size) for index in range(len(binStr)): if binStr[index] == '1': break index = bit_size - index ops[0].set_val(index)
def three_op_arith_reg(ops, vm, instr, operator): """ operator: this is the functional version of Python's +, -, *, etc. """ check_num_args(instr, ops, 3, type_ins=1) check_reg_only(instr, ops) # go through the register ops and make sure that they're even numbered for op in ops: checkEven(op) ops[0].set_val(operator(ops[1].get_val(), ops[2].get_val())) # check_overflow(operator(ops[1].get_val(), # ops[2].get_val()), # vm)) vm.changes.add(ops[0].get_nm())
def two_op_arith(ops, vm, instr, operator): """ operator: this is the functional version of Python's +, -, *, etc. """ check_num_args(instr, ops, 2) reg_one, reg_two = [int(x.get_nm()[-1]) for x in ops] # first_reg = vm.get_float_stack_register_at_offset(offset1) # second_reg = vm.get_float_stack_register_at_offset(offset2) # r1 = vm.fp_stack_registers[first_reg] # r2 = vm.fp_stack_registers[second_reg] # vm.fp_stack_registers[first_reg] = checkflag(operator(r1, r2), vm) if reg_one != 0 and reg_two != 0: raise InvalidOperand('Neither registers are ST0') r1 = vm.registers[f'ST{reg_one}'] r2 = vm.registers[f'ST{reg_two}'] vm.registers[f'ST{reg_one}'] = checkflag(operator(r1, r2), vm)
def fhook(self, ops, vm): check_num_args("BNE", ops, 3) disp = 0 if isinstance(ops[2], IntegerTok): disp = ops[2].get_val() else: raise InvalidArgument(ops[0].get_nm()) val_one, val_two = (0, 0) if isinstance(ops[0], Register): val_one = ops[0].get_val() if isinstance(ops[1], Register): val_two = ops[1].get_val() else: InvalidArgument(ops[1].get_nm()) else: InvalidArgument(ops[0].get_nm()) if val_one != val_two: current_ip = vm.get_ip() if current_ip + disp * 4 >= 0: vm.set_ip(current_ip + disp * 4) else: raise OutofBounds()