diff options
Diffstat (limited to 'execute.py')
| -rw-r--r-- | execute.py | 746 |
1 files changed, 508 insertions, 238 deletions
@@ -4,13 +4,13 @@ import numpy as np import math -class Label(): +class Label: def __init__(self, arity, name): self.arity = arity self.name = name -class Frame(): +class Frame: def __init__(self, arity, local_indices, self_ref): self.arity = arity self.local_indices = local_indices @@ -18,10 +18,10 @@ class Frame(): # takes the machinestate, opcode and operand to run. updates the machinestate -class Execute(): # pragma: no cover +class Execute: # pragma: no cover def __init__(self, machinestate): self.machinestate = machinestate - self.opcodeint = '' + self.opcodeint = "" self.immediates = [] self.op_gas = int() self.stack_top = [] @@ -30,7 +30,7 @@ class Execute(): # pragma: no cover return self.op_gas def chargeGasMem(self, mem_size_page): - #factor = 64 + # factor = 64 self.op_gas += 64 * mem_size_page def chargeGas(self, opcodeint): @@ -42,216 +42,242 @@ class Execute(): # pragma: no cover def getInstruction(self, opcodeint, immediates): self.opcodeint = opcodeint dummy = [] - #FIXME-why is it being cast to int? + # FIXME-why is it being cast to int? for i in immediates: dummy.append(int(i)) self.immediates = dummy def callExecuteMethod(self): - runmethod = self.instructionUnwinder(self.opcodeint, self.immediates, self.machinestate) - #print (repr(hex(self.opcodeint)) + ' ' + repr(self.immediates)) + runmethod = self.instructionUnwinder( + self.opcodeint, self.immediates, self.machinestate + ) + # print (repr(hex(self.opcodeint)) + ' ' + repr(self.immediates)) try: runmethod(self.opcodeint, self.immediates) except IndexError: # trap - print(Colors.red + 'bad stack access.' + Colors.ENDC) - #val2 = self.machinestate.Stack_Omni.pop() - + print(Colors.red + "bad stack access." + Colors.ENDC) + # val2 = self.machinestate.Stack_Omni.pop() def instructionUnwinder(self, opcodeint, immediates, machinestate): self.chargeGas(opcodeint) if opcodeint == 0: - return(self.run_unreachable) + return self.run_unreachable elif opcodeint == 1: - return(self.run_nop) + return self.run_nop elif opcodeint == 2: - return(self.run_block) + return self.run_block elif opcodeint == 3: - return(self.run_loop) + return self.run_loop elif opcodeint == 4: - return(self.run_if) + return self.run_if elif opcodeint == 5: - return(self.run_else) + return self.run_else elif opcodeint == 11: - return(self.run_end) + return self.run_end elif opcodeint == 12: - return(self.run_br) + return self.run_br elif opcodeint == 13: - return(self.run_br_if) + return self.run_br_if elif opcodeint == 14: - return(self.run_br_table) + return self.run_br_table elif opcodeint == 15: - return(self.run_return) + return self.run_return elif opcodeint == 16: - return(self.run_call) + return self.run_call elif opcodeint == 17: - return(self.run_call_indirect) + return self.run_call_indirect elif opcodeint == 26: - return(self.run_drop) + return self.run_drop elif opcodeint == 27: - return(self.run_select) + return self.run_select elif opcodeint == 32: - return(self.run_getlocal) + return self.run_getlocal elif opcodeint == 33: - return(self.run_setlocal) + return self.run_setlocal elif opcodeint == 34: - return(self.run_teelocal) + return self.run_teelocal elif opcodeint == 35: - return(self.run_getglobal) + return self.run_getglobal elif opcodeint == 36: - return(self.run_setglobal) + return self.run_setglobal elif opcodeint >= 40 and opcodeint <= 53: - return(self.run_load) + return self.run_load elif opcodeint >= 54 and opcodeint <= 62: - return(self.run_store) + return self.run_store elif opcodeint == 63: - return(self.run_current_memory) + return self.run_current_memory elif opcodeint == 64: self.chargeGasMem(immediates[0]) - return(self.run_grow_memory) + return self.run_grow_memory elif opcodeint >= 65 and opcodeint <= 68: - return(self.run_const) + return self.run_const elif opcodeint == 69 or opcodeint == 80: - return(self.run_eqz) - elif opcodeint == 70 or opcodeint == 81 or opcodeint == 91 or opcodeint == 97: - return(self.run_eq) - elif opcodeint == 71 or opcodeint == 82 or opcodeint == 92 or opcodeint == 98: - return(self.run_ne) + return self.run_eqz + elif ( + opcodeint == 70 + or opcodeint == 81 + or opcodeint == 91 + or opcodeint == 97 + ): + return self.run_eq + elif ( + opcodeint == 71 + or opcodeint == 82 + or opcodeint == 92 + or opcodeint == 98 + ): + return self.run_ne elif opcodeint == 72 or opcodeint == 83: - return(self.run_lt_s) + return self.run_lt_s elif opcodeint == 73 or opcodeint == 84: - return(self.run_lt_u) + return self.run_lt_u elif opcodeint == 74 or opcodeint == 85: - return(self.run_gt_s) + return self.run_gt_s elif opcodeint == 75 or opcodeint == 86: - return(self.run_gt_u) + return self.run_gt_u elif opcodeint == 76 or opcodeint == 87: - return(self.run_le_s) + return self.run_le_s elif opcodeint == 77 or opcodeint == 88: - return(self.run_le_u) + return self.run_le_u elif opcodeint == 78 or opcodeint == 89: - return(self.run_ge_s) + return self.run_ge_s elif opcodeint == 79 or opcodeint == 90: - return(self.run_ge_u) + return self.run_ge_u elif opcodeint == 93 or opcodeint == 99: - return(self.run_lt) + return self.run_lt elif opcodeint == 94 or opcodeint == 100: - return(self.run_gt) + return self.run_gt elif opcodeint == 95 or opcodeint == 101: - return(self.run_le) + return self.run_le elif opcodeint == 96 or opcodeint == 102: - return(self.run_ge) + return self.run_ge elif opcodeint == 103 or opcodeint == 121: - return(self.run_clz) + return self.run_clz elif opcodeint == 104 or opcodeint == 122: - return(self.run_ctz) + return self.run_ctz elif opcodeint == 105 or opcodeint == 123: - return(self.run_popcnt) - elif opcodeint == 106 or opcodeint == 124 or opcodeint == 146 or opcodeint == 160: - return(self.run_add) - elif opcodeint == 107 or opcodeint == 125 or opcodeint == 147 or opcodeint == 161: - return(self.run_sub) - elif opcodeint == 108 or opcodeint == 126 or opcodeint == 148 or opcodeint == 162: - return(self.run_mul) + return self.run_popcnt + elif ( + opcodeint == 106 + or opcodeint == 124 + or opcodeint == 146 + or opcodeint == 160 + ): + return self.run_add + elif ( + opcodeint == 107 + or opcodeint == 125 + or opcodeint == 147 + or opcodeint == 161 + ): + return self.run_sub + elif ( + opcodeint == 108 + or opcodeint == 126 + or opcodeint == 148 + or opcodeint == 162 + ): + return self.run_mul elif opcodeint == 109 or opcodeint == 127: - return(self.run_div_s) + return self.run_div_s elif opcodeint == 110 or opcodeint == 128: - return(self.run_div_u) + return self.run_div_u elif opcodeint == 111 or opcodeint == 129: - return(self.run_rem_s) + return self.run_rem_s elif opcodeint == 112 or opcodeint == 130: - return(self.run_rem_u) + return self.run_rem_u elif opcodeint == 113 or opcodeint == 131: - return(self.run_and) + return self.run_and elif opcodeint == 114 or opcodeint == 132: - return(self.run_or) + return self.run_or elif opcodeint == 115 or opcodeint == 133: - return(self.run_xor) + return self.run_xor elif opcodeint == 116 or opcodeint == 134: - return(self.run_shl) + return self.run_shl elif opcodeint == 117 or opcodeint == 135: - return(self.run_shr_s) + return self.run_shr_s elif opcodeint == 118 or opcodeint == 136: - return(self.run_shr_u) + return self.run_shr_u elif opcodeint == 119 or opcodeint == 137: - return(self.run_rotl) + return self.run_rotl elif opcodeint == 120 or opcodeint == 138: - return(self.run_rotr) + return self.run_rotr elif opcodeint == 139 or opcodeint == 153: - return(self.run_abs) + return self.run_abs elif opcodeint == 140 or opcodeint == 154: - return(self.run_neg) + return self.run_neg elif opcodeint == 141 or opcodeint == 155: - return(self.run_ceil) + return self.run_ceil elif opcodeint == 142 or opcodeint == 156: - return(self.run_floor) + return self.run_floor elif opcodeint == 143 or opcodeint == 157: - return(self.run_trunc) + return self.run_trunc elif opcodeint == 144 or opcodeint == 158: - return(self.run_nearest) + return self.run_nearest elif opcodeint == 145 or opcodeint == 159: - return(self.run_sqrt) + return self.run_sqrt elif opcodeint == 149 or opcodeint == 163: - return(self.run_div) + return self.run_div elif opcodeint == 150 or opcodeint == 164: - return(self.run_min) + return self.run_min elif opcodeint == 151 or opcodeint == 165: - return(self.run_max) + return self.run_max elif opcodeint == 152 or opcodeint == 166: - return(self.run_copysign) + return self.run_copysign elif opcodeint == 167: - return(self.run_i32wrapi64) + return self.run_i32wrapi64 elif opcodeint == 168: - return(self.run_i32trunc_sf32) + return self.run_i32trunc_sf32 elif opcodeint == 169: - return(self.run_i32trunc_uf32) + return self.run_i32trunc_uf32 elif opcodeint == 170: - return(self.run_i32trunc_sf64) + return self.run_i32trunc_sf64 elif opcodeint == 171: - return(self.run_i32trunc_uf64) + return self.run_i32trunc_uf64 elif opcodeint == 172: - return(self.run_i64extend_si32) + return self.run_i64extend_si32 elif opcodeint == 173: - return(self.run_i64extend_ui3o) + return self.run_i64extend_ui3o elif opcodeint == 174: - return(self.run_i64trunc_sf32) + return self.run_i64trunc_sf32 elif opcodeint == 175: - return(self.run_i64trunc_uf32) + return self.run_i64trunc_uf32 elif opcodeint == 176: - return(self.run_i64trunc_sf64) + return self.run_i64trunc_sf64 elif opcodeint == 177: - return(self.run_i64trunc_uf64) + return self.run_i64trunc_uf64 elif opcodeint == 178: - return(self.run_f32convert_si32) + return self.run_f32convert_si32 elif opcodeint == 179: - return(self.run_f32convert_ui32) + return self.run_f32convert_ui32 elif opcodeint == 180: - return(self.run_f32convert_si64) + return self.run_f32convert_si64 elif opcodeint == 181: - return(self.run_f32convert_ui64) + return self.run_f32convert_ui64 elif opcodeint == 182: - return(self.run_f32demotef64) + return self.run_f32demotef64 elif opcodeint == 183: - return(self.run_f64convert_si32) + return self.run_f64convert_si32 elif opcodeint == 184: - return(self.run_f64convert_ui32) + return self.run_f64convert_ui32 elif opcodeint == 185: - return(self.run_f64convert_si64) + return self.run_f64convert_si64 elif opcodeint == 186: - return(self.run_f64convert_ui64) + return self.run_f64convert_ui64 elif opcodeint == 187: - return(self.run_f64promotef32) + return self.run_f64promotef32 elif opcodeint == 188: - return(self.run_i32reinterpretf32) + return self.run_i32reinterpretf32 elif opcodeint == 189: - return(self.run_i64reinterpretf64) + return self.run_i64reinterpretf64 elif opcodeint == 190: - return(self.run_f32reinterpreti32) + return self.run_f32reinterpreti32 elif opcodeint == 191: - return(self.run_f64reinterpreti64) + return self.run_f64reinterpreti64 else: - raise Exception(Colors.red + 'unknown opcode' + Colors.ENDC) + raise Exception(Colors.red + "unknown opcode" + Colors.ENDC) def run_unreachable(self, opcodeint, immediates): # trap @@ -262,7 +288,9 @@ class Execute(): # pragma: no cover pass def run_block(self, opcodeint, immediates): - self.machinestate.Stack_Label.append(self.machinestate.Stack_Label_Height) + self.machinestate.Stack_Label.append( + self.machinestate.Stack_Label_Height + ) self.machinestate.Stack_Label_Height += 1 def run_loop(self, opcodeint, immediates): @@ -270,7 +298,9 @@ class Execute(): # pragma: no cover if not self.machinestate.Stack_Omni: print(Colors.red + "entered a loop. stack is empty." + Colors.ENDC) # exit 1 - self.machinestate.Stack_Label.append(self.machinestate.Stack_Label_Height) + self.machinestate.Stack_Label.append( + self.machinestate.Stack_Label_Height + ) self.machinestate.Stack_Label_Height += 1 val = self.machinestate.Stack_Omni.pop() if val != 0: @@ -285,18 +315,26 @@ class Execute(): # pragma: no cover pass def run_end(self, opcodeint, immediates): - #self.machinestate.Stack_Label.pop() + # self.machinestate.Stack_Label.pop() pass def run_br(self, opcodeint, immediates): if self.machinestate.Stack_Label_Height >= immediates[0] + 1: - print(Colors.red + "label stack does not have enough labels." + Colors.ENDC) + print( + Colors.red + + "label stack does not have enough labels." + + Colors.ENDC + ) # exit 1 if len(self.machinestate.Stack_Omni) < 1: - print(Colors.red + "the value stack does not have enough values." + Colors.ENDC) + print( + Colors.red + + "the value stack does not have enough values." + + Colors.ENDC + ) # exit 1 - #val = self.machinestate.Stack_Omni.pop() - #label = self.machinestate.Stack_Label.pop() + # val = self.machinestate.Stack_Omni.pop() + # label = self.machinestate.Stack_Label.pop() def run_br_if(self, opcodeint, immediates): val = self.machinestate.Stack_Omni.pop() @@ -328,11 +366,15 @@ class Execute(): # pragma: no cover self.machinestate.Stack_Omni.append(local) def run_setlocal(self, opcodeint, immediates): - self.machinestate.Index_Space_Locals[int(immediates[0])] = self.machinestate.Stack_Omni.pop() + self.machinestate.Index_Space_Locals[ + int(immediates[0]) + ] = self.machinestate.Stack_Omni.pop() def run_teelocal(self, dummy, immediates): # @DEVI-we dont pop and push - self.machinestate.Index_Space_Locals[int(immediates[0])] = self.machinestate.Stack_Omni[-1] + self.machinestate.Index_Space_Locals[ + int(immediates[0]) + ] = self.machinestate.Stack_Omni[-1] def run_getglobal(self, opcodeint, immediates): val = self.machinestate.Index_Space_Global[immediates[0]] @@ -345,75 +387,141 @@ class Execute(): # pragma: no cover # currently only one linear memory is allowed so thats the default. def run_load(self, opcodeint, immediates): if opcodeint == 40: - bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 4] + bytes = self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates) + 4 + ] self.machinestate.Stack_Omni.append(np.int32(bytes)) elif opcodeint == 41: - bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 8] + bytes = self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates) + 8 + ] self.machinestate.Stack_Omni.append(np.int64(bytes)) elif opcodeint == 42: - bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 4] + bytes = self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates) + 4 + ] self.machinestate.Stack_Omni.append(np.float32(bytes)) elif opcodeint == 43: - bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 8] + bytes = self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates) + 8 + ] self.machinestate.Stack_Omni.append(np.float64(bytes)) elif opcodeint == 44: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])]) - temp2 = (temp & 0x0000007f) | ((temp & 0x80) << 24) + temp = np.int8( + self.machinestate.Linear_Memory[0][int(immediates[1])] + ) + temp2 = (temp & 0x0000007F) | ((temp & 0x80) << 24) self.machinestate.append(np.int32(temp2)) elif opcodeint == 45: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])]) - temp2 = temp & 0x000000ff + temp = np.int8( + self.machinestate.Linear_Memory[0][int(immediates[1])] + ) + temp2 = temp & 0x000000FF self.machinestate.append(np.uint32(temp2)) elif opcodeint == 46: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)]) - temp2 = (temp & 0x00007fff) | ((temp & 0x8000) << 16) + temp = np.int8( + self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates[1] + 2) + ] + ) + temp2 = (temp & 0x00007FFF) | ((temp & 0x8000) << 16) self.machinestate.append(np.int32(temp2)) elif opcodeint == 47: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)]) - temp2 = temp & 0x0000ffff + temp = np.int8( + self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates[1] + 2) + ] + ) + temp2 = temp & 0x0000FFFF self.machinestate.append(np.uint32(temp2)) elif opcodeint == 48: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])]) - temp2 = (temp & 0x000000000000007f) | ((temp & 0x80) << 56) + temp = np.int8( + self.machinestate.Linear_Memory[0][int(immediates[1])] + ) + temp2 = (temp & 0x000000000000007F) | ((temp & 0x80) << 56) self.machinestate.append(np.int64(temp2)) elif opcodeint == 49: - temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1])]) + temp = np.uint8( + self.machinestate.Linear_Memory[0][int(immediates[1])] + ) self.machinestate.append(np.uint64(temp)) elif opcodeint == 50: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)]) - temp2 = (temp & 0x0000000000007fff) | ((temp & 0x8000) << 48) + temp = np.int8( + self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates[1] + 2) + ] + ) + temp2 = (temp & 0x0000000000007FFF) | ((temp & 0x8000) << 48) self.machinestate.append(np.int64(temp2)) elif opcodeint == 51: - temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)]) + temp = np.uint8( + self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates[1] + 2) + ] + ) self.machinestate.append(np.uint64(temp)) elif opcodeint == 52: - temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 4)]) - temp2 = (temp & 0x000000007fffffff) | ((temp & 0x80000000) << 32) + temp = np.int8( + self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates[1] + 4) + ] + ) + temp2 = (temp & 0x000000007FFFFFFF) | ((temp & 0x80000000) << 32) self.machinestate.append(np.int64(temp2)) elif opcodeint == 53: - temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 4)]) + temp = np.uint8( + self.machinestate.Linear_Memory[0][ + int(immediates[1]) : int(immediates[1] + 4) + ] + ) self.machinestate.append(np.uint64(temp)) else: - raise Exception(Colors.red + 'invalid load instruction.' + Colors.ENDC) + raise Exception( + Colors.red + "invalid load instruction." + Colors.ENDC + ) # currently only one linear memory is allowed so thats the default. def run_store(self, opcodeint, immediates): if opcodeint == 54: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = val & 0x000000ff - self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = val & 0x0000ff00 >> 8 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = val & 0x00ff0000 >> 16 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = val & 0xff000000 >> 24 + self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = ( + val & 0x000000FF + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = ( + val & 0x0000FF00 >> 8 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = ( + val & 0x00FF0000 >> 16 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = ( + val & 0xFF000000 >> 24 + ) elif opcodeint == 55: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = val & 0x00000000000000ff - self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = val & 0x000000000000ff00 >> 8 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = val & 0x0000000000ff0000 >> 16 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = val & 0x00000000ff000000 >> 24 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 4] = val & 0x000000ff00000000 >> 32 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 5] = val & 0x0000ff0000000000 >> 40 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 6] = val & 0x00ff000000000000 >> 48 - self.machinestate.Linear_Memory[0][int(immediates[1]) + 7] = val & 0xff00000000000000 >> 56 + self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = ( + val & 0x00000000000000FF + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = ( + val & 0x000000000000FF00 >> 8 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = ( + val & 0x0000000000FF0000 >> 16 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = ( + val & 0x00000000FF000000 >> 24 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 4] = ( + val & 0x000000FF00000000 >> 32 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 5] = ( + val & 0x0000FF0000000000 >> 40 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 6] = ( + val & 0x00FF000000000000 >> 48 + ) + self.machinestate.Linear_Memory[0][int(immediates[1]) + 7] = ( + val & 0xFF00000000000000 >> 56 + ) # @DEVI-FIXME-needs reinterpret cast elif opcodeint == 56: pass @@ -422,26 +530,48 @@ class Execute(): # pragma: no cover pass elif opcodeint == 58: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8(val & 0x000000ff) + self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8( + val & 0x000000FF + ) elif opcodeint == 59: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = np.in8(val & 0x000000ff) - self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = np.in8(val & 0x0000ff00 >> 8) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 0 + ] = np.in8(val & 0x000000FF) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 1 + ] = np.in8(val & 0x0000FF00 >> 8) elif opcodeint == 60: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8(val & 0x00000000000000ff) + self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8( + val & 0x00000000000000FF + ) elif opcodeint == 61: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = np.in8(val & 0x00000000000000ff) - self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = np.in8(val & 0x000000000000ff00 >> 8) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 0 + ] = np.in8(val & 0x00000000000000FF) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 1 + ] = np.in8(val & 0x000000000000FF00 >> 8) elif opcodeint == 62: val = self.machinestate.Stack_Omni.pop() - self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = np.in8(val & 0x00000000000000ff) - self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = np.in8(val & 0x000000000000ff00 >> 8) - self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = np.in8(val & 0x0000000000ff0000 >> 16) - self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = np.in8(val & 0x00000000ff000000 >> 24) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 0 + ] = np.in8(val & 0x00000000000000FF) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 1 + ] = np.in8(val & 0x000000000000FF00 >> 8) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 2 + ] = np.in8(val & 0x0000000000FF0000 >> 16) + self.machinestate.Linear_Memory[0][ + int(immediates[1]) + 3 + ] = np.in8(val & 0x00000000FF000000 >> 24) else: - raise Exception(Colors.red + 'invalid store instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid store instruction" + Colors.ENDC + ) def run_current_memory(self, opcodeint, immediates): pass @@ -459,7 +589,9 @@ class Execute(): # pragma: no cover elif opcodeint == 68: self.machinestate.Stack_Omni.append(immediates[0]) else: - raise Exception(Colors.red + 'invalid const instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid const instruction" + Colors.ENDC + ) def run_eqz(self, opcodeint, immediates): if opcodeint == 69 or opcodeint == 80: @@ -469,10 +601,17 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid eqz instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid eqz instruction" + Colors.ENDC + ) def run_eq(self, opcodeint, immediates): - if opcodeint == 70 or opcodeint == 81 or opcodeint == 91 or opcodeint == 97: + if ( + opcodeint == 70 + or opcodeint == 81 + or opcodeint == 91 + or opcodeint == 97 + ): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if val1 == val2: @@ -480,10 +619,17 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid eq instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid eq instruction" + Colors.ENDC + ) def run_ne(self, opcodeint, immediates): - if opcodeint == 71 or opcodeint == 82 or opcodeint == 92 or opcodeint == 98: + if ( + opcodeint == 71 + or opcodeint == 82 + or opcodeint == 92 + or opcodeint == 98 + ): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if val1 != val2: @@ -491,7 +637,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid ne instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid ne instruction" + Colors.ENDC + ) def run_lt_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -507,7 +655,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid lt_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid lt_s instruction" + Colors.ENDC + ) def run_lt_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -523,7 +673,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid lt_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid lt_u instruction" + Colors.ENDC + ) def run_gt_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -539,7 +691,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid gt_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid gt_s instruction" + Colors.ENDC + ) def run_gt_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -555,7 +709,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid gt_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid gt_u instruction" + Colors.ENDC + ) def run_le_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -571,7 +727,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid le_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid le_s instruction" + Colors.ENDC + ) def run_le_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -587,7 +745,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid le_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid le_u instruction" + Colors.ENDC + ) def run_ge_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -603,7 +763,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid ge_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid ge_s instruction" + Colors.ENDC + ) def run_ge_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -619,7 +781,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid ge_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid ge_u instruction" + Colors.ENDC + ) def run_lt(self, opcodeint, immediates): v2 = self.machinestate.Stack_Omni.pop() @@ -635,7 +799,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid lt instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid lt instruction" + Colors.ENDC + ) def run_gt(self, opcodeint, immediates): v2 = self.machinestate.Stack_Omni.pop() @@ -651,7 +817,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid gt instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid gt instruction" + Colors.ENDC + ) def run_le(self, opcodeint, immediates): v2 = self.machinestate.Stack_Omni.pop() @@ -667,7 +835,9 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid le instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid le instruction" + Colors.ENDC + ) def run_ge(self, opcodeint, immediates): v2 = self.machinestate.Stack_Omni.pop() @@ -683,34 +853,42 @@ class Execute(): # pragma: no cover else: self.machinestate.Stack_Omni.append(0) else: - raise Exception(Colors.red + 'invalid ge instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid ge instruction" + Colors.ENDC + ) def run_clz(self, opcodeint, immediates): val = self.machinestate.Stack_Omni.pop() if opcodeint == 103: - self.machinestate.Stack_Omni.append(clz(val, 'uint32')) + self.machinestate.Stack_Omni.append(clz(val, "uint32")) elif opcodeint == 121: - self.machinestate.Stack_Omni.append(clz(val, 'uint64')) + self.machinestate.Stack_Omni.append(clz(val, "uint64")) else: - raise Exception(Colors.red + 'invalid clz instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid clz instruction" + Colors.ENDC + ) def run_ctz(self, opcodeint, immediates): val = self.machinestate.Stack_Omni.pop() if opcodeint == 104: - self.machinestate.Stack_Omni.append(ctz(val, 'uint32')) + self.machinestate.Stack_Omni.append(ctz(val, "uint32")) elif opcodeint == 122: - self.machinestate.Stack_Omni.append(ctz(val, 'uint64')) + self.machinestate.Stack_Omni.append(ctz(val, "uint64")) else: - raise Exception(Colors.red + 'invalid ctz instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid ctz instruction" + Colors.ENDC + ) def run_popcnt(self, opcodeint, immediates): val = self.machinestate.Stack_Omni.pop() if opcodeint == 105: - self.machinestate.Stack_Omni.append(pop_cnt(val, 'uint32')) + self.machinestate.Stack_Omni.append(pop_cnt(val, "uint32")) elif opcodeint == 123: - self.machinestate.Stack_Omni.append(pop_cnt(val, 'uint64')) + self.machinestate.Stack_Omni.append(pop_cnt(val, "uint64")) else: - raise Exception(Colors.red + 'invalid popcnt instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid popcnt instruction" + Colors.ENDC + ) def run_add(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -724,7 +902,9 @@ class Execute(): # pragma: no cover elif opcodeint == 160: self.machinestate.Stack_Omni.append(np.float64(val1 + val2)) else: - raise Exception(Colors.red + 'invalid add instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid add instruction" + Colors.ENDC + ) def run_sub(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -738,7 +918,9 @@ class Execute(): # pragma: no cover elif opcodeint == 161: self.machinestate.Stack_Omni.append(np.float64(val1 - val2)) else: - raise Exception(Colors.red + 'invalid sub instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid sub instruction" + Colors.ENDC + ) def run_mul(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -752,107 +934,169 @@ class Execute(): # pragma: no cover elif opcodeint == 162: self.machinestate.Stack_Omni.append(np.float64(val1 * val2)) else: - raise Exception(Colors.red + 'invalid mul instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid mul instruction" + Colors.ENDC + ) def run_div_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 109: - self.machinestate.Stack_Omni.append(np.int32(np.int32(val1) / np.int32(val2))) + self.machinestate.Stack_Omni.append( + np.int32(np.int32(val1) / np.int32(val2)) + ) elif opcodeint == 127: - self.machinestate.Stack_Omni.append(np.int64(np.int64(val1) / np.int64(val2))) + self.machinestate.Stack_Omni.append( + np.int64(np.int64(val1) / np.int64(val2)) + ) else: - raise Exception(Colors.red + 'invalid div_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid div_s instruction" + Colors.ENDC + ) def run_div_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 110: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) / np.uint32(val2))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) / np.uint32(val2)) + ) elif opcodeint == 128: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) / np.uint64(val2))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) / np.uint64(val2)) + ) else: - raise Exception(Colors.red + 'invalid div_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid div_u instruction" + Colors.ENDC + ) def run_rem_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 111: - self.machinestate.Stack_Omni.append(np.int32(np.int32(val1) % np.int32(val2))) + self.machinestate.Stack_Omni.append( + np.int32(np.int32(val1) % np.int32(val2)) + ) elif opcodeint == 129: - self.machinestate.Stack_Omni.append(np.int64(np.int64(val1) % np.int64(val2))) + self.machinestate.Stack_Omni.append( + np.int64(np.int64(val1) % np.int64(val2)) + ) else: - raise Exception(Colors.red + 'invalid rem_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid rem_s instruction" + Colors.ENDC + ) def run_rem_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 112: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) % np.uint32(val2))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) % np.uint32(val2)) + ) elif opcodeint == 130: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) % np.uint64(val2))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) % np.uint64(val2)) + ) else: - raise Exception(Colors.red + 'invalid rem_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid rem_u instruction" + Colors.ENDC + ) def run_and(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 113: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) & np.uint32(val2))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) & np.uint32(val2)) + ) elif opcodeint == 131: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) & np.uint64(val2))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) & np.uint64(val2)) + ) else: - raise Exception(Colors.red + 'invalid and instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid and instruction" + Colors.ENDC + ) def run_or(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 114: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) | np.uint32(val2))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) | np.uint32(val2)) + ) elif opcodeint == 132: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) | np.uint64(val2))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) | np.uint64(val2)) + ) else: - raise Exception(Colors.red + 'invalid or instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid or instruction" + Colors.ENDC + ) def run_xor(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 115: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) ^ np.uint32(val2))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) ^ np.uint32(val2)) + ) elif opcodeint == 133: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) ^ np.uint64(val2))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) ^ np.uint64(val2)) + ) else: - raise Exception(Colors.red + 'invalid xor instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid xor instruction" + Colors.ENDC + ) def run_shl(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 116: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) << (np.uint32(val2)))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) << (np.uint32(val2))) + ) elif opcodeint == 134: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) << (np.uint64(val2)))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) << (np.uint64(val2))) + ) else: - raise Exception(Colors.red + 'invalid shl instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid shl instruction" + Colors.ENDC + ) def run_shr_s(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 117: - self.machinestate.Stack_Omni.append(np.int32(np.int32(val1) >> (np.int32(val2)))) + self.machinestate.Stack_Omni.append( + np.int32(np.int32(val1) >> (np.int32(val2))) + ) elif opcodeint == 135: - self.machinestate.Stack_Omni.append(np.int64(np.int64(val1) >> (np.int64(val2)))) + self.machinestate.Stack_Omni.append( + np.int64(np.int64(val1) >> (np.int64(val2))) + ) else: - raise Exception(Colors.red + 'invalid shr_s instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid shr_s instruction" + Colors.ENDC + ) def run_shr_u(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 118: - self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) >> (np.uint32(val2)))) + self.machinestate.Stack_Omni.append( + np.uint32(np.uint32(val1) >> (np.uint32(val2))) + ) elif opcodeint == 136: - self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) >> (np.uint64(val2)))) + self.machinestate.Stack_Omni.append( + np.uint64(np.uint64(val1) >> (np.uint64(val2))) + ) else: - raise Exception(Colors.red + 'invalid shr_u instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid shr_u instruction" + Colors.ENDC + ) def run_rotl(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -862,7 +1106,9 @@ class Execute(): # pragma: no cover elif opcodeint == 137: self.machinestate.Stack_Omni.append(rol(val1, 64, val2)) else: - raise Exception(Colors.red + 'invalid rotl instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid rotl instruction" + Colors.ENDC + ) def run_rotr(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -872,55 +1118,71 @@ class Execute(): # pragma: no cover elif opcodeint == 138: self.machinestate.Stack_Omni.append(ror(val1, 32, val2)) else: - raise Exception(Colors.red + 'invalid rotl instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid rotl instruction" + Colors.ENDC + ) def run_abs(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 139 or opcodeint == 153: self.machinestate.Stack_Omni.append(abs(val1)) else: - raise Exception(Colors.red + 'invalid abs instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid abs instruction" + Colors.ENDC + ) def run_neg(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 140 or opcodeint == 154: self.machinestate.Stack_Omni.append(-val1) else: - raise Exception(Colors.red + 'invalid neg instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid neg instruction" + Colors.ENDC + ) def run_ceil(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 141 or opcodeint == 155: self.machinestate.Stack_Omni.append(math.ceil(val1)) else: - raise Exception(Colors.red + 'invalid ceil instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid ceil instruction" + Colors.ENDC + ) def run_floor(self, opcodeint, immediates): if opcodeint == 142 or opcodeint == 156: self.machinestate.Stack_Omni.append(math.floor(val1)) else: - raise Exception(Colors.red + 'invalid floor instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid floor instruction" + Colors.ENDC + ) def run_trunc(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 143 or opcodeint == 157: self.machinestate.Stack_Omni.append(math.trunc(val1)) else: - raise Exception(Colors.red + 'invalid trunc instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid trunc instruction" + Colors.ENDC + ) def run_nearest(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 144 or opcodeint == 158: self.machinestate.Stack_Omni.append(round(val1)) else: - raise Exception(Colors.red + 'invalid nearest instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid nearest instruction" + Colors.ENDC + ) def run_sqrt(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() if opcodeint == 145 or opcodeint == 159: self.machinestate.Stack_Omni.append(math.sqrt(val1)) else: - raise Exception(Colors.red + 'invalid sqrt instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid sqrt instruction" + Colors.ENDC + ) def run_div(self, opcodeint, immediates): v2 = self.machinestate.Stack_Omni.pop() @@ -928,7 +1190,9 @@ class Execute(): # pragma: no cover if opcodeint == 149: self.machinestate.Stack_Omni.append(v1 / v2) else: - raise Exception(Colors.red + 'invalid float div instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid float div instruction" + Colors.ENDC + ) def run_min(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -936,7 +1200,9 @@ class Execute(): # pragma: no cover if opcodeint == 150 or opcodeint == 164: self.machinestate.Stack_Omni.append(min(val1, val2)) else: - raise Exception(Colors.red + 'invalid min instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid min instruction" + Colors.ENDC + ) def run_max(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -944,7 +1210,9 @@ class Execute(): # pragma: no cover if opcodeint == 151 or opcodeint == 165: self.machinestate.Stack_Omni.append(max(val1, val2)) else: - raise Exception(Colors.red + 'invalid max instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid max instruction" + Colors.ENDC + ) def run_copysign(self, opcodeint, immediates): val2 = self.machinestate.Stack_Omni.pop() @@ -952,7 +1220,9 @@ class Execute(): # pragma: no cover if opcodeint == 152 or opcodeint == 166: self.machinestate.Stack_Omni.append(math.copysign(val1, val2)) else: - raise Exception(Colors.red + 'invalid max instruction' + Colors.ENDC) + raise Exception( + Colors.red + "invalid max instruction" + Colors.ENDC + ) def run_i32wrapi64(self, opcodeint, immediates): val1 = self.machinestate.Stack_Omni.pop() |