1# This file is part of PeachPy package and is licensed under the Simplified BSD license. 2# See license.rst for the full text of the license. 3 4import inspect 5 6import peachpy.stream 7import peachpy.arm.function 8from peachpy.arm.instructions import QuasiInstruction, Instruction, Operand 9from peachpy.arm.isa import Extension 10 11 12class ArithmeticInstruction(Instruction): 13 def __init__(self, name, destination, source_x, source_y, origin=None): 14 allowed_instructions = ['ADD', 'ADDEQ', 'ADDNE', 'ADDCS', 'ADDHS', 'ADDCC', 'ADDLO', 'ADDMI', 'ADDPL', 'ADDVS', 15 'ADDVC', 'ADDHI', 'ADDLS', 'ADDGE', 'ADDLT', 'ADDGT', 'ADDLE', 16 'ADDS', 'ADDSEQ', 'ADDSNE', 'ADDSCS', 'ADDSHS', 'ADDSCC', 'ADDSLO', 'ADDSMI', 'ADDSPL', 17 'ADDSVS', 'ADDSVC', 'ADDSHI', 'ADDSLS', 'ADDSGE', 'ADDSLT', 'ADDSGT', 'ADDSLE', 18 'ADC', 'ADCEQ', 'ADCNE', 'ADCCS', 'ADCHS', 'ADCCC', 'ADCLO', 'ADCMI', 'ADCPL', 'ADCVS', 19 'ADCVC', 'ADCHI', 'ADCLS', 'ADCGE', 'ADCLT', 'ADCGT', 'ADCLE', 20 'ADCS', 'ADCSEQ', 'ADCSNE', 'ADCSCS', 'ADCSHS', 'ADCSCC', 'ADCSLO', 'ADCSMI', 'ADCSPL', 21 'ADCSVS', 'ADCSVC', 'ADCSHI', 'ADCSLS', 'ADCSGE', 'ADCSLT', 'ADCSGT', 'ADCSLE', 22 'SUB', 'SUBEQ', 'SUBNE', 'SUBCS', 'SUBHS', 'SUBCC', 'SUBLO', 'SUBMI', 'SUBPL', 'SUBVS', 23 'SUBVC', 'SUBHI', 'SUBLS', 'SUBGE', 'SUBLT', 'SUBGT', 'SUBLE', 24 'SUBS', 'SUBSEQ', 'SUBSNE', 'SUBSCS', 'SUBSHS', 'SUBSCC', 'SUBSLO', 'SUBSMI', 'SUBSPL', 25 'SUBSVS', 'SUBSVC', 'SUBSHI', 'SUBSLS', 'SUBSGE', 'SUBSLT', 'SUBSGT', 'SUBSLE', 26 'SBC', 'SBCEQ', 'SBCNE', 'SBCCS', 'SBCHS', 'SBCCC', 'SBCLO', 'SBCMI', 'SBCPL', 'SBCVS', 27 'SBCVC', 'SBCHI', 'SBCLS', 'SBCGE', 'SBCLT', 'SBCGT', 'SBCLE', 28 'SBCS', 'SBCSEQ', 'SBCSNE', 'SBCSCS', 'SBCSHS', 'SBCSCC', 'SBCSLO', 'SBCSMI', 'SBCSPL', 29 'SBCSVS', 'SBCSVC', 'SBCSHI', 'SBCSLS', 'SBCSGE', 'SBCSLT', 'SBCSGT', 'SBCSLE', 30 'RSB', 'RSBEQ', 'RSBNE', 'RSBCS', 'RSBHS', 'RSBCC', 'RSBLO', 'RSBMI', 'RSBPL', 'RSBVS', 31 'RSBVC', 'RSBHI', 'RSBLS', 'RSBGE', 'RSBLT', 'RSBGT', 'RSBLE', 32 'RSBS', 'RSBSEQ', 'RSBSNE', 'RSBSCS', 'RSBSHS', 'RSBSCC', 'RSBSLO', 'RSBSMI', 'RSBSPL', 33 'RSBSVS', 'RSBSVC', 'RSBSHI', 'RSBSLS', 'RSBSGE', 'RSBSLT', 'RSBSGT', 'RSBSLE', 34 'RSC', 'RSCEQ', 'RSCNE', 'RSCCS', 'RSCHS', 'RSCCC', 'RSCLO', 'RSCMI', 'RSCPL', 'RSCVS', 35 'RSCVC', 'RSCHI', 'RSCLS', 'RSCGE', 'RSCLT', 'RSCGT', 'RSCLE', 36 'RSCS', 'RSCSEQ', 'RSCSNE', 'RSCSCS', 'RSCSHS', 'RSCSCC', 'RSCSLO', 'RSCSMI', 'RSCSPL', 37 'RSCSVS', 'RSCSVC', 'RSCSHI', 'RSCSLS', 'RSCSGE', 'RSCSLT', 'RSCSGT', 'RSCSLE', 38 'AND', 'ANDEQ', 'ANDNE', 'ANDCS', 'ANDHS', 'ANDCC', 'ANDLO', 'ANDMI', 'ANDPL', 'ANDVS', 39 'ANDVC', 'ANDHI', 'ANDLS', 'ANDGE', 'ANDLT', 'ANDGT', 'ANDLE', 40 'ANDS', 'ANDSEQ', 'ANDSNE', 'ANDSCS', 'ANDSHS', 'ANDSCC', 'ANDSLO', 'ANDSMI', 'ANDSPL', 41 'ANDSVS', 'ANDSVC', 'ANDSHI', 'ANDSLS', 'ANDSGE', 'ANDSLT', 'ANDSGT', 'ANDSLE', 42 'BIC', 'BICEQ', 'BICNE', 'BICCS', 'BICHS', 'BICCC', 'BICLO', 'BICMI', 'BICPL', 'BICVS', 43 'BICVC', 'BICHI', 'BICLS', 'BICGE', 'BICLT', 'BICGT', 'BICLE', 44 'BICS', 'BICSEQ', 'BICSNE', 'BICSCS', 'BICSHS', 'BICSCC', 'BICSLO', 'BICSMI', 'BICSPL', 45 'BICSVS', 'BICSVC', 'BICSHI', 'BICSLS', 'BICSGE', 'BICSLT', 'BICSGT', 'BICSLE', 46 'ORR', 'ORREQ', 'ORRNE', 'ORRCS', 'ORRHS', 'ORRCC', 'ORRLO', 'ORRMI', 'ORRPL', 'ORRVS', 47 'ORRVC', 'ORRHI', 'ORRLS', 'ORRGE', 'ORRLT', 'ORRGT', 'ORRLE', 48 'ORRS', 'ORRSEQ', 'ORRSNE', 'ORRSCS', 'ORRSHS', 'ORRSCC', 'ORRSLO', 'ORRSMI', 'ORRSPL', 49 'ORRSVS', 'ORRSVC', 'ORRSHI', 'ORRSLS', 'ORRSGE', 'ORRSLT', 'ORRSGT', 'ORRSLE', 50 'EOR', 'EOREQ', 'EORNE', 'EORCS', 'EORHS', 'EORCC', 'EORLO', 'EORMI', 'EORPL', 'EORVS', 51 'EORVC', 'EORHI', 'EORLS', 'EORGE', 'EORLT', 'EORGT', 'EORLE', 52 'EORS', 'EORSEQ', 'EORSNE', 'EORSCS', 'EORSHS', 'EORSCC', 'EORSLO', 'EORSMI', 'EORSPL', 53 'EORSVS', 'EORSVC', 'EORSHI', 'EORSLS', 'EORSGE', 'EORSLT', 'EORSGT', 'EORSLE'] 54 super(ArithmeticInstruction, self).__init__(name, [destination, source_x, source_y], origin=origin) 55 if name not in allowed_instructions: 56 raise ValueError('Instruction {0} is not one of the allowed instructions ({1})' 57 .format(name, ", ".join(allowed_instructions))) 58 if destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_modified_immediate12(): 59 pass 60 elif destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_shifted_general_purpose_register(): 61 pass 62 else: 63 raise ValueError('Invalid operands in instruction {0} {1}, {2}, {3}' 64 .format(name, destination, source_x, source_y)) 65 66 def is_conditional(self): 67 return self.name[-2:] in {"EQ", "NE", "CS", "CC", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", 68 "LE"} 69 70 def get_input_registers_list(self): 71 if self.is_conditional(): 72 return self.operands[0].get_registers_list() + self.operands[1].get_registers_list() + self.operands[ 73 2].get_registers_list() 74 else: 75 return self.operands[1].get_registers_list() + self.operands[2].get_registers_list() 76 77 def get_output_registers_list(self): 78 return self.operands[0].get_registers_list() 79 80 81class ShiftInstruction(Instruction): 82 def __init__(self, name, destination, source_x, source_y, origin=None): 83 allowed_instructions = ['LSL', 'LSR', 'ASR'] 84 super(ShiftInstruction, self).__init__(name, [destination, source_x, source_y], origin=origin) 85 if name not in allowed_instructions: 86 raise ValueError('Instruction {0} is not one of the allowed instructions ({1})' 87 .format(name, ", ".join(allowed_instructions))) 88 if destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_immediate5(): 89 pass 90 elif destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_general_purpose_register(): 91 pass 92 else: 93 raise ValueError('Invalid operands in instruction {0} {1}, {2}, {3}' 94 .format(name, destination, source_x, source_y)) 95 96 def get_input_registers_list(self): 97 return self.operands[1].get_registers_list() + self.operands[2].get_registers_list() 98 99 def get_output_registers_list(self): 100 return self.operands[0].get_registers_list() 101 102 103class CompareInstruction(Instruction): 104 def __init__(self, name, source_x, source_y, origin=None): 105 allowed_instructions = ['CMP', 'CMPEQ', 'CMPNE', 'CMPCS', 'CMPHS', 'CMPCC', 'CMPLO', 'CMPMI', 'CMPPL', 'CMPVS', 106 'CMPVC', 'CMPHI', 'CMPLS', 'CMPGE', 'CMPLT', 'CMPGT', 'CMPLE', 107 'TEQ', 'TEQEQ', 'TEQNE', 'TEQCS', 'TEQHS', 'TEQCC', 'TEQLO', 'TEQMI', 'TEQPL', 'TEQVS', 108 'TEQVC', 'TEQHI', 'TEQLS', 'TEQGE', 'TEQLT', 'TEQGT', 'TEQLE', 109 'TST', 'TSTEQ', 'TSTNE', 'TSTCS', 'TSTHS', 'TSTCC', 'TSTLO', 'TSTMI', 'TSTPL', 'TSTVS', 110 'TSTVC', 'TSTHI', 'TSTLS', 'TSTGE', 'TSTLT', 'TSTGT', 'TSTLE', 111 'TEQ', 'TEQEQ', 'TEQNE', 'TEQCS', 'TEQHS', 'TEQCC', 'TEQLO', 'TEQMI', 'TEQPL', 'TEQVS', 112 'TEQVC', 'TEQHI', 'TEQLS', 'TEQGE', 'TEQLT', 'TEQGT', 'TEQLE'] 113 if name in allowed_instructions: 114 super(CompareInstruction, self).__init__(name, [source_x, source_y], origin=origin) 115 else: 116 raise ValueError('Instruction {0} is not one of the allowed instructions ({1})' 117 .format(name, ", ".join(allowed_instructions))) 118 if source_x.is_general_purpose_register() and source_y.is_modified_immediate12(): 119 pass 120 elif source_x.is_general_purpose_register() and source_y.is_general_purpose_register(): 121 pass 122 else: 123 raise ValueError('Invalid operands in instruction {0} {1}, {2}'.format(name, source_x, source_y)) 124 125 def get_input_registers_list(self): 126 return self.operands[0].get_registers_list() + self.operands[1].get_registers_list() 127 128 def get_output_registers_list(self): 129 return list() 130 131 132class MovInstruction(Instruction): 133 def __init__(self, name, destination, source, origin=None): 134 allowed_instructions = ['MOV', 'MOVEQ', 'MOVNE', 'MOVCS', 'MOVHS', 'MOVCC', 'MOVLO', 'MOVMI', 'MOVPL', 'MOVVS', 135 'MOVVC', 'MOVHI', 'MOVLS', 'MOVGE', 'MOVLT', 'MOVGT', 'MOVLE', 136 'MOVS', 'MOVSEQ', 'MOVSNE', 'MOVSCS', 'MOVSHS', 'MOVSCC', 'MOVSLO', 'MOVSMI', 'MOVSPL', 137 'MOVSVS', 'MOVSVC', 'MOVSHI', 'MOVSLS', 'MOVSGE', 'MOVSLT', 'MOVSGT', 'MOVSLE'] 138 if name in allowed_instructions: 139 super(MovInstruction, self).__init__(name, [destination, source], origin=origin) 140 else: 141 raise ValueError('Instruction {0} is not one of the allowed instructions ({1})' 142 .format(name, ", ".join(allowed_instructions))) 143 if destination.is_general_purpose_register() and source.is_modified_immediate12(): 144 pass 145 elif destination.is_general_purpose_register() and source.is_general_purpose_register(): 146 pass 147 else: 148 raise ValueError('Invalid operands in instruction {0} {1}, {2}'.format(name, destination, source)) 149 150 def is_conditional(self): 151 return self.name[-2:] in {"EQ", "NE", "CS", "CC", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", 152 "LE"} 153 154 def get_input_registers_list(self): 155 if self.is_conditional(): 156 return self.operands[0].get_registers_list() + self.operands[1].get_registers_list() 157 else: 158 return self.operands[1].get_registers_list() 159 160 def get_output_registers_list(self): 161 return self.operands[0].get_registers_list() 162 163 164class LoadStoreInstruction(Instruction): 165 load_instructions = ['LDR', 'LDRH', 'LDRSH', 'LDRB', 'LDRSB'] 166 store_instructions = ['STR', 'STRB', 'STRH'] 167 168 def __init__(self, name, register, address, increment, origin=None): 169 allowed_instructions = LoadStoreInstruction.load_instructions + LoadStoreInstruction.store_instructions 170 if name not in allowed_instructions: 171 raise ValueError('Instruction {0} is not one of the allowed instructions ({1})'.format(name, ", ".join( 172 allowed_instructions))) 173 if register.is_general_purpose_register() and address.is_memory_address(offset_bits=8) and increment.is_none(): 174 super(LoadStoreInstruction, self).__init__(name, [register, address], origin=origin) 175 elif name in {'STR', 'LDR', 'LDRB', 176 'STRB'} and register.is_general_purpose_register() and address.is_memory_address( 177 offset_bits=12) and increment.is_none(): 178 super(LoadStoreInstruction, self).__init__(name, [register, address], origin=origin) 179 elif register.is_general_purpose_register() and address.is_memory_address(offset_bits=0, 180 allow_writeback=False) and increment.is_offset8(): 181 super(LoadStoreInstruction, self).__init__(name, [register, address, increment], origin=origin) 182 elif register.is_general_purpose_register() and address.is_memory_address(offset_bits=0, 183 allow_writeback=False) and increment.is_offset12(): 184 super(LoadStoreInstruction, self).__init__(name, [register, address, increment], origin=origin) 185 else: 186 if increment.is_none(): 187 raise ValueError('Invalid operands in instruction {0} {1}, {2}'.format(name, register, address)) 188 else: 189 raise ValueError('Invalid operands in instruction {0} {1}, {2}, {3}' 190 .format(name, register, address, increment)) 191 192 def get_input_registers_list(self): 193 input_registers_list = self.operands[ 194 0].get_registers_list() if self.name in LoadStoreInstruction.store_instructions else list() 195 for operand in self.operands[1:]: 196 input_registers_list += operand.get_registers_list() 197 return input_registers_list 198 199 def get_output_registers_list(self): 200 output_registers_list = self.operands[ 201 0].get_registers_list() if self.name in LoadStoreInstruction.load_instructions else list() 202 if len(self.operands) > 2 or self.operands[1].is_preindexed_memory_address(): 203 output_registers_list.append(self.operands[1].base) 204 return output_registers_list 205 206 207class PushPopInstruction(Instruction): 208 def __init__(self, name, register_list, origin=None): 209 allowed_instructions = {'PUSH', 'POP'} 210 if name in allowed_instructions: 211 super(PushPopInstruction, self).__init__(name, [register_list], origin=origin) 212 else: 213 raise ValueError('Instruction {0} is not one of the allowed instructions'.format(name)) 214 if register_list.is_general_purpose_register_list(): 215 pass 216 else: 217 raise ValueError('Invalid operands in instruction {0} {1}'.format(name, register_list)) 218 219 def get_input_registers_list(self): 220 if self.name == 'PUSH': 221 return self.operands[0].get_registers_list() 222 else: 223 return list() 224 225 def get_output_registers_list(self): 226 if self.name == 'POP': 227 return self.operands[0].get_registers_list() 228 else: 229 return list() 230 231 232class BranchInstruction(Instruction): 233 def __init__(self, name, destination, origin=None): 234 allowed_instructions = {'B', 'BEQ', 'BNE', 'BCS', 'BHS', 'BCC', 'BLO', 'BMI', 'BPL', 'BVS', 'BVC', 'BHI', 'BLS', 235 'BGE', 'BLT', 'BGT', 'BLE'} 236 if name in allowed_instructions: 237 super(BranchInstruction, self).__init__(name, [destination], origin=origin) 238 self.is_visited = False 239 else: 240 raise ValueError('Instruction {0} is not one of the allowed instructions'.format(name)) 241 if destination.is_label(): 242 pass 243 else: 244 raise ValueError('Invalid operands in instruction {0} {1}'.format('BX', destination)) 245 246 def get_input_registers_list(self): 247 return self.operands[0].get_registers_list() 248 249 def get_output_registers_list(self): 250 return list() 251 252 def is_conditional(self): 253 return not self.name == 'B' 254 255 def __str__(self): 256 return self.name + " L" + str(self.operands[0]) 257 258 259class BranchExchangeInstruction(Instruction): 260 def __init__(self, destination, origin=None): 261 from peachpy.arm.registers import lr 262 super(BranchExchangeInstruction, self).__init__('BX', [destination], origin=origin) 263 if destination.is_general_purpose_register() and destination.register == lr: 264 pass 265 else: 266 raise ValueError('Invalid operands in instruction {0} {1}'.format('BX', destination)) 267 268 def get_input_registers_list(self): 269 return self.operands[0].get_registers_list() 270 271 def get_output_registers_list(self): 272 return list() 273 274 275class BreakInstruction(Instruction): 276 def __init__(self, origin=None): 277 super(BreakInstruction, self).__init__('BKPT', (), origin=origin) 278 279 def __str__(self): 280 return "BKPT" 281 282 def get_input_registers_list(self): 283 return [] 284 285 def get_output_registers_list(self): 286 return [] 287 288 def get_constant(self): 289 return None 290 291 def get_local_variable(self): 292 return None 293 294 295def BX(destination): 296 instruction = BranchExchangeInstruction(Operand(destination)) 297 if peachpy.stream.active_stream is not None: 298 peachpy.stream.active_stream.add_instruction(instruction) 299 return instruction 300 301 302def BKPT(): 303 instruction = BreakInstruction() 304 if peachpy.stream.active_stream is not None: 305 peachpy.stream.active_stream.add_instruction(instruction) 306 return instruction 307 308 309def ADD(destination, source_x, source_y=None): 310 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 311 if source_y is None: 312 (destination, source_x, source_y) = (destination, destination, source_x) 313 instruction = ArithmeticInstruction('ADD', Operand(destination), Operand(source_x), Operand(source_y), 314 origin=origin) 315 if peachpy.stream.active_stream is not None: 316 peachpy.stream.active_stream.add_instruction(instruction) 317 return instruction 318 319 320def ADDEQ(destination, source_x, source_y=None): 321 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 322 if source_y is None: 323 (destination, source_x, source_y) = (destination, destination, source_x) 324 instruction = ArithmeticInstruction('ADDEQ', Operand(destination), Operand(source_x), Operand(source_y), 325 origin=origin) 326 if peachpy.stream.active_stream is not None: 327 peachpy.stream.active_stream.add_instruction(instruction) 328 return instruction 329 330 331def ADDNE(destination, source_x, source_y=None): 332 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 333 if source_y is None: 334 (destination, source_x, source_y) = (destination, destination, source_x) 335 instruction = ArithmeticInstruction('ADDNE', Operand(destination), Operand(source_x), Operand(source_y), 336 origin=origin) 337 if peachpy.stream.active_stream is not None: 338 peachpy.stream.active_stream.add_instruction(instruction) 339 return instruction 340 341 342def ADDCS(destination, source_x, source_y=None): 343 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 344 if source_y is None: 345 (destination, source_x, source_y) = (destination, destination, source_x) 346 instruction = ArithmeticInstruction('ADDCS', Operand(destination), Operand(source_x), Operand(source_y), 347 origin=origin) 348 if peachpy.stream.active_stream is not None: 349 peachpy.stream.active_stream.add_instruction(instruction) 350 return instruction 351 352 353def ADDHS(destination, source_x, source_y=None): 354 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 355 if source_y is None: 356 (destination, source_x, source_y) = (destination, destination, source_x) 357 instruction = ArithmeticInstruction('ADDHS', Operand(destination), Operand(source_x), Operand(source_y), 358 origin=origin) 359 if peachpy.stream.active_stream is not None: 360 peachpy.stream.active_stream.add_instruction(instruction) 361 return instruction 362 363 364def ADDCC(destination, source_x, source_y=None): 365 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 366 if source_y is None: 367 (destination, source_x, source_y) = (destination, destination, source_x) 368 instruction = ArithmeticInstruction('ADDCC', Operand(destination), Operand(source_x), Operand(source_y), 369 origin=origin) 370 if peachpy.stream.active_stream is not None: 371 peachpy.stream.active_stream.add_instruction(instruction) 372 return instruction 373 374 375def ADDLO(destination, source_x, source_y=None): 376 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 377 if source_y is None: 378 (destination, source_x, source_y) = (destination, destination, source_x) 379 instruction = ArithmeticInstruction('ADDLO', Operand(destination), Operand(source_x), Operand(source_y), 380 origin=origin) 381 if peachpy.stream.active_stream is not None: 382 peachpy.stream.active_stream.add_instruction(instruction) 383 return instruction 384 385 386def ADDMI(destination, source_x, source_y=None): 387 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 388 if source_y is None: 389 (destination, source_x, source_y) = (destination, destination, source_x) 390 instruction = ArithmeticInstruction('ADDMI', Operand(destination), Operand(source_x), Operand(source_y), 391 origin=origin) 392 if peachpy.stream.active_stream is not None: 393 peachpy.stream.active_stream.add_instruction(instruction) 394 return instruction 395 396 397def ADDPL(destination, source_x, source_y=None): 398 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 399 if source_y is None: 400 (destination, source_x, source_y) = (destination, destination, source_x) 401 instruction = ArithmeticInstruction('ADDPL', Operand(destination), Operand(source_x), Operand(source_y), 402 origin=origin) 403 if peachpy.stream.active_stream is not None: 404 peachpy.stream.active_stream.add_instruction(instruction) 405 return instruction 406 407 408def ADDVS(destination, source_x, source_y=None): 409 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 410 if source_y is None: 411 (destination, source_x, source_y) = (destination, destination, source_x) 412 instruction = ArithmeticInstruction('ADDVS', Operand(destination), Operand(source_x), Operand(source_y), 413 origin=origin) 414 if peachpy.stream.active_stream is not None: 415 peachpy.stream.active_stream.add_instruction(instruction) 416 return instruction 417 418 419def ADDVC(destination, source_x, source_y=None): 420 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 421 if source_y is None: 422 (destination, source_x, source_y) = (destination, destination, source_x) 423 instruction = ArithmeticInstruction('ADDVC', Operand(destination), Operand(source_x), Operand(source_y), 424 origin=origin) 425 if peachpy.stream.active_stream is not None: 426 peachpy.stream.active_stream.add_instruction(instruction) 427 return instruction 428 429 430def ADDHI(destination, source_x, source_y=None): 431 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 432 if source_y is None: 433 (destination, source_x, source_y) = (destination, destination, source_x) 434 instruction = ArithmeticInstruction('ADDHI', Operand(destination), Operand(source_x), Operand(source_y), 435 origin=origin) 436 if peachpy.stream.active_stream is not None: 437 peachpy.stream.active_stream.add_instruction(instruction) 438 return instruction 439 440 441def ADDLS(destination, source_x, source_y=None): 442 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 443 if source_y is None: 444 (destination, source_x, source_y) = (destination, destination, source_x) 445 instruction = ArithmeticInstruction('ADDLS', Operand(destination), Operand(source_x), Operand(source_y), 446 origin=origin) 447 if peachpy.stream.active_stream is not None: 448 peachpy.stream.active_stream.add_instruction(instruction) 449 return instruction 450 451 452def ADDGE(destination, source_x, source_y=None): 453 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 454 if source_y is None: 455 (destination, source_x, source_y) = (destination, destination, source_x) 456 instruction = ArithmeticInstruction('ADDGE', Operand(destination), Operand(source_x), Operand(source_y), 457 origin=origin) 458 if peachpy.stream.active_stream is not None: 459 peachpy.stream.active_stream.add_instruction(instruction) 460 return instruction 461 462 463def ADDLT(destination, source_x, source_y=None): 464 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 465 if source_y is None: 466 (destination, source_x, source_y) = (destination, destination, source_x) 467 instruction = ArithmeticInstruction('ADDLT', Operand(destination), Operand(source_x), Operand(source_y), 468 origin=origin) 469 if peachpy.stream.active_stream is not None: 470 peachpy.stream.active_stream.add_instruction(instruction) 471 return instruction 472 473 474def ADDGT(destination, source_x, source_y=None): 475 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 476 if source_y is None: 477 (destination, source_x, source_y) = (destination, destination, source_x) 478 instruction = ArithmeticInstruction('ADDGT', Operand(destination), Operand(source_x), Operand(source_y), 479 origin=origin) 480 if peachpy.stream.active_stream is not None: 481 peachpy.stream.active_stream.add_instruction(instruction) 482 return instruction 483 484 485def ADDLE(destination, source_x, source_y=None): 486 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 487 if source_y is None: 488 (destination, source_x, source_y) = (destination, destination, source_x) 489 instruction = ArithmeticInstruction('ADDLE', Operand(destination), Operand(source_x), Operand(source_y), 490 origin=origin) 491 if peachpy.stream.active_stream is not None: 492 peachpy.stream.active_stream.add_instruction(instruction) 493 return instruction 494 495 496def ADDS(destination, source_x, source_y=None): 497 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 498 if source_y is None: 499 (destination, source_x, source_y) = (destination, destination, source_x) 500 instruction = ArithmeticInstruction('ADDS', Operand(destination), Operand(source_x), Operand(source_y), 501 origin=origin) 502 if peachpy.stream.active_stream is not None: 503 peachpy.stream.active_stream.add_instruction(instruction) 504 return instruction 505 506 507def ADDSEQ(destination, source_x, source_y=None): 508 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 509 if source_y is None: 510 (destination, source_x, source_y) = (destination, destination, source_x) 511 instruction = ArithmeticInstruction('ADDSEQ', Operand(destination), Operand(source_x), Operand(source_y), 512 origin=origin) 513 if peachpy.stream.active_stream is not None: 514 peachpy.stream.active_stream.add_instruction(instruction) 515 return instruction 516 517 518def ADDSNE(destination, source_x, source_y=None): 519 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 520 if source_y is None: 521 (destination, source_x, source_y) = (destination, destination, source_x) 522 instruction = ArithmeticInstruction('ADDSNE', Operand(destination), Operand(source_x), Operand(source_y), 523 origin=origin) 524 if peachpy.stream.active_stream is not None: 525 peachpy.stream.active_stream.add_instruction(instruction) 526 return instruction 527 528 529def ADDSCS(destination, source_x, source_y=None): 530 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 531 if source_y is None: 532 (destination, source_x, source_y) = (destination, destination, source_x) 533 instruction = ArithmeticInstruction('ADDSCS', Operand(destination), Operand(source_x), Operand(source_y), 534 origin=origin) 535 if peachpy.stream.active_stream is not None: 536 peachpy.stream.active_stream.add_instruction(instruction) 537 return instruction 538 539 540def ADDSHS(destination, source_x, source_y=None): 541 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 542 if source_y is None: 543 (destination, source_x, source_y) = (destination, destination, source_x) 544 instruction = ArithmeticInstruction('ADDSHS', Operand(destination), Operand(source_x), Operand(source_y), 545 origin=origin) 546 if peachpy.stream.active_stream is not None: 547 peachpy.stream.active_stream.add_instruction(instruction) 548 return instruction 549 550 551def ADDSCC(destination, source_x, source_y=None): 552 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 553 if source_y is None: 554 (destination, source_x, source_y) = (destination, destination, source_x) 555 instruction = ArithmeticInstruction('ADDSCC', Operand(destination), Operand(source_x), Operand(source_y), 556 origin=origin) 557 if peachpy.stream.active_stream is not None: 558 peachpy.stream.active_stream.add_instruction(instruction) 559 return instruction 560 561 562def ADDSLO(destination, source_x, source_y=None): 563 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 564 if source_y is None: 565 (destination, source_x, source_y) = (destination, destination, source_x) 566 instruction = ArithmeticInstruction('ADDSLO', Operand(destination), Operand(source_x), Operand(source_y), 567 origin=origin) 568 if peachpy.stream.active_stream is not None: 569 peachpy.stream.active_stream.add_instruction(instruction) 570 return instruction 571 572 573def ADDSMI(destination, source_x, source_y=None): 574 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 575 if source_y is None: 576 (destination, source_x, source_y) = (destination, destination, source_x) 577 instruction = ArithmeticInstruction('ADDSMI', Operand(destination), Operand(source_x), Operand(source_y), 578 origin=origin) 579 if peachpy.stream.active_stream is not None: 580 peachpy.stream.active_stream.add_instruction(instruction) 581 return instruction 582 583 584def ADDSPL(destination, source_x, source_y=None): 585 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 586 if source_y is None: 587 (destination, source_x, source_y) = (destination, destination, source_x) 588 instruction = ArithmeticInstruction('ADDSPL', Operand(destination), Operand(source_x), Operand(source_y), 589 origin=origin) 590 if peachpy.stream.active_stream is not None: 591 peachpy.stream.active_stream.add_instruction(instruction) 592 return instruction 593 594 595def ADDSVS(destination, source_x, source_y=None): 596 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 597 if source_y is None: 598 (destination, source_x, source_y) = (destination, destination, source_x) 599 instruction = ArithmeticInstruction('ADDSVS', Operand(destination), Operand(source_x), Operand(source_y), 600 origin=origin) 601 if peachpy.stream.active_stream is not None: 602 peachpy.stream.active_stream.add_instruction(instruction) 603 return instruction 604 605 606def ADDSVC(destination, source_x, source_y=None): 607 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 608 if source_y is None: 609 (destination, source_x, source_y) = (destination, destination, source_x) 610 instruction = ArithmeticInstruction('ADDSVC', Operand(destination), Operand(source_x), Operand(source_y), 611 origin=origin) 612 if peachpy.stream.active_stream is not None: 613 peachpy.stream.active_stream.add_instruction(instruction) 614 return instruction 615 616 617def ADDSHI(destination, source_x, source_y=None): 618 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 619 if source_y is None: 620 (destination, source_x, source_y) = (destination, destination, source_x) 621 instruction = ArithmeticInstruction('ADDSHI', Operand(destination), Operand(source_x), Operand(source_y), 622 origin=origin) 623 if peachpy.stream.active_stream is not None: 624 peachpy.stream.active_stream.add_instruction(instruction) 625 return instruction 626 627 628def ADDSLS(destination, source_x, source_y=None): 629 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 630 if source_y is None: 631 (destination, source_x, source_y) = (destination, destination, source_x) 632 instruction = ArithmeticInstruction('ADDSLS', Operand(destination), Operand(source_x), Operand(source_y), 633 origin=origin) 634 if peachpy.stream.active_stream is not None: 635 peachpy.stream.active_stream.add_instruction(instruction) 636 return instruction 637 638 639def ADDSGE(destination, source_x, source_y=None): 640 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 641 if source_y is None: 642 (destination, source_x, source_y) = (destination, destination, source_x) 643 instruction = ArithmeticInstruction('ADDSGE', Operand(destination), Operand(source_x), Operand(source_y), 644 origin=origin) 645 if peachpy.stream.active_stream is not None: 646 peachpy.stream.active_stream.add_instruction(instruction) 647 return instruction 648 649 650def ADDSLT(destination, source_x, source_y=None): 651 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 652 if source_y is None: 653 (destination, source_x, source_y) = (destination, destination, source_x) 654 instruction = ArithmeticInstruction('ADDSLT', Operand(destination), Operand(source_x), Operand(source_y), 655 origin=origin) 656 if peachpy.stream.active_stream is not None: 657 peachpy.stream.active_stream.add_instruction(instruction) 658 return instruction 659 660 661def ADDSGT(destination, source_x, source_y=None): 662 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 663 if source_y is None: 664 (destination, source_x, source_y) = (destination, destination, source_x) 665 instruction = ArithmeticInstruction('ADDSGT', Operand(destination), Operand(source_x), Operand(source_y), 666 origin=origin) 667 if peachpy.stream.active_stream is not None: 668 peachpy.stream.active_stream.add_instruction(instruction) 669 return instruction 670 671 672def ADDSLE(destination, source_x, source_y=None): 673 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 674 if source_y is None: 675 (destination, source_x, source_y) = (destination, destination, source_x) 676 instruction = ArithmeticInstruction('ADDSLE', Operand(destination), Operand(source_x), Operand(source_y), 677 origin=origin) 678 if peachpy.stream.active_stream is not None: 679 peachpy.stream.active_stream.add_instruction(instruction) 680 return instruction 681 682 683def ADC(destination, source_x, source_y=None): 684 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 685 if source_y is None: 686 (destination, source_x, source_y) = (destination, destination, source_x) 687 instruction = ArithmeticInstruction('ADC', Operand(destination), Operand(source_x), Operand(source_y), 688 origin=origin) 689 if peachpy.stream.active_stream is not None: 690 peachpy.stream.active_stream.add_instruction(instruction) 691 return instruction 692 693 694def ADCEQ(destination, source_x, source_y=None): 695 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 696 if source_y is None: 697 (destination, source_x, source_y) = (destination, destination, source_x) 698 instruction = ArithmeticInstruction('ADCEQ', Operand(destination), Operand(source_x), Operand(source_y), 699 origin=origin) 700 if peachpy.stream.active_stream is not None: 701 peachpy.stream.active_stream.add_instruction(instruction) 702 return instruction 703 704 705def ADCNE(destination, source_x, source_y=None): 706 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 707 if source_y is None: 708 (destination, source_x, source_y) = (destination, destination, source_x) 709 instruction = ArithmeticInstruction('ADCNE', Operand(destination), Operand(source_x), Operand(source_y), 710 origin=origin) 711 if peachpy.stream.active_stream is not None: 712 peachpy.stream.active_stream.add_instruction(instruction) 713 return instruction 714 715 716def ADCCS(destination, source_x, source_y=None): 717 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 718 if source_y is None: 719 (destination, source_x, source_y) = (destination, destination, source_x) 720 instruction = ArithmeticInstruction('ADCCS', Operand(destination), Operand(source_x), Operand(source_y), 721 origin=origin) 722 if peachpy.stream.active_stream is not None: 723 peachpy.stream.active_stream.add_instruction(instruction) 724 return instruction 725 726 727def ADCHS(destination, source_x, source_y=None): 728 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 729 if source_y is None: 730 (destination, source_x, source_y) = (destination, destination, source_x) 731 instruction = ArithmeticInstruction('ADCHS', Operand(destination), Operand(source_x), Operand(source_y), 732 origin=origin) 733 if peachpy.stream.active_stream is not None: 734 peachpy.stream.active_stream.add_instruction(instruction) 735 return instruction 736 737 738def ADCCC(destination, source_x, source_y=None): 739 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 740 if source_y is None: 741 (destination, source_x, source_y) = (destination, destination, source_x) 742 instruction = ArithmeticInstruction('ADCCC', Operand(destination), Operand(source_x), Operand(source_y), 743 origin=origin) 744 if peachpy.stream.active_stream is not None: 745 peachpy.stream.active_stream.add_instruction(instruction) 746 return instruction 747 748 749def ADCLO(destination, source_x, source_y=None): 750 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 751 if source_y is None: 752 (destination, source_x, source_y) = (destination, destination, source_x) 753 instruction = ArithmeticInstruction('ADCLO', Operand(destination), Operand(source_x), Operand(source_y), 754 origin=origin) 755 if peachpy.stream.active_stream is not None: 756 peachpy.stream.active_stream.add_instruction(instruction) 757 return instruction 758 759 760def ADCMI(destination, source_x, source_y=None): 761 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 762 if source_y is None: 763 (destination, source_x, source_y) = (destination, destination, source_x) 764 instruction = ArithmeticInstruction('ADCMI', Operand(destination), Operand(source_x), Operand(source_y), 765 origin=origin) 766 if peachpy.stream.active_stream is not None: 767 peachpy.stream.active_stream.add_instruction(instruction) 768 return instruction 769 770 771def ADCPL(destination, source_x, source_y=None): 772 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 773 if source_y is None: 774 (destination, source_x, source_y) = (destination, destination, source_x) 775 instruction = ArithmeticInstruction('ADCPL', Operand(destination), Operand(source_x), Operand(source_y), 776 origin=origin) 777 if peachpy.stream.active_stream is not None: 778 peachpy.stream.active_stream.add_instruction(instruction) 779 return instruction 780 781 782def ADCVS(destination, source_x, source_y=None): 783 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 784 if source_y is None: 785 (destination, source_x, source_y) = (destination, destination, source_x) 786 instruction = ArithmeticInstruction('ADCVS', Operand(destination), Operand(source_x), Operand(source_y), 787 origin=origin) 788 if peachpy.stream.active_stream is not None: 789 peachpy.stream.active_stream.add_instruction(instruction) 790 return instruction 791 792 793def ADCVC(destination, source_x, source_y=None): 794 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 795 if source_y is None: 796 (destination, source_x, source_y) = (destination, destination, source_x) 797 instruction = ArithmeticInstruction('ADCVC', Operand(destination), Operand(source_x), Operand(source_y), 798 origin=origin) 799 if peachpy.stream.active_stream is not None: 800 peachpy.stream.active_stream.add_instruction(instruction) 801 return instruction 802 803 804def ADCHI(destination, source_x, source_y=None): 805 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 806 if source_y is None: 807 (destination, source_x, source_y) = (destination, destination, source_x) 808 instruction = ArithmeticInstruction('ADCHI', Operand(destination), Operand(source_x), Operand(source_y), 809 origin=origin) 810 if peachpy.stream.active_stream is not None: 811 peachpy.stream.active_stream.add_instruction(instruction) 812 return instruction 813 814 815def ADCLS(destination, source_x, source_y=None): 816 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 817 if source_y is None: 818 (destination, source_x, source_y) = (destination, destination, source_x) 819 instruction = ArithmeticInstruction('ADCLS', Operand(destination), Operand(source_x), Operand(source_y), 820 origin=origin) 821 if peachpy.stream.active_stream is not None: 822 peachpy.stream.active_stream.add_instruction(instruction) 823 return instruction 824 825 826def ADCGE(destination, source_x, source_y=None): 827 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 828 if source_y is None: 829 (destination, source_x, source_y) = (destination, destination, source_x) 830 instruction = ArithmeticInstruction('ADCGE', Operand(destination), Operand(source_x), Operand(source_y), 831 origin=origin) 832 if peachpy.stream.active_stream is not None: 833 peachpy.stream.active_stream.add_instruction(instruction) 834 return instruction 835 836 837def ADCLT(destination, source_x, source_y=None): 838 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 839 if source_y is None: 840 (destination, source_x, source_y) = (destination, destination, source_x) 841 instruction = ArithmeticInstruction('ADCLT', Operand(destination), Operand(source_x), Operand(source_y), 842 origin=origin) 843 if peachpy.stream.active_stream is not None: 844 peachpy.stream.active_stream.add_instruction(instruction) 845 return instruction 846 847 848def ADCGT(destination, source_x, source_y=None): 849 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 850 if source_y is None: 851 (destination, source_x, source_y) = (destination, destination, source_x) 852 instruction = ArithmeticInstruction('ADCGT', Operand(destination), Operand(source_x), Operand(source_y), 853 origin=origin) 854 if peachpy.stream.active_stream is not None: 855 peachpy.stream.active_stream.add_instruction(instruction) 856 return instruction 857 858 859def ADCLE(destination, source_x, source_y=None): 860 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 861 if source_y is None: 862 (destination, source_x, source_y) = (destination, destination, source_x) 863 instruction = ArithmeticInstruction('ADCLE', Operand(destination), Operand(source_x), Operand(source_y), 864 origin=origin) 865 if peachpy.stream.active_stream is not None: 866 peachpy.stream.active_stream.add_instruction(instruction) 867 return instruction 868 869 870def ADCS(destination, source_x, source_y=None): 871 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 872 if source_y is None: 873 (destination, source_x, source_y) = (destination, destination, source_x) 874 instruction = ArithmeticInstruction('ADCS', Operand(destination), Operand(source_x), Operand(source_y), 875 origin=origin) 876 if peachpy.stream.active_stream is not None: 877 peachpy.stream.active_stream.add_instruction(instruction) 878 return instruction 879 880 881def ADCSEQ(destination, source_x, source_y=None): 882 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 883 if source_y is None: 884 (destination, source_x, source_y) = (destination, destination, source_x) 885 instruction = ArithmeticInstruction('ADCSEQ', Operand(destination), Operand(source_x), Operand(source_y), 886 origin=origin) 887 if peachpy.stream.active_stream is not None: 888 peachpy.stream.active_stream.add_instruction(instruction) 889 return instruction 890 891 892def ADCSNE(destination, source_x, source_y=None): 893 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 894 if source_y is None: 895 (destination, source_x, source_y) = (destination, destination, source_x) 896 instruction = ArithmeticInstruction('ADCSNE', Operand(destination), Operand(source_x), Operand(source_y), 897 origin=origin) 898 if peachpy.stream.active_stream is not None: 899 peachpy.stream.active_stream.add_instruction(instruction) 900 return instruction 901 902 903def ADCSCS(destination, source_x, source_y=None): 904 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 905 if source_y is None: 906 (destination, source_x, source_y) = (destination, destination, source_x) 907 instruction = ArithmeticInstruction('ADCSCS', Operand(destination), Operand(source_x), Operand(source_y), 908 origin=origin) 909 if peachpy.stream.active_stream is not None: 910 peachpy.stream.active_stream.add_instruction(instruction) 911 return instruction 912 913 914def ADCSHS(destination, source_x, source_y=None): 915 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 916 if source_y is None: 917 (destination, source_x, source_y) = (destination, destination, source_x) 918 instruction = ArithmeticInstruction('ADCSHS', Operand(destination), Operand(source_x), Operand(source_y), 919 origin=origin) 920 if peachpy.stream.active_stream is not None: 921 peachpy.stream.active_stream.add_instruction(instruction) 922 return instruction 923 924 925def ADCSCC(destination, source_x, source_y=None): 926 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 927 if source_y is None: 928 (destination, source_x, source_y) = (destination, destination, source_x) 929 instruction = ArithmeticInstruction('ADCSCC', Operand(destination), Operand(source_x), Operand(source_y), 930 origin=origin) 931 if peachpy.stream.active_stream is not None: 932 peachpy.stream.active_stream.add_instruction(instruction) 933 return instruction 934 935 936def ADCSLO(destination, source_x, source_y=None): 937 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 938 if source_y is None: 939 (destination, source_x, source_y) = (destination, destination, source_x) 940 instruction = ArithmeticInstruction('ADCSLO', Operand(destination), Operand(source_x), Operand(source_y), 941 origin=origin) 942 if peachpy.stream.active_stream is not None: 943 peachpy.stream.active_stream.add_instruction(instruction) 944 return instruction 945 946 947def ADCSMI(destination, source_x, source_y=None): 948 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 949 if source_y is None: 950 (destination, source_x, source_y) = (destination, destination, source_x) 951 instruction = ArithmeticInstruction('ADCSMI', Operand(destination), Operand(source_x), Operand(source_y), 952 origin=origin) 953 if peachpy.stream.active_stream is not None: 954 peachpy.stream.active_stream.add_instruction(instruction) 955 return instruction 956 957 958def ADCSPL(destination, source_x, source_y=None): 959 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 960 if source_y is None: 961 (destination, source_x, source_y) = (destination, destination, source_x) 962 instruction = ArithmeticInstruction('ADCSPL', Operand(destination), Operand(source_x), Operand(source_y), 963 origin=origin) 964 if peachpy.stream.active_stream is not None: 965 peachpy.stream.active_stream.add_instruction(instruction) 966 return instruction 967 968 969def ADCSVS(destination, source_x, source_y=None): 970 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 971 if source_y is None: 972 (destination, source_x, source_y) = (destination, destination, source_x) 973 instruction = ArithmeticInstruction('ADCSVS', Operand(destination), Operand(source_x), Operand(source_y), 974 origin=origin) 975 if peachpy.stream.active_stream is not None: 976 peachpy.stream.active_stream.add_instruction(instruction) 977 return instruction 978 979 980def ADCSVC(destination, source_x, source_y=None): 981 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 982 if source_y is None: 983 (destination, source_x, source_y) = (destination, destination, source_x) 984 instruction = ArithmeticInstruction('ADCSVC', Operand(destination), Operand(source_x), Operand(source_y), 985 origin=origin) 986 if peachpy.stream.active_stream is not None: 987 peachpy.stream.active_stream.add_instruction(instruction) 988 return instruction 989 990 991def ADCSHI(destination, source_x, source_y=None): 992 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 993 if source_y is None: 994 (destination, source_x, source_y) = (destination, destination, source_x) 995 instruction = ArithmeticInstruction('ADCSHI', Operand(destination), Operand(source_x), Operand(source_y), 996 origin=origin) 997 if peachpy.stream.active_stream is not None: 998 peachpy.stream.active_stream.add_instruction(instruction) 999 return instruction 1000 1001 1002def ADCSLS(destination, source_x, source_y=None): 1003 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1004 if source_y is None: 1005 (destination, source_x, source_y) = (destination, destination, source_x) 1006 instruction = ArithmeticInstruction('ADCSLS', Operand(destination), Operand(source_x), Operand(source_y), 1007 origin=origin) 1008 if peachpy.stream.active_stream is not None: 1009 peachpy.stream.active_stream.add_instruction(instruction) 1010 return instruction 1011 1012 1013def ADCSGE(destination, source_x, source_y=None): 1014 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1015 if source_y is None: 1016 (destination, source_x, source_y) = (destination, destination, source_x) 1017 instruction = ArithmeticInstruction('ADCSGE', Operand(destination), Operand(source_x), Operand(source_y), 1018 origin=origin) 1019 if peachpy.stream.active_stream is not None: 1020 peachpy.stream.active_stream.add_instruction(instruction) 1021 return instruction 1022 1023 1024def ADCSLT(destination, source_x, source_y=None): 1025 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1026 if source_y is None: 1027 (destination, source_x, source_y) = (destination, destination, source_x) 1028 instruction = ArithmeticInstruction('ADCSLT', Operand(destination), Operand(source_x), Operand(source_y), 1029 origin=origin) 1030 if peachpy.stream.active_stream is not None: 1031 peachpy.stream.active_stream.add_instruction(instruction) 1032 return instruction 1033 1034 1035def ADCSGT(destination, source_x, source_y=None): 1036 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1037 if source_y is None: 1038 (destination, source_x, source_y) = (destination, destination, source_x) 1039 instruction = ArithmeticInstruction('ADCSGT', Operand(destination), Operand(source_x), Operand(source_y), 1040 origin=origin) 1041 if peachpy.stream.active_stream is not None: 1042 peachpy.stream.active_stream.add_instruction(instruction) 1043 return instruction 1044 1045 1046def ADCSLE(destination, source_x, source_y=None): 1047 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1048 if source_y is None: 1049 (destination, source_x, source_y) = (destination, destination, source_x) 1050 instruction = ArithmeticInstruction('ADCSLE', Operand(destination), Operand(source_x), Operand(source_y), 1051 origin=origin) 1052 if peachpy.stream.active_stream is not None: 1053 peachpy.stream.active_stream.add_instruction(instruction) 1054 return instruction 1055 1056 1057def SUB(destination, source_x, source_y=None): 1058 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1059 if source_y is None: 1060 (destination, source_x, source_y) = (destination, destination, source_x) 1061 instruction = ArithmeticInstruction('SUB', Operand(destination), Operand(source_x), Operand(source_y), 1062 origin=origin) 1063 if peachpy.stream.active_stream is not None: 1064 peachpy.stream.active_stream.add_instruction(instruction) 1065 return instruction 1066 1067 1068def SUBEQ(destination, source_x, source_y=None): 1069 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1070 if source_y is None: 1071 (destination, source_x, source_y) = (destination, destination, source_x) 1072 instruction = ArithmeticInstruction('SUBEQ', Operand(destination), Operand(source_x), Operand(source_y), 1073 origin=origin) 1074 if peachpy.stream.active_stream is not None: 1075 peachpy.stream.active_stream.add_instruction(instruction) 1076 return instruction 1077 1078 1079def SUBNE(destination, source_x, source_y=None): 1080 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1081 if source_y is None: 1082 (destination, source_x, source_y) = (destination, destination, source_x) 1083 instruction = ArithmeticInstruction('SUBNE', Operand(destination), Operand(source_x), Operand(source_y), 1084 origin=origin) 1085 if peachpy.stream.active_stream is not None: 1086 peachpy.stream.active_stream.add_instruction(instruction) 1087 return instruction 1088 1089 1090def SUBCS(destination, source_x, source_y=None): 1091 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1092 if source_y is None: 1093 (destination, source_x, source_y) = (destination, destination, source_x) 1094 instruction = ArithmeticInstruction('SUBCS', Operand(destination), Operand(source_x), Operand(source_y), 1095 origin=origin) 1096 if peachpy.stream.active_stream is not None: 1097 peachpy.stream.active_stream.add_instruction(instruction) 1098 return instruction 1099 1100 1101def SUBHS(destination, source_x, source_y=None): 1102 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1103 if source_y is None: 1104 (destination, source_x, source_y) = (destination, destination, source_x) 1105 instruction = ArithmeticInstruction('SUBHS', Operand(destination), Operand(source_x), Operand(source_y), 1106 origin=origin) 1107 if peachpy.stream.active_stream is not None: 1108 peachpy.stream.active_stream.add_instruction(instruction) 1109 return instruction 1110 1111 1112def SUBCC(destination, source_x, source_y=None): 1113 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1114 if source_y is None: 1115 (destination, source_x, source_y) = (destination, destination, source_x) 1116 instruction = ArithmeticInstruction('SUBCC', Operand(destination), Operand(source_x), Operand(source_y), 1117 origin=origin) 1118 if peachpy.stream.active_stream is not None: 1119 peachpy.stream.active_stream.add_instruction(instruction) 1120 return instruction 1121 1122 1123def SUBLO(destination, source_x, source_y=None): 1124 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1125 if source_y is None: 1126 (destination, source_x, source_y) = (destination, destination, source_x) 1127 instruction = ArithmeticInstruction('SUBLO', Operand(destination), Operand(source_x), Operand(source_y), 1128 origin=origin) 1129 if peachpy.stream.active_stream is not None: 1130 peachpy.stream.active_stream.add_instruction(instruction) 1131 return instruction 1132 1133 1134def SUBMI(destination, source_x, source_y=None): 1135 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1136 if source_y is None: 1137 (destination, source_x, source_y) = (destination, destination, source_x) 1138 instruction = ArithmeticInstruction('SUBMI', Operand(destination), Operand(source_x), Operand(source_y), 1139 origin=origin) 1140 if peachpy.stream.active_stream is not None: 1141 peachpy.stream.active_stream.add_instruction(instruction) 1142 return instruction 1143 1144 1145def SUBPL(destination, source_x, source_y=None): 1146 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1147 if source_y is None: 1148 (destination, source_x, source_y) = (destination, destination, source_x) 1149 instruction = ArithmeticInstruction('SUBPL', Operand(destination), Operand(source_x), Operand(source_y), 1150 origin=origin) 1151 if peachpy.stream.active_stream is not None: 1152 peachpy.stream.active_stream.add_instruction(instruction) 1153 return instruction 1154 1155 1156def SUBVS(destination, source_x, source_y=None): 1157 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1158 if source_y is None: 1159 (destination, source_x, source_y) = (destination, destination, source_x) 1160 instruction = ArithmeticInstruction('SUBVS', Operand(destination), Operand(source_x), Operand(source_y), 1161 origin=origin) 1162 if peachpy.stream.active_stream is not None: 1163 peachpy.stream.active_stream.add_instruction(instruction) 1164 return instruction 1165 1166 1167def SUBVC(destination, source_x, source_y=None): 1168 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1169 if source_y is None: 1170 (destination, source_x, source_y) = (destination, destination, source_x) 1171 instruction = ArithmeticInstruction('SUBVC', Operand(destination), Operand(source_x), Operand(source_y), 1172 origin=origin) 1173 if peachpy.stream.active_stream is not None: 1174 peachpy.stream.active_stream.add_instruction(instruction) 1175 return instruction 1176 1177 1178def SUBHI(destination, source_x, source_y=None): 1179 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1180 if source_y is None: 1181 (destination, source_x, source_y) = (destination, destination, source_x) 1182 instruction = ArithmeticInstruction('SUBHI', Operand(destination), Operand(source_x), Operand(source_y), 1183 origin=origin) 1184 if peachpy.stream.active_stream is not None: 1185 peachpy.stream.active_stream.add_instruction(instruction) 1186 return instruction 1187 1188 1189def SUBLS(destination, source_x, source_y=None): 1190 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1191 if source_y is None: 1192 (destination, source_x, source_y) = (destination, destination, source_x) 1193 instruction = ArithmeticInstruction('SUBLS', Operand(destination), Operand(source_x), Operand(source_y), 1194 origin=origin) 1195 if peachpy.stream.active_stream is not None: 1196 peachpy.stream.active_stream.add_instruction(instruction) 1197 return instruction 1198 1199 1200def SUBGE(destination, source_x, source_y=None): 1201 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1202 if source_y is None: 1203 (destination, source_x, source_y) = (destination, destination, source_x) 1204 instruction = ArithmeticInstruction('SUBGE', Operand(destination), Operand(source_x), Operand(source_y), 1205 origin=origin) 1206 if peachpy.stream.active_stream is not None: 1207 peachpy.stream.active_stream.add_instruction(instruction) 1208 return instruction 1209 1210 1211def SUBLT(destination, source_x, source_y=None): 1212 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1213 if source_y is None: 1214 (destination, source_x, source_y) = (destination, destination, source_x) 1215 instruction = ArithmeticInstruction('SUBLT', Operand(destination), Operand(source_x), Operand(source_y), 1216 origin=origin) 1217 if peachpy.stream.active_stream is not None: 1218 peachpy.stream.active_stream.add_instruction(instruction) 1219 return instruction 1220 1221 1222def SUBGT(destination, source_x, source_y=None): 1223 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1224 if source_y is None: 1225 (destination, source_x, source_y) = (destination, destination, source_x) 1226 instruction = ArithmeticInstruction('SUBGT', Operand(destination), Operand(source_x), Operand(source_y), 1227 origin=origin) 1228 if peachpy.stream.active_stream is not None: 1229 peachpy.stream.active_stream.add_instruction(instruction) 1230 return instruction 1231 1232 1233def SUBLE(destination, source_x, source_y=None): 1234 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1235 if source_y is None: 1236 (destination, source_x, source_y) = (destination, destination, source_x) 1237 instruction = ArithmeticInstruction('SUBLE', Operand(destination), Operand(source_x), Operand(source_y), 1238 origin=origin) 1239 if peachpy.stream.active_stream is not None: 1240 peachpy.stream.active_stream.add_instruction(instruction) 1241 return instruction 1242 1243 1244def SUBS(destination, source_x, source_y=None): 1245 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1246 if source_y is None: 1247 (destination, source_x, source_y) = (destination, destination, source_x) 1248 instruction = ArithmeticInstruction('SUBS', Operand(destination), Operand(source_x), Operand(source_y), 1249 origin=origin) 1250 if peachpy.stream.active_stream is not None: 1251 peachpy.stream.active_stream.add_instruction(instruction) 1252 return instruction 1253 1254 1255def SUBSEQ(destination, source_x, source_y=None): 1256 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1257 if source_y is None: 1258 (destination, source_x, source_y) = (destination, destination, source_x) 1259 instruction = ArithmeticInstruction('SUBSEQ', Operand(destination), Operand(source_x), Operand(source_y), 1260 origin=origin) 1261 if peachpy.stream.active_stream is not None: 1262 peachpy.stream.active_stream.add_instruction(instruction) 1263 return instruction 1264 1265 1266def SUBSNE(destination, source_x, source_y=None): 1267 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1268 if source_y is None: 1269 (destination, source_x, source_y) = (destination, destination, source_x) 1270 instruction = ArithmeticInstruction('SUBSNE', Operand(destination), Operand(source_x), Operand(source_y), 1271 origin=origin) 1272 if peachpy.stream.active_stream is not None: 1273 peachpy.stream.active_stream.add_instruction(instruction) 1274 return instruction 1275 1276 1277def SUBSCS(destination, source_x, source_y=None): 1278 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1279 if source_y is None: 1280 (destination, source_x, source_y) = (destination, destination, source_x) 1281 instruction = ArithmeticInstruction('SUBSCS', Operand(destination), Operand(source_x), Operand(source_y), 1282 origin=origin) 1283 if peachpy.stream.active_stream is not None: 1284 peachpy.stream.active_stream.add_instruction(instruction) 1285 return instruction 1286 1287 1288def SUBSHS(destination, source_x, source_y=None): 1289 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1290 if source_y is None: 1291 (destination, source_x, source_y) = (destination, destination, source_x) 1292 instruction = ArithmeticInstruction('SUBSHS', Operand(destination), Operand(source_x), Operand(source_y), 1293 origin=origin) 1294 if peachpy.stream.active_stream is not None: 1295 peachpy.stream.active_stream.add_instruction(instruction) 1296 return instruction 1297 1298 1299def SUBSCC(destination, source_x, source_y=None): 1300 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1301 if source_y is None: 1302 (destination, source_x, source_y) = (destination, destination, source_x) 1303 instruction = ArithmeticInstruction('SUBSCC', Operand(destination), Operand(source_x), Operand(source_y), 1304 origin=origin) 1305 if peachpy.stream.active_stream is not None: 1306 peachpy.stream.active_stream.add_instruction(instruction) 1307 return instruction 1308 1309 1310def SUBSLO(destination, source_x, source_y=None): 1311 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1312 if source_y is None: 1313 (destination, source_x, source_y) = (destination, destination, source_x) 1314 instruction = ArithmeticInstruction('SUBSLO', Operand(destination), Operand(source_x), Operand(source_y), 1315 origin=origin) 1316 if peachpy.stream.active_stream is not None: 1317 peachpy.stream.active_stream.add_instruction(instruction) 1318 return instruction 1319 1320 1321def SUBSMI(destination, source_x, source_y=None): 1322 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1323 if source_y is None: 1324 (destination, source_x, source_y) = (destination, destination, source_x) 1325 instruction = ArithmeticInstruction('SUBSMI', Operand(destination), Operand(source_x), Operand(source_y), 1326 origin=origin) 1327 if peachpy.stream.active_stream is not None: 1328 peachpy.stream.active_stream.add_instruction(instruction) 1329 return instruction 1330 1331 1332def SUBSPL(destination, source_x, source_y=None): 1333 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1334 if source_y is None: 1335 (destination, source_x, source_y) = (destination, destination, source_x) 1336 instruction = ArithmeticInstruction('SUBSPL', Operand(destination), Operand(source_x), Operand(source_y), 1337 origin=origin) 1338 if peachpy.stream.active_stream is not None: 1339 peachpy.stream.active_stream.add_instruction(instruction) 1340 return instruction 1341 1342 1343def SUBSVS(destination, source_x, source_y=None): 1344 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1345 if source_y is None: 1346 (destination, source_x, source_y) = (destination, destination, source_x) 1347 instruction = ArithmeticInstruction('SUBSVS', Operand(destination), Operand(source_x), Operand(source_y), 1348 origin=origin) 1349 if peachpy.stream.active_stream is not None: 1350 peachpy.stream.active_stream.add_instruction(instruction) 1351 return instruction 1352 1353 1354def SUBSVC(destination, source_x, source_y=None): 1355 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1356 if source_y is None: 1357 (destination, source_x, source_y) = (destination, destination, source_x) 1358 instruction = ArithmeticInstruction('SUBSVC', Operand(destination), Operand(source_x), Operand(source_y), 1359 origin=origin) 1360 if peachpy.stream.active_stream is not None: 1361 peachpy.stream.active_stream.add_instruction(instruction) 1362 return instruction 1363 1364 1365def SUBSHI(destination, source_x, source_y=None): 1366 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1367 if source_y is None: 1368 (destination, source_x, source_y) = (destination, destination, source_x) 1369 instruction = ArithmeticInstruction('SUBSHI', Operand(destination), Operand(source_x), Operand(source_y), 1370 origin=origin) 1371 if peachpy.stream.active_stream is not None: 1372 peachpy.stream.active_stream.add_instruction(instruction) 1373 return instruction 1374 1375 1376def SUBSLS(destination, source_x, source_y=None): 1377 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1378 if source_y is None: 1379 (destination, source_x, source_y) = (destination, destination, source_x) 1380 instruction = ArithmeticInstruction('SUBSLS', Operand(destination), Operand(source_x), Operand(source_y), 1381 origin=origin) 1382 if peachpy.stream.active_stream is not None: 1383 peachpy.stream.active_stream.add_instruction(instruction) 1384 return instruction 1385 1386 1387def SUBSGE(destination, source_x, source_y=None): 1388 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1389 if source_y is None: 1390 (destination, source_x, source_y) = (destination, destination, source_x) 1391 instruction = ArithmeticInstruction('SUBSGE', Operand(destination), Operand(source_x), Operand(source_y), 1392 origin=origin) 1393 if peachpy.stream.active_stream is not None: 1394 peachpy.stream.active_stream.add_instruction(instruction) 1395 return instruction 1396 1397 1398def SUBSLT(destination, source_x, source_y=None): 1399 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1400 if source_y is None: 1401 (destination, source_x, source_y) = (destination, destination, source_x) 1402 instruction = ArithmeticInstruction('SUBSLT', Operand(destination), Operand(source_x), Operand(source_y), 1403 origin=origin) 1404 if peachpy.stream.active_stream is not None: 1405 peachpy.stream.active_stream.add_instruction(instruction) 1406 return instruction 1407 1408 1409def SUBSGT(destination, source_x, source_y=None): 1410 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1411 if source_y is None: 1412 (destination, source_x, source_y) = (destination, destination, source_x) 1413 instruction = ArithmeticInstruction('SUBSGT', Operand(destination), Operand(source_x), Operand(source_y), 1414 origin=origin) 1415 if peachpy.stream.active_stream is not None: 1416 peachpy.stream.active_stream.add_instruction(instruction) 1417 return instruction 1418 1419 1420def SUBSLE(destination, source_x, source_y=None): 1421 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1422 if source_y is None: 1423 (destination, source_x, source_y) = (destination, destination, source_x) 1424 instruction = ArithmeticInstruction('SUBSLE', Operand(destination), Operand(source_x), Operand(source_y), 1425 origin=origin) 1426 if peachpy.stream.active_stream is not None: 1427 peachpy.stream.active_stream.add_instruction(instruction) 1428 return instruction 1429 1430 1431def SBC(destination, source_x, source_y=None): 1432 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1433 if source_y is None: 1434 (destination, source_x, source_y) = (destination, destination, source_x) 1435 instruction = ArithmeticInstruction('SBC', Operand(destination), Operand(source_x), Operand(source_y), 1436 origin=origin) 1437 if peachpy.stream.active_stream is not None: 1438 peachpy.stream.active_stream.add_instruction(instruction) 1439 return instruction 1440 1441 1442def SBCEQ(destination, source_x, source_y=None): 1443 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1444 if source_y is None: 1445 (destination, source_x, source_y) = (destination, destination, source_x) 1446 instruction = ArithmeticInstruction('SBCEQ', Operand(destination), Operand(source_x), Operand(source_y), 1447 origin=origin) 1448 if peachpy.stream.active_stream is not None: 1449 peachpy.stream.active_stream.add_instruction(instruction) 1450 return instruction 1451 1452 1453def SBCNE(destination, source_x, source_y=None): 1454 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1455 if source_y is None: 1456 (destination, source_x, source_y) = (destination, destination, source_x) 1457 instruction = ArithmeticInstruction('SBCNE', Operand(destination), Operand(source_x), Operand(source_y), 1458 origin=origin) 1459 if peachpy.stream.active_stream is not None: 1460 peachpy.stream.active_stream.add_instruction(instruction) 1461 return instruction 1462 1463 1464def SBCCS(destination, source_x, source_y=None): 1465 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1466 if source_y is None: 1467 (destination, source_x, source_y) = (destination, destination, source_x) 1468 instruction = ArithmeticInstruction('SBCCS', Operand(destination), Operand(source_x), Operand(source_y), 1469 origin=origin) 1470 if peachpy.stream.active_stream is not None: 1471 peachpy.stream.active_stream.add_instruction(instruction) 1472 return instruction 1473 1474 1475def SBCHS(destination, source_x, source_y=None): 1476 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1477 if source_y is None: 1478 (destination, source_x, source_y) = (destination, destination, source_x) 1479 instruction = ArithmeticInstruction('SBCHS', Operand(destination), Operand(source_x), Operand(source_y), 1480 origin=origin) 1481 if peachpy.stream.active_stream is not None: 1482 peachpy.stream.active_stream.add_instruction(instruction) 1483 return instruction 1484 1485 1486def SBCCC(destination, source_x, source_y=None): 1487 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1488 if source_y is None: 1489 (destination, source_x, source_y) = (destination, destination, source_x) 1490 instruction = ArithmeticInstruction('SBCCC', Operand(destination), Operand(source_x), Operand(source_y), 1491 origin=origin) 1492 if peachpy.stream.active_stream is not None: 1493 peachpy.stream.active_stream.add_instruction(instruction) 1494 return instruction 1495 1496 1497def SBCLO(destination, source_x, source_y=None): 1498 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1499 if source_y is None: 1500 (destination, source_x, source_y) = (destination, destination, source_x) 1501 instruction = ArithmeticInstruction('SBCLO', Operand(destination), Operand(source_x), Operand(source_y), 1502 origin=origin) 1503 if peachpy.stream.active_stream is not None: 1504 peachpy.stream.active_stream.add_instruction(instruction) 1505 return instruction 1506 1507 1508def SBCMI(destination, source_x, source_y=None): 1509 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1510 if source_y is None: 1511 (destination, source_x, source_y) = (destination, destination, source_x) 1512 instruction = ArithmeticInstruction('SBCMI', Operand(destination), Operand(source_x), Operand(source_y), 1513 origin=origin) 1514 if peachpy.stream.active_stream is not None: 1515 peachpy.stream.active_stream.add_instruction(instruction) 1516 return instruction 1517 1518 1519def SBCPL(destination, source_x, source_y=None): 1520 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1521 if source_y is None: 1522 (destination, source_x, source_y) = (destination, destination, source_x) 1523 instruction = ArithmeticInstruction('SBCPL', Operand(destination), Operand(source_x), Operand(source_y), 1524 origin=origin) 1525 if peachpy.stream.active_stream is not None: 1526 peachpy.stream.active_stream.add_instruction(instruction) 1527 return instruction 1528 1529 1530def SBCVS(destination, source_x, source_y=None): 1531 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1532 if source_y is None: 1533 (destination, source_x, source_y) = (destination, destination, source_x) 1534 instruction = ArithmeticInstruction('SBCVS', Operand(destination), Operand(source_x), Operand(source_y), 1535 origin=origin) 1536 if peachpy.stream.active_stream is not None: 1537 peachpy.stream.active_stream.add_instruction(instruction) 1538 return instruction 1539 1540 1541def SBCVC(destination, source_x, source_y=None): 1542 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1543 if source_y is None: 1544 (destination, source_x, source_y) = (destination, destination, source_x) 1545 instruction = ArithmeticInstruction('SBCVC', Operand(destination), Operand(source_x), Operand(source_y), 1546 origin=origin) 1547 if peachpy.stream.active_stream is not None: 1548 peachpy.stream.active_stream.add_instruction(instruction) 1549 return instruction 1550 1551 1552def SBCHI(destination, source_x, source_y=None): 1553 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1554 if source_y is None: 1555 (destination, source_x, source_y) = (destination, destination, source_x) 1556 instruction = ArithmeticInstruction('SBCHI', Operand(destination), Operand(source_x), Operand(source_y), 1557 origin=origin) 1558 if peachpy.stream.active_stream is not None: 1559 peachpy.stream.active_stream.add_instruction(instruction) 1560 return instruction 1561 1562 1563def SBCLS(destination, source_x, source_y=None): 1564 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1565 if source_y is None: 1566 (destination, source_x, source_y) = (destination, destination, source_x) 1567 instruction = ArithmeticInstruction('SBCLS', Operand(destination), Operand(source_x), Operand(source_y), 1568 origin=origin) 1569 if peachpy.stream.active_stream is not None: 1570 peachpy.stream.active_stream.add_instruction(instruction) 1571 return instruction 1572 1573 1574def SBCGE(destination, source_x, source_y=None): 1575 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1576 if source_y is None: 1577 (destination, source_x, source_y) = (destination, destination, source_x) 1578 instruction = ArithmeticInstruction('SBCGE', Operand(destination), Operand(source_x), Operand(source_y), 1579 origin=origin) 1580 if peachpy.stream.active_stream is not None: 1581 peachpy.stream.active_stream.add_instruction(instruction) 1582 return instruction 1583 1584 1585def SBCLT(destination, source_x, source_y=None): 1586 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1587 if source_y is None: 1588 (destination, source_x, source_y) = (destination, destination, source_x) 1589 instruction = ArithmeticInstruction('SBCLT', Operand(destination), Operand(source_x), Operand(source_y), 1590 origin=origin) 1591 if peachpy.stream.active_stream is not None: 1592 peachpy.stream.active_stream.add_instruction(instruction) 1593 return instruction 1594 1595 1596def SBCGT(destination, source_x, source_y=None): 1597 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1598 if source_y is None: 1599 (destination, source_x, source_y) = (destination, destination, source_x) 1600 instruction = ArithmeticInstruction('SBCGT', Operand(destination), Operand(source_x), Operand(source_y), 1601 origin=origin) 1602 if peachpy.stream.active_stream is not None: 1603 peachpy.stream.active_stream.add_instruction(instruction) 1604 return instruction 1605 1606 1607def SBCLE(destination, source_x, source_y=None): 1608 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1609 if source_y is None: 1610 (destination, source_x, source_y) = (destination, destination, source_x) 1611 instruction = ArithmeticInstruction('SBCLE', Operand(destination), Operand(source_x), Operand(source_y), 1612 origin=origin) 1613 if peachpy.stream.active_stream is not None: 1614 peachpy.stream.active_stream.add_instruction(instruction) 1615 return instruction 1616 1617 1618def SBCS(destination, source_x, source_y=None): 1619 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1620 if source_y is None: 1621 (destination, source_x, source_y) = (destination, destination, source_x) 1622 instruction = ArithmeticInstruction('SBCS', Operand(destination), Operand(source_x), Operand(source_y), 1623 origin=origin) 1624 if peachpy.stream.active_stream is not None: 1625 peachpy.stream.active_stream.add_instruction(instruction) 1626 return instruction 1627 1628 1629def SBCSEQ(destination, source_x, source_y=None): 1630 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1631 if source_y is None: 1632 (destination, source_x, source_y) = (destination, destination, source_x) 1633 instruction = ArithmeticInstruction('SBCSEQ', Operand(destination), Operand(source_x), Operand(source_y), 1634 origin=origin) 1635 if peachpy.stream.active_stream is not None: 1636 peachpy.stream.active_stream.add_instruction(instruction) 1637 return instruction 1638 1639 1640def SBCSNE(destination, source_x, source_y=None): 1641 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1642 if source_y is None: 1643 (destination, source_x, source_y) = (destination, destination, source_x) 1644 instruction = ArithmeticInstruction('SBCSNE', Operand(destination), Operand(source_x), Operand(source_y), 1645 origin=origin) 1646 if peachpy.stream.active_stream is not None: 1647 peachpy.stream.active_stream.add_instruction(instruction) 1648 return instruction 1649 1650 1651def SBCSCS(destination, source_x, source_y=None): 1652 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1653 if source_y is None: 1654 (destination, source_x, source_y) = (destination, destination, source_x) 1655 instruction = ArithmeticInstruction('SBCSCS', Operand(destination), Operand(source_x), Operand(source_y), 1656 origin=origin) 1657 if peachpy.stream.active_stream is not None: 1658 peachpy.stream.active_stream.add_instruction(instruction) 1659 return instruction 1660 1661 1662def SBCSHS(destination, source_x, source_y=None): 1663 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1664 if source_y is None: 1665 (destination, source_x, source_y) = (destination, destination, source_x) 1666 instruction = ArithmeticInstruction('SBCSHS', Operand(destination), Operand(source_x), Operand(source_y), 1667 origin=origin) 1668 if peachpy.stream.active_stream is not None: 1669 peachpy.stream.active_stream.add_instruction(instruction) 1670 return instruction 1671 1672 1673def SBCSCC(destination, source_x, source_y=None): 1674 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1675 if source_y is None: 1676 (destination, source_x, source_y) = (destination, destination, source_x) 1677 instruction = ArithmeticInstruction('SBCSCC', Operand(destination), Operand(source_x), Operand(source_y), 1678 origin=origin) 1679 if peachpy.stream.active_stream is not None: 1680 peachpy.stream.active_stream.add_instruction(instruction) 1681 return instruction 1682 1683 1684def SBCSLO(destination, source_x, source_y=None): 1685 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1686 if source_y is None: 1687 (destination, source_x, source_y) = (destination, destination, source_x) 1688 instruction = ArithmeticInstruction('SBCSLO', Operand(destination), Operand(source_x), Operand(source_y), 1689 origin=origin) 1690 if peachpy.stream.active_stream is not None: 1691 peachpy.stream.active_stream.add_instruction(instruction) 1692 return instruction 1693 1694 1695def SBCSMI(destination, source_x, source_y=None): 1696 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1697 if source_y is None: 1698 (destination, source_x, source_y) = (destination, destination, source_x) 1699 instruction = ArithmeticInstruction('SBCSMI', Operand(destination), Operand(source_x), Operand(source_y), 1700 origin=origin) 1701 if peachpy.stream.active_stream is not None: 1702 peachpy.stream.active_stream.add_instruction(instruction) 1703 return instruction 1704 1705 1706def SBCSPL(destination, source_x, source_y=None): 1707 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1708 if source_y is None: 1709 (destination, source_x, source_y) = (destination, destination, source_x) 1710 instruction = ArithmeticInstruction('SBCSPL', Operand(destination), Operand(source_x), Operand(source_y), 1711 origin=origin) 1712 if peachpy.stream.active_stream is not None: 1713 peachpy.stream.active_stream.add_instruction(instruction) 1714 return instruction 1715 1716 1717def SBCSVS(destination, source_x, source_y=None): 1718 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1719 if source_y is None: 1720 (destination, source_x, source_y) = (destination, destination, source_x) 1721 instruction = ArithmeticInstruction('SBCSVS', Operand(destination), Operand(source_x), Operand(source_y), 1722 origin=origin) 1723 if peachpy.stream.active_stream is not None: 1724 peachpy.stream.active_stream.add_instruction(instruction) 1725 return instruction 1726 1727 1728def SBCSVC(destination, source_x, source_y=None): 1729 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1730 if source_y is None: 1731 (destination, source_x, source_y) = (destination, destination, source_x) 1732 instruction = ArithmeticInstruction('SBCSVC', Operand(destination), Operand(source_x), Operand(source_y), 1733 origin=origin) 1734 if peachpy.stream.active_stream is not None: 1735 peachpy.stream.active_stream.add_instruction(instruction) 1736 return instruction 1737 1738 1739def SBCSHI(destination, source_x, source_y=None): 1740 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1741 if source_y is None: 1742 (destination, source_x, source_y) = (destination, destination, source_x) 1743 instruction = ArithmeticInstruction('SBCSHI', Operand(destination), Operand(source_x), Operand(source_y), 1744 origin=origin) 1745 if peachpy.stream.active_stream is not None: 1746 peachpy.stream.active_stream.add_instruction(instruction) 1747 return instruction 1748 1749 1750def SBCSLS(destination, source_x, source_y=None): 1751 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1752 if source_y is None: 1753 (destination, source_x, source_y) = (destination, destination, source_x) 1754 instruction = ArithmeticInstruction('SBCSLS', Operand(destination), Operand(source_x), Operand(source_y), 1755 origin=origin) 1756 if peachpy.stream.active_stream is not None: 1757 peachpy.stream.active_stream.add_instruction(instruction) 1758 return instruction 1759 1760 1761def SBCSGE(destination, source_x, source_y=None): 1762 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1763 if source_y is None: 1764 (destination, source_x, source_y) = (destination, destination, source_x) 1765 instruction = ArithmeticInstruction('SBCSGE', Operand(destination), Operand(source_x), Operand(source_y), 1766 origin=origin) 1767 if peachpy.stream.active_stream is not None: 1768 peachpy.stream.active_stream.add_instruction(instruction) 1769 return instruction 1770 1771 1772def SBCSLT(destination, source_x, source_y=None): 1773 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1774 if source_y is None: 1775 (destination, source_x, source_y) = (destination, destination, source_x) 1776 instruction = ArithmeticInstruction('SBCSLT', Operand(destination), Operand(source_x), Operand(source_y), 1777 origin=origin) 1778 if peachpy.stream.active_stream is not None: 1779 peachpy.stream.active_stream.add_instruction(instruction) 1780 return instruction 1781 1782 1783def SBCSGT(destination, source_x, source_y=None): 1784 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1785 if source_y is None: 1786 (destination, source_x, source_y) = (destination, destination, source_x) 1787 instruction = ArithmeticInstruction('SBCSGT', Operand(destination), Operand(source_x), Operand(source_y), 1788 origin=origin) 1789 if peachpy.stream.active_stream is not None: 1790 peachpy.stream.active_stream.add_instruction(instruction) 1791 return instruction 1792 1793 1794def SBCSLE(destination, source_x, source_y=None): 1795 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1796 if source_y is None: 1797 (destination, source_x, source_y) = (destination, destination, source_x) 1798 instruction = ArithmeticInstruction('SBCSLE', Operand(destination), Operand(source_x), Operand(source_y), 1799 origin=origin) 1800 if peachpy.stream.active_stream is not None: 1801 peachpy.stream.active_stream.add_instruction(instruction) 1802 return instruction 1803 1804 1805def RSB(destination, source_x, source_y=None): 1806 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1807 if source_y is None: 1808 (destination, source_x, source_y) = (destination, destination, source_x) 1809 instruction = ArithmeticInstruction('RSB', Operand(destination), Operand(source_x), Operand(source_y), 1810 origin=origin) 1811 if peachpy.stream.active_stream is not None: 1812 peachpy.stream.active_stream.add_instruction(instruction) 1813 return instruction 1814 1815 1816def RSBEQ(destination, source_x, source_y=None): 1817 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1818 if source_y is None: 1819 (destination, source_x, source_y) = (destination, destination, source_x) 1820 instruction = ArithmeticInstruction('RSBEQ', Operand(destination), Operand(source_x), Operand(source_y), 1821 origin=origin) 1822 if peachpy.stream.active_stream is not None: 1823 peachpy.stream.active_stream.add_instruction(instruction) 1824 return instruction 1825 1826 1827def RSBNE(destination, source_x, source_y=None): 1828 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1829 if source_y is None: 1830 (destination, source_x, source_y) = (destination, destination, source_x) 1831 instruction = ArithmeticInstruction('RSBNE', Operand(destination), Operand(source_x), Operand(source_y), 1832 origin=origin) 1833 if peachpy.stream.active_stream is not None: 1834 peachpy.stream.active_stream.add_instruction(instruction) 1835 return instruction 1836 1837 1838def RSBCS(destination, source_x, source_y=None): 1839 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1840 if source_y is None: 1841 (destination, source_x, source_y) = (destination, destination, source_x) 1842 instruction = ArithmeticInstruction('RSBCS', Operand(destination), Operand(source_x), Operand(source_y), 1843 origin=origin) 1844 if peachpy.stream.active_stream is not None: 1845 peachpy.stream.active_stream.add_instruction(instruction) 1846 return instruction 1847 1848 1849def RSBHS(destination, source_x, source_y=None): 1850 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1851 if source_y is None: 1852 (destination, source_x, source_y) = (destination, destination, source_x) 1853 instruction = ArithmeticInstruction('RSBHS', Operand(destination), Operand(source_x), Operand(source_y), 1854 origin=origin) 1855 if peachpy.stream.active_stream is not None: 1856 peachpy.stream.active_stream.add_instruction(instruction) 1857 return instruction 1858 1859 1860def RSBCC(destination, source_x, source_y=None): 1861 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1862 if source_y is None: 1863 (destination, source_x, source_y) = (destination, destination, source_x) 1864 instruction = ArithmeticInstruction('RSBCC', Operand(destination), Operand(source_x), Operand(source_y), 1865 origin=origin) 1866 if peachpy.stream.active_stream is not None: 1867 peachpy.stream.active_stream.add_instruction(instruction) 1868 return instruction 1869 1870 1871def RSBLO(destination, source_x, source_y=None): 1872 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1873 if source_y is None: 1874 (destination, source_x, source_y) = (destination, destination, source_x) 1875 instruction = ArithmeticInstruction('RSBLO', Operand(destination), Operand(source_x), Operand(source_y), 1876 origin=origin) 1877 if peachpy.stream.active_stream is not None: 1878 peachpy.stream.active_stream.add_instruction(instruction) 1879 return instruction 1880 1881 1882def RSBMI(destination, source_x, source_y=None): 1883 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1884 if source_y is None: 1885 (destination, source_x, source_y) = (destination, destination, source_x) 1886 instruction = ArithmeticInstruction('RSBMI', Operand(destination), Operand(source_x), Operand(source_y), 1887 origin=origin) 1888 if peachpy.stream.active_stream is not None: 1889 peachpy.stream.active_stream.add_instruction(instruction) 1890 return instruction 1891 1892 1893def RSBPL(destination, source_x, source_y=None): 1894 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1895 if source_y is None: 1896 (destination, source_x, source_y) = (destination, destination, source_x) 1897 instruction = ArithmeticInstruction('RSBPL', Operand(destination), Operand(source_x), Operand(source_y), 1898 origin=origin) 1899 if peachpy.stream.active_stream is not None: 1900 peachpy.stream.active_stream.add_instruction(instruction) 1901 return instruction 1902 1903 1904def RSBVS(destination, source_x, source_y=None): 1905 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1906 if source_y is None: 1907 (destination, source_x, source_y) = (destination, destination, source_x) 1908 instruction = ArithmeticInstruction('RSBVS', Operand(destination), Operand(source_x), Operand(source_y), 1909 origin=origin) 1910 if peachpy.stream.active_stream is not None: 1911 peachpy.stream.active_stream.add_instruction(instruction) 1912 return instruction 1913 1914 1915def RSBVC(destination, source_x, source_y=None): 1916 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1917 if source_y is None: 1918 (destination, source_x, source_y) = (destination, destination, source_x) 1919 instruction = ArithmeticInstruction('RSBVC', Operand(destination), Operand(source_x), Operand(source_y), 1920 origin=origin) 1921 if peachpy.stream.active_stream is not None: 1922 peachpy.stream.active_stream.add_instruction(instruction) 1923 return instruction 1924 1925 1926def RSBHI(destination, source_x, source_y=None): 1927 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1928 if source_y is None: 1929 (destination, source_x, source_y) = (destination, destination, source_x) 1930 instruction = ArithmeticInstruction('RSBHI', Operand(destination), Operand(source_x), Operand(source_y), 1931 origin=origin) 1932 if peachpy.stream.active_stream is not None: 1933 peachpy.stream.active_stream.add_instruction(instruction) 1934 return instruction 1935 1936 1937def RSBLS(destination, source_x, source_y=None): 1938 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1939 if source_y is None: 1940 (destination, source_x, source_y) = (destination, destination, source_x) 1941 instruction = ArithmeticInstruction('RSBLS', Operand(destination), Operand(source_x), Operand(source_y), 1942 origin=origin) 1943 if peachpy.stream.active_stream is not None: 1944 peachpy.stream.active_stream.add_instruction(instruction) 1945 return instruction 1946 1947 1948def RSBGE(destination, source_x, source_y=None): 1949 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1950 if source_y is None: 1951 (destination, source_x, source_y) = (destination, destination, source_x) 1952 instruction = ArithmeticInstruction('RSBGE', Operand(destination), Operand(source_x), Operand(source_y), 1953 origin=origin) 1954 if peachpy.stream.active_stream is not None: 1955 peachpy.stream.active_stream.add_instruction(instruction) 1956 return instruction 1957 1958 1959def RSBLT(destination, source_x, source_y=None): 1960 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1961 if source_y is None: 1962 (destination, source_x, source_y) = (destination, destination, source_x) 1963 instruction = ArithmeticInstruction('RSBLT', Operand(destination), Operand(source_x), Operand(source_y), 1964 origin=origin) 1965 if peachpy.stream.active_stream is not None: 1966 peachpy.stream.active_stream.add_instruction(instruction) 1967 return instruction 1968 1969 1970def RSBGT(destination, source_x, source_y=None): 1971 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1972 if source_y is None: 1973 (destination, source_x, source_y) = (destination, destination, source_x) 1974 instruction = ArithmeticInstruction('RSBGT', Operand(destination), Operand(source_x), Operand(source_y), 1975 origin=origin) 1976 if peachpy.stream.active_stream is not None: 1977 peachpy.stream.active_stream.add_instruction(instruction) 1978 return instruction 1979 1980 1981def RSBLE(destination, source_x, source_y=None): 1982 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1983 if source_y is None: 1984 (destination, source_x, source_y) = (destination, destination, source_x) 1985 instruction = ArithmeticInstruction('RSBLE', Operand(destination), Operand(source_x), Operand(source_y), 1986 origin=origin) 1987 if peachpy.stream.active_stream is not None: 1988 peachpy.stream.active_stream.add_instruction(instruction) 1989 return instruction 1990 1991 1992def RSBS(destination, source_x, source_y=None): 1993 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 1994 if source_y is None: 1995 (destination, source_x, source_y) = (destination, destination, source_x) 1996 instruction = ArithmeticInstruction('RSBS', Operand(destination), Operand(source_x), Operand(source_y), 1997 origin=origin) 1998 if peachpy.stream.active_stream is not None: 1999 peachpy.stream.active_stream.add_instruction(instruction) 2000 return instruction 2001 2002 2003def RSBSEQ(destination, source_x, source_y=None): 2004 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2005 if source_y is None: 2006 (destination, source_x, source_y) = (destination, destination, source_x) 2007 instruction = ArithmeticInstruction('RSBSEQ', Operand(destination), Operand(source_x), Operand(source_y), 2008 origin=origin) 2009 if peachpy.stream.active_stream is not None: 2010 peachpy.stream.active_stream.add_instruction(instruction) 2011 return instruction 2012 2013 2014def RSBSNE(destination, source_x, source_y=None): 2015 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2016 if source_y is None: 2017 (destination, source_x, source_y) = (destination, destination, source_x) 2018 instruction = ArithmeticInstruction('RSBSNE', Operand(destination), Operand(source_x), Operand(source_y), 2019 origin=origin) 2020 if peachpy.stream.active_stream is not None: 2021 peachpy.stream.active_stream.add_instruction(instruction) 2022 return instruction 2023 2024 2025def RSBSCS(destination, source_x, source_y=None): 2026 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2027 if source_y is None: 2028 (destination, source_x, source_y) = (destination, destination, source_x) 2029 instruction = ArithmeticInstruction('RSBSCS', Operand(destination), Operand(source_x), Operand(source_y), 2030 origin=origin) 2031 if peachpy.stream.active_stream is not None: 2032 peachpy.stream.active_stream.add_instruction(instruction) 2033 return instruction 2034 2035 2036def RSBSHS(destination, source_x, source_y=None): 2037 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2038 if source_y is None: 2039 (destination, source_x, source_y) = (destination, destination, source_x) 2040 instruction = ArithmeticInstruction('RSBSHS', Operand(destination), Operand(source_x), Operand(source_y), 2041 origin=origin) 2042 if peachpy.stream.active_stream is not None: 2043 peachpy.stream.active_stream.add_instruction(instruction) 2044 return instruction 2045 2046 2047def RSBSCC(destination, source_x, source_y=None): 2048 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2049 if source_y is None: 2050 (destination, source_x, source_y) = (destination, destination, source_x) 2051 instruction = ArithmeticInstruction('RSBSCC', Operand(destination), Operand(source_x), Operand(source_y), 2052 origin=origin) 2053 if peachpy.stream.active_stream is not None: 2054 peachpy.stream.active_stream.add_instruction(instruction) 2055 return instruction 2056 2057 2058def RSBSLO(destination, source_x, source_y=None): 2059 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2060 if source_y is None: 2061 (destination, source_x, source_y) = (destination, destination, source_x) 2062 instruction = ArithmeticInstruction('RSBSLO', Operand(destination), Operand(source_x), Operand(source_y), 2063 origin=origin) 2064 if peachpy.stream.active_stream is not None: 2065 peachpy.stream.active_stream.add_instruction(instruction) 2066 return instruction 2067 2068 2069def RSBSMI(destination, source_x, source_y=None): 2070 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2071 if source_y is None: 2072 (destination, source_x, source_y) = (destination, destination, source_x) 2073 instruction = ArithmeticInstruction('RSBSMI', Operand(destination), Operand(source_x), Operand(source_y), 2074 origin=origin) 2075 if peachpy.stream.active_stream is not None: 2076 peachpy.stream.active_stream.add_instruction(instruction) 2077 return instruction 2078 2079 2080def RSBSPL(destination, source_x, source_y=None): 2081 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2082 if source_y is None: 2083 (destination, source_x, source_y) = (destination, destination, source_x) 2084 instruction = ArithmeticInstruction('RSBSPL', Operand(destination), Operand(source_x), Operand(source_y), 2085 origin=origin) 2086 if peachpy.stream.active_stream is not None: 2087 peachpy.stream.active_stream.add_instruction(instruction) 2088 return instruction 2089 2090 2091def RSBSVS(destination, source_x, source_y=None): 2092 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2093 if source_y is None: 2094 (destination, source_x, source_y) = (destination, destination, source_x) 2095 instruction = ArithmeticInstruction('RSBSVS', Operand(destination), Operand(source_x), Operand(source_y), 2096 origin=origin) 2097 if peachpy.stream.active_stream is not None: 2098 peachpy.stream.active_stream.add_instruction(instruction) 2099 return instruction 2100 2101 2102def RSBSVC(destination, source_x, source_y=None): 2103 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2104 if source_y is None: 2105 (destination, source_x, source_y) = (destination, destination, source_x) 2106 instruction = ArithmeticInstruction('RSBSVC', Operand(destination), Operand(source_x), Operand(source_y), 2107 origin=origin) 2108 if peachpy.stream.active_stream is not None: 2109 peachpy.stream.active_stream.add_instruction(instruction) 2110 return instruction 2111 2112 2113def RSBSHI(destination, source_x, source_y=None): 2114 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2115 if source_y is None: 2116 (destination, source_x, source_y) = (destination, destination, source_x) 2117 instruction = ArithmeticInstruction('RSBSHI', Operand(destination), Operand(source_x), Operand(source_y), 2118 origin=origin) 2119 if peachpy.stream.active_stream is not None: 2120 peachpy.stream.active_stream.add_instruction(instruction) 2121 return instruction 2122 2123 2124def RSBSLS(destination, source_x, source_y=None): 2125 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2126 if source_y is None: 2127 (destination, source_x, source_y) = (destination, destination, source_x) 2128 instruction = ArithmeticInstruction('RSBSLS', Operand(destination), Operand(source_x), Operand(source_y), 2129 origin=origin) 2130 if peachpy.stream.active_stream is not None: 2131 peachpy.stream.active_stream.add_instruction(instruction) 2132 return instruction 2133 2134 2135def RSBSGE(destination, source_x, source_y=None): 2136 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2137 if source_y is None: 2138 (destination, source_x, source_y) = (destination, destination, source_x) 2139 instruction = ArithmeticInstruction('RSBSGE', Operand(destination), Operand(source_x), Operand(source_y), 2140 origin=origin) 2141 if peachpy.stream.active_stream is not None: 2142 peachpy.stream.active_stream.add_instruction(instruction) 2143 return instruction 2144 2145 2146def RSBSLT(destination, source_x, source_y=None): 2147 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2148 if source_y is None: 2149 (destination, source_x, source_y) = (destination, destination, source_x) 2150 instruction = ArithmeticInstruction('RSBSLT', Operand(destination), Operand(source_x), Operand(source_y), 2151 origin=origin) 2152 if peachpy.stream.active_stream is not None: 2153 peachpy.stream.active_stream.add_instruction(instruction) 2154 return instruction 2155 2156 2157def RSBSGT(destination, source_x, source_y=None): 2158 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2159 if source_y is None: 2160 (destination, source_x, source_y) = (destination, destination, source_x) 2161 instruction = ArithmeticInstruction('RSBSGT', Operand(destination), Operand(source_x), Operand(source_y), 2162 origin=origin) 2163 if peachpy.stream.active_stream is not None: 2164 peachpy.stream.active_stream.add_instruction(instruction) 2165 return instruction 2166 2167 2168def RSBSLE(destination, source_x, source_y=None): 2169 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2170 if source_y is None: 2171 (destination, source_x, source_y) = (destination, destination, source_x) 2172 instruction = ArithmeticInstruction('RSBSLE', Operand(destination), Operand(source_x), Operand(source_y), 2173 origin=origin) 2174 if peachpy.stream.active_stream is not None: 2175 peachpy.stream.active_stream.add_instruction(instruction) 2176 return instruction 2177 2178 2179def RSC(destination, source_x, source_y=None): 2180 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2181 if source_y is None: 2182 (destination, source_x, source_y) = (destination, destination, source_x) 2183 instruction = ArithmeticInstruction('RSC', Operand(destination), Operand(source_x), Operand(source_y), 2184 origin=origin) 2185 if peachpy.stream.active_stream is not None: 2186 peachpy.stream.active_stream.add_instruction(instruction) 2187 return instruction 2188 2189 2190def RSCEQ(destination, source_x, source_y=None): 2191 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2192 if source_y is None: 2193 (destination, source_x, source_y) = (destination, destination, source_x) 2194 instruction = ArithmeticInstruction('RSCEQ', Operand(destination), Operand(source_x), Operand(source_y), 2195 origin=origin) 2196 if peachpy.stream.active_stream is not None: 2197 peachpy.stream.active_stream.add_instruction(instruction) 2198 return instruction 2199 2200 2201def RSCNE(destination, source_x, source_y=None): 2202 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2203 if source_y is None: 2204 (destination, source_x, source_y) = (destination, destination, source_x) 2205 instruction = ArithmeticInstruction('RSCNE', Operand(destination), Operand(source_x), Operand(source_y), 2206 origin=origin) 2207 if peachpy.stream.active_stream is not None: 2208 peachpy.stream.active_stream.add_instruction(instruction) 2209 return instruction 2210 2211 2212def RSCCS(destination, source_x, source_y=None): 2213 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2214 if source_y is None: 2215 (destination, source_x, source_y) = (destination, destination, source_x) 2216 instruction = ArithmeticInstruction('RSCCS', Operand(destination), Operand(source_x), Operand(source_y), 2217 origin=origin) 2218 if peachpy.stream.active_stream is not None: 2219 peachpy.stream.active_stream.add_instruction(instruction) 2220 return instruction 2221 2222 2223def RSCHS(destination, source_x, source_y=None): 2224 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2225 if source_y is None: 2226 (destination, source_x, source_y) = (destination, destination, source_x) 2227 instruction = ArithmeticInstruction('RSCHS', Operand(destination), Operand(source_x), Operand(source_y), 2228 origin=origin) 2229 if peachpy.stream.active_stream is not None: 2230 peachpy.stream.active_stream.add_instruction(instruction) 2231 return instruction 2232 2233 2234def RSCCC(destination, source_x, source_y=None): 2235 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2236 if source_y is None: 2237 (destination, source_x, source_y) = (destination, destination, source_x) 2238 instruction = ArithmeticInstruction('RSCCC', Operand(destination), Operand(source_x), Operand(source_y), 2239 origin=origin) 2240 if peachpy.stream.active_stream is not None: 2241 peachpy.stream.active_stream.add_instruction(instruction) 2242 return instruction 2243 2244 2245def RSCLO(destination, source_x, source_y=None): 2246 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2247 if source_y is None: 2248 (destination, source_x, source_y) = (destination, destination, source_x) 2249 instruction = ArithmeticInstruction('RSCLO', Operand(destination), Operand(source_x), Operand(source_y), 2250 origin=origin) 2251 if peachpy.stream.active_stream is not None: 2252 peachpy.stream.active_stream.add_instruction(instruction) 2253 return instruction 2254 2255 2256def RSCMI(destination, source_x, source_y=None): 2257 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2258 if source_y is None: 2259 (destination, source_x, source_y) = (destination, destination, source_x) 2260 instruction = ArithmeticInstruction('RSCMI', Operand(destination), Operand(source_x), Operand(source_y), 2261 origin=origin) 2262 if peachpy.stream.active_stream is not None: 2263 peachpy.stream.active_stream.add_instruction(instruction) 2264 return instruction 2265 2266 2267def RSCPL(destination, source_x, source_y=None): 2268 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2269 if source_y is None: 2270 (destination, source_x, source_y) = (destination, destination, source_x) 2271 instruction = ArithmeticInstruction('RSCPL', Operand(destination), Operand(source_x), Operand(source_y), 2272 origin=origin) 2273 if peachpy.stream.active_stream is not None: 2274 peachpy.stream.active_stream.add_instruction(instruction) 2275 return instruction 2276 2277 2278def RSCVS(destination, source_x, source_y=None): 2279 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2280 if source_y is None: 2281 (destination, source_x, source_y) = (destination, destination, source_x) 2282 instruction = ArithmeticInstruction('RSCVS', Operand(destination), Operand(source_x), Operand(source_y), 2283 origin=origin) 2284 if peachpy.stream.active_stream is not None: 2285 peachpy.stream.active_stream.add_instruction(instruction) 2286 return instruction 2287 2288 2289def RSCVC(destination, source_x, source_y=None): 2290 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2291 if source_y is None: 2292 (destination, source_x, source_y) = (destination, destination, source_x) 2293 instruction = ArithmeticInstruction('RSCVC', Operand(destination), Operand(source_x), Operand(source_y), 2294 origin=origin) 2295 if peachpy.stream.active_stream is not None: 2296 peachpy.stream.active_stream.add_instruction(instruction) 2297 return instruction 2298 2299 2300def RSCHI(destination, source_x, source_y=None): 2301 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2302 if source_y is None: 2303 (destination, source_x, source_y) = (destination, destination, source_x) 2304 instruction = ArithmeticInstruction('RSCHI', Operand(destination), Operand(source_x), Operand(source_y), 2305 origin=origin) 2306 if peachpy.stream.active_stream is not None: 2307 peachpy.stream.active_stream.add_instruction(instruction) 2308 return instruction 2309 2310 2311def RSCLS(destination, source_x, source_y=None): 2312 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2313 if source_y is None: 2314 (destination, source_x, source_y) = (destination, destination, source_x) 2315 instruction = ArithmeticInstruction('RSCLS', Operand(destination), Operand(source_x), Operand(source_y), 2316 origin=origin) 2317 if peachpy.stream.active_stream is not None: 2318 peachpy.stream.active_stream.add_instruction(instruction) 2319 return instruction 2320 2321 2322def RSCGE(destination, source_x, source_y=None): 2323 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2324 if source_y is None: 2325 (destination, source_x, source_y) = (destination, destination, source_x) 2326 instruction = ArithmeticInstruction('RSCGE', Operand(destination), Operand(source_x), Operand(source_y), 2327 origin=origin) 2328 if peachpy.stream.active_stream is not None: 2329 peachpy.stream.active_stream.add_instruction(instruction) 2330 return instruction 2331 2332 2333def RSCLT(destination, source_x, source_y=None): 2334 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2335 if source_y is None: 2336 (destination, source_x, source_y) = (destination, destination, source_x) 2337 instruction = ArithmeticInstruction('RSCLT', Operand(destination), Operand(source_x), Operand(source_y), 2338 origin=origin) 2339 if peachpy.stream.active_stream is not None: 2340 peachpy.stream.active_stream.add_instruction(instruction) 2341 return instruction 2342 2343 2344def RSCGT(destination, source_x, source_y=None): 2345 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2346 if source_y is None: 2347 (destination, source_x, source_y) = (destination, destination, source_x) 2348 instruction = ArithmeticInstruction('RSCGT', Operand(destination), Operand(source_x), Operand(source_y), 2349 origin=origin) 2350 if peachpy.stream.active_stream is not None: 2351 peachpy.stream.active_stream.add_instruction(instruction) 2352 return instruction 2353 2354 2355def RSCLE(destination, source_x, source_y=None): 2356 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2357 if source_y is None: 2358 (destination, source_x, source_y) = (destination, destination, source_x) 2359 instruction = ArithmeticInstruction('RSCLE', Operand(destination), Operand(source_x), Operand(source_y), 2360 origin=origin) 2361 if peachpy.stream.active_stream is not None: 2362 peachpy.stream.active_stream.add_instruction(instruction) 2363 return instruction 2364 2365 2366def RSCS(destination, source_x, source_y=None): 2367 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2368 if source_y is None: 2369 (destination, source_x, source_y) = (destination, destination, source_x) 2370 instruction = ArithmeticInstruction('RSCS', Operand(destination), Operand(source_x), Operand(source_y), 2371 origin=origin) 2372 if peachpy.stream.active_stream is not None: 2373 peachpy.stream.active_stream.add_instruction(instruction) 2374 return instruction 2375 2376 2377def RSCSEQ(destination, source_x, source_y=None): 2378 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2379 if source_y is None: 2380 (destination, source_x, source_y) = (destination, destination, source_x) 2381 instruction = ArithmeticInstruction('RSCSEQ', Operand(destination), Operand(source_x), Operand(source_y), 2382 origin=origin) 2383 if peachpy.stream.active_stream is not None: 2384 peachpy.stream.active_stream.add_instruction(instruction) 2385 return instruction 2386 2387 2388def RSCSNE(destination, source_x, source_y=None): 2389 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2390 if source_y is None: 2391 (destination, source_x, source_y) = (destination, destination, source_x) 2392 instruction = ArithmeticInstruction('RSCSNE', Operand(destination), Operand(source_x), Operand(source_y), 2393 origin=origin) 2394 if peachpy.stream.active_stream is not None: 2395 peachpy.stream.active_stream.add_instruction(instruction) 2396 return instruction 2397 2398 2399def RSCSCS(destination, source_x, source_y=None): 2400 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2401 if source_y is None: 2402 (destination, source_x, source_y) = (destination, destination, source_x) 2403 instruction = ArithmeticInstruction('RSCSCS', Operand(destination), Operand(source_x), Operand(source_y), 2404 origin=origin) 2405 if peachpy.stream.active_stream is not None: 2406 peachpy.stream.active_stream.add_instruction(instruction) 2407 return instruction 2408 2409 2410def RSCSHS(destination, source_x, source_y=None): 2411 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2412 if source_y is None: 2413 (destination, source_x, source_y) = (destination, destination, source_x) 2414 instruction = ArithmeticInstruction('RSCSHS', Operand(destination), Operand(source_x), Operand(source_y), 2415 origin=origin) 2416 if peachpy.stream.active_stream is not None: 2417 peachpy.stream.active_stream.add_instruction(instruction) 2418 return instruction 2419 2420 2421def RSCSCC(destination, source_x, source_y=None): 2422 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2423 if source_y is None: 2424 (destination, source_x, source_y) = (destination, destination, source_x) 2425 instruction = ArithmeticInstruction('RSCSCC', Operand(destination), Operand(source_x), Operand(source_y), 2426 origin=origin) 2427 if peachpy.stream.active_stream is not None: 2428 peachpy.stream.active_stream.add_instruction(instruction) 2429 return instruction 2430 2431 2432def RSCSLO(destination, source_x, source_y=None): 2433 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2434 if source_y is None: 2435 (destination, source_x, source_y) = (destination, destination, source_x) 2436 instruction = ArithmeticInstruction('RSCSLO', Operand(destination), Operand(source_x), Operand(source_y), 2437 origin=origin) 2438 if peachpy.stream.active_stream is not None: 2439 peachpy.stream.active_stream.add_instruction(instruction) 2440 return instruction 2441 2442 2443def RSCSMI(destination, source_x, source_y=None): 2444 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2445 if source_y is None: 2446 (destination, source_x, source_y) = (destination, destination, source_x) 2447 instruction = ArithmeticInstruction('RSCSMI', Operand(destination), Operand(source_x), Operand(source_y), 2448 origin=origin) 2449 if peachpy.stream.active_stream is not None: 2450 peachpy.stream.active_stream.add_instruction(instruction) 2451 return instruction 2452 2453 2454def RSCSPL(destination, source_x, source_y=None): 2455 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2456 if source_y is None: 2457 (destination, source_x, source_y) = (destination, destination, source_x) 2458 instruction = ArithmeticInstruction('RSCSPL', Operand(destination), Operand(source_x), Operand(source_y), 2459 origin=origin) 2460 if peachpy.stream.active_stream is not None: 2461 peachpy.stream.active_stream.add_instruction(instruction) 2462 return instruction 2463 2464 2465def RSCSVS(destination, source_x, source_y=None): 2466 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2467 if source_y is None: 2468 (destination, source_x, source_y) = (destination, destination, source_x) 2469 instruction = ArithmeticInstruction('RSCSVS', Operand(destination), Operand(source_x), Operand(source_y), 2470 origin=origin) 2471 if peachpy.stream.active_stream is not None: 2472 peachpy.stream.active_stream.add_instruction(instruction) 2473 return instruction 2474 2475 2476def RSCSVC(destination, source_x, source_y=None): 2477 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2478 if source_y is None: 2479 (destination, source_x, source_y) = (destination, destination, source_x) 2480 instruction = ArithmeticInstruction('RSCSVC', Operand(destination), Operand(source_x), Operand(source_y), 2481 origin=origin) 2482 if peachpy.stream.active_stream is not None: 2483 peachpy.stream.active_stream.add_instruction(instruction) 2484 return instruction 2485 2486 2487def RSCSHI(destination, source_x, source_y=None): 2488 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2489 if source_y is None: 2490 (destination, source_x, source_y) = (destination, destination, source_x) 2491 instruction = ArithmeticInstruction('RSCSHI', Operand(destination), Operand(source_x), Operand(source_y), 2492 origin=origin) 2493 if peachpy.stream.active_stream is not None: 2494 peachpy.stream.active_stream.add_instruction(instruction) 2495 return instruction 2496 2497 2498def RSCSLS(destination, source_x, source_y=None): 2499 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2500 if source_y is None: 2501 (destination, source_x, source_y) = (destination, destination, source_x) 2502 instruction = ArithmeticInstruction('RSCSLS', Operand(destination), Operand(source_x), Operand(source_y), 2503 origin=origin) 2504 if peachpy.stream.active_stream is not None: 2505 peachpy.stream.active_stream.add_instruction(instruction) 2506 return instruction 2507 2508 2509def RSCSGE(destination, source_x, source_y=None): 2510 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2511 if source_y is None: 2512 (destination, source_x, source_y) = (destination, destination, source_x) 2513 instruction = ArithmeticInstruction('RSCSGE', Operand(destination), Operand(source_x), Operand(source_y), 2514 origin=origin) 2515 if peachpy.stream.active_stream is not None: 2516 peachpy.stream.active_stream.add_instruction(instruction) 2517 return instruction 2518 2519 2520def RSCSLT(destination, source_x, source_y=None): 2521 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2522 if source_y is None: 2523 (destination, source_x, source_y) = (destination, destination, source_x) 2524 instruction = ArithmeticInstruction('RSCSLT', Operand(destination), Operand(source_x), Operand(source_y), 2525 origin=origin) 2526 if peachpy.stream.active_stream is not None: 2527 peachpy.stream.active_stream.add_instruction(instruction) 2528 return instruction 2529 2530 2531def RSCSGT(destination, source_x, source_y=None): 2532 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2533 if source_y is None: 2534 (destination, source_x, source_y) = (destination, destination, source_x) 2535 instruction = ArithmeticInstruction('RSCSGT', Operand(destination), Operand(source_x), Operand(source_y), 2536 origin=origin) 2537 if peachpy.stream.active_stream is not None: 2538 peachpy.stream.active_stream.add_instruction(instruction) 2539 return instruction 2540 2541 2542def RSCSLE(destination, source_x, source_y=None): 2543 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2544 if source_y is None: 2545 (destination, source_x, source_y) = (destination, destination, source_x) 2546 instruction = ArithmeticInstruction('RSCSLE', Operand(destination), Operand(source_x), Operand(source_y), 2547 origin=origin) 2548 if peachpy.stream.active_stream is not None: 2549 peachpy.stream.active_stream.add_instruction(instruction) 2550 return instruction 2551 2552 2553def AND(destination, source_x, source_y=None): 2554 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2555 if source_y is None: 2556 (destination, source_x, source_y) = (destination, destination, source_x) 2557 instruction = ArithmeticInstruction('AND', Operand(destination), Operand(source_x), Operand(source_y), 2558 origin=origin) 2559 if peachpy.stream.active_stream is not None: 2560 peachpy.stream.active_stream.add_instruction(instruction) 2561 return instruction 2562 2563 2564def ANDEQ(destination, source_x, source_y=None): 2565 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2566 if source_y is None: 2567 (destination, source_x, source_y) = (destination, destination, source_x) 2568 instruction = ArithmeticInstruction('ANDEQ', Operand(destination), Operand(source_x), Operand(source_y), 2569 origin=origin) 2570 if peachpy.stream.active_stream is not None: 2571 peachpy.stream.active_stream.add_instruction(instruction) 2572 return instruction 2573 2574 2575def ANDNE(destination, source_x, source_y=None): 2576 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2577 if source_y is None: 2578 (destination, source_x, source_y) = (destination, destination, source_x) 2579 instruction = ArithmeticInstruction('ANDNE', Operand(destination), Operand(source_x), Operand(source_y), 2580 origin=origin) 2581 if peachpy.stream.active_stream is not None: 2582 peachpy.stream.active_stream.add_instruction(instruction) 2583 return instruction 2584 2585 2586def ANDCS(destination, source_x, source_y=None): 2587 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2588 if source_y is None: 2589 (destination, source_x, source_y) = (destination, destination, source_x) 2590 instruction = ArithmeticInstruction('ANDCS', Operand(destination), Operand(source_x), Operand(source_y), 2591 origin=origin) 2592 if peachpy.stream.active_stream is not None: 2593 peachpy.stream.active_stream.add_instruction(instruction) 2594 return instruction 2595 2596 2597def ANDHS(destination, source_x, source_y=None): 2598 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2599 if source_y is None: 2600 (destination, source_x, source_y) = (destination, destination, source_x) 2601 instruction = ArithmeticInstruction('ANDHS', Operand(destination), Operand(source_x), Operand(source_y), 2602 origin=origin) 2603 if peachpy.stream.active_stream is not None: 2604 peachpy.stream.active_stream.add_instruction(instruction) 2605 return instruction 2606 2607 2608def ANDCC(destination, source_x, source_y=None): 2609 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2610 if source_y is None: 2611 (destination, source_x, source_y) = (destination, destination, source_x) 2612 instruction = ArithmeticInstruction('ANDCC', Operand(destination), Operand(source_x), Operand(source_y), 2613 origin=origin) 2614 if peachpy.stream.active_stream is not None: 2615 peachpy.stream.active_stream.add_instruction(instruction) 2616 return instruction 2617 2618 2619def ANDLO(destination, source_x, source_y=None): 2620 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2621 if source_y is None: 2622 (destination, source_x, source_y) = (destination, destination, source_x) 2623 instruction = ArithmeticInstruction('ANDLO', Operand(destination), Operand(source_x), Operand(source_y), 2624 origin=origin) 2625 if peachpy.stream.active_stream is not None: 2626 peachpy.stream.active_stream.add_instruction(instruction) 2627 return instruction 2628 2629 2630def ANDMI(destination, source_x, source_y=None): 2631 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2632 if source_y is None: 2633 (destination, source_x, source_y) = (destination, destination, source_x) 2634 instruction = ArithmeticInstruction('ANDMI', Operand(destination), Operand(source_x), Operand(source_y), 2635 origin=origin) 2636 if peachpy.stream.active_stream is not None: 2637 peachpy.stream.active_stream.add_instruction(instruction) 2638 return instruction 2639 2640 2641def ANDPL(destination, source_x, source_y=None): 2642 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2643 if source_y is None: 2644 (destination, source_x, source_y) = (destination, destination, source_x) 2645 instruction = ArithmeticInstruction('ANDPL', Operand(destination), Operand(source_x), Operand(source_y), 2646 origin=origin) 2647 if peachpy.stream.active_stream is not None: 2648 peachpy.stream.active_stream.add_instruction(instruction) 2649 return instruction 2650 2651 2652def ANDVS(destination, source_x, source_y=None): 2653 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2654 if source_y is None: 2655 (destination, source_x, source_y) = (destination, destination, source_x) 2656 instruction = ArithmeticInstruction('ANDVS', Operand(destination), Operand(source_x), Operand(source_y), 2657 origin=origin) 2658 if peachpy.stream.active_stream is not None: 2659 peachpy.stream.active_stream.add_instruction(instruction) 2660 return instruction 2661 2662 2663def ANDVC(destination, source_x, source_y=None): 2664 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2665 if source_y is None: 2666 (destination, source_x, source_y) = (destination, destination, source_x) 2667 instruction = ArithmeticInstruction('ANDVC', Operand(destination), Operand(source_x), Operand(source_y), 2668 origin=origin) 2669 if peachpy.stream.active_stream is not None: 2670 peachpy.stream.active_stream.add_instruction(instruction) 2671 return instruction 2672 2673 2674def ANDHI(destination, source_x, source_y=None): 2675 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2676 if source_y is None: 2677 (destination, source_x, source_y) = (destination, destination, source_x) 2678 instruction = ArithmeticInstruction('ANDHI', Operand(destination), Operand(source_x), Operand(source_y), 2679 origin=origin) 2680 if peachpy.stream.active_stream is not None: 2681 peachpy.stream.active_stream.add_instruction(instruction) 2682 return instruction 2683 2684 2685def ANDLS(destination, source_x, source_y=None): 2686 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2687 if source_y is None: 2688 (destination, source_x, source_y) = (destination, destination, source_x) 2689 instruction = ArithmeticInstruction('ANDLS', Operand(destination), Operand(source_x), Operand(source_y), 2690 origin=origin) 2691 if peachpy.stream.active_stream is not None: 2692 peachpy.stream.active_stream.add_instruction(instruction) 2693 return instruction 2694 2695 2696def ANDGE(destination, source_x, source_y=None): 2697 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2698 if source_y is None: 2699 (destination, source_x, source_y) = (destination, destination, source_x) 2700 instruction = ArithmeticInstruction('ANDGE', Operand(destination), Operand(source_x), Operand(source_y), 2701 origin=origin) 2702 if peachpy.stream.active_stream is not None: 2703 peachpy.stream.active_stream.add_instruction(instruction) 2704 return instruction 2705 2706 2707def ANDLT(destination, source_x, source_y=None): 2708 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2709 if source_y is None: 2710 (destination, source_x, source_y) = (destination, destination, source_x) 2711 instruction = ArithmeticInstruction('ANDLT', Operand(destination), Operand(source_x), Operand(source_y), 2712 origin=origin) 2713 if peachpy.stream.active_stream is not None: 2714 peachpy.stream.active_stream.add_instruction(instruction) 2715 return instruction 2716 2717 2718def ANDGT(destination, source_x, source_y=None): 2719 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2720 if source_y is None: 2721 (destination, source_x, source_y) = (destination, destination, source_x) 2722 instruction = ArithmeticInstruction('ANDGT', Operand(destination), Operand(source_x), Operand(source_y), 2723 origin=origin) 2724 if peachpy.stream.active_stream is not None: 2725 peachpy.stream.active_stream.add_instruction(instruction) 2726 return instruction 2727 2728 2729def ANDLE(destination, source_x, source_y=None): 2730 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2731 if source_y is None: 2732 (destination, source_x, source_y) = (destination, destination, source_x) 2733 instruction = ArithmeticInstruction('ANDLE', Operand(destination), Operand(source_x), Operand(source_y), 2734 origin=origin) 2735 if peachpy.stream.active_stream is not None: 2736 peachpy.stream.active_stream.add_instruction(instruction) 2737 return instruction 2738 2739 2740def ANDS(destination, source_x, source_y=None): 2741 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2742 if source_y is None: 2743 (destination, source_x, source_y) = (destination, destination, source_x) 2744 instruction = ArithmeticInstruction('ANDS', Operand(destination), Operand(source_x), Operand(source_y), 2745 origin=origin) 2746 if peachpy.stream.active_stream is not None: 2747 peachpy.stream.active_stream.add_instruction(instruction) 2748 return instruction 2749 2750 2751def ANDSEQ(destination, source_x, source_y=None): 2752 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2753 if source_y is None: 2754 (destination, source_x, source_y) = (destination, destination, source_x) 2755 instruction = ArithmeticInstruction('ANDSEQ', Operand(destination), Operand(source_x), Operand(source_y), 2756 origin=origin) 2757 if peachpy.stream.active_stream is not None: 2758 peachpy.stream.active_stream.add_instruction(instruction) 2759 return instruction 2760 2761 2762def ANDSNE(destination, source_x, source_y=None): 2763 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2764 if source_y is None: 2765 (destination, source_x, source_y) = (destination, destination, source_x) 2766 instruction = ArithmeticInstruction('ANDSNE', Operand(destination), Operand(source_x), Operand(source_y), 2767 origin=origin) 2768 if peachpy.stream.active_stream is not None: 2769 peachpy.stream.active_stream.add_instruction(instruction) 2770 return instruction 2771 2772 2773def ANDSCS(destination, source_x, source_y=None): 2774 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2775 if source_y is None: 2776 (destination, source_x, source_y) = (destination, destination, source_x) 2777 instruction = ArithmeticInstruction('ANDSCS', Operand(destination), Operand(source_x), Operand(source_y), 2778 origin=origin) 2779 if peachpy.stream.active_stream is not None: 2780 peachpy.stream.active_stream.add_instruction(instruction) 2781 return instruction 2782 2783 2784def ANDSHS(destination, source_x, source_y=None): 2785 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2786 if source_y is None: 2787 (destination, source_x, source_y) = (destination, destination, source_x) 2788 instruction = ArithmeticInstruction('ANDSHS', Operand(destination), Operand(source_x), Operand(source_y), 2789 origin=origin) 2790 if peachpy.stream.active_stream is not None: 2791 peachpy.stream.active_stream.add_instruction(instruction) 2792 return instruction 2793 2794 2795def ANDSCC(destination, source_x, source_y=None): 2796 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2797 if source_y is None: 2798 (destination, source_x, source_y) = (destination, destination, source_x) 2799 instruction = ArithmeticInstruction('ANDSCC', Operand(destination), Operand(source_x), Operand(source_y), 2800 origin=origin) 2801 if peachpy.stream.active_stream is not None: 2802 peachpy.stream.active_stream.add_instruction(instruction) 2803 return instruction 2804 2805 2806def ANDSLO(destination, source_x, source_y=None): 2807 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2808 if source_y is None: 2809 (destination, source_x, source_y) = (destination, destination, source_x) 2810 instruction = ArithmeticInstruction('ANDSLO', Operand(destination), Operand(source_x), Operand(source_y), 2811 origin=origin) 2812 if peachpy.stream.active_stream is not None: 2813 peachpy.stream.active_stream.add_instruction(instruction) 2814 return instruction 2815 2816 2817def ANDSMI(destination, source_x, source_y=None): 2818 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2819 if source_y is None: 2820 (destination, source_x, source_y) = (destination, destination, source_x) 2821 instruction = ArithmeticInstruction('ANDSMI', Operand(destination), Operand(source_x), Operand(source_y), 2822 origin=origin) 2823 if peachpy.stream.active_stream is not None: 2824 peachpy.stream.active_stream.add_instruction(instruction) 2825 return instruction 2826 2827 2828def ANDSPL(destination, source_x, source_y=None): 2829 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2830 if source_y is None: 2831 (destination, source_x, source_y) = (destination, destination, source_x) 2832 instruction = ArithmeticInstruction('ANDSPL', Operand(destination), Operand(source_x), Operand(source_y), 2833 origin=origin) 2834 if peachpy.stream.active_stream is not None: 2835 peachpy.stream.active_stream.add_instruction(instruction) 2836 return instruction 2837 2838 2839def ANDSVS(destination, source_x, source_y=None): 2840 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2841 if source_y is None: 2842 (destination, source_x, source_y) = (destination, destination, source_x) 2843 instruction = ArithmeticInstruction('ANDSVS', Operand(destination), Operand(source_x), Operand(source_y), 2844 origin=origin) 2845 if peachpy.stream.active_stream is not None: 2846 peachpy.stream.active_stream.add_instruction(instruction) 2847 return instruction 2848 2849 2850def ANDSVC(destination, source_x, source_y=None): 2851 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2852 if source_y is None: 2853 (destination, source_x, source_y) = (destination, destination, source_x) 2854 instruction = ArithmeticInstruction('ANDSVC', Operand(destination), Operand(source_x), Operand(source_y), 2855 origin=origin) 2856 if peachpy.stream.active_stream is not None: 2857 peachpy.stream.active_stream.add_instruction(instruction) 2858 return instruction 2859 2860 2861def ANDSHI(destination, source_x, source_y=None): 2862 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2863 if source_y is None: 2864 (destination, source_x, source_y) = (destination, destination, source_x) 2865 instruction = ArithmeticInstruction('ANDSHI', Operand(destination), Operand(source_x), Operand(source_y), 2866 origin=origin) 2867 if peachpy.stream.active_stream is not None: 2868 peachpy.stream.active_stream.add_instruction(instruction) 2869 return instruction 2870 2871 2872def ANDSLS(destination, source_x, source_y=None): 2873 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2874 if source_y is None: 2875 (destination, source_x, source_y) = (destination, destination, source_x) 2876 instruction = ArithmeticInstruction('ANDSLS', Operand(destination), Operand(source_x), Operand(source_y), 2877 origin=origin) 2878 if peachpy.stream.active_stream is not None: 2879 peachpy.stream.active_stream.add_instruction(instruction) 2880 return instruction 2881 2882 2883def ANDSGE(destination, source_x, source_y=None): 2884 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2885 if source_y is None: 2886 (destination, source_x, source_y) = (destination, destination, source_x) 2887 instruction = ArithmeticInstruction('ANDSGE', Operand(destination), Operand(source_x), Operand(source_y), 2888 origin=origin) 2889 if peachpy.stream.active_stream is not None: 2890 peachpy.stream.active_stream.add_instruction(instruction) 2891 return instruction 2892 2893 2894def ANDSLT(destination, source_x, source_y=None): 2895 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2896 if source_y is None: 2897 (destination, source_x, source_y) = (destination, destination, source_x) 2898 instruction = ArithmeticInstruction('ANDSLT', Operand(destination), Operand(source_x), Operand(source_y), 2899 origin=origin) 2900 if peachpy.stream.active_stream is not None: 2901 peachpy.stream.active_stream.add_instruction(instruction) 2902 return instruction 2903 2904 2905def ANDSGT(destination, source_x, source_y=None): 2906 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2907 if source_y is None: 2908 (destination, source_x, source_y) = (destination, destination, source_x) 2909 instruction = ArithmeticInstruction('ANDSGT', Operand(destination), Operand(source_x), Operand(source_y), 2910 origin=origin) 2911 if peachpy.stream.active_stream is not None: 2912 peachpy.stream.active_stream.add_instruction(instruction) 2913 return instruction 2914 2915 2916def ANDSLE(destination, source_x, source_y=None): 2917 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2918 if source_y is None: 2919 (destination, source_x, source_y) = (destination, destination, source_x) 2920 instruction = ArithmeticInstruction('ANDSLE', Operand(destination), Operand(source_x), Operand(source_y), 2921 origin=origin) 2922 if peachpy.stream.active_stream is not None: 2923 peachpy.stream.active_stream.add_instruction(instruction) 2924 return instruction 2925 2926 2927def BIC(destination, source_x, source_y=None): 2928 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2929 if source_y is None: 2930 (destination, source_x, source_y) = (destination, destination, source_x) 2931 instruction = ArithmeticInstruction('BIC', Operand(destination), Operand(source_x), Operand(source_y), 2932 origin=origin) 2933 if peachpy.stream.active_stream is not None: 2934 peachpy.stream.active_stream.add_instruction(instruction) 2935 return instruction 2936 2937 2938def BICEQ(destination, source_x, source_y=None): 2939 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2940 if source_y is None: 2941 (destination, source_x, source_y) = (destination, destination, source_x) 2942 instruction = ArithmeticInstruction('BICEQ', Operand(destination), Operand(source_x), Operand(source_y), 2943 origin=origin) 2944 if peachpy.stream.active_stream is not None: 2945 peachpy.stream.active_stream.add_instruction(instruction) 2946 return instruction 2947 2948 2949def BICNE(destination, source_x, source_y=None): 2950 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2951 if source_y is None: 2952 (destination, source_x, source_y) = (destination, destination, source_x) 2953 instruction = ArithmeticInstruction('BICNE', Operand(destination), Operand(source_x), Operand(source_y), 2954 origin=origin) 2955 if peachpy.stream.active_stream is not None: 2956 peachpy.stream.active_stream.add_instruction(instruction) 2957 return instruction 2958 2959 2960def BICCS(destination, source_x, source_y=None): 2961 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2962 if source_y is None: 2963 (destination, source_x, source_y) = (destination, destination, source_x) 2964 instruction = ArithmeticInstruction('BICCS', Operand(destination), Operand(source_x), Operand(source_y), 2965 origin=origin) 2966 if peachpy.stream.active_stream is not None: 2967 peachpy.stream.active_stream.add_instruction(instruction) 2968 return instruction 2969 2970 2971def BICHS(destination, source_x, source_y=None): 2972 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2973 if source_y is None: 2974 (destination, source_x, source_y) = (destination, destination, source_x) 2975 instruction = ArithmeticInstruction('BICHS', Operand(destination), Operand(source_x), Operand(source_y), 2976 origin=origin) 2977 if peachpy.stream.active_stream is not None: 2978 peachpy.stream.active_stream.add_instruction(instruction) 2979 return instruction 2980 2981 2982def BICCC(destination, source_x, source_y=None): 2983 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2984 if source_y is None: 2985 (destination, source_x, source_y) = (destination, destination, source_x) 2986 instruction = ArithmeticInstruction('BICCC', Operand(destination), Operand(source_x), Operand(source_y), 2987 origin=origin) 2988 if peachpy.stream.active_stream is not None: 2989 peachpy.stream.active_stream.add_instruction(instruction) 2990 return instruction 2991 2992 2993def BICLO(destination, source_x, source_y=None): 2994 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 2995 if source_y is None: 2996 (destination, source_x, source_y) = (destination, destination, source_x) 2997 instruction = ArithmeticInstruction('BICLO', Operand(destination), Operand(source_x), Operand(source_y), 2998 origin=origin) 2999 if peachpy.stream.active_stream is not None: 3000 peachpy.stream.active_stream.add_instruction(instruction) 3001 return instruction 3002 3003 3004def BICMI(destination, source_x, source_y=None): 3005 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3006 if source_y is None: 3007 (destination, source_x, source_y) = (destination, destination, source_x) 3008 instruction = ArithmeticInstruction('BICMI', Operand(destination), Operand(source_x), Operand(source_y), 3009 origin=origin) 3010 if peachpy.stream.active_stream is not None: 3011 peachpy.stream.active_stream.add_instruction(instruction) 3012 return instruction 3013 3014 3015def BICPL(destination, source_x, source_y=None): 3016 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3017 if source_y is None: 3018 (destination, source_x, source_y) = (destination, destination, source_x) 3019 instruction = ArithmeticInstruction('BICPL', Operand(destination), Operand(source_x), Operand(source_y), 3020 origin=origin) 3021 if peachpy.stream.active_stream is not None: 3022 peachpy.stream.active_stream.add_instruction(instruction) 3023 return instruction 3024 3025 3026def BICVS(destination, source_x, source_y=None): 3027 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3028 if source_y is None: 3029 (destination, source_x, source_y) = (destination, destination, source_x) 3030 instruction = ArithmeticInstruction('BICVS', Operand(destination), Operand(source_x), Operand(source_y), 3031 origin=origin) 3032 if peachpy.stream.active_stream is not None: 3033 peachpy.stream.active_stream.add_instruction(instruction) 3034 return instruction 3035 3036 3037def BICVC(destination, source_x, source_y=None): 3038 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3039 if source_y is None: 3040 (destination, source_x, source_y) = (destination, destination, source_x) 3041 instruction = ArithmeticInstruction('BICVC', Operand(destination), Operand(source_x), Operand(source_y), 3042 origin=origin) 3043 if peachpy.stream.active_stream is not None: 3044 peachpy.stream.active_stream.add_instruction(instruction) 3045 return instruction 3046 3047 3048def BICHI(destination, source_x, source_y=None): 3049 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3050 if source_y is None: 3051 (destination, source_x, source_y) = (destination, destination, source_x) 3052 instruction = ArithmeticInstruction('BICHI', Operand(destination), Operand(source_x), Operand(source_y), 3053 origin=origin) 3054 if peachpy.stream.active_stream is not None: 3055 peachpy.stream.active_stream.add_instruction(instruction) 3056 return instruction 3057 3058 3059def BICLS(destination, source_x, source_y=None): 3060 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3061 if source_y is None: 3062 (destination, source_x, source_y) = (destination, destination, source_x) 3063 instruction = ArithmeticInstruction('BICLS', Operand(destination), Operand(source_x), Operand(source_y), 3064 origin=origin) 3065 if peachpy.stream.active_stream is not None: 3066 peachpy.stream.active_stream.add_instruction(instruction) 3067 return instruction 3068 3069 3070def BICGE(destination, source_x, source_y=None): 3071 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3072 if source_y is None: 3073 (destination, source_x, source_y) = (destination, destination, source_x) 3074 instruction = ArithmeticInstruction('BICGE', Operand(destination), Operand(source_x), Operand(source_y), 3075 origin=origin) 3076 if peachpy.stream.active_stream is not None: 3077 peachpy.stream.active_stream.add_instruction(instruction) 3078 return instruction 3079 3080 3081def BICLT(destination, source_x, source_y=None): 3082 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3083 if source_y is None: 3084 (destination, source_x, source_y) = (destination, destination, source_x) 3085 instruction = ArithmeticInstruction('BICLT', Operand(destination), Operand(source_x), Operand(source_y), 3086 origin=origin) 3087 if peachpy.stream.active_stream is not None: 3088 peachpy.stream.active_stream.add_instruction(instruction) 3089 return instruction 3090 3091 3092def BICGT(destination, source_x, source_y=None): 3093 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3094 if source_y is None: 3095 (destination, source_x, source_y) = (destination, destination, source_x) 3096 instruction = ArithmeticInstruction('BICGT', Operand(destination), Operand(source_x), Operand(source_y), 3097 origin=origin) 3098 if peachpy.stream.active_stream is not None: 3099 peachpy.stream.active_stream.add_instruction(instruction) 3100 return instruction 3101 3102 3103def BICLE(destination, source_x, source_y=None): 3104 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3105 if source_y is None: 3106 (destination, source_x, source_y) = (destination, destination, source_x) 3107 instruction = ArithmeticInstruction('BICLE', Operand(destination), Operand(source_x), Operand(source_y), 3108 origin=origin) 3109 if peachpy.stream.active_stream is not None: 3110 peachpy.stream.active_stream.add_instruction(instruction) 3111 return instruction 3112 3113 3114def BICS(destination, source_x, source_y=None): 3115 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3116 if source_y is None: 3117 (destination, source_x, source_y) = (destination, destination, source_x) 3118 instruction = ArithmeticInstruction('BICS', Operand(destination), Operand(source_x), Operand(source_y), 3119 origin=origin) 3120 if peachpy.stream.active_stream is not None: 3121 peachpy.stream.active_stream.add_instruction(instruction) 3122 return instruction 3123 3124 3125def BICSEQ(destination, source_x, source_y=None): 3126 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3127 if source_y is None: 3128 (destination, source_x, source_y) = (destination, destination, source_x) 3129 instruction = ArithmeticInstruction('BICSEQ', Operand(destination), Operand(source_x), Operand(source_y), 3130 origin=origin) 3131 if peachpy.stream.active_stream is not None: 3132 peachpy.stream.active_stream.add_instruction(instruction) 3133 return instruction 3134 3135 3136def BICSNE(destination, source_x, source_y=None): 3137 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3138 if source_y is None: 3139 (destination, source_x, source_y) = (destination, destination, source_x) 3140 instruction = ArithmeticInstruction('BICSNE', Operand(destination), Operand(source_x), Operand(source_y), 3141 origin=origin) 3142 if peachpy.stream.active_stream is not None: 3143 peachpy.stream.active_stream.add_instruction(instruction) 3144 return instruction 3145 3146 3147def BICSCS(destination, source_x, source_y=None): 3148 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3149 if source_y is None: 3150 (destination, source_x, source_y) = (destination, destination, source_x) 3151 instruction = ArithmeticInstruction('BICSCS', Operand(destination), Operand(source_x), Operand(source_y), 3152 origin=origin) 3153 if peachpy.stream.active_stream is not None: 3154 peachpy.stream.active_stream.add_instruction(instruction) 3155 return instruction 3156 3157 3158def BICSHS(destination, source_x, source_y=None): 3159 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3160 if source_y is None: 3161 (destination, source_x, source_y) = (destination, destination, source_x) 3162 instruction = ArithmeticInstruction('BICSHS', Operand(destination), Operand(source_x), Operand(source_y), 3163 origin=origin) 3164 if peachpy.stream.active_stream is not None: 3165 peachpy.stream.active_stream.add_instruction(instruction) 3166 return instruction 3167 3168 3169def BICSCC(destination, source_x, source_y=None): 3170 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3171 if source_y is None: 3172 (destination, source_x, source_y) = (destination, destination, source_x) 3173 instruction = ArithmeticInstruction('BICSCC', Operand(destination), Operand(source_x), Operand(source_y), 3174 origin=origin) 3175 if peachpy.stream.active_stream is not None: 3176 peachpy.stream.active_stream.add_instruction(instruction) 3177 return instruction 3178 3179 3180def BICSLO(destination, source_x, source_y=None): 3181 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3182 if source_y is None: 3183 (destination, source_x, source_y) = (destination, destination, source_x) 3184 instruction = ArithmeticInstruction('BICSLO', Operand(destination), Operand(source_x), Operand(source_y), 3185 origin=origin) 3186 if peachpy.stream.active_stream is not None: 3187 peachpy.stream.active_stream.add_instruction(instruction) 3188 return instruction 3189 3190 3191def BICSMI(destination, source_x, source_y=None): 3192 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3193 if source_y is None: 3194 (destination, source_x, source_y) = (destination, destination, source_x) 3195 instruction = ArithmeticInstruction('BICSMI', Operand(destination), Operand(source_x), Operand(source_y), 3196 origin=origin) 3197 if peachpy.stream.active_stream is not None: 3198 peachpy.stream.active_stream.add_instruction(instruction) 3199 return instruction 3200 3201 3202def BICSPL(destination, source_x, source_y=None): 3203 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3204 if source_y is None: 3205 (destination, source_x, source_y) = (destination, destination, source_x) 3206 instruction = ArithmeticInstruction('BICSPL', Operand(destination), Operand(source_x), Operand(source_y), 3207 origin=origin) 3208 if peachpy.stream.active_stream is not None: 3209 peachpy.stream.active_stream.add_instruction(instruction) 3210 return instruction 3211 3212 3213def BICSVS(destination, source_x, source_y=None): 3214 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3215 if source_y is None: 3216 (destination, source_x, source_y) = (destination, destination, source_x) 3217 instruction = ArithmeticInstruction('BICSVS', Operand(destination), Operand(source_x), Operand(source_y), 3218 origin=origin) 3219 if peachpy.stream.active_stream is not None: 3220 peachpy.stream.active_stream.add_instruction(instruction) 3221 return instruction 3222 3223 3224def BICSVC(destination, source_x, source_y=None): 3225 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3226 if source_y is None: 3227 (destination, source_x, source_y) = (destination, destination, source_x) 3228 instruction = ArithmeticInstruction('BICSVC', Operand(destination), Operand(source_x), Operand(source_y), 3229 origin=origin) 3230 if peachpy.stream.active_stream is not None: 3231 peachpy.stream.active_stream.add_instruction(instruction) 3232 return instruction 3233 3234 3235def BICSHI(destination, source_x, source_y=None): 3236 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3237 if source_y is None: 3238 (destination, source_x, source_y) = (destination, destination, source_x) 3239 instruction = ArithmeticInstruction('BICSHI', Operand(destination), Operand(source_x), Operand(source_y), 3240 origin=origin) 3241 if peachpy.stream.active_stream is not None: 3242 peachpy.stream.active_stream.add_instruction(instruction) 3243 return instruction 3244 3245 3246def BICSLS(destination, source_x, source_y=None): 3247 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3248 if source_y is None: 3249 (destination, source_x, source_y) = (destination, destination, source_x) 3250 instruction = ArithmeticInstruction('BICSLS', Operand(destination), Operand(source_x), Operand(source_y), 3251 origin=origin) 3252 if peachpy.stream.active_stream is not None: 3253 peachpy.stream.active_stream.add_instruction(instruction) 3254 return instruction 3255 3256 3257def BICSGE(destination, source_x, source_y=None): 3258 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3259 if source_y is None: 3260 (destination, source_x, source_y) = (destination, destination, source_x) 3261 instruction = ArithmeticInstruction('BICSGE', Operand(destination), Operand(source_x), Operand(source_y), 3262 origin=origin) 3263 if peachpy.stream.active_stream is not None: 3264 peachpy.stream.active_stream.add_instruction(instruction) 3265 return instruction 3266 3267 3268def BICSLT(destination, source_x, source_y=None): 3269 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3270 if source_y is None: 3271 (destination, source_x, source_y) = (destination, destination, source_x) 3272 instruction = ArithmeticInstruction('BICSLT', Operand(destination), Operand(source_x), Operand(source_y), 3273 origin=origin) 3274 if peachpy.stream.active_stream is not None: 3275 peachpy.stream.active_stream.add_instruction(instruction) 3276 return instruction 3277 3278 3279def BICSGT(destination, source_x, source_y=None): 3280 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3281 if source_y is None: 3282 (destination, source_x, source_y) = (destination, destination, source_x) 3283 instruction = ArithmeticInstruction('BICSGT', Operand(destination), Operand(source_x), Operand(source_y), 3284 origin=origin) 3285 if peachpy.stream.active_stream is not None: 3286 peachpy.stream.active_stream.add_instruction(instruction) 3287 return instruction 3288 3289 3290def BICSLE(destination, source_x, source_y=None): 3291 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3292 if source_y is None: 3293 (destination, source_x, source_y) = (destination, destination, source_x) 3294 instruction = ArithmeticInstruction('BICSLE', Operand(destination), Operand(source_x), Operand(source_y), 3295 origin=origin) 3296 if peachpy.stream.active_stream is not None: 3297 peachpy.stream.active_stream.add_instruction(instruction) 3298 return instruction 3299 3300 3301def ORR(destination, source_x, source_y=None): 3302 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3303 if source_y is None: 3304 (destination, source_x, source_y) = (destination, destination, source_x) 3305 instruction = ArithmeticInstruction('ORR', Operand(destination), Operand(source_x), Operand(source_y), 3306 origin=origin) 3307 if peachpy.stream.active_stream is not None: 3308 peachpy.stream.active_stream.add_instruction(instruction) 3309 return instruction 3310 3311 3312def ORREQ(destination, source_x, source_y=None): 3313 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3314 if source_y is None: 3315 (destination, source_x, source_y) = (destination, destination, source_x) 3316 instruction = ArithmeticInstruction('ORREQ', Operand(destination), Operand(source_x), Operand(source_y), 3317 origin=origin) 3318 if peachpy.stream.active_stream is not None: 3319 peachpy.stream.active_stream.add_instruction(instruction) 3320 return instruction 3321 3322 3323def ORRNE(destination, source_x, source_y=None): 3324 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3325 if source_y is None: 3326 (destination, source_x, source_y) = (destination, destination, source_x) 3327 instruction = ArithmeticInstruction('ORRNE', Operand(destination), Operand(source_x), Operand(source_y), 3328 origin=origin) 3329 if peachpy.stream.active_stream is not None: 3330 peachpy.stream.active_stream.add_instruction(instruction) 3331 return instruction 3332 3333 3334def ORRCS(destination, source_x, source_y=None): 3335 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3336 if source_y is None: 3337 (destination, source_x, source_y) = (destination, destination, source_x) 3338 instruction = ArithmeticInstruction('ORRCS', Operand(destination), Operand(source_x), Operand(source_y), 3339 origin=origin) 3340 if peachpy.stream.active_stream is not None: 3341 peachpy.stream.active_stream.add_instruction(instruction) 3342 return instruction 3343 3344 3345def ORRHS(destination, source_x, source_y=None): 3346 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3347 if source_y is None: 3348 (destination, source_x, source_y) = (destination, destination, source_x) 3349 instruction = ArithmeticInstruction('ORRHS', Operand(destination), Operand(source_x), Operand(source_y), 3350 origin=origin) 3351 if peachpy.stream.active_stream is not None: 3352 peachpy.stream.active_stream.add_instruction(instruction) 3353 return instruction 3354 3355 3356def ORRCC(destination, source_x, source_y=None): 3357 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3358 if source_y is None: 3359 (destination, source_x, source_y) = (destination, destination, source_x) 3360 instruction = ArithmeticInstruction('ORRCC', Operand(destination), Operand(source_x), Operand(source_y), 3361 origin=origin) 3362 if peachpy.stream.active_stream is not None: 3363 peachpy.stream.active_stream.add_instruction(instruction) 3364 return instruction 3365 3366 3367def ORRLO(destination, source_x, source_y=None): 3368 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3369 if source_y is None: 3370 (destination, source_x, source_y) = (destination, destination, source_x) 3371 instruction = ArithmeticInstruction('ORRLO', Operand(destination), Operand(source_x), Operand(source_y), 3372 origin=origin) 3373 if peachpy.stream.active_stream is not None: 3374 peachpy.stream.active_stream.add_instruction(instruction) 3375 return instruction 3376 3377 3378def ORRMI(destination, source_x, source_y=None): 3379 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3380 if source_y is None: 3381 (destination, source_x, source_y) = (destination, destination, source_x) 3382 instruction = ArithmeticInstruction('ORRMI', Operand(destination), Operand(source_x), Operand(source_y), 3383 origin=origin) 3384 if peachpy.stream.active_stream is not None: 3385 peachpy.stream.active_stream.add_instruction(instruction) 3386 return instruction 3387 3388 3389def ORRPL(destination, source_x, source_y=None): 3390 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3391 if source_y is None: 3392 (destination, source_x, source_y) = (destination, destination, source_x) 3393 instruction = ArithmeticInstruction('ORRPL', Operand(destination), Operand(source_x), Operand(source_y), 3394 origin=origin) 3395 if peachpy.stream.active_stream is not None: 3396 peachpy.stream.active_stream.add_instruction(instruction) 3397 return instruction 3398 3399 3400def ORRVS(destination, source_x, source_y=None): 3401 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3402 if source_y is None: 3403 (destination, source_x, source_y) = (destination, destination, source_x) 3404 instruction = ArithmeticInstruction('ORRVS', Operand(destination), Operand(source_x), Operand(source_y), 3405 origin=origin) 3406 if peachpy.stream.active_stream is not None: 3407 peachpy.stream.active_stream.add_instruction(instruction) 3408 return instruction 3409 3410 3411def ORRVC(destination, source_x, source_y=None): 3412 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3413 if source_y is None: 3414 (destination, source_x, source_y) = (destination, destination, source_x) 3415 instruction = ArithmeticInstruction('ORRVC', Operand(destination), Operand(source_x), Operand(source_y), 3416 origin=origin) 3417 if peachpy.stream.active_stream is not None: 3418 peachpy.stream.active_stream.add_instruction(instruction) 3419 return instruction 3420 3421 3422def ORRHI(destination, source_x, source_y=None): 3423 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3424 if source_y is None: 3425 (destination, source_x, source_y) = (destination, destination, source_x) 3426 instruction = ArithmeticInstruction('ORRHI', Operand(destination), Operand(source_x), Operand(source_y), 3427 origin=origin) 3428 if peachpy.stream.active_stream is not None: 3429 peachpy.stream.active_stream.add_instruction(instruction) 3430 return instruction 3431 3432 3433def ORRLS(destination, source_x, source_y=None): 3434 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3435 if source_y is None: 3436 (destination, source_x, source_y) = (destination, destination, source_x) 3437 instruction = ArithmeticInstruction('ORRLS', Operand(destination), Operand(source_x), Operand(source_y), 3438 origin=origin) 3439 if peachpy.stream.active_stream is not None: 3440 peachpy.stream.active_stream.add_instruction(instruction) 3441 return instruction 3442 3443 3444def ORRGE(destination, source_x, source_y=None): 3445 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3446 if source_y is None: 3447 (destination, source_x, source_y) = (destination, destination, source_x) 3448 instruction = ArithmeticInstruction('ORRGE', Operand(destination), Operand(source_x), Operand(source_y), 3449 origin=origin) 3450 if peachpy.stream.active_stream is not None: 3451 peachpy.stream.active_stream.add_instruction(instruction) 3452 return instruction 3453 3454 3455def ORRLT(destination, source_x, source_y=None): 3456 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3457 if source_y is None: 3458 (destination, source_x, source_y) = (destination, destination, source_x) 3459 instruction = ArithmeticInstruction('ORRLT', Operand(destination), Operand(source_x), Operand(source_y), 3460 origin=origin) 3461 if peachpy.stream.active_stream is not None: 3462 peachpy.stream.active_stream.add_instruction(instruction) 3463 return instruction 3464 3465 3466def ORRGT(destination, source_x, source_y=None): 3467 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3468 if source_y is None: 3469 (destination, source_x, source_y) = (destination, destination, source_x) 3470 instruction = ArithmeticInstruction('ORRGT', Operand(destination), Operand(source_x), Operand(source_y), 3471 origin=origin) 3472 if peachpy.stream.active_stream is not None: 3473 peachpy.stream.active_stream.add_instruction(instruction) 3474 return instruction 3475 3476 3477def ORRLE(destination, source_x, source_y=None): 3478 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3479 if source_y is None: 3480 (destination, source_x, source_y) = (destination, destination, source_x) 3481 instruction = ArithmeticInstruction('ORRLE', Operand(destination), Operand(source_x), Operand(source_y), 3482 origin=origin) 3483 if peachpy.stream.active_stream is not None: 3484 peachpy.stream.active_stream.add_instruction(instruction) 3485 return instruction 3486 3487 3488def ORRS(destination, source_x, source_y=None): 3489 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3490 if source_y is None: 3491 (destination, source_x, source_y) = (destination, destination, source_x) 3492 instruction = ArithmeticInstruction('ORRS', Operand(destination), Operand(source_x), Operand(source_y), 3493 origin=origin) 3494 if peachpy.stream.active_stream is not None: 3495 peachpy.stream.active_stream.add_instruction(instruction) 3496 return instruction 3497 3498 3499def ORRSEQ(destination, source_x, source_y=None): 3500 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3501 if source_y is None: 3502 (destination, source_x, source_y) = (destination, destination, source_x) 3503 instruction = ArithmeticInstruction('ORRSEQ', Operand(destination), Operand(source_x), Operand(source_y), 3504 origin=origin) 3505 if peachpy.stream.active_stream is not None: 3506 peachpy.stream.active_stream.add_instruction(instruction) 3507 return instruction 3508 3509 3510def ORRSNE(destination, source_x, source_y=None): 3511 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3512 if source_y is None: 3513 (destination, source_x, source_y) = (destination, destination, source_x) 3514 instruction = ArithmeticInstruction('ORRSNE', Operand(destination), Operand(source_x), Operand(source_y), 3515 origin=origin) 3516 if peachpy.stream.active_stream is not None: 3517 peachpy.stream.active_stream.add_instruction(instruction) 3518 return instruction 3519 3520 3521def ORRSCS(destination, source_x, source_y=None): 3522 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3523 if source_y is None: 3524 (destination, source_x, source_y) = (destination, destination, source_x) 3525 instruction = ArithmeticInstruction('ORRSCS', Operand(destination), Operand(source_x), Operand(source_y), 3526 origin=origin) 3527 if peachpy.stream.active_stream is not None: 3528 peachpy.stream.active_stream.add_instruction(instruction) 3529 return instruction 3530 3531 3532def ORRSHS(destination, source_x, source_y=None): 3533 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3534 if source_y is None: 3535 (destination, source_x, source_y) = (destination, destination, source_x) 3536 instruction = ArithmeticInstruction('ORRSHS', Operand(destination), Operand(source_x), Operand(source_y), 3537 origin=origin) 3538 if peachpy.stream.active_stream is not None: 3539 peachpy.stream.active_stream.add_instruction(instruction) 3540 return instruction 3541 3542 3543def ORRSCC(destination, source_x, source_y=None): 3544 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3545 if source_y is None: 3546 (destination, source_x, source_y) = (destination, destination, source_x) 3547 instruction = ArithmeticInstruction('ORRSCC', Operand(destination), Operand(source_x), Operand(source_y), 3548 origin=origin) 3549 if peachpy.stream.active_stream is not None: 3550 peachpy.stream.active_stream.add_instruction(instruction) 3551 return instruction 3552 3553 3554def ORRSLO(destination, source_x, source_y=None): 3555 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3556 if source_y is None: 3557 (destination, source_x, source_y) = (destination, destination, source_x) 3558 instruction = ArithmeticInstruction('ORRSLO', Operand(destination), Operand(source_x), Operand(source_y), 3559 origin=origin) 3560 if peachpy.stream.active_stream is not None: 3561 peachpy.stream.active_stream.add_instruction(instruction) 3562 return instruction 3563 3564 3565def ORRSMI(destination, source_x, source_y=None): 3566 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3567 if source_y is None: 3568 (destination, source_x, source_y) = (destination, destination, source_x) 3569 instruction = ArithmeticInstruction('ORRSMI', Operand(destination), Operand(source_x), Operand(source_y), 3570 origin=origin) 3571 if peachpy.stream.active_stream is not None: 3572 peachpy.stream.active_stream.add_instruction(instruction) 3573 return instruction 3574 3575 3576def ORRSPL(destination, source_x, source_y=None): 3577 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3578 if source_y is None: 3579 (destination, source_x, source_y) = (destination, destination, source_x) 3580 instruction = ArithmeticInstruction('ORRSPL', Operand(destination), Operand(source_x), Operand(source_y), 3581 origin=origin) 3582 if peachpy.stream.active_stream is not None: 3583 peachpy.stream.active_stream.add_instruction(instruction) 3584 return instruction 3585 3586 3587def ORRSVS(destination, source_x, source_y=None): 3588 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3589 if source_y is None: 3590 (destination, source_x, source_y) = (destination, destination, source_x) 3591 instruction = ArithmeticInstruction('ORRSVS', Operand(destination), Operand(source_x), Operand(source_y), 3592 origin=origin) 3593 if peachpy.stream.active_stream is not None: 3594 peachpy.stream.active_stream.add_instruction(instruction) 3595 return instruction 3596 3597 3598def ORRSVC(destination, source_x, source_y=None): 3599 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3600 if source_y is None: 3601 (destination, source_x, source_y) = (destination, destination, source_x) 3602 instruction = ArithmeticInstruction('ORRSVC', Operand(destination), Operand(source_x), Operand(source_y), 3603 origin=origin) 3604 if peachpy.stream.active_stream is not None: 3605 peachpy.stream.active_stream.add_instruction(instruction) 3606 return instruction 3607 3608 3609def ORRSHI(destination, source_x, source_y=None): 3610 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3611 if source_y is None: 3612 (destination, source_x, source_y) = (destination, destination, source_x) 3613 instruction = ArithmeticInstruction('ORRSHI', Operand(destination), Operand(source_x), Operand(source_y), 3614 origin=origin) 3615 if peachpy.stream.active_stream is not None: 3616 peachpy.stream.active_stream.add_instruction(instruction) 3617 return instruction 3618 3619 3620def ORRSLS(destination, source_x, source_y=None): 3621 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3622 if source_y is None: 3623 (destination, source_x, source_y) = (destination, destination, source_x) 3624 instruction = ArithmeticInstruction('ORRSLS', Operand(destination), Operand(source_x), Operand(source_y), 3625 origin=origin) 3626 if peachpy.stream.active_stream is not None: 3627 peachpy.stream.active_stream.add_instruction(instruction) 3628 return instruction 3629 3630 3631def ORRSGE(destination, source_x, source_y=None): 3632 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3633 if source_y is None: 3634 (destination, source_x, source_y) = (destination, destination, source_x) 3635 instruction = ArithmeticInstruction('ORRSGE', Operand(destination), Operand(source_x), Operand(source_y), 3636 origin=origin) 3637 if peachpy.stream.active_stream is not None: 3638 peachpy.stream.active_stream.add_instruction(instruction) 3639 return instruction 3640 3641 3642def ORRSLT(destination, source_x, source_y=None): 3643 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3644 if source_y is None: 3645 (destination, source_x, source_y) = (destination, destination, source_x) 3646 instruction = ArithmeticInstruction('ORRSLT', Operand(destination), Operand(source_x), Operand(source_y), 3647 origin=origin) 3648 if peachpy.stream.active_stream is not None: 3649 peachpy.stream.active_stream.add_instruction(instruction) 3650 return instruction 3651 3652 3653def ORRSGT(destination, source_x, source_y=None): 3654 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3655 if source_y is None: 3656 (destination, source_x, source_y) = (destination, destination, source_x) 3657 instruction = ArithmeticInstruction('ORRSGT', Operand(destination), Operand(source_x), Operand(source_y), 3658 origin=origin) 3659 if peachpy.stream.active_stream is not None: 3660 peachpy.stream.active_stream.add_instruction(instruction) 3661 return instruction 3662 3663 3664def ORRSLE(destination, source_x, source_y=None): 3665 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3666 if source_y is None: 3667 (destination, source_x, source_y) = (destination, destination, source_x) 3668 instruction = ArithmeticInstruction('ORRSLE', Operand(destination), Operand(source_x), Operand(source_y), 3669 origin=origin) 3670 if peachpy.stream.active_stream is not None: 3671 peachpy.stream.active_stream.add_instruction(instruction) 3672 return instruction 3673 3674 3675def EOR(destination, source_x, source_y=None): 3676 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3677 if source_y is None: 3678 (destination, source_x, source_y) = (destination, destination, source_x) 3679 instruction = ArithmeticInstruction('EOR', Operand(destination), Operand(source_x), Operand(source_y), 3680 origin=origin) 3681 if peachpy.stream.active_stream is not None: 3682 peachpy.stream.active_stream.add_instruction(instruction) 3683 return instruction 3684 3685 3686def EOREQ(destination, source_x, source_y=None): 3687 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3688 if source_y is None: 3689 (destination, source_x, source_y) = (destination, destination, source_x) 3690 instruction = ArithmeticInstruction('EOREQ', Operand(destination), Operand(source_x), Operand(source_y), 3691 origin=origin) 3692 if peachpy.stream.active_stream is not None: 3693 peachpy.stream.active_stream.add_instruction(instruction) 3694 return instruction 3695 3696 3697def EORNE(destination, source_x, source_y=None): 3698 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3699 if source_y is None: 3700 (destination, source_x, source_y) = (destination, destination, source_x) 3701 instruction = ArithmeticInstruction('EORNE', Operand(destination), Operand(source_x), Operand(source_y), 3702 origin=origin) 3703 if peachpy.stream.active_stream is not None: 3704 peachpy.stream.active_stream.add_instruction(instruction) 3705 return instruction 3706 3707 3708def EORCS(destination, source_x, source_y=None): 3709 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3710 if source_y is None: 3711 (destination, source_x, source_y) = (destination, destination, source_x) 3712 instruction = ArithmeticInstruction('EORCS', Operand(destination), Operand(source_x), Operand(source_y), 3713 origin=origin) 3714 if peachpy.stream.active_stream is not None: 3715 peachpy.stream.active_stream.add_instruction(instruction) 3716 return instruction 3717 3718 3719def EORHS(destination, source_x, source_y=None): 3720 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3721 if source_y is None: 3722 (destination, source_x, source_y) = (destination, destination, source_x) 3723 instruction = ArithmeticInstruction('EORHS', Operand(destination), Operand(source_x), Operand(source_y), 3724 origin=origin) 3725 if peachpy.stream.active_stream is not None: 3726 peachpy.stream.active_stream.add_instruction(instruction) 3727 return instruction 3728 3729 3730def EORCC(destination, source_x, source_y=None): 3731 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3732 if source_y is None: 3733 (destination, source_x, source_y) = (destination, destination, source_x) 3734 instruction = ArithmeticInstruction('EORCC', Operand(destination), Operand(source_x), Operand(source_y), 3735 origin=origin) 3736 if peachpy.stream.active_stream is not None: 3737 peachpy.stream.active_stream.add_instruction(instruction) 3738 return instruction 3739 3740 3741def EORLO(destination, source_x, source_y=None): 3742 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3743 if source_y is None: 3744 (destination, source_x, source_y) = (destination, destination, source_x) 3745 instruction = ArithmeticInstruction('EORLO', Operand(destination), Operand(source_x), Operand(source_y), 3746 origin=origin) 3747 if peachpy.stream.active_stream is not None: 3748 peachpy.stream.active_stream.add_instruction(instruction) 3749 return instruction 3750 3751 3752def EORMI(destination, source_x, source_y=None): 3753 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3754 if source_y is None: 3755 (destination, source_x, source_y) = (destination, destination, source_x) 3756 instruction = ArithmeticInstruction('EORMI', Operand(destination), Operand(source_x), Operand(source_y), 3757 origin=origin) 3758 if peachpy.stream.active_stream is not None: 3759 peachpy.stream.active_stream.add_instruction(instruction) 3760 return instruction 3761 3762 3763def EORPL(destination, source_x, source_y=None): 3764 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3765 if source_y is None: 3766 (destination, source_x, source_y) = (destination, destination, source_x) 3767 instruction = ArithmeticInstruction('EORPL', Operand(destination), Operand(source_x), Operand(source_y), 3768 origin=origin) 3769 if peachpy.stream.active_stream is not None: 3770 peachpy.stream.active_stream.add_instruction(instruction) 3771 return instruction 3772 3773 3774def EORVS(destination, source_x, source_y=None): 3775 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3776 if source_y is None: 3777 (destination, source_x, source_y) = (destination, destination, source_x) 3778 instruction = ArithmeticInstruction('EORVS', Operand(destination), Operand(source_x), Operand(source_y), 3779 origin=origin) 3780 if peachpy.stream.active_stream is not None: 3781 peachpy.stream.active_stream.add_instruction(instruction) 3782 return instruction 3783 3784 3785def EORVC(destination, source_x, source_y=None): 3786 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3787 if source_y is None: 3788 (destination, source_x, source_y) = (destination, destination, source_x) 3789 instruction = ArithmeticInstruction('EORVC', Operand(destination), Operand(source_x), Operand(source_y), 3790 origin=origin) 3791 if peachpy.stream.active_stream is not None: 3792 peachpy.stream.active_stream.add_instruction(instruction) 3793 return instruction 3794 3795 3796def EORHI(destination, source_x, source_y=None): 3797 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3798 if source_y is None: 3799 (destination, source_x, source_y) = (destination, destination, source_x) 3800 instruction = ArithmeticInstruction('EORHI', Operand(destination), Operand(source_x), Operand(source_y), 3801 origin=origin) 3802 if peachpy.stream.active_stream is not None: 3803 peachpy.stream.active_stream.add_instruction(instruction) 3804 return instruction 3805 3806 3807def EORLS(destination, source_x, source_y=None): 3808 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3809 if source_y is None: 3810 (destination, source_x, source_y) = (destination, destination, source_x) 3811 instruction = ArithmeticInstruction('EORLS', Operand(destination), Operand(source_x), Operand(source_y), 3812 origin=origin) 3813 if peachpy.stream.active_stream is not None: 3814 peachpy.stream.active_stream.add_instruction(instruction) 3815 return instruction 3816 3817 3818def EORGE(destination, source_x, source_y=None): 3819 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3820 if source_y is None: 3821 (destination, source_x, source_y) = (destination, destination, source_x) 3822 instruction = ArithmeticInstruction('EORGE', Operand(destination), Operand(source_x), Operand(source_y), 3823 origin=origin) 3824 if peachpy.stream.active_stream is not None: 3825 peachpy.stream.active_stream.add_instruction(instruction) 3826 return instruction 3827 3828 3829def EORLT(destination, source_x, source_y=None): 3830 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3831 if source_y is None: 3832 (destination, source_x, source_y) = (destination, destination, source_x) 3833 instruction = ArithmeticInstruction('EORLT', Operand(destination), Operand(source_x), Operand(source_y), 3834 origin=origin) 3835 if peachpy.stream.active_stream is not None: 3836 peachpy.stream.active_stream.add_instruction(instruction) 3837 return instruction 3838 3839 3840def EORGT(destination, source_x, source_y=None): 3841 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3842 if source_y is None: 3843 (destination, source_x, source_y) = (destination, destination, source_x) 3844 instruction = ArithmeticInstruction('EORGT', Operand(destination), Operand(source_x), Operand(source_y), 3845 origin=origin) 3846 if peachpy.stream.active_stream is not None: 3847 peachpy.stream.active_stream.add_instruction(instruction) 3848 return instruction 3849 3850 3851def EORLE(destination, source_x, source_y=None): 3852 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3853 if source_y is None: 3854 (destination, source_x, source_y) = (destination, destination, source_x) 3855 instruction = ArithmeticInstruction('EORLE', Operand(destination), Operand(source_x), Operand(source_y), 3856 origin=origin) 3857 if peachpy.stream.active_stream is not None: 3858 peachpy.stream.active_stream.add_instruction(instruction) 3859 return instruction 3860 3861 3862def EORS(destination, source_x, source_y=None): 3863 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3864 if source_y is None: 3865 (destination, source_x, source_y) = (destination, destination, source_x) 3866 instruction = ArithmeticInstruction('EORS', Operand(destination), Operand(source_x), Operand(source_y), 3867 origin=origin) 3868 if peachpy.stream.active_stream is not None: 3869 peachpy.stream.active_stream.add_instruction(instruction) 3870 return instruction 3871 3872 3873def EORSEQ(destination, source_x, source_y=None): 3874 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3875 if source_y is None: 3876 (destination, source_x, source_y) = (destination, destination, source_x) 3877 instruction = ArithmeticInstruction('EORSEQ', Operand(destination), Operand(source_x), Operand(source_y), 3878 origin=origin) 3879 if peachpy.stream.active_stream is not None: 3880 peachpy.stream.active_stream.add_instruction(instruction) 3881 return instruction 3882 3883 3884def EORSNE(destination, source_x, source_y=None): 3885 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3886 if source_y is None: 3887 (destination, source_x, source_y) = (destination, destination, source_x) 3888 instruction = ArithmeticInstruction('EORSNE', Operand(destination), Operand(source_x), Operand(source_y), 3889 origin=origin) 3890 if peachpy.stream.active_stream is not None: 3891 peachpy.stream.active_stream.add_instruction(instruction) 3892 return instruction 3893 3894 3895def EORSCS(destination, source_x, source_y=None): 3896 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3897 if source_y is None: 3898 (destination, source_x, source_y) = (destination, destination, source_x) 3899 instruction = ArithmeticInstruction('EORSCS', Operand(destination), Operand(source_x), Operand(source_y), 3900 origin=origin) 3901 if peachpy.stream.active_stream is not None: 3902 peachpy.stream.active_stream.add_instruction(instruction) 3903 return instruction 3904 3905 3906def EORSHS(destination, source_x, source_y=None): 3907 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3908 if source_y is None: 3909 (destination, source_x, source_y) = (destination, destination, source_x) 3910 instruction = ArithmeticInstruction('EORSHS', Operand(destination), Operand(source_x), Operand(source_y), 3911 origin=origin) 3912 if peachpy.stream.active_stream is not None: 3913 peachpy.stream.active_stream.add_instruction(instruction) 3914 return instruction 3915 3916 3917def EORSCC(destination, source_x, source_y=None): 3918 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3919 if source_y is None: 3920 (destination, source_x, source_y) = (destination, destination, source_x) 3921 instruction = ArithmeticInstruction('EORSCC', Operand(destination), Operand(source_x), Operand(source_y), 3922 origin=origin) 3923 if peachpy.stream.active_stream is not None: 3924 peachpy.stream.active_stream.add_instruction(instruction) 3925 return instruction 3926 3927 3928def EORSLO(destination, source_x, source_y=None): 3929 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3930 if source_y is None: 3931 (destination, source_x, source_y) = (destination, destination, source_x) 3932 instruction = ArithmeticInstruction('EORSLO', Operand(destination), Operand(source_x), Operand(source_y), 3933 origin=origin) 3934 if peachpy.stream.active_stream is not None: 3935 peachpy.stream.active_stream.add_instruction(instruction) 3936 return instruction 3937 3938 3939def EORSMI(destination, source_x, source_y=None): 3940 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3941 if source_y is None: 3942 (destination, source_x, source_y) = (destination, destination, source_x) 3943 instruction = ArithmeticInstruction('EORSMI', Operand(destination), Operand(source_x), Operand(source_y), 3944 origin=origin) 3945 if peachpy.stream.active_stream is not None: 3946 peachpy.stream.active_stream.add_instruction(instruction) 3947 return instruction 3948 3949 3950def EORSPL(destination, source_x, source_y=None): 3951 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3952 if source_y is None: 3953 (destination, source_x, source_y) = (destination, destination, source_x) 3954 instruction = ArithmeticInstruction('EORSPL', Operand(destination), Operand(source_x), Operand(source_y), 3955 origin=origin) 3956 if peachpy.stream.active_stream is not None: 3957 peachpy.stream.active_stream.add_instruction(instruction) 3958 return instruction 3959 3960 3961def EORSVS(destination, source_x, source_y=None): 3962 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3963 if source_y is None: 3964 (destination, source_x, source_y) = (destination, destination, source_x) 3965 instruction = ArithmeticInstruction('EORSVS', Operand(destination), Operand(source_x), Operand(source_y), 3966 origin=origin) 3967 if peachpy.stream.active_stream is not None: 3968 peachpy.stream.active_stream.add_instruction(instruction) 3969 return instruction 3970 3971 3972def EORSVC(destination, source_x, source_y=None): 3973 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3974 if source_y is None: 3975 (destination, source_x, source_y) = (destination, destination, source_x) 3976 instruction = ArithmeticInstruction('EORSVC', Operand(destination), Operand(source_x), Operand(source_y), 3977 origin=origin) 3978 if peachpy.stream.active_stream is not None: 3979 peachpy.stream.active_stream.add_instruction(instruction) 3980 return instruction 3981 3982 3983def EORSHI(destination, source_x, source_y=None): 3984 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3985 if source_y is None: 3986 (destination, source_x, source_y) = (destination, destination, source_x) 3987 instruction = ArithmeticInstruction('EORSHI', Operand(destination), Operand(source_x), Operand(source_y), 3988 origin=origin) 3989 if peachpy.stream.active_stream is not None: 3990 peachpy.stream.active_stream.add_instruction(instruction) 3991 return instruction 3992 3993 3994def EORSLS(destination, source_x, source_y=None): 3995 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 3996 if source_y is None: 3997 (destination, source_x, source_y) = (destination, destination, source_x) 3998 instruction = ArithmeticInstruction('EORSLS', Operand(destination), Operand(source_x), Operand(source_y), 3999 origin=origin) 4000 if peachpy.stream.active_stream is not None: 4001 peachpy.stream.active_stream.add_instruction(instruction) 4002 return instruction 4003 4004 4005def EORSGE(destination, source_x, source_y=None): 4006 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4007 if source_y is None: 4008 (destination, source_x, source_y) = (destination, destination, source_x) 4009 instruction = ArithmeticInstruction('EORSGE', Operand(destination), Operand(source_x), Operand(source_y), 4010 origin=origin) 4011 if peachpy.stream.active_stream is not None: 4012 peachpy.stream.active_stream.add_instruction(instruction) 4013 return instruction 4014 4015 4016def EORSLT(destination, source_x, source_y=None): 4017 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4018 if source_y is None: 4019 (destination, source_x, source_y) = (destination, destination, source_x) 4020 instruction = ArithmeticInstruction('EORSLT', Operand(destination), Operand(source_x), Operand(source_y), 4021 origin=origin) 4022 if peachpy.stream.active_stream is not None: 4023 peachpy.stream.active_stream.add_instruction(instruction) 4024 return instruction 4025 4026 4027def EORSGT(destination, source_x, source_y=None): 4028 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4029 if source_y is None: 4030 (destination, source_x, source_y) = (destination, destination, source_x) 4031 instruction = ArithmeticInstruction('EORSGT', Operand(destination), Operand(source_x), Operand(source_y), 4032 origin=origin) 4033 if peachpy.stream.active_stream is not None: 4034 peachpy.stream.active_stream.add_instruction(instruction) 4035 return instruction 4036 4037 4038def EORSLE(destination, source_x, source_y=None): 4039 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4040 if source_y is None: 4041 (destination, source_x, source_y) = (destination, destination, source_x) 4042 instruction = ArithmeticInstruction('EORSLE', Operand(destination), Operand(source_x), Operand(source_y), 4043 origin=origin) 4044 if peachpy.stream.active_stream is not None: 4045 peachpy.stream.active_stream.add_instruction(instruction) 4046 return instruction 4047 4048 4049def LSL(destination, source_x, source_y=None): 4050 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4051 if source_y is None: 4052 (destination, source_x, source_y) = (destination, destination, source_x) 4053 instruction = ShiftInstruction('LSL', Operand(destination), Operand(source_x), Operand(source_y), origin=origin) 4054 if peachpy.stream.active_stream is not None: 4055 peachpy.stream.active_stream.add_instruction(instruction) 4056 return instruction 4057 4058 4059def LSR(destination, source_x, source_y=None): 4060 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4061 if source_y is None: 4062 (destination, source_x, source_y) = (destination, destination, source_x) 4063 instruction = ShiftInstruction('LSR', Operand(destination), Operand(source_x), Operand(source_y), origin=origin) 4064 if peachpy.stream.active_stream is not None: 4065 peachpy.stream.active_stream.add_instruction(instruction) 4066 return instruction 4067 4068 4069def ASR(destination, source_x, source_y=None): 4070 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4071 if source_y is None: 4072 (destination, source_x, source_y) = (destination, destination, source_x) 4073 instruction = ShiftInstruction('ASR', Operand(destination), Operand(source_x), Operand(source_y), origin=origin) 4074 if peachpy.stream.active_stream is not None: 4075 peachpy.stream.active_stream.add_instruction(instruction) 4076 return instruction 4077 4078 4079def CMP(source_x, source_y): 4080 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4081 instruction = CompareInstruction('CMP', Operand(source_x), Operand(source_y), origin=origin) 4082 if peachpy.stream.active_stream is not None: 4083 peachpy.stream.active_stream.add_instruction(instruction) 4084 return instruction 4085 4086 4087def CMPEQ(source_x, source_y): 4088 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4089 instruction = CompareInstruction('CMPEQ', Operand(source_x), Operand(source_y), origin=origin) 4090 if peachpy.stream.active_stream is not None: 4091 peachpy.stream.active_stream.add_instruction(instruction) 4092 return instruction 4093 4094 4095def CMPNE(source_x, source_y): 4096 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4097 instruction = CompareInstruction('CMPNE', Operand(source_x), Operand(source_y), origin=origin) 4098 if peachpy.stream.active_stream is not None: 4099 peachpy.stream.active_stream.add_instruction(instruction) 4100 return instruction 4101 4102 4103def CMPCS(source_x, source_y): 4104 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4105 instruction = CompareInstruction('CMPCS', Operand(source_x), Operand(source_y), origin=origin) 4106 if peachpy.stream.active_stream is not None: 4107 peachpy.stream.active_stream.add_instruction(instruction) 4108 return instruction 4109 4110 4111def CMPHS(source_x, source_y): 4112 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4113 instruction = CompareInstruction('CMPHS', Operand(source_x), Operand(source_y), origin=origin) 4114 if peachpy.stream.active_stream is not None: 4115 peachpy.stream.active_stream.add_instruction(instruction) 4116 return instruction 4117 4118 4119def CMPCC(source_x, source_y): 4120 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4121 instruction = CompareInstruction('CMPCC', Operand(source_x), Operand(source_y), origin=origin) 4122 if peachpy.stream.active_stream is not None: 4123 peachpy.stream.active_stream.add_instruction(instruction) 4124 return instruction 4125 4126 4127def CMPLO(source_x, source_y): 4128 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4129 instruction = CompareInstruction('CMPLO', Operand(source_x), Operand(source_y), origin=origin) 4130 if peachpy.stream.active_stream is not None: 4131 peachpy.stream.active_stream.add_instruction(instruction) 4132 return instruction 4133 4134 4135def CMPMI(source_x, source_y): 4136 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4137 instruction = CompareInstruction('CMPMI', Operand(source_x), Operand(source_y), origin=origin) 4138 if peachpy.stream.active_stream is not None: 4139 peachpy.stream.active_stream.add_instruction(instruction) 4140 return instruction 4141 4142 4143def CMPPL(source_x, source_y): 4144 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4145 instruction = CompareInstruction('CMPPL', Operand(source_x), Operand(source_y), origin=origin) 4146 if peachpy.stream.active_stream is not None: 4147 peachpy.stream.active_stream.add_instruction(instruction) 4148 return instruction 4149 4150 4151def CMPVS(source_x, source_y): 4152 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4153 instruction = CompareInstruction('CMPVS', Operand(source_x), Operand(source_y), origin=origin) 4154 if peachpy.stream.active_stream is not None: 4155 peachpy.stream.active_stream.add_instruction(instruction) 4156 return instruction 4157 4158 4159def CMPVC(source_x, source_y): 4160 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4161 instruction = CompareInstruction('CMPVC', Operand(source_x), Operand(source_y), origin=origin) 4162 if peachpy.stream.active_stream is not None: 4163 peachpy.stream.active_stream.add_instruction(instruction) 4164 return instruction 4165 4166 4167def CMPHI(source_x, source_y): 4168 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4169 instruction = CompareInstruction('CMPHI', Operand(source_x), Operand(source_y), origin=origin) 4170 if peachpy.stream.active_stream is not None: 4171 peachpy.stream.active_stream.add_instruction(instruction) 4172 return instruction 4173 4174 4175def CMPLS(source_x, source_y): 4176 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4177 instruction = CompareInstruction('CMPLS', Operand(source_x), Operand(source_y), origin=origin) 4178 if peachpy.stream.active_stream is not None: 4179 peachpy.stream.active_stream.add_instruction(instruction) 4180 return instruction 4181 4182 4183def CMPGE(source_x, source_y): 4184 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4185 instruction = CompareInstruction('CMPGE', Operand(source_x), Operand(source_y), origin=origin) 4186 if peachpy.stream.active_stream is not None: 4187 peachpy.stream.active_stream.add_instruction(instruction) 4188 return instruction 4189 4190 4191def CMPLT(source_x, source_y): 4192 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4193 instruction = CompareInstruction('CMPLT', Operand(source_x), Operand(source_y), origin=origin) 4194 if peachpy.stream.active_stream is not None: 4195 peachpy.stream.active_stream.add_instruction(instruction) 4196 return instruction 4197 4198 4199def CMPGT(source_x, source_y): 4200 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4201 instruction = CompareInstruction('CMPGT', Operand(source_x), Operand(source_y), origin=origin) 4202 if peachpy.stream.active_stream is not None: 4203 peachpy.stream.active_stream.add_instruction(instruction) 4204 return instruction 4205 4206 4207def CMPLE(source_x, source_y): 4208 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4209 instruction = CompareInstruction('CMPLE', Operand(source_x), Operand(source_y), origin=origin) 4210 if peachpy.stream.active_stream is not None: 4211 peachpy.stream.active_stream.add_instruction(instruction) 4212 return instruction 4213 4214 4215def CMN(source_x, source_y): 4216 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4217 instruction = CompareInstruction('CMN', Operand(source_x), Operand(source_y), origin=origin) 4218 if peachpy.stream.active_stream is not None: 4219 peachpy.stream.active_stream.add_instruction(instruction) 4220 return instruction 4221 4222 4223def CMNEQ(source_x, source_y): 4224 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4225 instruction = CompareInstruction('CMNEQ', Operand(source_x), Operand(source_y), origin=origin) 4226 if peachpy.stream.active_stream is not None: 4227 peachpy.stream.active_stream.add_instruction(instruction) 4228 return instruction 4229 4230 4231def CMNNE(source_x, source_y): 4232 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4233 instruction = CompareInstruction('CMNNE', Operand(source_x), Operand(source_y), origin=origin) 4234 if peachpy.stream.active_stream is not None: 4235 peachpy.stream.active_stream.add_instruction(instruction) 4236 return instruction 4237 4238 4239def CMNCS(source_x, source_y): 4240 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4241 instruction = CompareInstruction('CMNCS', Operand(source_x), Operand(source_y), origin=origin) 4242 if peachpy.stream.active_stream is not None: 4243 peachpy.stream.active_stream.add_instruction(instruction) 4244 return instruction 4245 4246 4247def CMNHS(source_x, source_y): 4248 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4249 instruction = CompareInstruction('CMNHS', Operand(source_x), Operand(source_y), origin=origin) 4250 if peachpy.stream.active_stream is not None: 4251 peachpy.stream.active_stream.add_instruction(instruction) 4252 return instruction 4253 4254 4255def CMNCC(source_x, source_y): 4256 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4257 instruction = CompareInstruction('CMNCC', Operand(source_x), Operand(source_y), origin=origin) 4258 if peachpy.stream.active_stream is not None: 4259 peachpy.stream.active_stream.add_instruction(instruction) 4260 return instruction 4261 4262 4263def CMNLO(source_x, source_y): 4264 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4265 instruction = CompareInstruction('CMNLO', Operand(source_x), Operand(source_y), origin=origin) 4266 if peachpy.stream.active_stream is not None: 4267 peachpy.stream.active_stream.add_instruction(instruction) 4268 return instruction 4269 4270 4271def CMNMI(source_x, source_y): 4272 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4273 instruction = CompareInstruction('CMNMI', Operand(source_x), Operand(source_y), origin=origin) 4274 if peachpy.stream.active_stream is not None: 4275 peachpy.stream.active_stream.add_instruction(instruction) 4276 return instruction 4277 4278 4279def CMNPL(source_x, source_y): 4280 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4281 instruction = CompareInstruction('CMNPL', Operand(source_x), Operand(source_y), origin=origin) 4282 if peachpy.stream.active_stream is not None: 4283 peachpy.stream.active_stream.add_instruction(instruction) 4284 return instruction 4285 4286 4287def CMNVS(source_x, source_y): 4288 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4289 instruction = CompareInstruction('CMNVS', Operand(source_x), Operand(source_y), origin=origin) 4290 if peachpy.stream.active_stream is not None: 4291 peachpy.stream.active_stream.add_instruction(instruction) 4292 return instruction 4293 4294 4295def CMNVC(source_x, source_y): 4296 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4297 instruction = CompareInstruction('CMNVC', Operand(source_x), Operand(source_y), origin=origin) 4298 if peachpy.stream.active_stream is not None: 4299 peachpy.stream.active_stream.add_instruction(instruction) 4300 return instruction 4301 4302 4303def CMNHI(source_x, source_y): 4304 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4305 instruction = CompareInstruction('CMNHI', Operand(source_x), Operand(source_y), origin=origin) 4306 if peachpy.stream.active_stream is not None: 4307 peachpy.stream.active_stream.add_instruction(instruction) 4308 return instruction 4309 4310 4311def CMNLS(source_x, source_y): 4312 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4313 instruction = CompareInstruction('CMNLS', Operand(source_x), Operand(source_y), origin=origin) 4314 if peachpy.stream.active_stream is not None: 4315 peachpy.stream.active_stream.add_instruction(instruction) 4316 return instruction 4317 4318 4319def CMNGE(source_x, source_y): 4320 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4321 instruction = CompareInstruction('CMNGE', Operand(source_x), Operand(source_y), origin=origin) 4322 if peachpy.stream.active_stream is not None: 4323 peachpy.stream.active_stream.add_instruction(instruction) 4324 return instruction 4325 4326 4327def CMNLT(source_x, source_y): 4328 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4329 instruction = CompareInstruction('CMNLT', Operand(source_x), Operand(source_y), origin=origin) 4330 if peachpy.stream.active_stream is not None: 4331 peachpy.stream.active_stream.add_instruction(instruction) 4332 return instruction 4333 4334 4335def CMNGT(source_x, source_y): 4336 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4337 instruction = CompareInstruction('CMNGT', Operand(source_x), Operand(source_y), origin=origin) 4338 if peachpy.stream.active_stream is not None: 4339 peachpy.stream.active_stream.add_instruction(instruction) 4340 return instruction 4341 4342 4343def CMNLE(source_x, source_y): 4344 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4345 instruction = CompareInstruction('CMNLE', Operand(source_x), Operand(source_y), origin=origin) 4346 if peachpy.stream.active_stream is not None: 4347 peachpy.stream.active_stream.add_instruction(instruction) 4348 return instruction 4349 4350 4351def TST(source_x, source_y): 4352 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4353 instruction = CompareInstruction('TST', Operand(source_x), Operand(source_y), origin=origin) 4354 if peachpy.stream.active_stream is not None: 4355 peachpy.stream.active_stream.add_instruction(instruction) 4356 return instruction 4357 4358 4359def TSTEQ(source_x, source_y): 4360 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4361 instruction = CompareInstruction('TSTEQ', Operand(source_x), Operand(source_y), origin=origin) 4362 if peachpy.stream.active_stream is not None: 4363 peachpy.stream.active_stream.add_instruction(instruction) 4364 return instruction 4365 4366 4367def TSTNE(source_x, source_y): 4368 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4369 instruction = CompareInstruction('TSTNE', Operand(source_x), Operand(source_y), origin=origin) 4370 if peachpy.stream.active_stream is not None: 4371 peachpy.stream.active_stream.add_instruction(instruction) 4372 return instruction 4373 4374 4375def TSTCS(source_x, source_y): 4376 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4377 instruction = CompareInstruction('TSTCS', Operand(source_x), Operand(source_y), origin=origin) 4378 if peachpy.stream.active_stream is not None: 4379 peachpy.stream.active_stream.add_instruction(instruction) 4380 return instruction 4381 4382 4383def TSTHS(source_x, source_y): 4384 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4385 instruction = CompareInstruction('TSTHS', Operand(source_x), Operand(source_y), origin=origin) 4386 if peachpy.stream.active_stream is not None: 4387 peachpy.stream.active_stream.add_instruction(instruction) 4388 return instruction 4389 4390 4391def TSTCC(source_x, source_y): 4392 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4393 instruction = CompareInstruction('TSTCC', Operand(source_x), Operand(source_y), origin=origin) 4394 if peachpy.stream.active_stream is not None: 4395 peachpy.stream.active_stream.add_instruction(instruction) 4396 return instruction 4397 4398 4399def TSTLO(source_x, source_y): 4400 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4401 instruction = CompareInstruction('TSTLO', Operand(source_x), Operand(source_y), origin=origin) 4402 if peachpy.stream.active_stream is not None: 4403 peachpy.stream.active_stream.add_instruction(instruction) 4404 return instruction 4405 4406 4407def TSTMI(source_x, source_y): 4408 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4409 instruction = CompareInstruction('TSTMI', Operand(source_x), Operand(source_y), origin=origin) 4410 if peachpy.stream.active_stream is not None: 4411 peachpy.stream.active_stream.add_instruction(instruction) 4412 return instruction 4413 4414 4415def TSTPL(source_x, source_y): 4416 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4417 instruction = CompareInstruction('TSTPL', Operand(source_x), Operand(source_y), origin=origin) 4418 if peachpy.stream.active_stream is not None: 4419 peachpy.stream.active_stream.add_instruction(instruction) 4420 return instruction 4421 4422 4423def TSTVS(source_x, source_y): 4424 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4425 instruction = CompareInstruction('TSTVS', Operand(source_x), Operand(source_y), origin=origin) 4426 if peachpy.stream.active_stream is not None: 4427 peachpy.stream.active_stream.add_instruction(instruction) 4428 return instruction 4429 4430 4431def TSTVC(source_x, source_y): 4432 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4433 instruction = CompareInstruction('TSTVC', Operand(source_x), Operand(source_y), origin=origin) 4434 if peachpy.stream.active_stream is not None: 4435 peachpy.stream.active_stream.add_instruction(instruction) 4436 return instruction 4437 4438 4439def TSTHI(source_x, source_y): 4440 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4441 instruction = CompareInstruction('TSTHI', Operand(source_x), Operand(source_y), origin=origin) 4442 if peachpy.stream.active_stream is not None: 4443 peachpy.stream.active_stream.add_instruction(instruction) 4444 return instruction 4445 4446 4447def TSTLS(source_x, source_y): 4448 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4449 instruction = CompareInstruction('TSTLS', Operand(source_x), Operand(source_y), origin=origin) 4450 if peachpy.stream.active_stream is not None: 4451 peachpy.stream.active_stream.add_instruction(instruction) 4452 return instruction 4453 4454 4455def TSTGE(source_x, source_y): 4456 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4457 instruction = CompareInstruction('TSTGE', Operand(source_x), Operand(source_y), origin=origin) 4458 if peachpy.stream.active_stream is not None: 4459 peachpy.stream.active_stream.add_instruction(instruction) 4460 return instruction 4461 4462 4463def TSTLT(source_x, source_y): 4464 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4465 instruction = CompareInstruction('TSTLT', Operand(source_x), Operand(source_y), origin=origin) 4466 if peachpy.stream.active_stream is not None: 4467 peachpy.stream.active_stream.add_instruction(instruction) 4468 return instruction 4469 4470 4471def TSTGT(source_x, source_y): 4472 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4473 instruction = CompareInstruction('TSTGT', Operand(source_x), Operand(source_y), origin=origin) 4474 if peachpy.stream.active_stream is not None: 4475 peachpy.stream.active_stream.add_instruction(instruction) 4476 return instruction 4477 4478 4479def TSTLE(source_x, source_y): 4480 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4481 instruction = CompareInstruction('TSTLE', Operand(source_x), Operand(source_y), origin=origin) 4482 if peachpy.stream.active_stream is not None: 4483 peachpy.stream.active_stream.add_instruction(instruction) 4484 return instruction 4485 4486 4487def TEQ(source_x, source_y): 4488 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4489 instruction = CompareInstruction('TEQ', Operand(source_x), Operand(source_y), origin=origin) 4490 if peachpy.stream.active_stream is not None: 4491 peachpy.stream.active_stream.add_instruction(instruction) 4492 return instruction 4493 4494 4495def TEQEQ(source_x, source_y): 4496 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4497 instruction = CompareInstruction('TEQEQ', Operand(source_x), Operand(source_y), origin=origin) 4498 if peachpy.stream.active_stream is not None: 4499 peachpy.stream.active_stream.add_instruction(instruction) 4500 return instruction 4501 4502 4503def TEQNE(source_x, source_y): 4504 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4505 instruction = CompareInstruction('TEQNE', Operand(source_x), Operand(source_y), origin=origin) 4506 if peachpy.stream.active_stream is not None: 4507 peachpy.stream.active_stream.add_instruction(instruction) 4508 return instruction 4509 4510 4511def TEQCS(source_x, source_y): 4512 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4513 instruction = CompareInstruction('TEQCS', Operand(source_x), Operand(source_y), origin=origin) 4514 if peachpy.stream.active_stream is not None: 4515 peachpy.stream.active_stream.add_instruction(instruction) 4516 return instruction 4517 4518 4519def TEQHS(source_x, source_y): 4520 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4521 instruction = CompareInstruction('TEQHS', Operand(source_x), Operand(source_y), origin=origin) 4522 if peachpy.stream.active_stream is not None: 4523 peachpy.stream.active_stream.add_instruction(instruction) 4524 return instruction 4525 4526 4527def TEQCC(source_x, source_y): 4528 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4529 instruction = CompareInstruction('TEQCC', Operand(source_x), Operand(source_y), origin=origin) 4530 if peachpy.stream.active_stream is not None: 4531 peachpy.stream.active_stream.add_instruction(instruction) 4532 return instruction 4533 4534 4535def TEQLO(source_x, source_y): 4536 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4537 instruction = CompareInstruction('TEQLO', Operand(source_x), Operand(source_y), origin=origin) 4538 if peachpy.stream.active_stream is not None: 4539 peachpy.stream.active_stream.add_instruction(instruction) 4540 return instruction 4541 4542 4543def TEQMI(source_x, source_y): 4544 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4545 instruction = CompareInstruction('TEQMI', Operand(source_x), Operand(source_y), origin=origin) 4546 if peachpy.stream.active_stream is not None: 4547 peachpy.stream.active_stream.add_instruction(instruction) 4548 return instruction 4549 4550 4551def TEQPL(source_x, source_y): 4552 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4553 instruction = CompareInstruction('TEQPL', Operand(source_x), Operand(source_y), origin=origin) 4554 if peachpy.stream.active_stream is not None: 4555 peachpy.stream.active_stream.add_instruction(instruction) 4556 return instruction 4557 4558 4559def TEQVS(source_x, source_y): 4560 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4561 instruction = CompareInstruction('TEQVS', Operand(source_x), Operand(source_y), origin=origin) 4562 if peachpy.stream.active_stream is not None: 4563 peachpy.stream.active_stream.add_instruction(instruction) 4564 return instruction 4565 4566 4567def TEQVC(source_x, source_y): 4568 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4569 instruction = CompareInstruction('TEQVC', Operand(source_x), Operand(source_y), origin=origin) 4570 if peachpy.stream.active_stream is not None: 4571 peachpy.stream.active_stream.add_instruction(instruction) 4572 return instruction 4573 4574 4575def TEQHI(source_x, source_y): 4576 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4577 instruction = CompareInstruction('TEQHI', Operand(source_x), Operand(source_y), origin=origin) 4578 if peachpy.stream.active_stream is not None: 4579 peachpy.stream.active_stream.add_instruction(instruction) 4580 return instruction 4581 4582 4583def TEQLS(source_x, source_y): 4584 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4585 instruction = CompareInstruction('TEQLS', Operand(source_x), Operand(source_y), origin=origin) 4586 if peachpy.stream.active_stream is not None: 4587 peachpy.stream.active_stream.add_instruction(instruction) 4588 return instruction 4589 4590 4591def TEQGE(source_x, source_y): 4592 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4593 instruction = CompareInstruction('TEQGE', Operand(source_x), Operand(source_y), origin=origin) 4594 if peachpy.stream.active_stream is not None: 4595 peachpy.stream.active_stream.add_instruction(instruction) 4596 return instruction 4597 4598 4599def TEQLT(source_x, source_y): 4600 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4601 instruction = CompareInstruction('TEQLT', Operand(source_x), Operand(source_y), origin=origin) 4602 if peachpy.stream.active_stream is not None: 4603 peachpy.stream.active_stream.add_instruction(instruction) 4604 return instruction 4605 4606 4607def TEQGT(source_x, source_y): 4608 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4609 instruction = CompareInstruction('TEQGT', Operand(source_x), Operand(source_y), origin=origin) 4610 if peachpy.stream.active_stream is not None: 4611 peachpy.stream.active_stream.add_instruction(instruction) 4612 return instruction 4613 4614 4615def TEQLE(source_x, source_y): 4616 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4617 instruction = CompareInstruction('TEQLE', Operand(source_x), Operand(source_y), origin=origin) 4618 if peachpy.stream.active_stream is not None: 4619 peachpy.stream.active_stream.add_instruction(instruction) 4620 return instruction 4621 4622 4623def MOV(destination, source): 4624 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4625 instruction = MovInstruction('MOV', Operand(destination), Operand(source), origin=origin) 4626 if peachpy.stream.active_stream is not None: 4627 peachpy.stream.active_stream.add_instruction(instruction) 4628 return instruction 4629 4630 4631def MOVEQ(destination, source): 4632 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4633 instruction = MovInstruction('MOVEQ', Operand(destination), Operand(source), origin=origin) 4634 if peachpy.stream.active_stream is not None: 4635 peachpy.stream.active_stream.add_instruction(instruction) 4636 return instruction 4637 4638 4639def MOVNE(destination, source): 4640 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4641 instruction = MovInstruction('MOVNE', Operand(destination), Operand(source), origin=origin) 4642 if peachpy.stream.active_stream is not None: 4643 peachpy.stream.active_stream.add_instruction(instruction) 4644 return instruction 4645 4646 4647def MOVCS(destination, source): 4648 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4649 instruction = MovInstruction('MOVCS', Operand(destination), Operand(source), origin=origin) 4650 if peachpy.stream.active_stream is not None: 4651 peachpy.stream.active_stream.add_instruction(instruction) 4652 return instruction 4653 4654 4655def MOVHS(destination, source): 4656 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4657 instruction = MovInstruction('MOVHS', Operand(destination), Operand(source), origin=origin) 4658 if peachpy.stream.active_stream is not None: 4659 peachpy.stream.active_stream.add_instruction(instruction) 4660 return instruction 4661 4662 4663def MOVCC(destination, source): 4664 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4665 instruction = MovInstruction('MOVCC', Operand(destination), Operand(source), origin=origin) 4666 if peachpy.stream.active_stream is not None: 4667 peachpy.stream.active_stream.add_instruction(instruction) 4668 return instruction 4669 4670 4671def MOVLO(destination, source): 4672 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4673 instruction = MovInstruction('MOVLO', Operand(destination), Operand(source), origin=origin) 4674 if peachpy.stream.active_stream is not None: 4675 peachpy.stream.active_stream.add_instruction(instruction) 4676 return instruction 4677 4678 4679def MOVMI(destination, source): 4680 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4681 instruction = MovInstruction('MOVMI', Operand(destination), Operand(source), origin=origin) 4682 if peachpy.stream.active_stream is not None: 4683 peachpy.stream.active_stream.add_instruction(instruction) 4684 return instruction 4685 4686 4687def MOVPL(destination, source): 4688 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4689 instruction = MovInstruction('MOVPL', Operand(destination), Operand(source), origin=origin) 4690 if peachpy.stream.active_stream is not None: 4691 peachpy.stream.active_stream.add_instruction(instruction) 4692 return instruction 4693 4694 4695def MOVVS(destination, source): 4696 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4697 instruction = MovInstruction('MOVVS', Operand(destination), Operand(source), origin=origin) 4698 if peachpy.stream.active_stream is not None: 4699 peachpy.stream.active_stream.add_instruction(instruction) 4700 return instruction 4701 4702 4703def MOVVC(destination, source): 4704 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4705 instruction = MovInstruction('MOVVC', Operand(destination), Operand(source), origin=origin) 4706 if peachpy.stream.active_stream is not None: 4707 peachpy.stream.active_stream.add_instruction(instruction) 4708 return instruction 4709 4710 4711def MOVHI(destination, source): 4712 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4713 instruction = MovInstruction('MOVHI', Operand(destination), Operand(source), origin=origin) 4714 if peachpy.stream.active_stream is not None: 4715 peachpy.stream.active_stream.add_instruction(instruction) 4716 return instruction 4717 4718 4719def MOVLS(destination, source): 4720 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4721 instruction = MovInstruction('MOVLS', Operand(destination), Operand(source), origin=origin) 4722 if peachpy.stream.active_stream is not None: 4723 peachpy.stream.active_stream.add_instruction(instruction) 4724 return instruction 4725 4726 4727def MOVGE(destination, source): 4728 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4729 instruction = MovInstruction('MOVGE', Operand(destination), Operand(source), origin=origin) 4730 if peachpy.stream.active_stream is not None: 4731 peachpy.stream.active_stream.add_instruction(instruction) 4732 return instruction 4733 4734 4735def MOVLT(destination, source): 4736 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4737 instruction = MovInstruction('MOVLT', Operand(destination), Operand(source), origin=origin) 4738 if peachpy.stream.active_stream is not None: 4739 peachpy.stream.active_stream.add_instruction(instruction) 4740 return instruction 4741 4742 4743def MOVGT(destination, source): 4744 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4745 instruction = MovInstruction('MOVGT', Operand(destination), Operand(source), origin=origin) 4746 if peachpy.stream.active_stream is not None: 4747 peachpy.stream.active_stream.add_instruction(instruction) 4748 return instruction 4749 4750 4751def MOVLE(destination, source): 4752 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4753 instruction = MovInstruction('MOVLE', Operand(destination), Operand(source), origin=origin) 4754 if peachpy.stream.active_stream is not None: 4755 peachpy.stream.active_stream.add_instruction(instruction) 4756 return instruction 4757 4758 4759def MOVS(destination, source): 4760 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4761 instruction = MovInstruction('MOVS', Operand(destination), Operand(source), origin=origin) 4762 if peachpy.stream.active_stream is not None: 4763 peachpy.stream.active_stream.add_instruction(instruction) 4764 return instruction 4765 4766 4767def MOVSEQ(destination, source): 4768 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4769 instruction = MovInstruction('MOVSEQ', Operand(destination), Operand(source), origin=origin) 4770 if peachpy.stream.active_stream is not None: 4771 peachpy.stream.active_stream.add_instruction(instruction) 4772 return instruction 4773 4774 4775def MOVSNE(destination, source): 4776 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4777 instruction = MovInstruction('MOVSNE', Operand(destination), Operand(source), origin=origin) 4778 if peachpy.stream.active_stream is not None: 4779 peachpy.stream.active_stream.add_instruction(instruction) 4780 return instruction 4781 4782 4783def MOVSCS(destination, source): 4784 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4785 instruction = MovInstruction('MOVSCS', Operand(destination), Operand(source), origin=origin) 4786 if peachpy.stream.active_stream is not None: 4787 peachpy.stream.active_stream.add_instruction(instruction) 4788 return instruction 4789 4790 4791def MOVSHS(destination, source): 4792 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4793 instruction = MovInstruction('MOVSHS', Operand(destination), Operand(source), origin=origin) 4794 if peachpy.stream.active_stream is not None: 4795 peachpy.stream.active_stream.add_instruction(instruction) 4796 return instruction 4797 4798 4799def MOVSCC(destination, source): 4800 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4801 instruction = MovInstruction('MOVSCC', Operand(destination), Operand(source), origin=origin) 4802 if peachpy.stream.active_stream is not None: 4803 peachpy.stream.active_stream.add_instruction(instruction) 4804 return instruction 4805 4806 4807def MOVSLO(destination, source): 4808 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4809 instruction = MovInstruction('MOVSLO', Operand(destination), Operand(source), origin=origin) 4810 if peachpy.stream.active_stream is not None: 4811 peachpy.stream.active_stream.add_instruction(instruction) 4812 return instruction 4813 4814 4815def MOVSMI(destination, source): 4816 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4817 instruction = MovInstruction('MOVSMI', Operand(destination), Operand(source), origin=origin) 4818 if peachpy.stream.active_stream is not None: 4819 peachpy.stream.active_stream.add_instruction(instruction) 4820 return instruction 4821 4822 4823def MOVSPL(destination, source): 4824 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4825 instruction = MovInstruction('MOVSPL', Operand(destination), Operand(source), origin=origin) 4826 if peachpy.stream.active_stream is not None: 4827 peachpy.stream.active_stream.add_instruction(instruction) 4828 return instruction 4829 4830 4831def MOVSVS(destination, source): 4832 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4833 instruction = MovInstruction('MOVSVS', Operand(destination), Operand(source), origin=origin) 4834 if peachpy.stream.active_stream is not None: 4835 peachpy.stream.active_stream.add_instruction(instruction) 4836 return instruction 4837 4838 4839def MOVSVC(destination, source): 4840 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4841 instruction = MovInstruction('MOVSVC', Operand(destination), Operand(source), origin=origin) 4842 if peachpy.stream.active_stream is not None: 4843 peachpy.stream.active_stream.add_instruction(instruction) 4844 return instruction 4845 4846 4847def MOVSHI(destination, source): 4848 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4849 instruction = MovInstruction('MOVSHI', Operand(destination), Operand(source), origin=origin) 4850 if peachpy.stream.active_stream is not None: 4851 peachpy.stream.active_stream.add_instruction(instruction) 4852 return instruction 4853 4854 4855def MOVSLS(destination, source): 4856 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4857 instruction = MovInstruction('MOVSLS', Operand(destination), Operand(source), origin=origin) 4858 if peachpy.stream.active_stream is not None: 4859 peachpy.stream.active_stream.add_instruction(instruction) 4860 return instruction 4861 4862 4863def MOVSGE(destination, source): 4864 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4865 instruction = MovInstruction('MOVSGE', Operand(destination), Operand(source), origin=origin) 4866 if peachpy.stream.active_stream is not None: 4867 peachpy.stream.active_stream.add_instruction(instruction) 4868 return instruction 4869 4870 4871def MOVSLT(destination, source): 4872 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4873 instruction = MovInstruction('MOVSLT', Operand(destination), Operand(source), origin=origin) 4874 if peachpy.stream.active_stream is not None: 4875 peachpy.stream.active_stream.add_instruction(instruction) 4876 return instruction 4877 4878 4879def MOVSGT(destination, source): 4880 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4881 instruction = MovInstruction('MOVSGT', Operand(destination), Operand(source), origin=origin) 4882 if peachpy.stream.active_stream is not None: 4883 peachpy.stream.active_stream.add_instruction(instruction) 4884 return instruction 4885 4886 4887def MOVSLE(destination, source): 4888 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4889 instruction = MovInstruction('MOVSLE', Operand(destination), Operand(source), origin=origin) 4890 if peachpy.stream.active_stream is not None: 4891 peachpy.stream.active_stream.add_instruction(instruction) 4892 return instruction 4893 4894 4895def PUSH(register_list): 4896 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4897 instruction = PushPopInstruction('PUSH', Operand(register_list), origin=origin) 4898 if peachpy.stream.active_stream is not None: 4899 peachpy.stream.active_stream.add_instruction(instruction) 4900 return instruction 4901 4902 4903def POP(register_list): 4904 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4905 instruction = PushPopInstruction('POP', Operand(register_list), origin=origin) 4906 if peachpy.stream.active_stream is not None: 4907 peachpy.stream.active_stream.add_instruction(instruction) 4908 return instruction 4909 4910 4911def LDR(register, address, increment=None): 4912 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4913 instruction = LoadStoreInstruction('LDR', Operand(register), Operand(address), Operand(increment), origin=origin) 4914 if peachpy.stream.active_stream is not None: 4915 peachpy.stream.active_stream.add_instruction(instruction) 4916 return instruction 4917 4918 4919def STR(register, address, increment=None): 4920 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4921 instruction = LoadStoreInstruction('STR', Operand(register), Operand(address), Operand(increment), origin=origin) 4922 if peachpy.stream.active_stream is not None: 4923 peachpy.stream.active_stream.add_instruction(instruction) 4924 return instruction 4925 4926 4927def LDRH(register, address, increment=None): 4928 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4929 instruction = LoadStoreInstruction('LDRH', Operand(register), Operand(address), Operand(increment), origin=origin) 4930 if peachpy.stream.active_stream is not None: 4931 peachpy.stream.active_stream.add_instruction(instruction) 4932 return instruction 4933 4934 4935def LDRSH(register, address, increment=None): 4936 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4937 instruction = LoadStoreInstruction('LDRSH', Operand(register), Operand(address), Operand(increment), origin=origin) 4938 if peachpy.stream.active_stream is not None: 4939 peachpy.stream.active_stream.add_instruction(instruction) 4940 return instruction 4941 4942 4943def STRH(register, address, increment=None): 4944 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4945 instruction = LoadStoreInstruction('STRH', Operand(register), Operand(address), Operand(increment), origin=origin) 4946 if peachpy.stream.active_stream is not None: 4947 peachpy.stream.active_stream.add_instruction(instruction) 4948 return instruction 4949 4950 4951def LDRB(register, address, increment=None): 4952 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4953 instruction = LoadStoreInstruction('LDRB', Operand(register), Operand(address), Operand(increment), origin=origin) 4954 if peachpy.stream.active_stream is not None: 4955 peachpy.stream.active_stream.add_instruction(instruction) 4956 return instruction 4957 4958 4959def LDRSB(register, address, increment=None): 4960 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4961 instruction = LoadStoreInstruction('LDRSB', Operand(register), Operand(address), Operand(increment), origin=origin) 4962 if peachpy.stream.active_stream is not None: 4963 peachpy.stream.active_stream.add_instruction(instruction) 4964 return instruction 4965 4966 4967def STRB(register, address, increment=None): 4968 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4969 instruction = LoadStoreInstruction('STRB', Operand(register), Operand(address), Operand(increment), origin=origin) 4970 if peachpy.stream.active_stream is not None: 4971 peachpy.stream.active_stream.add_instruction(instruction) 4972 return instruction 4973 4974 4975def B(destination): 4976 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4977 instruction = BranchInstruction('B', Operand(destination), origin=origin) 4978 if peachpy.stream.active_stream is not None: 4979 peachpy.stream.active_stream.add_instruction(instruction) 4980 return instruction 4981 4982 4983def BEQ(destination): 4984 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4985 instruction = BranchInstruction('BEQ', Operand(destination), origin=origin) 4986 if peachpy.stream.active_stream is not None: 4987 peachpy.stream.active_stream.add_instruction(instruction) 4988 return instruction 4989 4990 4991def BNE(destination): 4992 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 4993 instruction = BranchInstruction('BNE', Operand(destination), origin=origin) 4994 if peachpy.stream.active_stream is not None: 4995 peachpy.stream.active_stream.add_instruction(instruction) 4996 return instruction 4997 4998 4999def BCS(destination): 5000 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5001 instruction = BranchInstruction('BCS', Operand(destination), origin=origin) 5002 if peachpy.stream.active_stream is not None: 5003 peachpy.stream.active_stream.add_instruction(instruction) 5004 return instruction 5005 5006 5007def BHS(destination): 5008 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5009 instruction = BranchInstruction('BHS', Operand(destination), origin=origin) 5010 if peachpy.stream.active_stream is not None: 5011 peachpy.stream.active_stream.add_instruction(instruction) 5012 return instruction 5013 5014 5015def BCC(destination): 5016 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5017 instruction = BranchInstruction('BCC', Operand(destination), origin=origin) 5018 if peachpy.stream.active_stream is not None: 5019 peachpy.stream.active_stream.add_instruction(instruction) 5020 return instruction 5021 5022 5023def BLO(destination): 5024 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5025 instruction = BranchInstruction('BLO', Operand(destination), origin=origin) 5026 if peachpy.stream.active_stream is not None: 5027 peachpy.stream.active_stream.add_instruction(instruction) 5028 return instruction 5029 5030 5031def BMI(destination): 5032 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5033 instruction = BranchInstruction('BMI', Operand(destination), origin=origin) 5034 if peachpy.stream.active_stream is not None: 5035 peachpy.stream.active_stream.add_instruction(instruction) 5036 return instruction 5037 5038 5039def BPL(destination): 5040 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5041 instruction = BranchInstruction('BPL', Operand(destination), origin=origin) 5042 if peachpy.stream.active_stream is not None: 5043 peachpy.stream.active_stream.add_instruction(instruction) 5044 return instruction 5045 5046 5047def BVS(destination): 5048 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5049 instruction = BranchInstruction('BVS', Operand(destination), origin=origin) 5050 if peachpy.stream.active_stream is not None: 5051 peachpy.stream.active_stream.add_instruction(instruction) 5052 return instruction 5053 5054 5055def BVC(destination): 5056 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5057 instruction = BranchInstruction('BVC', Operand(destination), origin=origin) 5058 if peachpy.stream.active_stream is not None: 5059 peachpy.stream.active_stream.add_instruction(instruction) 5060 return instruction 5061 5062 5063def BHI(destination): 5064 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5065 instruction = BranchInstruction('BHI', Operand(destination), origin=origin) 5066 if peachpy.stream.active_stream is not None: 5067 peachpy.stream.active_stream.add_instruction(instruction) 5068 return instruction 5069 5070 5071def BLS(destination): 5072 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5073 instruction = BranchInstruction('BLS', Operand(destination), origin=origin) 5074 if peachpy.stream.active_stream is not None: 5075 peachpy.stream.active_stream.add_instruction(instruction) 5076 return instruction 5077 5078 5079def BGE(destination): 5080 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5081 instruction = BranchInstruction('BGE', Operand(destination), origin=origin) 5082 if peachpy.stream.active_stream is not None: 5083 peachpy.stream.active_stream.add_instruction(instruction) 5084 return instruction 5085 5086 5087def BLT(destination): 5088 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5089 instruction = BranchInstruction('BLT', Operand(destination), origin=origin) 5090 if peachpy.stream.active_stream is not None: 5091 peachpy.stream.active_stream.add_instruction(instruction) 5092 return instruction 5093 5094 5095def BGT(destination): 5096 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5097 instruction = BranchInstruction('BGT', Operand(destination), origin=origin) 5098 if peachpy.stream.active_stream is not None: 5099 peachpy.stream.active_stream.add_instruction(instruction) 5100 return instruction 5101 5102 5103def BLE(destination): 5104 origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None 5105 instruction = BranchInstruction('BLE', Operand(destination), origin=origin) 5106 if peachpy.stream.active_stream is not None: 5107 peachpy.stream.active_stream.add_instruction(instruction) 5108 return instruction 5109 5110 5111