PyNerva 0.0.7__py3-none-any.whl

nervapy/arm/instructions.py

@@ -0,0 +1,519 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+
+class QuasiInstruction(object):
+    def __init__(self, name, origin=None):
+        super(QuasiInstruction, self).__init__()
+        self.name = name
+        self.line_number = origin[1][2] if origin else None
+        self.source_file = origin[1][1] if origin else None
+        self.source_code = origin[1][4][0].strip() if origin else None
+
+
+class Instruction(QuasiInstruction):
+    def __init__(self, name, operands, isa_extensions=None, origin=None):
+        import nervapy.x86_64.isa
+
+        super(Instruction, self).__init__(name, origin=origin)
+        self.operands = operands
+        self.isa_extensions = nervapy.x86_64.isa.Extensions(isa_extensions)
+        self.available_registers = set()
+        self.live_registers = set()
+
+    def __len__(self):
+        return self.size
+
+    def __str__(self):
+        return self.name + " " + ", ".join(map(str, self.operands))
+
+    def get_registers_list(self):
+        return [
+            register
+            for operand in self.operands
+            for register in operand.get_registers_list()
+        ]
+
+    def get_local_variable(self):
+        for operand in self.operands:
+            if isinstance(operand, Operand) and operand.is_local_variable():
+                return operand.variable
+
+    def get_constant(self):
+        for operand in self.operands:
+            if isinstance(operand, Operand) and operand.is_constant():
+                return operand.constant
+
+
+class Operand(object):
+    RegisterType = 1
+    RegisterListType = 2
+    RegisterLanesType = 3
+    RegisterLanesListType = 4
+    ShiftedRegisterType = 5
+    AddressRegisterType = 6
+    ImmediateType = 7
+    MemoryType = 8
+    ConstantType = 9
+    VariableType = 10
+    LabelType = 11
+    NoneType = 12
+
+    def __init__(self, operand):
+        super(Operand, self).__init__()
+        import copy
+
+        from nervapy import Constant
+        from nervapy.arm.function import LocalVariable
+        from nervapy.arm.pseudo import ExternalFunction, Label
+        from nervapy.arm.registers import (DRegisterLanes,
+                                           GeneralPurposeRegister,
+                                           GeneralPurposeRegisterWriteback,
+                                           Register,
+                                           ShiftedGeneralPurposeRegister)
+        from nervapy.util import is_int
+
+        if isinstance(operand, GeneralPurposeRegisterWriteback):
+            self.type = Operand.AddressRegisterType
+            self.register = copy.deepcopy(operand.register)
+        elif isinstance(operand, Register):
+            self.type = Operand.RegisterType
+            self.register = copy.deepcopy(operand)
+        elif isinstance(operand, DRegisterLanes):
+            self.type = Operand.RegisterLanesType
+            self.lanes = copy.deepcopy(operand)
+        elif isinstance(operand, ShiftedGeneralPurposeRegister):
+            self.type = Operand.ShiftedRegisterType
+            self.register = copy.deepcopy(operand)
+        elif isinstance(operand, tuple):
+            if all(isinstance(element, Register) for element in operand):
+                if (
+                    len(set((register.type, register.size) for register in operand))
+                    == 1
+                ):
+                    self.type = Operand.RegisterListType
+                    self.register_list = copy.deepcopy(operand)
+                else:
+                    raise TypeError(
+                        "Register in the list {0} have different types".format(
+                            ", ".join(operand)
+                        )
+                    )
+            elif all(isinstance(element, DRegisterLanes) for element in operand):
+                self.type = Operand.RegisterLanesListType
+                self.register_list = copy.deepcopy(operand)
+            else:
+                raise TypeError("Unknown tuple elements {0}".format(operand))
+        elif is_int(operand):
+            if -9223372036854775808 <= operand <= 18446744073709551615:
+                self.type = Operand.ImmediateType
+                self.immediate = operand
+            else:
+                raise ValueError(
+                    "The immediate operand {0} is not a 64-bit value".format(operand)
+                )
+        elif isinstance(operand, list):
+            if len(operand) == 1 and (
+                isinstance(operand[0], GeneralPurposeRegister)
+                or isinstance(operand[0], GeneralPurposeRegisterWriteback)
+            ):
+                self.type = Operand.MemoryType
+                self.base = copy.deepcopy(operand[0])
+                self.offset = None
+            elif (
+                len(operand) == 2
+                and isinstance(operand[0], GeneralPurposeRegister)
+                and (
+                    isinstance(operand[1], int)
+                    or isinstance(operand[1], ShiftedGeneralPurposeRegister)
+                )
+            ):
+                self.type = Operand.MemoryType
+                self.base = copy.deepcopy(operand[0])
+                self.offset = operand[1]
+            else:
+                raise ValueError(
+                    "Memory operand must be a list with only one or two elements"
+                )
+        elif isinstance(operand, Constant):
+            self.type = Operand.ConstantType
+            self.constant = operand
+            self.size = operand.size * operand.repeats
+        elif isinstance(operand, LocalVariable):
+            self.type = Operand.VariableType
+            self.variable = operand
+            self.size = operand.size * 8
+        elif isinstance(operand, ExternalFunction):
+            # Treat external functions as labels
+            self.type = Operand.LabelType
+            self.label = operand.name
+        elif isinstance(operand, str):
+            self.type = Operand.LabelType
+            self.label = operand
+        elif isinstance(operand, Label):
+            self.type = Operand.LabelType
+            self.label = operand.name
+        elif operand is None:
+            self.type = Operand.NoneType
+        else:
+            raise TypeError(
+                "The operand {0} is not a valid assembly instruction operand".format(
+                    operand
+                )
+            )
+
+    def __str__(self):
+        if self.is_constant():
+            if self.constant.prefix is None:
+                return "[rel {0}]".format(self.constant.label)
+            else:
+                return "[rel {1}.{0}]".format(self.constant.label, self.constant.prefix)
+        elif self.is_local_variable():
+            return str(self.variable)
+        elif self.is_memory_address():
+            from nervapy.arm.registers import GeneralPurposeRegisterWriteback
+
+            if self.offset is None:
+                if isinstance(self.base, GeneralPurposeRegisterWriteback):
+                    return "[" + str(self.base.register) + "]!"
+                else:
+                    return "[" + str(self.base) + "]"
+            else:
+                if isinstance(self.base, GeneralPurposeRegisterWriteback):
+                    return (
+                        "[" + str(self.base.register) + ", #" + str(self.offset) + "]!"
+                    )
+                else:
+                    if isinstance(self.offset, int):
+                        return "[" + str(self.base) + ", #" + str(self.offset) + "]"
+                    else:
+                        return "[" + str(self.base) + ", " + str(self.offset) + "]"
+        elif self.is_register() or self.is_shifted_general_purpose_register():
+            return str(self.register)
+        elif self.is_register_lanes():
+            return str(self.register)
+        elif self.is_address_register():
+            return str(self.register) + "!"
+        elif self.is_register_list() or self.is_register_lanes_list():
+            return "{" + ", ".join(map(str, self.register_list)) + "}"
+        elif self.is_label():
+            return self.label
+        elif self.is_immediate():
+            return "#" + str(self.immediate)
+        elif self.is_none():
+            return ""
+        else:
+            raise TypeError("Unsupported operand type")
+
+    def __eq__(self, other):
+        if isinstance(other, Operand) and self.type == other.type:
+            if self.is_immediate():
+                return self.immediate == other.immediate
+            elif self.is_register():
+                return self.register == other.register
+            elif self.is_memory_address():
+                return self.base == other.base and self.offset == other.offset
+            elif self.is_label():
+                return self.label == other.label
+            else:
+                return False
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    def is_none(self):
+        return self.type == Operand.NoneType
+
+    def is_immediate(self):
+        return self.type == Operand.ImmediateType
+
+    def is_immediate5(self):
+        return self.is_immediate() and 0 <= self.immediate <= 31
+
+    def is_modified_immediate12(self):
+        def rotate32(x, n):
+            return ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF
+
+        if self.type == Operand.ImmediateType:
+            if -2147483648 <= self.immediate <= 4294967295:
+                dword = self.immediate & 0xFFFFFFFF
+                
+                # Check byte replication patterns (ARM ARM A5.3.2)
+                # Pattern 0b00: 0x000000XY
+                if dword <= 0xFF:
+                    return True
+                
+                # Pattern 0b01: 0x00XY00XY
+                if (dword & 0xFF00FF00) == 0 and ((dword >> 16) & 0xFF) == (dword & 0xFF):
+                    return True
+                
+                # Pattern 0b10: 0xXY00XY00
+                if (dword & 0x00FF00FF) == 0 and ((dword >> 24) & 0xFF) == ((dword >> 8) & 0xFF):
+                    return True
+                
+                # Pattern 0b11: 0xXYXYXYXY
+                byte_val = dword & 0xFF
+                if dword == (byte_val << 24) | (byte_val << 16) | (byte_val << 8) | byte_val:
+                    return True
+                
+                # Rotation patterns (original check)
+                ndword = (~self.immediate) & 0xFFFFFFFF
+                return any(
+                    [
+                        (rotate32(dword, n) & 0xFFFFFF00) == 0x00000000
+                        or (rotate32(ndword, n) & 0xFFFFFF00) == 0x00000000
+                        for n in range(0, 32, 2)
+                    ]
+                )
+            else:
+                return False
+        else:
+            return False
+
+    def is_neon_modified_immediate8(self):
+        return self.type == Operand.ImmediateType and -128 <= self.immediate <= 255
+
+    def is_neon_modified_immediate16(self):
+        if self.type == Operand.ImmediateType and -32768 <= self.immediate <= 65535:
+            hword = self.immediate & 0xFFFF
+            return (hword & 0xFF00) == 0 or (hword & 0x00FF) == 0
+        else:
+            return False
+
+    def is_neon_modified_immediate32(self):
+        if (
+            self.type == Operand.ImmediateType
+            and -2147483648 <= self.immediate <= 4294967295
+        ):
+            word = self.immediate & 0xFFFFFFFF
+            return (
+                (word & 0x00FFFFFF) == 0x00000000
+                or (word & 0xFF00FFFF) == 0x00000000
+                or (word & 0xFFFF00FF) == 0x00000000
+                or (word & 0xFFFFFF00) == 0x00000000
+                or (word & 0xFF00FFFF) == 0x0000FFFF
+                or (word & 0xFFFF00FF) == 0x000000FF
+            )
+        else:
+            return False
+
+    def is_neon_modified_immediate64(self):
+        if (
+            self.type == Operand.ImmediateType
+            and -2147483648 <= self.immediate <= 4294967295
+        ):
+            dword = self.immediate & 0xFFFFFFFFFFFFFFFF
+            byte = dword & 0xFF
+            return all([(dword >> n) & 0xFF == byte for n in range(8, 64, 8)])
+        else:
+            return False
+
+    def is_preindexed_memory_address(self):
+        from nervapy.arm.registers import GeneralPurposeRegisterWriteback
+
+        return (
+            self.type == Operand.MemoryType
+            and self.offset is not None
+            and isinstance(self.base, GeneralPurposeRegisterWriteback)
+        )
+
+    def is_memory_address(self, offset_bits=None, allow_writeback=True):
+        from nervapy.arm.registers import (GeneralPurposeRegisterWriteback,
+                                           ShiftedGeneralPurposeRegister)
+
+        if self.type == Operand.MemoryType:
+            if not allow_writeback and isinstance(
+                self.base, GeneralPurposeRegisterWriteback
+            ):
+                return False
+            else:
+                if self.offset is None or offset_bits is None:
+                    return True
+                elif isinstance(self.offset, ShiftedGeneralPurposeRegister):
+                    return True
+                else:
+                    bound = (1 << offset_bits) - 1
+                    return -bound <= self.offset <= bound
+        else:
+            return False
+
+    def is_writeback_memory_address(self):
+        from nervapy.arm.registers import GeneralPurposeRegisterWriteback
+
+        return self.type == Operand.MemoryType and isinstance(
+            self.base, GeneralPurposeRegisterWriteback
+        )
+
+    def is_memory_address_offset8_mod4(self):
+        return self.type == Operand.MemoryType and (
+            self.offset is None or -1020 <= self.offset <= 1020 and self.offset % 4 == 0
+        )
+
+    def is_offset8(self):
+        return self.type == Operand.ImmediateType and -255 <= self.immediate <= 255
+
+    def is_offset12(self):
+        return self.type == Operand.ImmediateType and -4095 <= self.immediate <= 4095
+
+    def is_label(self):
+        return self.type == Operand.LabelType
+
+    def is_constant(self):
+        return self.type == Operand.ConstantType
+
+    def is_local_variable(self):
+        return self.type == Operand.VariableType
+
+    def is_register(self):
+        return self.type == Operand.RegisterType
+
+    def is_register_lanes(self):
+        return self.type == Operand.RegisterLanesType
+
+    def is_register_list(self):
+        return self.is_register() or self.type == Operand.RegisterListType
+
+    def is_register_lanes_list(self):
+        return self.type == Operand.RegisterLanesListType
+
+    def is_general_purpose_register(self):
+        from nervapy.arm.registers import GeneralPurposeRegister
+
+        return self.type == Operand.RegisterType and isinstance(
+            self.register, GeneralPurposeRegister
+        )
+
+    def is_shifted_general_purpose_register(self):
+        from nervapy.arm.registers import ShiftedGeneralPurposeRegister
+
+        return (
+            self.is_general_purpose_register()
+            or self.type == Operand.ShiftedRegisterType
+            and isinstance(self.register, ShiftedGeneralPurposeRegister)
+        )
+
+    def is_general_purpose_register_list(self):
+        from nervapy.arm.registers import GeneralPurposeRegister
+
+        return (
+            self.is_general_purpose_register()
+            or self.type == Operand.RegisterListType
+            and isinstance(self.register_list[0], GeneralPurposeRegister)
+        )
+
+    def is_address_register(self):
+        return (
+            self.is_general_purpose_register()
+            or self.type == Operand.AddressRegisterType
+        )
+
+    def is_wmmx_register(self):
+        from nervapy.arm.registers import WMMXRegister
+
+        return self.type == Operand.RegisterType and isinstance(
+            self.register, WMMXRegister
+        )
+
+    def is_s_register(self):
+        from nervapy.arm.registers import SRegister
+
+        return self.type == Operand.RegisterType and isinstance(
+            self.register, SRegister
+        )
+
+    def is_s_register_list(self):
+        from nervapy.arm.registers import SRegister
+
+        return (
+            self.is_s_register()
+            or self.type == Operand.RegisterListType
+            and isinstance(self.register_list[0], SRegister)
+        )
+
+    def is_d_register(self):
+        from nervapy.arm.registers import DRegister
+
+        return self.type == Operand.RegisterType and isinstance(
+            self.register, DRegister
+        )
+
+    def is_d_register_list(self):
+        from nervapy.arm.registers import DRegister
+
+        return (
+            self.is_d_register()
+            or self.type == Operand.RegisterListType
+            and isinstance(self.register_list[0], DRegister)
+        )
+
+    def is_q_register(self):
+        from nervapy.arm.registers import QRegister
+
+        return self.type == Operand.RegisterType and isinstance(
+            self.register, QRegister
+        )
+
+    def is_vldst1_register_list(self):
+        from nervapy.arm.registers import DRegister
+
+        return (
+            self.is_d_register()
+            or self.type == Operand.RegisterListType
+            and isinstance(self.register_list[0], DRegister)
+            and len(self.register_list) <= 4
+        )
+
+    def is_vldst1_register_lanes_list(self):
+        from nervapy.arm.registers import DRegisterLanes
+
+        return (
+            self.type == Operand.RegisterLanesType
+            and isinstance(self.register, DRegisterLanes)
+            or self.type == Operand.RegisterLanesListType
+            and all(
+                isinstance(register, DRegisterLanes) for register in self.register_list
+            )
+        )
+
+    def is_general_purpose_memory_address(self):
+        return self.type == Operand.MemoryType and -4095 <= self.offset <= 4095
+
+    def get_registers_list(self):
+        from nervapy.arm.registers import (GeneralPurposeRegisterWriteback,
+                                           ShiftedGeneralPurposeRegister, sp)
+
+        if self.is_address_register() or self.is_register() or self.is_register_lanes():
+            return [self.register]
+        elif self.is_shifted_general_purpose_register():
+            return [self.register.register]
+        elif self.is_constant():
+            return list()
+        elif self.is_local_variable():
+            return [sp]
+        elif self.is_register_list():
+            return list(self.register_list)
+        elif self.is_register_lanes_list():
+            return [register_lanes.register for register_lanes in self.register_list]
+        elif self.is_memory_address():
+            if isinstance(self.base, GeneralPurposeRegisterWriteback):
+                return [self.base.register]
+            else:
+                if isinstance(self.offset, ShiftedGeneralPurposeRegister):
+                    return [self.base, self.offset.register]
+                else:
+                    return [self.base]
+        else:
+            return list()
+
+    def get_writeback_registers_list(self):
+        if self.is_memory_address():
+            from nervapy.arm.registers import GeneralPurposeRegisterWriteback
+
+            if isinstance(self.base, GeneralPurposeRegisterWriteback):
+                return [self.base.register]
+            else:
+                return [self.base]
+        else:
+            return list()