src/openpower/test/bitmanip/av_cases.py

   1 from openpower.sv.trans.svp64 import SVP64Asm
   2 import random
   3 from openpower.test.common import TestAccumulatorBase
   4 from openpower.endian import bigendian
   5 from openpower.simulator.program import Program
   6 from openpower.decoder.selectable_int import SelectableInt
   7 from openpower.decoder.power_enums import XER_bits
   8 from openpower.decoder.isa.caller import special_sprs
   9 from openpower.decoder.helpers import exts
  10 from openpower.test.state import ExpectedState
  11 import unittest
  12
  13
  14 class AVTestCase(TestAccumulatorBase):
  15
  16     def case_0_maxs(self):
  17         lst = ["maxs 3, 1, 2"]
  18         lst = list(SVP64Asm(lst, bigendian))
  19
  20         initial_regs = [0] * 32
  21         initial_regs[1] = 0xc523e996a8ff6215
  22         initial_regs[2] = 0xe1e5b9cc9864c4a8
  23         e = ExpectedState(pc=4)
  24         e.intregs[1] = 0xc523e996a8ff6215
  25         e.intregs[2] = 0xe1e5b9cc9864c4a8
  26         e.intregs[3] = 0xe1e5b9cc9864c4a8
  27         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
  28
  29     def case_1_maxs(self):
  30         lst = ["maxs 3, 1, 2"]
  31         lst = list(SVP64Asm(lst, bigendian))
  32
  33         initial_regs = [0] * 32
  34         initial_regs[1] = 0xe1e5b9cc9864c4a8
  35         initial_regs[2] = 0xc523e996a8ff6215
  36         e = ExpectedState(pc=4)
  37         e.intregs[1] = 0xe1e5b9cc9864c4a8
  38         e.intregs[2] = 0xc523e996a8ff6215
  39         e.intregs[3] = 0xe1e5b9cc9864c4a8
  40         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
  41
  42     def case_2_maxs_(self):
  43         lst = [f"maxs. 3, 1, 2"]
  44         lst = list(SVP64Asm(lst, bigendian))
  45
  46         initial_regs = [0] * 32
  47         initial_regs[1] = 0xc523e996a8ff6215
  48         initial_regs[2] = 0xe1e5b9cc9864c4a8
  49         e = ExpectedState(pc=4)
  50         e.intregs[1] = 0xc523e996a8ff6215
  51         e.intregs[2] = 0xe1e5b9cc9864c4a8
  52         e.intregs[3] = 0xe1e5b9cc9864c4a8
  53         e.crregs[0] = 0x8
  54         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
  55
  56     def case_3_maxs_(self):
  57         lst = [f"maxs. 3, 1, 2"]
  58         lst = list(SVP64Asm(lst, bigendian))
  59
  60         initial_regs = [0] * 32
  61         initial_regs[1] = 0xc523e996a8ff6215
  62         initial_regs[2] = 0
  63         e = ExpectedState(pc=4)
  64         e.intregs[1] = 0xc523e996a8ff6215
  65         e.intregs[2] = 0
  66         e.intregs[3] = 0
  67         e.crregs[0] = 0x2 # RT is zero
  68         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
  69
  70     def case_4_maxs_(self):
  71         lst = [f"maxs. 3, 1, 2"]
  72         lst = list(SVP64Asm(lst, bigendian))
  73
  74         initial_regs = [0] * 32
  75         initial_regs[1] = 1
  76         initial_regs[2] = 0
  77         e = ExpectedState(pc=4)
  78         e.intregs[1] = 1
  79         e.intregs[2] = 0
  80         e.intregs[3] = 1
  81         e.crregs[0] = 0x4 # RT is +ve
  82         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
  83
  84     def case_5_maxs_(self):
  85         """max negative number compared against +ve number
  86         """
  87         lst = [f"maxs. 3, 1, 2"]
  88         lst = list(SVP64Asm(lst, bigendian))
  89
  90         initial_regs = [0] * 32
  91         initial_regs[1] = 1
  92         initial_regs[2] = 0x8000_0000_0000_0000
  93         e = ExpectedState(pc=4)
  94         e.intregs[1] = 1
  95         e.intregs[2] = 0x8000_0000_0000_0000
  96         e.intregs[3] = 1
  97         e.crregs[0] = 0x4 # RT is +ve
  98         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
  99
 100     def case_0_mins(self):
 101         lst = ["mins 3, 1, 2"]
 102         lst = list(SVP64Asm(lst, bigendian))
 103
 104         initial_regs = [0] * 32
 105         initial_regs[1] = 0xc523e996a8ff6215
 106         initial_regs[2] = 0xe1e5b9cc9864c4a8
 107         e = ExpectedState(pc=4)
 108         e.intregs[1] = 0xc523e996a8ff6215
 109         e.intregs[2] = 0xe1e5b9cc9864c4a8
 110         e.intregs[3] = 0xc523e996a8ff6215
 111         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 112
 113     def case_2_mins_(self):
 114         lst = [f"mins. 3, 1, 2"]
 115         lst = list(SVP64Asm(lst, bigendian))
 116
 117         initial_regs = [0] * 32
 118         initial_regs[1] = 0xc523e996a8ff6215
 119         initial_regs[2] = 0xe1e5b9cc9864c4a8
 120         e = ExpectedState(pc=4)
 121         e.intregs[1] = 0xc523e996a8ff6215
 122         e.intregs[2] = 0xe1e5b9cc9864c4a8
 123         e.intregs[3] = 0xc523e996a8ff6215
 124         e.crregs[0] = 0x8
 125         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 126
 127     def case_5_mins_(self):
 128         """min negative number compared against +ve number
 129         """
 130         lst = [f"mins. 3, 1, 2"]
 131         lst = list(SVP64Asm(lst, bigendian))
 132
 133         initial_regs = [0] * 32
 134         initial_regs[1] = 1
 135         initial_regs[2] = 0x8000_0000_0000_0000
 136         e = ExpectedState(pc=4)
 137         e.intregs[1] = 1
 138         e.intregs[2] = 0x8000_0000_0000_0000
 139         e.intregs[3] = 0x8000_0000_0000_0000
 140         e.crregs[0] = 0x8 # RT is -ve
 141         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 142
 143     def case_0_maxu(self):
 144         lst = ["maxu 3, 1, 2"]
 145         lst = list(SVP64Asm(lst, bigendian))
 146
 147         initial_regs = [0] * 32
 148         initial_regs[1] = 0xc523e996a8ff6215
 149         initial_regs[2] = 0xe1e5b9cc9864c4a8
 150         e = ExpectedState(pc=4)
 151         e.intregs[1] = 0xc523e996a8ff6215
 152         e.intregs[2] = 0xe1e5b9cc9864c4a8
 153         e.intregs[3] = 0xe1e5b9cc9864c4a8
 154         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 155
 156     def case_5_minu_(self):
 157         """min +ve numbers
 158         """
 159         lst = [f"minu. 3, 1, 2"]
 160         lst = list(SVP64Asm(lst, bigendian))
 161
 162         initial_regs = [0] * 32
 163         initial_regs[1] = 1
 164         initial_regs[2] = 0x8000_0000_0000_0000
 165         e = ExpectedState(pc=4)
 166         e.intregs[1] = 1
 167         e.intregs[2] = 0x8000_0000_0000_0000
 168         e.intregs[3] = min(e.intregs[1], e.intregs[2])
 169         e.crregs[0] = 0x4
 170         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 171
 172     def case_0_avgadd(self):
 173         lst = ["avgadd 3, 1, 2"]
 174         lst = list(SVP64Asm(lst, bigendian))
 175
 176         initial_regs = [0] * 32
 177         initial_regs[1] = 0xc523e996a8ff6215
 178         initial_regs[2] = 0xe1e5b9cc9864c4a8
 179         e = ExpectedState(pc=4)
 180         e.intregs[1] = 0xc523e996a8ff6215
 181         e.intregs[2] = 0xe1e5b9cc9864c4a8
 182         e.intregs[3] = 0xd384d1b1a0b2135f
 183         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 184
 185     def case_1_avgadd(self):
 186         lst = ["avgadd 3, 1, 2"]
 187         lst = list(SVP64Asm(lst, bigendian))
 188
 189         initial_regs = [0] * 32
 190         initial_regs[1] = 0xc523e996a8ff6214
 191         initial_regs[2] = 0xe1e5b9cc9864c4a8
 192         e = ExpectedState(pc=4)
 193         e.intregs[1] = 0xc523e996a8ff6214
 194         e.intregs[2] = 0xe1e5b9cc9864c4a8
 195         e.intregs[3] = 0xd384d1b1a0b2135e
 196         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 197
 198     def case_2_avgadd(self):
 199         lst = ["avgadd 3, 1, 2"]
 200         lst = list(SVP64Asm(lst, bigendian))
 201
 202         initial_regs = [0] * 32
 203         initial_regs[1] = 0xc523e996a8ff6213
 204         initial_regs[2] = 0xe1e5b9cc9864c4a8
 205         e = ExpectedState(pc=4)
 206         e.intregs[1] = 0xc523e996a8ff6213
 207         e.intregs[2] = 0xe1e5b9cc9864c4a8
 208         e.intregs[3] = 0xd384d1b1a0b2135e
 209         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 210
 211     def case_3_avgadd(self):
 212         lst = ["avgadd 3, 1, 2"]
 213         lst = list(SVP64Asm(lst, bigendian))
 214
 215         initial_regs = [0] * 32
 216         initial_regs[1] = 0xffffffffffffffff
 217         initial_regs[2] = 0xffffffffffffffff
 218         e = ExpectedState(pc=4)
 219         e.intregs[1] = 0xffffffffffffffff
 220         e.intregs[2] = 0xffffffffffffffff
 221         e.intregs[3] = 0xffffffffffffffff
 222         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 223
 224     def case_0_absdu(self):
 225         lst = ["absdu 3, 1, 2"]
 226         lst = list(SVP64Asm(lst, bigendian))
 227
 228         initial_regs = [0] * 32
 229         initial_regs[1] = 0x1
 230         initial_regs[2] = 0x2
 231         e = ExpectedState(pc=4)
 232         e.intregs[1] = 0x1
 233         e.intregs[2] = 0x2
 234         e.intregs[3] = 0x1
 235         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 236
 237     def case_1_absdu(self):
 238         lst = ["absdu 3, 1, 2"]
 239         lst = list(SVP64Asm(lst, bigendian))
 240
 241         initial_regs = [0] * 32
 242         initial_regs[1] = 0xffffffffffffffff
 243         initial_regs[2] = 0x2
 244         e = ExpectedState(pc=4)
 245         e.intregs[1] = 0xffffffffffffffff
 246         e.intregs[2] = 0x2
 247         e.intregs[3] = 0x3
 248         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 249
 250     def case_2_absdu(self):
 251         lst = ["absdu 3, 1, 2"]
 252         lst = list(SVP64Asm(lst, bigendian))
 253
 254         initial_regs = [0] * 32
 255         initial_regs[1] = 0x2
 256         initial_regs[2] = 0xffffffffffffffff
 257         e = ExpectedState(pc=4)
 258         e.intregs[1] = 0x2
 259         e.intregs[2] = 0xffffffffffffffff
 260         e.intregs[3] = 0x3
 261         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 262
 263     def case_0_absaddu(self):
 264         lst = ["absaddu 3, 1, 2",
 265                "absaddu 3, 4, 5",
 266         ]
 267         lst = list(SVP64Asm(lst, bigendian))
 268
 269         initial_regs = [0] * 32
 270         initial_regs[1] = 0x2
 271         initial_regs[2] = 0x1
 272         initial_regs[4] = 0x9
 273         initial_regs[5] = 0x3
 274         e = ExpectedState(pc=8)
 275         e.intregs[1] = 0x2
 276         e.intregs[2] = 0x1
 277         e.intregs[3] = 0x7
 278         e.intregs[4] = 0x9
 279         e.intregs[5] = 0x3
 280         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 281
 282     def case_1_absaddu(self):
 283         lst = ["absaddu 3, 1, 2",
 284                "absaddu 3, 4, 5",
 285         ]
 286         lst = list(SVP64Asm(lst, bigendian))
 287
 288         initial_regs = [0] * 32
 289         initial_regs[1] = 0x1
 290         initial_regs[2] = 0x2
 291         initial_regs[4] = 0x9
 292         initial_regs[5] = 0x3
 293         e = ExpectedState(pc=8)
 294         e.intregs[1] = 0x1
 295         e.intregs[2] = 0x2
 296         e.intregs[3] = 0x7
 297         e.intregs[4] = 0x9
 298         e.intregs[5] = 0x3
 299         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 300
 301     def case_2_absaddu(self):
 302         """weird case where there's a negative number
 303         * -1 is greater than 2 (as an unsigned number)
 304           therefore difference is (-1)-(2) which is -3
 305           RT=RT+-3
 306             =0-3
 307             =-3
 308         * 9 is greater than 3
 309           therefore differences is (9)-(3) which is 6
 310           RT=RT+6
 311             =-3+6
 312             =3
 313         * answer: RT=3
 314         """
 315         lst = ["absaddu 3, 1, 2",
 316                "absaddu 3, 4, 5",
 317         ]
 318         lst = list(SVP64Asm(lst, bigendian))
 319
 320         initial_regs = [0] * 32
 321         initial_regs[1] = 0x2
 322         initial_regs[2] = 0xffffffffffffffff
 323         initial_regs[4] = 0x9
 324         initial_regs[5] = 0x3
 325         e = ExpectedState(pc=8)
 326         e.intregs[1] = 0x2
 327         e.intregs[2] = 0xffffffffffffffff
 328         e.intregs[3] = 0x3 # ((-1)-(2)) + ((9)-(3))
 329         e.intregs[4] = 0x9
 330         e.intregs[5] = 0x3
 331         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 332
 333     def case_0_absadds(self):
 334         lst = ["absadds 3, 1, 2",
 335                "absadds 3, 4, 5",
 336         ]
 337         lst = list(SVP64Asm(lst, bigendian))
 338
 339         initial_regs = [0] * 32
 340         initial_regs[1] = 0x2
 341         initial_regs[2] = 0x1
 342         initial_regs[4] = 0x9
 343         initial_regs[5] = 0x3
 344         e = ExpectedState(pc=8)
 345         e.intregs[1] = 0x2
 346         e.intregs[2] = 0x1
 347         e.intregs[3] = 0x7
 348         e.intregs[4] = 0x9
 349         e.intregs[5] = 0x3
 350         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 351
 352     def case_2_absadds(self):
 353         """unlike the absaddu weird case, the 0xfff is treated as signed
 354         so (2) < (-1) and the difference is (2--1)=3.  next instruction
 355         adds 6 more.  answer: 9
 356         """
 357         lst = ["absadds 3, 1, 2",
 358                "absadds 3, 4, 5",
 359         ]
 360         lst = list(SVP64Asm(lst, bigendian))
 361
 362         initial_regs = [0] * 32
 363         initial_regs[1] = 0x2
 364         initial_regs[2] = 0xffffffffffffffff
 365         initial_regs[4] = 0x9
 366         initial_regs[5] = 0x3
 367         e = ExpectedState(pc=8)
 368         e.intregs[1] = 0x2
 369         e.intregs[2] = 0xffffffffffffffff
 370         e.intregs[3] = 9
 371         e.intregs[4] = 0x9
 372         e.intregs[5] = 0x3
 373         self.add_case(Program(lst, bigendian), initial_regs, expected=e)
 374