src/openpower/test/ldst/ldst_cases.py

   1 from openpower.simulator.program import Program
   2 from openpower.endian import bigendian
   3 from openpower.test.common import TestAccumulatorBase
   4
   5
   6 class LDSTTestCase(TestAccumulatorBase):
   7
   8     def case_1_load(self):
   9         lst = ["lhz 3, 0(1)"]
  10         initial_regs = [0] * 32
  11         initial_regs[1] = 0x0004
  12         initial_regs[2] = 0x0008
  13         initial_mem = {0x0000: (0x5432123412345678, 8),
  14                        0x0008: (0xabcdef0187654321, 8),
  15                        0x0020: (0x1828384822324252, 8),
  16                         }
  17         self.add_case(Program(lst, bigendian), initial_regs,
  18                              initial_mem=initial_mem)
  19
  20     def case_2_load_store(self):
  21         lst = [
  22                "stb 3, 1(2)",
  23                "lbz 4, 1(2)",
  24         ]
  25         initial_regs = [0] * 32
  26         initial_regs[1] = 0x0004
  27         initial_regs[2] = 0x0008
  28         initial_regs[3] = 0x00ee
  29         initial_mem = {0x0000: (0x5432123412345678, 8),
  30                        0x0008: (0xabcdef0187654321, 8),
  31                        0x0020: (0x1828384822324252, 8),
  32                         }
  33         self.add_case(Program(lst, bigendian), initial_regs,
  34                              initial_mem=initial_mem)
  35
  36     def case_3_load_store(self):
  37         lst = ["sth 4, 0(2)",
  38                "lhz 4, 0(2)"]
  39         initial_regs = [0] * 32
  40         initial_regs[1] = 0x0004
  41         initial_regs[2] = 0x0002
  42         initial_regs[3] = 0x15eb
  43         initial_mem = {0x0000: (0x5432123412345678, 8),
  44                        0x0008: (0xabcdef0187654321, 8),
  45                        0x0020: (0x1828384822324252, 8),
  46                         }
  47         self.add_case(Program(lst, bigendian), initial_regs,
  48                              initial_mem=initial_mem)
  49
  50     def case_4_load_store_rev_ext(self):
  51         lst = ["stwx 1, 4, 2",
  52                "lwbrx 3, 4, 2"]
  53         initial_regs = [0] * 32
  54         initial_regs[1] = 0x5678
  55         initial_regs[2] = 0x001c
  56         initial_regs[4] = 0x0008
  57         initial_mem = {0x0000: (0x5432123412345678, 8),
  58                        0x0008: (0xabcdef0187654321, 8),
  59                        0x0020: (0x1828384822324252, 8),
  60                         }
  61         self.add_case(Program(lst, bigendian), initial_regs,
  62                              initial_mem=initial_mem)
  63
  64     def case_5_load_store_rev_ext(self):
  65         lst = ["stwbrx 1, 4, 2",
  66                "lwzx 3, 4, 2"]
  67         initial_regs = [0] * 32
  68         initial_regs[1] = 0x5678
  69         initial_regs[2] = 0x001c
  70         initial_regs[4] = 0x0008
  71         initial_mem = {0x0000: (0x5432123412345678, 8),
  72                        0x0008: (0xabcdef0187654321, 8),
  73                        0x0020: (0x1828384822324252, 8),
  74                         }
  75         self.add_case(Program(lst, bigendian), initial_regs,
  76                              initial_mem=initial_mem)
  77
  78     def case_6_load_store_rev_ext(self):
  79         lst = ["stwbrx 1, 4, 2",
  80                "lwbrx 3, 4, 2"]
  81         initial_regs = [0] * 32
  82         initial_regs[1] = 0x5678
  83         initial_regs[2] = 0x001c
  84         initial_regs[4] = 0x0008
  85         initial_mem = {0x0000: (0x5432123412345678, 8),
  86                        0x0008: (0xabcdef0187654321, 8),
  87                        0x0020: (0x1828384822324252, 8),
  88                         }
  89         self.add_case(Program(lst, bigendian), initial_regs,
  90                              initial_mem=initial_mem)
  91
  92     def case_7_load_store_d(self):
  93         lst = [
  94                "std 3, 0(2)",
  95                "ld 4, 0(2)",
  96         ]
  97         initial_regs = [0] * 32
  98         initial_regs[1] = 0x0004
  99         initial_regs[2] = 0x0008
 100         initial_regs[3] = 0x00ee
 101         initial_mem = {0x0000: (0x5432123412345678, 8),
 102                        0x0008: (0xabcdef0187654321, 8),
 103                        0x0020: (0x1828384822324252, 8),
 104                         }
 105         self.add_case(Program(lst, bigendian), initial_regs,
 106                              initial_mem=initial_mem)
 107
 108     def case_8_load_store_d_update(self):
 109         lst = [
 110                "stdu 3, 0(2)",
 111                "ld 4, 0(2)",
 112         ]
 113         initial_regs = [0] * 32
 114         initial_regs[1] = 0x0004
 115         initial_regs[2] = 0x0008
 116         initial_regs[3] = 0x00ee
 117         initial_mem = {0x0000: (0x5432123412345678, 8),
 118                        0x0008: (0xabcdef0187654321, 8),
 119                        0x0020: (0x1828384822324252, 8),
 120                         }
 121         self.add_case(Program(lst, bigendian), initial_regs,
 122                              initial_mem=initial_mem)
 123
 124     def case_9_load_algebraic_1(self):
 125         lst = ["lwax 3, 4, 2"]
 126         initial_regs = [0] * 32
 127         initial_regs[1] = 0x5678
 128         initial_regs[2] = 0x001c
 129         initial_regs[4] = 0x0008
 130         initial_mem = {0x0000: (0x5432123412345678, 8),
 131                        0x0008: (0xabcdef0187654321, 8),
 132                        0x0020: (0xf000000f0000ffff, 8),
 133                         }
 134         self.add_case(Program(lst, bigendian), initial_regs,
 135                              initial_mem=initial_mem)
 136
 137     def case_9_load_algebraic_2(self):
 138         lst = ["lwax 3, 4, 2"]
 139         initial_regs = [0] * 32
 140         initial_regs[1] = 0x5678
 141         initial_regs[2] = 0x001c
 142         initial_regs[4] = 0x0008
 143         initial_mem = {0x0000: (0x5432123412345678, 8),
 144                        0x0008: (0xabcdef0187654321, 8),
 145                        0x0020: (0x7000000f0000ffff, 8),
 146                         }
 147         self.add_case(Program(lst, bigendian), initial_regs,
 148                              initial_mem=initial_mem)
 149
 150     def case_9_load_algebraic_3(self):
 151         lst = ["lwaux 3, 4, 2"]
 152         initial_regs = [0] * 32
 153         initial_regs[1] = 0x5678
 154         initial_regs[2] = 0x001c
 155         initial_regs[4] = 0x0008
 156         initial_mem = {0x0000: (0x5432123412345678, 8),
 157                        0x0008: (0xabcdef0187654321, 8),
 158                        0x0020: (0xf000000f0000ffff, 8),
 159                         }
 160         self.add_case(Program(lst, bigendian), initial_regs,
 161                              initial_mem=initial_mem)
 162
 163     def case_9_load_algebraic_4(self):
 164         lst = ["lwa 3, 4(4)"]
 165         initial_regs = [0] * 32
 166         initial_regs[1] = 0x5678
 167         initial_regs[4] = 0x0020
 168         initial_mem = {0x0000: (0x5432123412345678, 8),
 169                        0x0008: (0xabcdef0187654321, 8),
 170                        0x0020: (0xf000000f1234ffff, 8),
 171                         }
 172         self.add_case(Program(lst, bigendian), initial_regs,
 173                              initial_mem=initial_mem)
 174
 175     def case_10_load_algebraic_1(self):
 176         lst = ["lhax 3, 4, 2"]
 177         initial_regs = [0] * 32
 178         initial_regs[1] = 0x5678
 179         initial_regs[2] = 0x001c
 180         initial_regs[4] = 0x0008
 181         initial_mem = {0x0000: (0x5432123412345678, 8),
 182                        0x0008: (0xabcdef0187654321, 8),
 183                        0x0020: (0x0000f00f0000ffff, 8),
 184                         }
 185         self.add_case(Program(lst, bigendian), initial_regs,
 186                              initial_mem=initial_mem)
 187
 188     def case_10_load_algebraic_2(self):
 189         lst = ["lhax 3, 4, 2"]
 190         initial_regs = [0] * 32
 191         initial_regs[1] = 0x5678
 192         initial_regs[2] = 0x001c
 193         initial_regs[4] = 0x0008
 194         initial_mem = {0x0000: (0x5432123412345678, 8),
 195                        0x0008: (0xabcdef0187654321, 8),
 196                        0x0020: (0x0000700f0000ffff, 8),
 197                         }
 198         self.add_case(Program(lst, bigendian), initial_regs,
 199                              initial_mem=initial_mem)
 200
 201     def case_10_load_store_cix(self):
 202         lst = ["stbcix 1, 4, 2",
 203                "lwzcix 3, 4, 2"]
 204         initial_regs = [0] * 32
 205         initial_regs[1] = 0x5678
 206         initial_regs[2] = 0x001c
 207         initial_regs[4] = 0x0008
 208         initial_mem = {0x0000: (0x5432123412345678, 8),
 209                        0x0008: (0xabcdef0187654321, 8),
 210                        0x0020: (0x1828384822324252, 8),
 211                         }
 212         self.add_case(Program(lst, bigendian), initial_regs,
 213                              initial_mem=initial_mem)
 214