1 import random
   2 
   3 AARCH64_AS = "as"
   4 AARCH64_OBJDUMP = "objdump"
   5 AARCH64_OBJCOPY = "objcopy"
   6 




   7 class Operand(object):
   8 
   9      def generate(self):
  10         return self
  11 
  12 class Register(Operand):
  13 
  14     def generate(self):
  15         self.number = random.randint(0, 30)
  16         return self
  17 
  18     def astr(self, prefix):
  19         return prefix + str(self.number)
  20 
  21 class FloatRegister(Register):
  22 
  23     def __str__(self):
  24         return self.astr("v")
  25 
  26     def nextReg(self):
  27         next = FloatRegister()
  28         next.number = (self.number + 1) % 32
  29         return next
  30 
  31 class GeneralRegister(Register):
  32 
  33     def __str__(self):
  34         return self.astr("r")
  35 
  36 class GeneralRegisterOrZr(Register):
  37 
  38     def generate(self):
  39         self.number = random.randint(0, 31)
  40         return self
  41 
  42     def astr(self, prefix = ""):
  43         if (self.number == 31):
  44             return prefix + "zr"
  45         else:
  46             return prefix + str(self.number)
  47 
  48     def __str__(self):
  49         if (self.number == 31):
  50             return self.astr()
  51         else:
  52             return self.astr("r")
  53 
  54 class GeneralRegisterOrSp(Register):
  55     def generate(self):
  56         self.number = random.randint(0, 31)
  57         return self
  58 
  59     def astr(self, prefix = ""):
  60         if (self.number == 31):
  61             return "sp"
  62         else:
  63             return prefix + str(self.number)
  64 
  65     def __str__(self):
  66         if (self.number == 31):
  67             return self.astr()
  68         else:
  69             return self.astr("r")
  70 
  71 class FloatZero(Operand):
  72 
  73     def __str__(self):
  74         return "0.0"
  75 
  76     def astr(self, ignored):

   1 import random
   2 
   3 AARCH64_AS = "as"
   4 AARCH64_OBJDUMP = "objdump"
   5 AARCH64_OBJCOPY = "objcopy"
   6 
   7 # r18 is used for TLS on Windows ABI.
   8 REGS30 = [reg for reg in range(0,30) if reg != 18]
   9 REGS31 = REGS30 + [31]
  10 
  11 class Operand(object):
  12 
  13      def generate(self):
  14         return self
  15 
  16 class Register(Operand):
  17 
  18     def generate(self):
  19         self.number = random.choice(REGS30)
  20         return self
  21 
  22     def astr(self, prefix):
  23         return prefix + str(self.number)
  24 
  25 class FloatRegister(Register):
  26 
  27     def __str__(self):
  28         return self.astr("v")
  29 
  30     def nextReg(self):
  31         next = FloatRegister()
  32         next.number = (self.number + 1) % 32
  33         return next
  34 
  35 class GeneralRegister(Register):
  36 
  37     def __str__(self):
  38         return self.astr("r")
  39 
  40 class GeneralRegisterOrZr(Register):
  41 
  42     def generate(self):
  43         self.number = random.choice(REGS31)
  44         return self
  45 
  46     def astr(self, prefix = ""):
  47         if (self.number == 31):
  48             return prefix + "zr"
  49         else:
  50             return prefix + str(self.number)
  51 
  52     def __str__(self):
  53         if (self.number == 31):
  54             return self.astr()
  55         else:
  56             return self.astr("r")
  57 
  58 class GeneralRegisterOrSp(Register):
  59     def generate(self):
  60         self.number = random.choice(REGS31)
  61         return self
  62 
  63     def astr(self, prefix = ""):
  64         if (self.number == 31):
  65             return "sp"
  66         else:
  67             return prefix + str(self.number)
  68 
  69     def __str__(self):
  70         if (self.number == 31):
  71             return self.astr()
  72         else:
  73             return self.astr("r")
  74 
  75 class FloatZero(Operand):
  76 
  77     def __str__(self):
  78         return "0.0"
  79 
  80     def astr(self, ignored):