1 // Copyright 2016, VIXL authors 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are met: 6 // 7 // * Redistributions of source code must retain the above copyright notice, 8 // this list of conditions and the following disclaimer. 9 // * Redistributions in binary form must reproduce the above copyright notice, 10 // this list of conditions and the following disclaimer in the documentation 11 // and/or other materials provided with the distribution. 12 // * Neither the name of ARM Limited nor the names of its contributors may be 13 // used to endorse or promote products derived from this software without 14 // specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND 17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 27 28 // ----------------------------------------------------------------------------- 29 // This file is auto generated from the 30 // test/aarch32/config/template-simulator-aarch32.cc.in template file using 31 // tools/generate_tests.py. 32 // 33 // PLEASE DO NOT EDIT. 34 // ----------------------------------------------------------------------------- 35 36 37 #include "test-runner.h" 38 39 #include "test-utils.h" 40 #include "test-utils-aarch32.h" 41 42 #include "aarch32/assembler-aarch32.h" 43 #include "aarch32/macro-assembler-aarch32.h" 44 #include "aarch32/disasm-aarch32.h" 45 46 #define __ masm. 47 #define BUF_SIZE (4096) 48 49 #ifdef VIXL_INCLUDE_SIMULATOR_AARCH32 50 // Run tests with the simulator. 51 52 #define SETUP() MacroAssembler masm(BUF_SIZE) 53 54 #define START() masm.GetBuffer()->Reset() 55 56 #define END() \ 57 __ Hlt(0); \ 58 __ FinalizeCode(); 59 60 // TODO: Run the tests in the simulator. 61 #define RUN() 62 63 #define TEARDOWN() 64 65 #else // ifdef VIXL_INCLUDE_SIMULATOR_AARCH32. 66 67 #define SETUP() \ 68 MacroAssembler masm(BUF_SIZE); \ 69 UseScratchRegisterScope harness_scratch(&masm); \ 70 harness_scratch.ExcludeAll(); 71 72 #define START() \ 73 masm.GetBuffer()->Reset(); \ 74 __ Push(r4); \ 75 __ Push(r5); \ 76 __ Push(r6); \ 77 __ Push(r7); \ 78 __ Push(r8); \ 79 __ Push(r9); \ 80 __ Push(r10); \ 81 __ Push(r11); \ 82 __ Push(lr); \ 83 harness_scratch.Include(ip); 84 85 #define END() \ 86 harness_scratch.Exclude(ip); \ 87 __ Pop(lr); \ 88 __ Pop(r11); \ 89 __ Pop(r10); \ 90 __ Pop(r9); \ 91 __ Pop(r8); \ 92 __ Pop(r7); \ 93 __ Pop(r6); \ 94 __ Pop(r5); \ 95 __ Pop(r4); \ 96 __ Bx(lr); \ 97 __ FinalizeCode(); 98 99 #define RUN() \ 100 { \ 101 int pcs_offset = masm.IsUsingT32() ? 1 : 0; \ 102 masm.GetBuffer()->SetExecutable(); \ 103 ExecuteMemory(masm.GetBuffer()->GetStartAddress<byte*>(), \ 104 masm.GetSizeOfCodeGenerated(), \ 105 pcs_offset); \ 106 masm.GetBuffer()->SetWritable(); \ 107 } 108 109 #define TEARDOWN() harness_scratch.Close(); 110 111 #endif // ifdef VIXL_INCLUDE_SIMULATOR_AARCH32 112 113 namespace vixl { 114 namespace aarch32 { 115 116 // List of instruction encodings: 117 #define FOREACH_INSTRUCTION(M) \ 118 M(Add) \ 119 M(Adds) \ 120 M(Rsb) \ 121 M(Rsbs) \ 122 M(Sub) \ 123 M(Subs) 124 125 126 // The following definitions are defined again in each generated test, therefore 127 // we need to place them in an anomymous namespace. It expresses that they are 128 // local to this file only, and the compiler is not allowed to share these types 129 // across test files during template instantiation. Specifically, `Operands` and 130 // `Inputs` have various layouts across generated tests so they absolutely 131 // cannot be shared. 132 133 #ifdef VIXL_INCLUDE_TARGET_T32 134 namespace { 135 136 // Values to be passed to the assembler to produce the instruction under test. 137 struct Operands { 138 Condition cond; 139 Register rd; 140 Register rn; 141 int32_t immediate; 142 }; 143 144 // Input data to feed to the instruction. 145 struct Inputs { 146 uint32_t apsr; 147 uint32_t rd; 148 uint32_t rn; 149 }; 150 151 // This structure contains all input data needed to test one specific encoding. 152 // It used to generate a loop over an instruction. 153 struct TestLoopData { 154 // The `operands` fields represents the values to pass to the assembler to 155 // produce the instruction. 156 Operands operands; 157 // Description of the operands, used for error reporting. 158 const char* operands_description; 159 // Unique identifier, used for generating traces. 160 const char* identifier; 161 // Array of values to be fed to the instruction. 162 size_t input_size; 163 const Inputs* inputs; 164 }; 165 166 static const Inputs kRdIsRn[] = {{ZFlag, 0x00007fff, 0x00007fff}, 167 {CFlag, 0xffffff83, 0xffffff83}, 168 {NCFlag, 0x00000000, 0x00000000}, 169 {NCVFlag, 0x00000000, 0x00000000}, 170 {NZFlag, 0x00000000, 0x00000000}, 171 {VFlag, 0x00000002, 0x00000002}, 172 {NCFlag, 0xfffffffe, 0xfffffffe}, 173 {NCVFlag, 0x00007ffd, 0x00007ffd}, 174 {NZCVFlag, 0xffffffff, 0xffffffff}, 175 {ZVFlag, 0xffffffff, 0xffffffff}, 176 {CFlag, 0x00000002, 0x00000002}, 177 {ZFlag, 0x80000001, 0x80000001}, 178 {ZCFlag, 0x00007ffe, 0x00007ffe}, 179 {ZVFlag, 0xffff8000, 0xffff8000}, 180 {CFlag, 0x0000007e, 0x0000007e}, 181 {ZFlag, 0xcccccccc, 0xcccccccc}, 182 {NVFlag, 0xffff8000, 0xffff8000}, 183 {CFlag, 0x00000001, 0x00000001}, 184 {NFlag, 0x00000001, 0x00000001}, 185 {NZFlag, 0xffffffe0, 0xffffffe0}, 186 {CVFlag, 0xfffffffd, 0xfffffffd}, 187 {ZVFlag, 0x00007ffe, 0x00007ffe}, 188 {ZCVFlag, 0x55555555, 0x55555555}, 189 {NCFlag, 0x00000020, 0x00000020}, 190 {ZCFlag, 0xffffff81, 0xffffff81}, 191 {ZCFlag, 0xcccccccc, 0xcccccccc}, 192 {ZCFlag, 0x00000020, 0x00000020}, 193 {NCVFlag, 0xffff8000, 0xffff8000}, 194 {NZVFlag, 0xffff8001, 0xffff8001}, 195 {ZVFlag, 0xffffff81, 0xffffff81}, 196 {NZVFlag, 0xffffff81, 0xffffff81}, 197 {NZVFlag, 0x00000000, 0x00000000}, 198 {NVFlag, 0x00000001, 0x00000001}, 199 {NCVFlag, 0x33333333, 0x33333333}, 200 {NZCVFlag, 0xffff8001, 0xffff8001}, 201 {NZCFlag, 0xffffffff, 0xffffffff}, 202 {NCVFlag, 0x80000000, 0x80000000}, 203 {ZCFlag, 0x00000001, 0x00000001}, 204 {CVFlag, 0x00000020, 0x00000020}, 205 {NCFlag, 0xffff8003, 0xffff8003}, 206 {CVFlag, 0x00000002, 0x00000002}, 207 {NZCFlag, 0x80000000, 0x80000000}, 208 {VFlag, 0xffffff83, 0xffffff83}, 209 {NZFlag, 0x33333333, 0x33333333}, 210 {NCVFlag, 0x00007ffe, 0x00007ffe}, 211 {NFlag, 0xffffff81, 0xffffff81}, 212 {NZVFlag, 0x00000020, 0x00000020}, 213 {CVFlag, 0x00007fff, 0x00007fff}, 214 {NZCFlag, 0xffff8003, 0xffff8003}, 215 {ZCFlag, 0xfffffffd, 0xfffffffd}, 216 {NZFlag, 0xcccccccc, 0xcccccccc}, 217 {ZCFlag, 0xffffffff, 0xffffffff}, 218 {ZVFlag, 0xffffffe0, 0xffffffe0}, 219 {ZCFlag, 0x55555555, 0x55555555}, 220 {NVFlag, 0x00000020, 0x00000020}, 221 {NFlag, 0xffff8000, 0xffff8000}, 222 {ZFlag, 0x00000000, 0x00000000}, 223 {VFlag, 0xffffffe0, 0xffffffe0}, 224 {CFlag, 0xffff8001, 0xffff8001}, 225 {NZCVFlag, 0xfffffffd, 0xfffffffd}, 226 {NCVFlag, 0x0000007d, 0x0000007d}, 227 {NCVFlag, 0x0000007f, 0x0000007f}, 228 {NZFlag, 0xffff8003, 0xffff8003}, 229 {ZCFlag, 0xffffff82, 0xffffff82}, 230 {ZFlag, 0xffff8001, 0xffff8001}, 231 {NZFlag, 0xffff8002, 0xffff8002}, 232 {NZFlag, 0x00000020, 0x00000020}, 233 {NCFlag, 0x33333333, 0x33333333}, 234 {ZCVFlag, 0x80000000, 0x80000000}, 235 {NZCFlag, 0xffffffe0, 0xffffffe0}, 236 {NZFlag, 0x00007fff, 0x00007fff}, 237 {NZVFlag, 0x00000002, 0x00000002}, 238 {NFlag, 0x55555555, 0x55555555}, 239 {NVFlag, 0xffffffff, 0xffffffff}, 240 {NCFlag, 0x00007fff, 0x00007fff}, 241 {NZCVFlag, 0xffffff81, 0xffffff81}, 242 {ZCVFlag, 0x00007fff, 0x00007fff}, 243 {NZFlag, 0x0000007d, 0x0000007d}, 244 {VFlag, 0x00007ffe, 0x00007ffe}, 245 {CVFlag, 0xffffff83, 0xffffff83}, 246 {NZFlag, 0x80000000, 0x80000000}, 247 {ZCFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 248 {NCFlag, 0x0000007f, 0x0000007f}, 249 {CFlag, 0x00000020, 0x00000020}, 250 {NZCFlag, 0x00000001, 0x00000001}, 251 {NZCFlag, 0xcccccccc, 0xcccccccc}, 252 {NZCFlag, 0xffffff80, 0xffffff80}, 253 {NCVFlag, 0xffff8003, 0xffff8003}, 254 {NFlag, 0x0000007d, 0x0000007d}, 255 {NZVFlag, 0x55555555, 0x55555555}, 256 {NZCVFlag, 0xfffffffe, 0xfffffffe}, 257 {NCFlag, 0xffff8000, 0xffff8000}, 258 {CFlag, 0x80000001, 0x80000001}, 259 {NVFlag, 0xffffffe0, 0xffffffe0}, 260 {CFlag, 0xffffff82, 0xffffff82}, 261 {NZCVFlag, 0x00007ffd, 0x00007ffd}, 262 {CFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 263 {NZCFlag, 0xffffff81, 0xffffff81}, 264 {ZFlag, 0x00007ffd, 0x00007ffd}, 265 {NZVFlag, 0xffffffe0, 0xffffffe0}, 266 {NZVFlag, 0x00007ffe, 0x00007ffe}, 267 {NZFlag, 0x7ffffffd, 0x7ffffffd}, 268 {NZCFlag, 0xfffffffe, 0xfffffffe}, 269 {NZCVFlag, 0x7ffffffd, 0x7ffffffd}, 270 {ZVFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 271 {CFlag, 0x00000000, 0x00000000}, 272 {ZCVFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 273 {NZFlag, 0x00007ffd, 0x00007ffd}, 274 {VFlag, 0xffff8000, 0xffff8000}, 275 {CVFlag, 0xcccccccc, 0xcccccccc}, 276 {NZCVFlag, 0xffff8003, 0xffff8003}, 277 {NVFlag, 0x00007ffe, 0x00007ffe}, 278 {ZVFlag, 0xfffffffd, 0xfffffffd}, 279 {NZCFlag, 0x0000007e, 0x0000007e}, 280 {VFlag, 0x00000000, 0x00000000}, 281 {NZFlag, 0x00000002, 0x00000002}, 282 {ZCFlag, 0x7fffffff, 0x7fffffff}, 283 {ZFlag, 0x0000007e, 0x0000007e}, 284 {NZCFlag, 0x7fffffff, 0x7fffffff}, 285 {ZVFlag, 0xffff8002, 0xffff8002}, 286 {ZFlag, 0x00000020, 0x00000020}, 287 {NZFlag, 0xffffff81, 0xffffff81}, 288 {ZCVFlag, 0x00000000, 0x00000000}, 289 {CFlag, 0xffffff81, 0xffffff81}, 290 {NVFlag, 0x0000007e, 0x0000007e}, 291 {NZFlag, 0x55555555, 0x55555555}, 292 {CFlag, 0x0000007d, 0x0000007d}, 293 {NCFlag, 0x7fffffff, 0x7fffffff}, 294 {NCFlag, 0xffff8001, 0xffff8001}, 295 {CFlag, 0xffffffe0, 0xffffffe0}, 296 {ZVFlag, 0x7ffffffe, 0x7ffffffe}, 297 {VFlag, 0x7ffffffd, 0x7ffffffd}, 298 {CFlag, 0xffffffff, 0xffffffff}, 299 {ZCFlag, 0xffff8000, 0xffff8000}, 300 {NZVFlag, 0xffff8003, 0xffff8003}, 301 {NCFlag, 0x0000007d, 0x0000007d}, 302 {NZVFlag, 0x0000007f, 0x0000007f}, 303 {CFlag, 0xcccccccc, 0xcccccccc}, 304 {CVFlag, 0x00000001, 0x00000001}, 305 {NZCFlag, 0xffff8001, 0xffff8001}, 306 {NCVFlag, 0x00000020, 0x00000020}, 307 {NZVFlag, 0xffffff82, 0xffffff82}, 308 {NCFlag, 0x00007ffd, 0x00007ffd}, 309 {ZVFlag, 0x0000007e, 0x0000007e}, 310 {NZFlag, 0x80000001, 0x80000001}, 311 {NVFlag, 0x7ffffffe, 0x7ffffffe}, 312 {NZCVFlag, 0x00000000, 0x00000000}, 313 {CVFlag, 0x55555555, 0x55555555}, 314 {ZVFlag, 0x00000020, 0x00000020}, 315 {VFlag, 0x00000020, 0x00000020}, 316 {NFlag, 0xcccccccc, 0xcccccccc}, 317 {NVFlag, 0x0000007d, 0x0000007d}, 318 {CVFlag, 0x0000007f, 0x0000007f}, 319 {NZCFlag, 0x00000002, 0x00000002}, 320 {NZCFlag, 0x00007fff, 0x00007fff}, 321 {NZVFlag, 0x0000007d, 0x0000007d}, 322 {NZVFlag, 0xfffffffd, 0xfffffffd}, 323 {NFlag, 0x00000002, 0x00000002}, 324 {NZCVFlag, 0x0000007d, 0x0000007d}, 325 {NVFlag, 0xffffff82, 0xffffff82}, 326 {VFlag, 0x00007fff, 0x00007fff}, 327 {NZCVFlag, 0x00000001, 0x00000001}, 328 {ZFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 329 {CVFlag, 0xffff8002, 0xffff8002}, 330 {NFlag, 0x7fffffff, 0x7fffffff}, 331 {NCVFlag, 0xffffff80, 0xffffff80}, 332 {ZFlag, 0x33333333, 0x33333333}, 333 {NZFlag, 0x00000001, 0x00000001}, 334 {NCVFlag, 0x7ffffffe, 0x7ffffffe}, 335 {VFlag, 0x00000001, 0x00000001}, 336 {ZCFlag, 0x0000007f, 0x0000007f}, 337 {ZVFlag, 0x80000001, 0x80000001}, 338 {ZVFlag, 0xffff8003, 0xffff8003}, 339 {NCVFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 340 {NZCVFlag, 0xffffffe0, 0xffffffe0}, 341 {VFlag, 0x33333333, 0x33333333}, 342 {NCFlag, 0xffffff80, 0xffffff80}, 343 {ZFlag, 0x00007ffe, 0x00007ffe}, 344 {NVFlag, 0x00000000, 0x00000000}, 345 {NZCFlag, 0x00007ffd, 0x00007ffd}, 346 {NZFlag, 0xfffffffd, 0xfffffffd}, 347 {VFlag, 0xffffffff, 0xffffffff}, 348 {NZCFlag, 0xffffff83, 0xffffff83}, 349 {NZVFlag, 0xffff8002, 0xffff8002}, 350 {NZCVFlag, 0x33333333, 0x33333333}, 351 {ZCVFlag, 0xfffffffd, 0xfffffffd}, 352 {ZCFlag, 0x80000001, 0x80000001}, 353 {NCFlag, 0x00007ffe, 0x00007ffe}, 354 {NFlag, 0xfffffffd, 0xfffffffd}, 355 {NZCVFlag, 0x7fffffff, 0x7fffffff}, 356 {VFlag, 0xffff8001, 0xffff8001}, 357 {NZVFlag, 0xffff8000, 0xffff8000}, 358 {ZCVFlag, 0xcccccccc, 0xcccccccc}, 359 {VFlag, 0x7ffffffe, 0x7ffffffe}, 360 {ZFlag, 0xffff8002, 0xffff8002}, 361 {ZCFlag, 0x0000007d, 0x0000007d}, 362 {NZCVFlag, 0xffffff83, 0xffffff83}, 363 {ZVFlag, 0x00000001, 0x00000001}, 364 {NZCVFlag, 0xffff8002, 0xffff8002}, 365 {ZCFlag, 0xffffff83, 0xffffff83}, 366 {CFlag, 0xffff8003, 0xffff8003}, 367 {NCVFlag, 0xffffffff, 0xffffffff}, 368 {CFlag, 0xfffffffe, 0xfffffffe}, 369 {NZFlag, 0xffffff80, 0xffffff80}, 370 {CVFlag, 0x00007ffd, 0x00007ffd}, 371 {ZCVFlag, 0x0000007d, 0x0000007d}, 372 {ZVFlag, 0xcccccccc, 0xcccccccc}, 373 {NVFlag, 0x00007ffd, 0x00007ffd}, 374 {NZFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 375 {ZFlag, 0x0000007f, 0x0000007f}, 376 {CVFlag, 0xffff8003, 0xffff8003}, 377 {ZFlag, 0xffffffe0, 0xffffffe0}, 378 {NZVFlag, 0xcccccccc, 0xcccccccc}, 379 {NFlag, 0x00007ffe, 0x00007ffe}, 380 {NFlag, 0xffff8003, 0xffff8003}, 381 {NZVFlag, 0xffffffff, 0xffffffff}, 382 {CFlag, 0x00007fff, 0x00007fff}, 383 {NCVFlag, 0x7fffffff, 0x7fffffff}, 384 {CFlag, 0x33333333, 0x33333333}, 385 {ZCFlag, 0x80000000, 0x80000000}, 386 {ZCFlag, 0x0000007e, 0x0000007e}, 387 {NVFlag, 0x7fffffff, 0x7fffffff}, 388 {NZFlag, 0x7ffffffe, 0x7ffffffe}, 389 {CFlag, 0xffff8002, 0xffff8002}, 390 {NCFlag, 0x80000000, 0x80000000}, 391 {VFlag, 0x7fffffff, 0x7fffffff}, 392 {NZFlag, 0xffffffff, 0xffffffff}, 393 {NFlag, 0x7ffffffd, 0x7ffffffd}, 394 {ZFlag, 0x00000002, 0x00000002}, 395 {ZCVFlag, 0xffff8003, 0xffff8003}, 396 {CFlag, 0x7fffffff, 0x7fffffff}, 397 {CFlag, 0x0000007f, 0x0000007f}, 398 {VFlag, 0x80000001, 0x80000001}, 399 {ZCFlag, 0x00007fff, 0x00007fff}, 400 {CFlag, 0xfffffffd, 0xfffffffd}, 401 {NZFlag, 0x7fffffff, 0x7fffffff}, 402 {CVFlag, 0xffff8001, 0xffff8001}, 403 {NZVFlag, 0x00007fff, 0x00007fff}, 404 {NZVFlag, 0x7ffffffe, 0x7ffffffe}, 405 {ZCVFlag, 0x0000007e, 0x0000007e}, 406 {NZVFlag, 0x00000001, 0x00000001}, 407 {ZFlag, 0xffffffff, 0xffffffff}, 408 {NZFlag, 0xfffffffe, 0xfffffffe}, 409 {NZCVFlag, 0x0000007f, 0x0000007f}, 410 {NZCVFlag, 0x80000000, 0x80000000}, 411 {VFlag, 0x55555555, 0x55555555}, 412 {NVFlag, 0xffff8001, 0xffff8001}, 413 {NFlag, 0xffffff83, 0xffffff83}, 414 {NZVFlag, 0x7ffffffd, 0x7ffffffd}, 415 {ZVFlag, 0x00000000, 0x00000000}, 416 {NCVFlag, 0xfffffffd, 0xfffffffd}, 417 {CFlag, 0x00007ffe, 0x00007ffe}, 418 {NVFlag, 0xffffff83, 0xffffff83}, 419 {NZFlag, 0x0000007e, 0x0000007e}, 420 {VFlag, 0x80000000, 0x80000000}, 421 {NZCFlag, 0xffff8000, 0xffff8000}, 422 {ZCFlag, 0xffff8001, 0xffff8001}, 423 {NVFlag, 0x00007fff, 0x00007fff}, 424 {ZCVFlag, 0xffffff81, 0xffffff81}, 425 {NZVFlag, 0x0000007e, 0x0000007e}, 426 {CVFlag, 0xffff8000, 0xffff8000}, 427 {VFlag, 0xffffff82, 0xffffff82}, 428 {VFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 429 {NZCVFlag, 0xcccccccc, 0xcccccccc}, 430 {CVFlag, 0x33333333, 0x33333333}, 431 {NCFlag, 0xffffffff, 0xffffffff}, 432 {VFlag, 0xffffff80, 0xffffff80}, 433 {NVFlag, 0xffff8002, 0xffff8002}, 434 {ZCFlag, 0x00000000, 0x00000000}, 435 {ZCVFlag, 0x80000001, 0x80000001}, 436 {NZCVFlag, 0x80000001, 0x80000001}, 437 {NCFlag, 0x55555555, 0x55555555}, 438 {CVFlag, 0x7ffffffe, 0x7ffffffe}, 439 {ZVFlag, 0x7ffffffd, 0x7ffffffd}, 440 {ZCVFlag, 0xffff8000, 0xffff8000}, 441 {ZCFlag, 0xffff8002, 0xffff8002}, 442 {NFlag, 0xfffffffe, 0xfffffffe}, 443 {ZCVFlag, 0x0000007f, 0x0000007f}, 444 {NCVFlag, 0xfffffffe, 0xfffffffe}, 445 {ZCVFlag, 0x7fffffff, 0x7fffffff}, 446 {CVFlag, 0x0000007e, 0x0000007e}, 447 {NZCVFlag, 0x7ffffffe, 0x7ffffffe}, 448 {CFlag, 0xffffff80, 0xffffff80}, 449 {VFlag, 0x00007ffd, 0x00007ffd}, 450 {CVFlag, 0xffffffe0, 0xffffffe0}, 451 {CFlag, 0x7ffffffe, 0x7ffffffe}, 452 {CFlag, 0x80000000, 0x80000000}, 453 {CVFlag, 0xfffffffe, 0xfffffffe}, 454 {NCVFlag, 0xffff8002, 0xffff8002}, 455 {ZCVFlag, 0x33333333, 0x33333333}, 456 {NZCFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 457 {NVFlag, 0x55555555, 0x55555555}, 458 {NVFlag, 0x80000000, 0x80000000}, 459 {NZCVFlag, 0x00007ffe, 0x00007ffe}, 460 {ZFlag, 0xffffff83, 0xffffff83}, 461 {NCFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 462 {NZVFlag, 0xfffffffe, 0xfffffffe}, 463 {CVFlag, 0xaaaaaaaa, 0xaaaaaaaa}, 464 {NZCFlag, 0xffff8002, 0xffff8002}, 465 {VFlag, 0x0000007d, 0x0000007d}}; 466 467 static const Inputs kRdIsNotRn[] = {{NZCVFlag, 0xffff8000, 0xffffffff}, 468 {CVFlag, 0xcccccccc, 0xffffff80}, 469 {NCFlag, 0xfffffffe, 0xfffffffd}, 470 {NCFlag, 0xcccccccc, 0xcccccccc}, 471 {ZFlag, 0x80000001, 0xffffffff}, 472 {NCFlag, 0xffffff82, 0x0000007d}, 473 {NCVFlag, 0x0000007d, 0xffff8001}, 474 {NVFlag, 0x00007fff, 0x7fffffff}, 475 {NVFlag, 0x80000001, 0xffffff82}, 476 {ZCVFlag, 0xffffffff, 0x0000007e}, 477 {ZCVFlag, 0xffffff80, 0x0000007d}, 478 {ZCVFlag, 0x00000020, 0xaaaaaaaa}, 479 {CVFlag, 0x00007fff, 0x00000020}, 480 {NVFlag, 0xffff8000, 0xffffff82}, 481 {NZFlag, 0xffffff82, 0x7ffffffe}, 482 {NZVFlag, 0xffff8003, 0x33333333}, 483 {ZCVFlag, 0x00007ffe, 0x7ffffffe}, 484 {NFlag, 0x0000007f, 0xffffffff}, 485 {NZCFlag, 0x33333333, 0x80000000}, 486 {ZCFlag, 0x80000001, 0xffffffff}, 487 {VFlag, 0x00007ffd, 0x00000001}, 488 {ZVFlag, 0xffffffff, 0x0000007e}, 489 {NZFlag, 0x00000001, 0xcccccccc}, 490 {NZVFlag, 0x00000020, 0xffff8001}, 491 {NCVFlag, 0x7ffffffe, 0xffffff80}, 492 {ZCFlag, 0x33333333, 0x00007fff}, 493 {CFlag, 0xffffff82, 0x0000007e}, 494 {ZCFlag, 0x55555555, 0xffff8003}, 495 {NFlag, 0x0000007f, 0x00000001}, 496 {ZCVFlag, 0x00000020, 0xfffffffd}, 497 {ZVFlag, 0x0000007e, 0xffff8003}, 498 {ZCVFlag, 0x00000020, 0x80000001}, 499 {ZCFlag, 0xfffffffe, 0x55555555}, 500 {NFlag, 0xfffffffd, 0xfffffffe}, 501 {VFlag, 0xffffff82, 0x7ffffffe}, 502 {CVFlag, 0xffffff80, 0x0000007f}, 503 {NVFlag, 0x00000020, 0xffff8001}, 504 {NCFlag, 0x0000007d, 0x80000000}, 505 {CVFlag, 0x00000020, 0xffffff83}, 506 {NZCVFlag, 0x0000007f, 0x00000000}, 507 {ZVFlag, 0xffffff82, 0x7ffffffd}, 508 {ZVFlag, 0xffff8000, 0x80000001}, 509 {NFlag, 0xcccccccc, 0x0000007e}, 510 {NFlag, 0x55555555, 0xffffff80}, 511 {NCFlag, 0x80000000, 0x00007ffd}, 512 {ZVFlag, 0x00007ffd, 0x00007ffe}, 513 {ZCVFlag, 0x00000000, 0x7ffffffe}, 514 {ZFlag, 0xffff8001, 0xffffffff}, 515 {NCFlag, 0xfffffffe, 0x55555555}, 516 {VFlag, 0x7ffffffd, 0x80000001}, 517 {VFlag, 0x80000000, 0xffffffff}, 518 {CFlag, 0xffffff82, 0xffffff80}, 519 {NZCFlag, 0xffff8003, 0xfffffffd}, 520 {CFlag, 0x00000020, 0x00007fff}, 521 {NZVFlag, 0xffff8002, 0xfffffffe}, 522 {NVFlag, 0xffffff80, 0x0000007e}, 523 {NVFlag, 0xcccccccc, 0x0000007d}, 524 {CFlag, 0x0000007f, 0x00000001}, 525 {ZVFlag, 0xffff8002, 0xffffff81}, 526 {NZVFlag, 0x80000000, 0x00007ffe}, 527 {NZCVFlag, 0x80000000, 0x7ffffffe}, 528 {ZVFlag, 0x7ffffffe, 0x80000000}, 529 {ZFlag, 0xffff8000, 0xffffff80}, 530 {VFlag, 0x00007ffd, 0x00007ffd}, 531 {ZCFlag, 0x0000007d, 0x0000007e}, 532 {NCFlag, 0x00000000, 0x7ffffffe}, 533 {NVFlag, 0x00000020, 0xaaaaaaaa}, 534 {NVFlag, 0xffffff83, 0x0000007e}, 535 {NZFlag, 0xffff8002, 0x7ffffffd}, 536 {CVFlag, 0xcccccccc, 0x00000001}, 537 {NZFlag, 0x33333333, 0x0000007e}, 538 {NZCFlag, 0x00000002, 0x7ffffffd}, 539 {NZFlag, 0x00007ffd, 0xffffff80}, 540 {ZVFlag, 0x00007ffd, 0xfffffffe}, 541 {NZCVFlag, 0xffff8000, 0x80000000}, 542 {NZFlag, 0xffff8002, 0xffffffff}, 543 {CFlag, 0x00000002, 0xffff8000}, 544 {NZCFlag, 0x0000007d, 0xffffff80}, 545 {ZVFlag, 0x0000007d, 0xffff8003}, 546 {VFlag, 0x55555555, 0xffff8000}, 547 {CFlag, 0x00007fff, 0x00000001}, 548 {VFlag, 0x80000001, 0x33333333}, 549 {ZCFlag, 0xaaaaaaaa, 0xffffff82}, 550 {VFlag, 0x00000002, 0x00007ffd}, 551 {ZVFlag, 0x7ffffffe, 0xffff8001}, 552 {ZCFlag, 0x7fffffff, 0x00000000}, 553 {CVFlag, 0x55555555, 0x0000007e}, 554 {VFlag, 0x55555555, 0x0000007e}, 555 {NZCVFlag, 0x80000000, 0x7ffffffd}, 556 {ZFlag, 0x0000007d, 0x00000000}, 557 {NZVFlag, 0xffffff80, 0x00000002}, 558 {NVFlag, 0xfffffffd, 0x00000001}, 559 {ZVFlag, 0x7ffffffd, 0xfffffffd}, 560 {VFlag, 0xffff8002, 0x55555555}, 561 {ZCVFlag, 0x00000001, 0xffff8002}, 562 {NVFlag, 0xffff8002, 0x00000020}, 563 {ZFlag, 0x33333333, 0xffff8002}, 564 {ZCVFlag, 0x55555555, 0xffffff82}, 565 {CVFlag, 0x7ffffffe, 0xffffffe0}, 566 {NVFlag, 0xcccccccc, 0x00007ffd}, 567 {NZFlag, 0x00000001, 0x0000007f}, 568 {ZFlag, 0xfffffffe, 0x00007fff}, 569 {NCVFlag, 0x80000001, 0xffffff83}, 570 {NCVFlag, 0xaaaaaaaa, 0xffff8002}, 571 {ZVFlag, 0x00007fff, 0xffff8000}, 572 {ZFlag, 0xffff8001, 0xfffffffd}, 573 {CFlag, 0x55555555, 0x80000000}, 574 {ZCVFlag, 0xcccccccc, 0xfffffffe}, 575 {NZCVFlag, 0xffff8003, 0x7fffffff}, 576 {NZCVFlag, 0x00007ffe, 0xffffff81}, 577 {NZCFlag, 0xfffffffd, 0xaaaaaaaa}, 578 {NVFlag, 0x00000002, 0x00000020}, 579 {ZCVFlag, 0xffff8003, 0xfffffffd}, 580 {NFlag, 0xffff8001, 0x00007ffe}, 581 {ZCFlag, 0xaaaaaaaa, 0x00000002}, 582 {NCVFlag, 0xffff8000, 0xfffffffe}, 583 {CFlag, 0x00000020, 0x00000000}, 584 {NZVFlag, 0x00007ffd, 0xffffff81}, 585 {NVFlag, 0x00007fff, 0x00000020}, 586 {ZFlag, 0x0000007e, 0x80000001}, 587 {CVFlag, 0x0000007d, 0xaaaaaaaa}, 588 {NZVFlag, 0x7fffffff, 0x55555555}, 589 {VFlag, 0xffffffff, 0x00007ffd}, 590 {NFlag, 0x80000000, 0xffffffe0}, 591 {ZVFlag, 0xffffff82, 0xfffffffe}, 592 {CVFlag, 0x0000007d, 0x00007fff}, 593 {CFlag, 0x7ffffffe, 0x55555555}, 594 {ZFlag, 0xffffff82, 0x7fffffff}, 595 {NZCFlag, 0xfffffffd, 0xffffff83}, 596 {CVFlag, 0x80000001, 0x80000000}, 597 {ZVFlag, 0x00000001, 0xfffffffe}, 598 {CVFlag, 0x00000001, 0x33333333}, 599 {NZFlag, 0x7ffffffd, 0x80000000}, 600 {NZVFlag, 0x00007ffd, 0xaaaaaaaa}, 601 {CVFlag, 0x0000007e, 0xffffff82}, 602 {CVFlag, 0x7ffffffe, 0xffff8002}, 603 {NVFlag, 0xfffffffe, 0xffff8003}, 604 {NFlag, 0x7fffffff, 0x80000001}, 605 {CFlag, 0xffffff82, 0x00000002}, 606 {CVFlag, 0xcccccccc, 0x0000007e}, 607 {NZCVFlag, 0x00000001, 0x7ffffffe}, 608 {NFlag, 0x00000000, 0x55555555}, 609 {NZFlag, 0xffffff81, 0x00000000}, 610 {NZVFlag, 0xffffffe0, 0x0000007e}, 611 {ZCFlag, 0xffff8002, 0xaaaaaaaa}, 612 {NZVFlag, 0x7fffffff, 0x0000007d}, 613 {ZVFlag, 0x0000007e, 0xffff8001}, 614 {NCVFlag, 0xffffff83, 0xaaaaaaaa}, 615 {ZFlag, 0xffffff82, 0xffffff83}, 616 {VFlag, 0x00000001, 0x55555555}, 617 {NFlag, 0x00000020, 0x80000000}, 618 {NZFlag, 0x00000000, 0xfffffffe}, 619 {VFlag, 0xffffff83, 0xaaaaaaaa}, 620 {ZFlag, 0xffff8002, 0xffffff83}, 621 {NZVFlag, 0xcccccccc, 0x7ffffffe}, 622 {ZVFlag, 0x00000000, 0x55555555}, 623 {NCFlag, 0x33333333, 0xffff8003}, 624 {NZCVFlag, 0xfffffffd, 0x00000000}, 625 {NZCVFlag, 0x00000020, 0xffff8000}, 626 {CVFlag, 0xffff8001, 0xffffff83}, 627 {CFlag, 0xffffff83, 0x33333333}, 628 {CVFlag, 0x7ffffffd, 0x00000020}, 629 {NCVFlag, 0xffffffe0, 0x80000000}, 630 {NCVFlag, 0xffffff82, 0xcccccccc}, 631 {NZCVFlag, 0xaaaaaaaa, 0x00007fff}, 632 {VFlag, 0xcccccccc, 0xffff8003}, 633 {ZCVFlag, 0x55555555, 0xffffffe0}, 634 {NZCFlag, 0xffffff83, 0xffff8000}, 635 {ZVFlag, 0xffff8001, 0x0000007d}, 636 {CVFlag, 0xffffff83, 0x00000002}, 637 {NVFlag, 0x7fffffff, 0x0000007d}, 638 {VFlag, 0x55555555, 0x33333333}, 639 {NCVFlag, 0x00000002, 0xffffff80}, 640 {ZFlag, 0xfffffffd, 0x00007fff}, 641 {ZCFlag, 0xffff8003, 0x0000007d}, 642 {NZCFlag, 0xffff8002, 0xffff8000}, 643 {NCVFlag, 0x00000020, 0xffff8002}, 644 {ZVFlag, 0xffff8000, 0x00000020}, 645 {ZCVFlag, 0x0000007f, 0xffffffe0}, 646 {NZCFlag, 0xffffff80, 0x33333333}, 647 {NCVFlag, 0x00007fff, 0xaaaaaaaa}, 648 {ZCVFlag, 0x00000020, 0xffffff82}, 649 {NFlag, 0x00000000, 0x0000007d}, 650 {NCVFlag, 0x00000001, 0x00007ffe}, 651 {ZFlag, 0x80000001, 0x00000002}, 652 {NZVFlag, 0xffff8000, 0x00000020}, 653 {CVFlag, 0xffff8002, 0xcccccccc}, 654 {NVFlag, 0xffffff83, 0x80000000}, 655 {ZCFlag, 0x0000007f, 0xffffff80}, 656 {NZFlag, 0xcccccccc, 0xffffffff}, 657 {NZFlag, 0x00007fff, 0x0000007f}, 658 {NZFlag, 0xfffffffd, 0xffff8001}, 659 {CFlag, 0x0000007d, 0x7ffffffd}, 660 {ZCFlag, 0xffff8000, 0xffff8003}, 661 {ZVFlag, 0xffffffff, 0xffffffe0}, 662 {NZCFlag, 0x00007ffd, 0xcccccccc}, 663 {NCVFlag, 0x0000007d, 0x00000020}, 664 {ZCFlag, 0xaaaaaaaa, 0x80000000}, 665 {ZCVFlag, 0xfffffffd, 0x0000007d}, 666 {ZFlag, 0xffffffe0, 0xfffffffe}, 667 {VFlag, 0xffff8003, 0x80000000}, 668 {NZCFlag, 0x00007fff, 0xffffff82}, 669 {NCVFlag, 0x00000002, 0x33333333}, 670 {NZCVFlag, 0x00000000, 0xffffff82}, 671 {VFlag, 0x80000000, 0x80000000}, 672 {ZVFlag, 0x80000001, 0x33333333}, 673 {ZFlag, 0x7ffffffe, 0x00007fff}, 674 {NZCVFlag, 0x7fffffff, 0x00007fff}, 675 {ZCFlag, 0xffffff83, 0xaaaaaaaa}, 676 {NZVFlag, 0xffff8002, 0xffffffe0}, 677 {VFlag, 0xfffffffd, 0xffffff81}, 678 {NZFlag, 0x7fffffff, 0x7ffffffd}, 679 {NZCVFlag, 0x0000007f, 0xcccccccc}, 680 {NZCFlag, 0xffff8001, 0x00000020}, 681 {ZFlag, 0x00000020, 0xffff8002}, 682 {ZVFlag, 0x55555555, 0x00007ffd}, 683 {NZVFlag, 0xcccccccc, 0x33333333}, 684 {CFlag, 0x80000000, 0x80000000}, 685 {ZCVFlag, 0xcccccccc, 0x00007ffd}, 686 {ZFlag, 0xffff8002, 0xffffff80}, 687 {CVFlag, 0x7ffffffd, 0xffffff80}, 688 {NZCVFlag, 0x00000001, 0x00000001}, 689 {NFlag, 0xfffffffe, 0xffffffe0}, 690 {ZVFlag, 0x0000007e, 0x0000007f}, 691 {NCVFlag, 0xffff8002, 0xffff8002}, 692 {ZCVFlag, 0xffffff82, 0x80000001}, 693 {CVFlag, 0x0000007d, 0x0000007d}, 694 {NZVFlag, 0xcccccccc, 0xffffff83}, 695 {VFlag, 0xffffff82, 0xfffffffd}, 696 {CFlag, 0x0000007d, 0x0000007f}, 697 {NFlag, 0x0000007d, 0x00000001}, 698 {NVFlag, 0x00007ffd, 0xfffffffe}, 699 {NZVFlag, 0x33333333, 0xffffff80}, 700 {NVFlag, 0x0000007e, 0x00007ffe}, 701 {ZFlag, 0xffff8001, 0x0000007e}, 702 {VFlag, 0x80000000, 0x00000002}, 703 {NVFlag, 0x00000020, 0x00007ffe}, 704 {CFlag, 0x00007ffe, 0x0000007f}, 705 {ZCFlag, 0xffff8002, 0x00000020}, 706 {NCVFlag, 0x00000001, 0xffff8000}, 707 {NZCVFlag, 0x0000007e, 0xffff8001}, 708 {ZCFlag, 0x0000007f, 0xffffff81}, 709 {ZVFlag, 0xfffffffd, 0x00007ffd}, 710 {NCFlag, 0x0000007d, 0xcccccccc}, 711 {NZFlag, 0xfffffffd, 0xfffffffe}, 712 {ZCFlag, 0xffff8003, 0x80000000}, 713 {CFlag, 0x0000007d, 0xffff8002}, 714 {ZVFlag, 0x0000007f, 0x00007ffe}, 715 {NCVFlag, 0xffff8002, 0x00000001}, 716 {ZCFlag, 0x80000001, 0x0000007e}, 717 {NCFlag, 0x00000000, 0xaaaaaaaa}, 718 {ZCVFlag, 0x33333333, 0x80000001}, 719 {CFlag, 0x80000000, 0x0000007d}, 720 {NCVFlag, 0x80000001, 0x80000000}, 721 {ZCVFlag, 0x7ffffffe, 0xffffff82}, 722 {ZCFlag, 0xfffffffd, 0xffff8000}, 723 {ZFlag, 0x80000000, 0x55555555}, 724 {ZVFlag, 0x0000007d, 0xffff8000}, 725 {ZCFlag, 0x80000001, 0xffff8001}, 726 {NVFlag, 0xffff8002, 0x00007ffe}, 727 {ZCFlag, 0x00000000, 0xffff8000}, 728 {CFlag, 0xffffff81, 0xffffffff}, 729 {CFlag, 0xffffffff, 0x80000001}, 730 {CFlag, 0x80000001, 0x7ffffffd}, 731 {ZFlag, 0x80000001, 0x00007fff}, 732 {ZVFlag, 0xffff8002, 0xffff8001}, 733 {NZFlag, 0x80000000, 0x00007ffd}, 734 {NZCFlag, 0x33333333, 0xcccccccc}, 735 {ZCFlag, 0xffffffff, 0x33333333}, 736 {VFlag, 0x80000001, 0x55555555}, 737 {CFlag, 0xffffff82, 0x00000001}, 738 {ZVFlag, 0xffff8003, 0xffff8001}, 739 {NCVFlag, 0xffff8003, 0xffffffe0}, 740 {ZCVFlag, 0xffffffe0, 0x7ffffffd}, 741 {NFlag, 0xffff8003, 0x7ffffffe}, 742 {VFlag, 0xffffffff, 0x00000001}, 743 {CVFlag, 0xcccccccc, 0xfffffffe}, 744 {NZVFlag, 0xffff8003, 0x0000007f}, 745 {NZVFlag, 0x0000007d, 0x00000002}, 746 {NVFlag, 0x0000007d, 0x00000000}, 747 {NVFlag, 0x00000002, 0xffff8002}, 748 {ZCVFlag, 0xffff8001, 0xfffffffd}, 749 {CVFlag, 0x00007fff, 0x0000007d}, 750 {NCFlag, 0x33333333, 0x00000002}, 751 {NCVFlag, 0xcccccccc, 0xaaaaaaaa}, 752 {CVFlag, 0x80000000, 0x00007ffd}, 753 {NZFlag, 0xffffff81, 0x55555555}, 754 {CFlag, 0xffff8003, 0x33333333}, 755 {NZCVFlag, 0xffffffe0, 0xffffff82}, 756 {NVFlag, 0x80000001, 0xfffffffd}, 757 {CFlag, 0xffff8000, 0x33333333}, 758 {NCVFlag, 0xffff8003, 0x0000007f}, 759 {CFlag, 0x00000000, 0x0000007d}, 760 {NVFlag, 0x0000007e, 0xcccccccc}, 761 {NZFlag, 0x7ffffffe, 0xffffffe0}, 762 {ZVFlag, 0xffffffe0, 0xffffff82}, 763 {ZCVFlag, 0x80000001, 0x55555555}, 764 {NZFlag, 0xcccccccc, 0xffff8001}, 765 {NFlag, 0x55555555, 0x00000020}, 766 {ZVFlag, 0x00007ffd, 0xffffff83}}; 767 768 static const Inputs kImmediate[] = {{CFlag, 0xabababab, 0xffffff82}, 769 {CVFlag, 0xabababab, 0x0000007f}, 770 {NFlag, 0xabababab, 0x80000001}, 771 {NZFlag, 0xabababab, 0xfffffffd}, 772 {VFlag, 0xabababab, 0x7ffffffd}, 773 {CFlag, 0xabababab, 0x7ffffffe}, 774 {ZFlag, 0xabababab, 0xaaaaaaaa}, 775 {NZVFlag, 0xabababab, 0x0000007e}, 776 {NZVFlag, 0xabababab, 0x80000001}, 777 {CFlag, 0xabababab, 0xffffff81}, 778 {NZVFlag, 0xabababab, 0xfffffffd}, 779 {NZFlag, 0xabababab, 0x00007fff}, 780 {VFlag, 0xabababab, 0x00000001}, 781 {CVFlag, 0xabababab, 0xffffffff}, 782 {NZCVFlag, 0xabababab, 0xffffffff}, 783 {CFlag, 0xabababab, 0x00000000}, 784 {NZFlag, 0xabababab, 0xffffff83}, 785 {NCFlag, 0xabababab, 0x0000007e}, 786 {NZCVFlag, 0xabababab, 0x7fffffff}, 787 {ZCVFlag, 0xabababab, 0x00000002}, 788 {CFlag, 0xabababab, 0x80000000}, 789 {NZCFlag, 0xabababab, 0x7ffffffd}, 790 {ZFlag, 0xabababab, 0xffff8000}, 791 {CFlag, 0xabababab, 0x7ffffffd}, 792 {NVFlag, 0xabababab, 0x55555555}, 793 {NZCFlag, 0xabababab, 0xfffffffd}, 794 {CVFlag, 0xabababab, 0xaaaaaaaa}, 795 {NZCVFlag, 0xabababab, 0xffff8003}, 796 {NZFlag, 0xabababab, 0xffffffe0}, 797 {NZCFlag, 0xabababab, 0x00007ffd}, 798 {ZCVFlag, 0xabababab, 0xffffff80}, 799 {NZFlag, 0xabababab, 0x7ffffffd}, 800 {ZCFlag, 0xabababab, 0x7fffffff}, 801 {ZVFlag, 0xabababab, 0xffffff81}, 802 {VFlag, 0xabababab, 0x7fffffff}, 803 {NCVFlag, 0xabababab, 0xcccccccc}, 804 {ZVFlag, 0xabababab, 0x00007fff}, 805 {NZFlag, 0xabababab, 0x00000002}, 806 {NVFlag, 0xabababab, 0x00000002}, 807 {ZVFlag, 0xabababab, 0xffff8002}, 808 {NZVFlag, 0xabababab, 0x00000020}, 809 {ZCVFlag, 0xabababab, 0xaaaaaaaa}, 810 {ZCFlag, 0xabababab, 0x00000000}, 811 {NZCVFlag, 0xabababab, 0xaaaaaaaa}, 812 {NZFlag, 0xabababab, 0xfffffffe}, 813 {NZCFlag, 0xabababab, 0xffffffe0}, 814 {NFlag, 0xabababab, 0xaaaaaaaa}, 815 {ZVFlag, 0xabababab, 0xffffff80}, 816 {VFlag, 0xabababab, 0x0000007f}, 817 {ZVFlag, 0xabababab, 0x33333333}, 818 {NZFlag, 0xabababab, 0x00007ffd}, 819 {NCFlag, 0xabababab, 0x00000002}, 820 {NVFlag, 0xabababab, 0x00007ffd}, 821 {ZFlag, 0xabababab, 0x00000001}, 822 {CVFlag, 0xabababab, 0x7fffffff}, 823 {CFlag, 0xabababab, 0xaaaaaaaa}, 824 {NZCVFlag, 0xabababab, 0x80000001}, 825 {CVFlag, 0xabababab, 0x00000002}, 826 {ZVFlag, 0xabababab, 0x0000007e}, 827 {VFlag, 0xabababab, 0xffffffff}, 828 {NCFlag, 0xabababab, 0x00000001}, 829 {NZCFlag, 0xabababab, 0xcccccccc}, 830 {CVFlag, 0xabababab, 0x80000001}, 831 {NVFlag, 0xabababab, 0xffffff82}, 832 {NZCVFlag, 0xabababab, 0x0000007e}, 833 {CFlag, 0xabababab, 0xffffffe0}, 834 {ZCFlag, 0xabababab, 0xffff8002}, 835 {NZVFlag, 0xabababab, 0x7fffffff}, 836 {NZVFlag, 0xabababab, 0x33333333}, 837 {NZCFlag, 0xabababab, 0x0000007d}, 838 {NFlag, 0xabababab, 0x7ffffffe}, 839 {ZCVFlag, 0xabababab, 0xcccccccc}, 840 {ZCFlag, 0xabababab, 0xfffffffe}, 841 {NVFlag, 0xabababab, 0x00007ffe}, 842 {NZFlag, 0xabababab, 0x00007ffe}, 843 {NCVFlag, 0xabababab, 0xffffff82}, 844 {NZVFlag, 0xabababab, 0x00000002}, 845 {ZVFlag, 0xabababab, 0x7fffffff}, 846 {NZCFlag, 0xabababab, 0xffff8001}, 847 {VFlag, 0xabababab, 0xffffff83}, 848 {ZCVFlag, 0xabababab, 0x0000007e}, 849 {NZCFlag, 0xabababab, 0xffffff83}, 850 {NCFlag, 0xabababab, 0x00007fff}, 851 {NCVFlag, 0xabababab, 0x7ffffffe}, 852 {CFlag, 0xabababab, 0x00000020}, 853 {NFlag, 0xabababab, 0x00007ffd}, 854 {NZFlag, 0xabababab, 0x7fffffff}, 855 {NZCFlag, 0xabababab, 0xffff8002}, 856 {ZVFlag, 0xabababab, 0x0000007f}, 857 {NZVFlag, 0xabababab, 0xffffff83}, 858 {NZVFlag, 0xabababab, 0xffffffff}, 859 {ZFlag, 0xabababab, 0x80000000}, 860 {ZVFlag, 0xabababab, 0xffffff82}, 861 {ZVFlag, 0xabababab, 0x80000000}, 862 {NZFlag, 0xabababab, 0xaaaaaaaa}, 863 {CFlag, 0xabababab, 0xfffffffe}, 864 {NZCVFlag, 0xabababab, 0x00000000}, 865 {VFlag, 0xabababab, 0x80000001}, 866 {ZCVFlag, 0xabababab, 0xfffffffd}, 867 {NFlag, 0xabababab, 0xffffffff}, 868 {VFlag, 0xabababab, 0xcccccccc}, 869 {NFlag, 0xabababab, 0xffff8003}, 870 {NZVFlag, 0xabababab, 0xfffffffe}, 871 {CVFlag, 0xabababab, 0xffff8001}, 872 {NZVFlag, 0xabababab, 0x00007fff}, 873 {VFlag, 0xabababab, 0x33333333}, 874 {ZCVFlag, 0xabababab, 0x00007ffd}, 875 {NCFlag, 0xabababab, 0xfffffffe}, 876 {ZVFlag, 0xabababab, 0xffffff83}, 877 {NFlag, 0xabababab, 0x00007fff}, 878 {NVFlag, 0xabababab, 0x80000000}, 879 {NCVFlag, 0xabababab, 0xffffff80}, 880 {ZFlag, 0xabababab, 0x7fffffff}, 881 {NFlag, 0xabababab, 0x00000020}, 882 {NFlag, 0xabababab, 0x7ffffffd}, 883 {NFlag, 0xabababab, 0x0000007f}, 884 {NZCVFlag, 0xabababab, 0x00000020}, 885 {NCVFlag, 0xabababab, 0xfffffffe}, 886 {ZVFlag, 0xabababab, 0xcccccccc}, 887 {NCFlag, 0xabababab, 0xffffffe0}, 888 {CVFlag, 0xabababab, 0xffffff82}, 889 {NCFlag, 0xabababab, 0x00000000}, 890 {VFlag, 0xabababab, 0xffff8000}, 891 {VFlag, 0xabababab, 0xffff8003}, 892 {NCFlag, 0xabababab, 0xffffffff}, 893 {NZCFlag, 0xabababab, 0x55555555}, 894 {ZVFlag, 0xabababab, 0xfffffffe}, 895 {NZFlag, 0xabababab, 0x7ffffffe}, 896 {ZCVFlag, 0xabababab, 0x7ffffffe}, 897 {ZVFlag, 0xabababab, 0xffffffe0}, 898 {NZCFlag, 0xabababab, 0x0000007e}, 899 {CFlag, 0xabababab, 0x7fffffff}, 900 {NZVFlag, 0xabababab, 0x55555555}, 901 {NZCVFlag, 0xabababab, 0xcccccccc}, 902 {ZCVFlag, 0xabababab, 0x80000000}, 903 {NFlag, 0xabababab, 0x55555555}, 904 {ZCVFlag, 0xabababab, 0xffffffe0}, 905 {NCFlag, 0xabababab, 0xffff8000}, 906 {NCFlag, 0xabababab, 0xffff8001}, 907 {NVFlag, 0xabababab, 0x7ffffffe}, 908 {ZVFlag, 0xabababab, 0x00007ffe}, 909 {NVFlag, 0xabababab, 0x00000020}, 910 {NFlag, 0xabababab, 0x7fffffff}, 911 {NZFlag, 0xabababab, 0x33333333}, 912 {ZCFlag, 0xabababab, 0xffff8001}, 913 {ZFlag, 0xabababab, 0xffffffe0}, 914 {VFlag, 0xabababab, 0xffffffe0}, 915 {VFlag, 0xabababab, 0xffffff80}, 916 {NCVFlag, 0xabababab, 0x80000000}, 917 {ZCFlag, 0xabababab, 0x55555555}, 918 {CFlag, 0xabababab, 0xffff8001}, 919 {CFlag, 0xabababab, 0xffff8002}, 920 {ZVFlag, 0xabababab, 0xffff8000}, 921 {CFlag, 0xabababab, 0x80000001}, 922 {NZCVFlag, 0xabababab, 0x0000007d}, 923 {NZCVFlag, 0xabababab, 0xfffffffd}, 924 {CVFlag, 0xabababab, 0xffffff81}, 925 {NVFlag, 0xabababab, 0xffff8002}, 926 {ZCFlag, 0xabababab, 0x7ffffffe}, 927 {ZCVFlag, 0xabababab, 0xffffff82}, 928 {ZCVFlag, 0xabababab, 0x33333333}, 929 {NCFlag, 0xabababab, 0x33333333}, 930 {NZCVFlag, 0xabababab, 0x00000002}, 931 {NFlag, 0xabababab, 0x00000001}, 932 {NVFlag, 0xabababab, 0xffff8003}, 933 {NZCVFlag, 0xabababab, 0x00000001}, 934 {CFlag, 0xabababab, 0xffff8003}, 935 {NVFlag, 0xabababab, 0x0000007e}, 936 {CVFlag, 0xabababab, 0x80000000}, 937 {ZFlag, 0xabababab, 0xffffffff}, 938 {NFlag, 0xabababab, 0xfffffffd}, 939 {NVFlag, 0xabababab, 0x00007fff}, 940 {NZCVFlag, 0xabababab, 0x7ffffffd}, 941 {NZVFlag, 0xabababab, 0x00000000}, 942 {NZCFlag, 0xabababab, 0xfffffffe}, 943 {ZVFlag, 0xabababab, 0x7ffffffe}, 944 {CFlag, 0xabababab, 0xffffffff}, 945 {ZCFlag, 0xabababab, 0xffffff82}, 946 {ZCFlag, 0xabababab, 0xffffff83}, 947 {ZCFlag, 0xabababab, 0x00000002}, 948 {NZFlag, 0xabababab, 0x0000007e}, 949 {NZCVFlag, 0xabababab, 0xffffffe0}, 950 {NZFlag, 0xabababab, 0x00000001}, 951 {ZVFlag, 0xabababab, 0x55555555}, 952 {ZCVFlag, 0xabababab, 0x00007fff}, 953 {NFlag, 0xabababab, 0x33333333}, 954 {ZFlag, 0xabababab, 0x00000000}, 955 {NVFlag, 0xabababab, 0x7fffffff}, 956 {ZVFlag, 0xabababab, 0xfffffffd}, 957 {ZFlag, 0xabababab, 0x00000020}, 958 {NCVFlag, 0xabababab, 0xfffffffd}, 959 {NZCFlag, 0xabababab, 0x80000000}, 960 {NVFlag, 0xabababab, 0x80000001}, 961 {ZFlag, 0xabababab, 0xffff8002}, 962 {NZCVFlag, 0xabababab, 0xffff8001}, 963 {NFlag, 0xabababab, 0xfffffffe}, 964 {ZVFlag, 0xabababab, 0x0000007d}, 965 {NCFlag, 0xabababab, 0x00007ffd}, 966 {NFlag, 0xabababab, 0xffff8001}, 967 {NZCFlag, 0xabababab, 0xaaaaaaaa}, 968 {NZCFlag, 0xabababab, 0x00000020}, 969 {ZCVFlag, 0xabababab, 0x7fffffff}, 970 {ZCVFlag, 0xabababab, 0x00000001}, 971 {NVFlag, 0xabababab, 0xcccccccc}, 972 {NFlag, 0xabababab, 0x80000000}, 973 {NFlag, 0xabababab, 0xffffffe0}, 974 {ZCFlag, 0xabababab, 0xffffffff}, 975 {CVFlag, 0xabababab, 0x00000000}, 976 {ZCFlag, 0xabababab, 0xffff8000}, 977 {ZCFlag, 0xabababab, 0x00007ffd}, 978 {NCFlag, 0xabababab, 0x0000007f}, 979 {ZVFlag, 0xabababab, 0x00000020}, 980 {VFlag, 0xabababab, 0xffff8002}, 981 {ZFlag, 0xabababab, 0xffffff81}, 982 {CVFlag, 0xabababab, 0xffff8003}, 983 {NFlag, 0xabababab, 0xffffff80}, 984 {NVFlag, 0xabababab, 0xaaaaaaaa}, 985 {CFlag, 0xabababab, 0x00000001}, 986 {ZCVFlag, 0xabababab, 0xffff8003}, 987 {NCFlag, 0xabababab, 0xfffffffd}, 988 {CVFlag, 0xabababab, 0xffffff83}, 989 {ZCFlag, 0xabababab, 0xfffffffd}, 990 {CVFlag, 0xabababab, 0x0000007d}, 991 {ZCVFlag, 0xabababab, 0xffffff83}, 992 {NCFlag, 0xabababab, 0xffffff81}, 993 {NFlag, 0xabababab, 0xffff8000}, 994 {NZFlag, 0xabababab, 0x80000001}, 995 {NCFlag, 0xabababab, 0x55555555}, 996 {NCVFlag, 0xabababab, 0xaaaaaaaa}, 997 {NZCFlag, 0xabababab, 0xffffffff}, 998 {ZFlag, 0xabababab, 0x33333333}, 999 {NCFlag, 0xabababab, 0xffffff82}, 1000 {NZFlag, 0xabababab, 0xffff8001}, 1001 {VFlag, 0xabababab, 0x7ffffffe}, 1002 {NZCVFlag, 0xabababab, 0x7ffffffe}, 1003 {ZFlag, 0xabababab, 0x80000001}, 1004 {NVFlag, 0xabababab, 0xffffff80}, 1005 {NFlag, 0xabababab, 0x0000007e}, 1006 {NCVFlag, 0xabababab, 0x00007ffd}, 1007 {CFlag, 0xabababab, 0x0000007e}, 1008 {NZVFlag, 0xabababab, 0xcccccccc}, 1009 {NZVFlag, 0xabababab, 0x0000007f}, 1010 {ZFlag, 0xabababab, 0xffffff83}, 1011 {VFlag, 0xabababab, 0xaaaaaaaa}, 1012 {ZVFlag, 0xabababab, 0x7ffffffd}, 1013 {ZVFlag, 0xabababab, 0xffffffff}, 1014 {NZCVFlag, 0xabababab, 0x0000007f}, 1015 {NCVFlag, 0xabababab, 0x0000007e}, 1016 {NZVFlag, 0xabababab, 0xffffff82}, 1017 {CFlag, 0xabababab, 0xffffff80}, 1018 {NZCVFlag, 0xabababab, 0x80000000}, 1019 {NZVFlag, 0xabababab, 0x7ffffffe}, 1020 {NZFlag, 0xabababab, 0xffffff80}, 1021 {NZFlag, 0xabababab, 0xffff8000}, 1022 {NCFlag, 0xabababab, 0xaaaaaaaa}, 1023 {NFlag, 0xabababab, 0x00000000}, 1024 {NZFlag, 0xabababab, 0xcccccccc}, 1025 {ZCFlag, 0xabababab, 0xffffffe0}, 1026 {CVFlag, 0xabababab, 0xcccccccc}, 1027 {VFlag, 0xabababab, 0xfffffffd}, 1028 {CVFlag, 0xabababab, 0x7ffffffd}, 1029 {ZCFlag, 0xabababab, 0x00000020}, 1030 {CVFlag, 0xabababab, 0x00007ffe}, 1031 {ZCFlag, 0xabababab, 0xffffff80}, 1032 {NVFlag, 0xabababab, 0xfffffffd}, 1033 {NZCFlag, 0xabababab, 0x00000001}, 1034 {CVFlag, 0xabababab, 0x00000001}, 1035 {NVFlag, 0xabababab, 0xffffff83}, 1036 {ZCVFlag, 0xabababab, 0x7ffffffd}, 1037 {NZVFlag, 0xabababab, 0xffff8000}, 1038 {CVFlag, 0xabababab, 0xffffffe0}, 1039 {NCFlag, 0xabababab, 0x0000007d}, 1040 {VFlag, 0xabababab, 0x00007ffd}, 1041 {NZCFlag, 0xabababab, 0xffffff81}, 1042 {NCVFlag, 0xabababab, 0x00007fff}, 1043 {NVFlag, 0xabababab, 0x0000007f}, 1044 {CFlag, 0xabababab, 0xcccccccc}, 1045 {ZFlag, 0xabababab, 0xcccccccc}, 1046 {ZCFlag, 0xabababab, 0x80000000}, 1047 {VFlag, 0xabababab, 0x0000007d}, 1048 {NFlag, 0xabababab, 0xcccccccc}, 1049 {NCFlag, 0xabababab, 0x7fffffff}, 1050 {VFlag, 0xabababab, 0xffffff81}, 1051 {NCVFlag, 0xabababab, 0xffffffff}, 1052 {NZFlag, 0xabababab, 0xffff8002}, 1053 {NZVFlag, 0xabababab, 0x80000000}, 1054 {ZCVFlag, 0xabababab, 0x0000007f}, 1055 {ZFlag, 0xabababab, 0x0000007f}, 1056 {VFlag, 0xabababab, 0xffff8001}, 1057 {NVFlag, 0xabababab, 0x00000000}, 1058 {ZFlag, 0xabababab, 0x00007ffd}, 1059 {NCVFlag, 0xabababab, 0x80000001}, 1060 {NCVFlag, 0xabababab, 0xffff8002}, 1061 {NCFlag, 0xabababab, 0x7ffffffe}, 1062 {ZCFlag, 0xabababab, 0x7ffffffd}, 1063 {NZCFlag, 0xabababab, 0x80000001}, 1064 {ZCFlag, 0xabababab, 0x0000007f}, 1065 {VFlag, 0xabababab, 0x80000000}, 1066 {NCFlag, 0xabababab, 0x80000001}, 1067 {NVFlag, 0xabababab, 0xffffff81}}; 1068 1069 1070 // A loop will be generated for each element of this array. 1071 const TestLoopData kTests[] = {{{ne, r2, r2, 45}, 1072 "ne r2 r2 45", 1073 "RdIsRn_ne_r2_r2_45", 1074 ARRAY_SIZE(kRdIsRn), 1075 kRdIsRn}, 1076 {{cs, r6, r6, 59}, 1077 "cs r6 r6 59", 1078 "RdIsRn_cs_r6_r6_59", 1079 ARRAY_SIZE(kRdIsRn), 1080 kRdIsRn}, 1081 {{mi, r6, r6, 211}, 1082 "mi r6 r6 211", 1083 "RdIsRn_mi_r6_r6_211", 1084 ARRAY_SIZE(kRdIsRn), 1085 kRdIsRn}, 1086 {{lt, r5, r5, 36}, 1087 "lt r5 r5 36", 1088 "RdIsRn_lt_r5_r5_36", 1089 ARRAY_SIZE(kRdIsRn), 1090 kRdIsRn}, 1091 {{cc, r7, r7, 7}, 1092 "cc r7 r7 7", 1093 "RdIsRn_cc_r7_r7_7", 1094 ARRAY_SIZE(kRdIsRn), 1095 kRdIsRn}, 1096 {{cs, r7, r7, 215}, 1097 "cs r7 r7 215", 1098 "RdIsRn_cs_r7_r7_215", 1099 ARRAY_SIZE(kRdIsRn), 1100 kRdIsRn}, 1101 {{pl, r6, r6, 54}, 1102 "pl r6 r6 54", 1103 "RdIsRn_pl_r6_r6_54", 1104 ARRAY_SIZE(kRdIsRn), 1105 kRdIsRn}, 1106 {{lt, r6, r6, 221}, 1107 "lt r6 r6 221", 1108 "RdIsRn_lt_r6_r6_221", 1109 ARRAY_SIZE(kRdIsRn), 1110 kRdIsRn}, 1111 {{ne, r2, r2, 40}, 1112 "ne r2 r2 40", 1113 "RdIsRn_ne_r2_r2_40", 1114 ARRAY_SIZE(kRdIsRn), 1115 kRdIsRn}, 1116 {{hi, r5, r5, 158}, 1117 "hi r5 r5 158", 1118 "RdIsRn_hi_r5_r5_158", 1119 ARRAY_SIZE(kRdIsRn), 1120 kRdIsRn}, 1121 {{cs, r0, r0, 18}, 1122 "cs r0 r0 18", 1123 "RdIsRn_cs_r0_r0_18", 1124 ARRAY_SIZE(kRdIsRn), 1125 kRdIsRn}, 1126 {{ne, r3, r3, 205}, 1127 "ne r3 r3 205", 1128 "RdIsRn_ne_r3_r3_205", 1129 ARRAY_SIZE(kRdIsRn), 1130 kRdIsRn}, 1131 {{vc, r0, r0, 97}, 1132 "vc r0 r0 97", 1133 "RdIsRn_vc_r0_r0_97", 1134 ARRAY_SIZE(kRdIsRn), 1135 kRdIsRn}, 1136 {{hi, r2, r2, 197}, 1137 "hi r2 r2 197", 1138 "RdIsRn_hi_r2_r2_197", 1139 ARRAY_SIZE(kRdIsRn), 1140 kRdIsRn}, 1141 {{cs, r0, r0, 248}, 1142 "cs r0 r0 248", 1143 "RdIsRn_cs_r0_r0_248", 1144 ARRAY_SIZE(kRdIsRn), 1145 kRdIsRn}, 1146 {{ne, r4, r4, 108}, 1147 "ne r4 r4 108", 1148 "RdIsRn_ne_r4_r4_108", 1149 ARRAY_SIZE(kRdIsRn), 1150 kRdIsRn}, 1151 {{vs, r3, r3, 73}, 1152 "vs r3 r3 73", 1153 "RdIsRn_vs_r3_r3_73", 1154 ARRAY_SIZE(kRdIsRn), 1155 kRdIsRn}, 1156 {{ne, r7, r7, 230}, 1157 "ne r7 r7 230", 1158 "RdIsRn_ne_r7_r7_230", 1159 ARRAY_SIZE(kRdIsRn), 1160 kRdIsRn}, 1161 {{eq, r0, r0, 100}, 1162 "eq r0 r0 100", 1163 "RdIsRn_eq_r0_r0_100", 1164 ARRAY_SIZE(kRdIsRn), 1165 kRdIsRn}, 1166 {{mi, r5, r5, 211}, 1167 "mi r5 r5 211", 1168 "RdIsRn_mi_r5_r5_211", 1169 ARRAY_SIZE(kRdIsRn), 1170 kRdIsRn}, 1171 {{ge, r2, r3, 225}, 1172 "ge r2 r3 225", 1173 "RdIsNotRn_ge_r2_r3_225", 1174 ARRAY_SIZE(kRdIsNotRn), 1175 kRdIsNotRn}, 1176 {{vs, r3, r1, 64}, 1177 "vs r3 r1 64", 1178 "RdIsNotRn_vs_r3_r1_64", 1179 ARRAY_SIZE(kRdIsNotRn), 1180 kRdIsNotRn}, 1181 {{vs, r0, r1, 93}, 1182 "vs r0 r1 93", 1183 "RdIsNotRn_vs_r0_r1_93", 1184 ARRAY_SIZE(kRdIsNotRn), 1185 kRdIsNotRn}, 1186 {{ne, r5, r1, 247}, 1187 "ne r5 r1 247", 1188 "RdIsNotRn_ne_r5_r1_247", 1189 ARRAY_SIZE(kRdIsNotRn), 1190 kRdIsNotRn}, 1191 {{vs, r1, r7, 9}, 1192 "vs r1 r7 9", 1193 "RdIsNotRn_vs_r1_r7_9", 1194 ARRAY_SIZE(kRdIsNotRn), 1195 kRdIsNotRn}, 1196 {{le, r0, r2, 201}, 1197 "le r0 r2 201", 1198 "RdIsNotRn_le_r0_r2_201", 1199 ARRAY_SIZE(kRdIsNotRn), 1200 kRdIsNotRn}, 1201 {{vs, r6, r0, 176}, 1202 "vs r6 r0 176", 1203 "RdIsNotRn_vs_r6_r0_176", 1204 ARRAY_SIZE(kRdIsNotRn), 1205 kRdIsNotRn}, 1206 {{vc, r0, r1, 248}, 1207 "vc r0 r1 248", 1208 "RdIsNotRn_vc_r0_r1_248", 1209 ARRAY_SIZE(kRdIsNotRn), 1210 kRdIsNotRn}, 1211 {{al, r7, r6, 64}, 1212 "al r7 r6 64", 1213 "RdIsNotRn_al_r7_r6_64", 1214 ARRAY_SIZE(kRdIsNotRn), 1215 kRdIsNotRn}, 1216 {{al, r5, r7, 175}, 1217 "al r5 r7 175", 1218 "RdIsNotRn_al_r5_r7_175", 1219 ARRAY_SIZE(kRdIsNotRn), 1220 kRdIsNotRn}, 1221 {{al, r0, r4, 182}, 1222 "al r0 r4 182", 1223 "RdIsNotRn_al_r0_r4_182", 1224 ARRAY_SIZE(kRdIsNotRn), 1225 kRdIsNotRn}, 1226 {{ls, r7, r5, 58}, 1227 "ls r7 r5 58", 1228 "RdIsNotRn_ls_r7_r5_58", 1229 ARRAY_SIZE(kRdIsNotRn), 1230 kRdIsNotRn}, 1231 {{vc, r0, r7, 205}, 1232 "vc r0 r7 205", 1233 "RdIsNotRn_vc_r0_r7_205", 1234 ARRAY_SIZE(kRdIsNotRn), 1235 kRdIsNotRn}, 1236 {{pl, r1, r3, 135}, 1237 "pl r1 r3 135", 1238 "RdIsNotRn_pl_r1_r3_135", 1239 ARRAY_SIZE(kRdIsNotRn), 1240 kRdIsNotRn}, 1241 {{gt, r4, r3, 253}, 1242 "gt r4 r3 253", 1243 "RdIsNotRn_gt_r4_r3_253", 1244 ARRAY_SIZE(kRdIsNotRn), 1245 kRdIsNotRn}, 1246 {{al, r1, r7, 32}, 1247 "al r1 r7 32", 1248 "RdIsNotRn_al_r1_r7_32", 1249 ARRAY_SIZE(kRdIsNotRn), 1250 kRdIsNotRn}, 1251 {{eq, r1, r7, 139}, 1252 "eq r1 r7 139", 1253 "RdIsNotRn_eq_r1_r7_139", 1254 ARRAY_SIZE(kRdIsNotRn), 1255 kRdIsNotRn}, 1256 {{lt, r0, r5, 248}, 1257 "lt r0 r5 248", 1258 "RdIsNotRn_lt_r0_r5_248", 1259 ARRAY_SIZE(kRdIsNotRn), 1260 kRdIsNotRn}, 1261 {{hi, r0, r6, 89}, 1262 "hi r0 r6 89", 1263 "RdIsNotRn_hi_r0_r6_89", 1264 ARRAY_SIZE(kRdIsNotRn), 1265 kRdIsNotRn}, 1266 {{cc, r3, r5, 210}, 1267 "cc r3 r5 210", 1268 "RdIsNotRn_cc_r3_r5_210", 1269 ARRAY_SIZE(kRdIsNotRn), 1270 kRdIsNotRn}, 1271 {{cs, r0, r0, 187}, 1272 "cs r0 r0 187", 1273 "Immediate_cs_r0_r0_187", 1274 ARRAY_SIZE(kImmediate), 1275 kImmediate}, 1276 {{hi, r0, r0, 236}, 1277 "hi r0 r0 236", 1278 "Immediate_hi_r0_r0_236", 1279 ARRAY_SIZE(kImmediate), 1280 kImmediate}, 1281 {{eq, r0, r0, 133}, 1282 "eq r0 r0 133", 1283 "Immediate_eq_r0_r0_133", 1284 ARRAY_SIZE(kImmediate), 1285 kImmediate}, 1286 {{mi, r0, r0, 193}, 1287 "mi r0 r0 193", 1288 "Immediate_mi_r0_r0_193", 1289 ARRAY_SIZE(kImmediate), 1290 kImmediate}, 1291 {{cc, r0, r0, 73}, 1292 "cc r0 r0 73", 1293 "Immediate_cc_r0_r0_73", 1294 ARRAY_SIZE(kImmediate), 1295 kImmediate}, 1296 {{cs, r0, r0, 93}, 1297 "cs r0 r0 93", 1298 "Immediate_cs_r0_r0_93", 1299 ARRAY_SIZE(kImmediate), 1300 kImmediate}, 1301 {{ne, r0, r0, 130}, 1302 "ne r0 r0 130", 1303 "Immediate_ne_r0_r0_130", 1304 ARRAY_SIZE(kImmediate), 1305 kImmediate}, 1306 {{ge, r0, r0, 209}, 1307 "ge r0 r0 209", 1308 "Immediate_ge_r0_r0_209", 1309 ARRAY_SIZE(kImmediate), 1310 kImmediate}, 1311 {{lt, r0, r0, 42}, 1312 "lt r0 r0 42", 1313 "Immediate_lt_r0_r0_42", 1314 ARRAY_SIZE(kImmediate), 1315 kImmediate}, 1316 {{cs, r0, r0, 177}, 1317 "cs r0 r0 177", 1318 "Immediate_cs_r0_r0_177", 1319 ARRAY_SIZE(kImmediate), 1320 kImmediate}, 1321 {{lt, r0, r0, 139}, 1322 "lt r0 r0 139", 1323 "Immediate_lt_r0_r0_139", 1324 ARRAY_SIZE(kImmediate), 1325 kImmediate}, 1326 {{mi, r0, r0, 43}, 1327 "mi r0 r0 43", 1328 "Immediate_mi_r0_r0_43", 1329 ARRAY_SIZE(kImmediate), 1330 kImmediate}, 1331 {{cs, r0, r0, 247}, 1332 "cs r0 r0 247", 1333 "Immediate_cs_r0_r0_247", 1334 ARRAY_SIZE(kImmediate), 1335 kImmediate}, 1336 {{ls, r0, r0, 170}, 1337 "ls r0 r0 170", 1338 "Immediate_ls_r0_r0_170", 1339 ARRAY_SIZE(kImmediate), 1340 kImmediate}, 1341 {{cs, r0, r0, 185}, 1342 "cs r0 r0 185", 1343 "Immediate_cs_r0_r0_185", 1344 ARRAY_SIZE(kImmediate), 1345 kImmediate}, 1346 {{ne, r0, r0, 246}, 1347 "ne r0 r0 246", 1348 "Immediate_ne_r0_r0_246", 1349 ARRAY_SIZE(kImmediate), 1350 kImmediate}, 1351 {{mi, r0, r0, 179}, 1352 "mi r0 r0 179", 1353 "Immediate_mi_r0_r0_179", 1354 ARRAY_SIZE(kImmediate), 1355 kImmediate}, 1356 {{pl, r0, r0, 7}, 1357 "pl r0 r0 7", 1358 "Immediate_pl_r0_r0_7", 1359 ARRAY_SIZE(kImmediate), 1360 kImmediate}, 1361 {{mi, r0, r0, 177}, 1362 "mi r0 r0 177", 1363 "Immediate_mi_r0_r0_177", 1364 ARRAY_SIZE(kImmediate), 1365 kImmediate}, 1366 {{gt, r0, r0, 175}, 1367 "gt r0 r0 175", 1368 "Immediate_gt_r0_r0_175", 1369 ARRAY_SIZE(kImmediate), 1370 kImmediate}}; 1371 1372 // We record all inputs to the instructions as outputs. This way, we also check 1373 // that what shouldn't change didn't change. 1374 struct TestResult { 1375 size_t output_size; 1376 const Inputs* outputs; 1377 }; 1378 1379 // These headers each contain an array of `TestResult` with the reference output 1380 // values. The reference arrays are names `kReference{mnemonic}`. 1381 #include "aarch32/traces/simulator-cond-rdlow-rnlow-operand-immediate-t32-add.h" 1382 #include "aarch32/traces/simulator-cond-rdlow-rnlow-operand-immediate-t32-adds.h" 1383 #include "aarch32/traces/simulator-cond-rdlow-rnlow-operand-immediate-t32-rsb.h" 1384 #include "aarch32/traces/simulator-cond-rdlow-rnlow-operand-immediate-t32-rsbs.h" 1385 #include "aarch32/traces/simulator-cond-rdlow-rnlow-operand-immediate-t32-sub.h" 1386 #include "aarch32/traces/simulator-cond-rdlow-rnlow-operand-immediate-t32-subs.h" 1387 1388 1389 // The maximum number of errors to report in detail for each test. 1390 const unsigned kErrorReportLimit = 8; 1391 1392 typedef void (MacroAssembler::*Fn)(Condition cond, 1393 Register rd, 1394 Register rn, 1395 const Operand& op); 1396 1397 void TestHelper(Fn instruction, 1398 const char* mnemonic, 1399 const TestResult reference[]) { 1400 SETUP(); 1401 masm.UseT32(); 1402 START(); 1403 1404 // Data to compare to `reference`. 1405 TestResult* results[ARRAY_SIZE(kTests)]; 1406 1407 // Test cases for memory bound instructions may allocate a buffer and save its 1408 // address in this array. 1409 byte* scratch_memory_buffers[ARRAY_SIZE(kTests)]; 1410 1411 // Generate a loop for each element in `kTests`. Each loop tests one specific 1412 // instruction. 1413 for (unsigned i = 0; i < ARRAY_SIZE(kTests); i++) { 1414 // Allocate results on the heap for this test. 1415 results[i] = new TestResult; 1416 results[i]->outputs = new Inputs[kTests[i].input_size]; 1417 results[i]->output_size = kTests[i].input_size; 1418 1419 size_t input_stride = sizeof(kTests[i].inputs[0]) * kTests[i].input_size; 1420 VIXL_ASSERT(IsUint32(input_stride)); 1421 1422 scratch_memory_buffers[i] = NULL; 1423 1424 Label loop; 1425 UseScratchRegisterScope scratch_registers(&masm); 1426 // Include all registers from r0 ro r12. 1427 scratch_registers.Include(RegisterList(0x1fff)); 1428 1429 // Values to pass to the macro-assembler. 1430 Condition cond = kTests[i].operands.cond; 1431 Register rd = kTests[i].operands.rd; 1432 Register rn = kTests[i].operands.rn; 1433 int32_t immediate = kTests[i].operands.immediate; 1434 Operand op(immediate); 1435 scratch_registers.Exclude(rd); 1436 scratch_registers.Exclude(rn); 1437 1438 // Allocate reserved registers for our own use. 1439 Register input_ptr = scratch_registers.Acquire(); 1440 Register input_end = scratch_registers.Acquire(); 1441 Register result_ptr = scratch_registers.Acquire(); 1442 1443 // Initialize `input_ptr` to the first element and `input_end` the address 1444 // after the array. 1445 __ Mov(input_ptr, Operand::From(kTests[i].inputs)); 1446 __ Add(input_end, input_ptr, static_cast<uint32_t>(input_stride)); 1447 __ Mov(result_ptr, Operand::From(results[i]->outputs)); 1448 __ Bind(&loop); 1449 1450 { 1451 UseScratchRegisterScope temp_registers(&masm); 1452 Register nzcv_bits = temp_registers.Acquire(); 1453 Register saved_q_bit = temp_registers.Acquire(); 1454 // Save the `Q` bit flag. 1455 __ Mrs(saved_q_bit, APSR); 1456 __ And(saved_q_bit, saved_q_bit, QFlag); 1457 // Set the `NZCV` and `Q` flags together. 1458 __ Ldr(nzcv_bits, MemOperand(input_ptr, offsetof(Inputs, apsr))); 1459 __ Orr(nzcv_bits, nzcv_bits, saved_q_bit); 1460 __ Msr(APSR_nzcvq, nzcv_bits); 1461 } 1462 __ Ldr(rd, MemOperand(input_ptr, offsetof(Inputs, rd))); 1463 __ Ldr(rn, MemOperand(input_ptr, offsetof(Inputs, rn))); 1464 1465 (masm.*instruction)(cond, rd, rn, op); 1466 1467 { 1468 UseScratchRegisterScope temp_registers(&masm); 1469 Register nzcv_bits = temp_registers.Acquire(); 1470 __ Mrs(nzcv_bits, APSR); 1471 // Only record the NZCV bits. 1472 __ And(nzcv_bits, nzcv_bits, NZCVFlag); 1473 __ Str(nzcv_bits, MemOperand(result_ptr, offsetof(Inputs, apsr))); 1474 } 1475 __ Str(rd, MemOperand(result_ptr, offsetof(Inputs, rd))); 1476 __ Str(rn, MemOperand(result_ptr, offsetof(Inputs, rn))); 1477 1478 // Advance the result pointer. 1479 __ Add(result_ptr, result_ptr, Operand::From(sizeof(kTests[i].inputs[0]))); 1480 // Loop back until `input_ptr` is lower than `input_base`. 1481 __ Add(input_ptr, input_ptr, Operand::From(sizeof(kTests[i].inputs[0]))); 1482 __ Cmp(input_ptr, input_end); 1483 __ B(ne, &loop); 1484 } 1485 1486 END(); 1487 1488 RUN(); 1489 1490 if (Test::generate_test_trace()) { 1491 // Print the results. 1492 for (size_t i = 0; i < ARRAY_SIZE(kTests); i++) { 1493 printf("const Inputs kOutputs_%s_%s[] = {\n", 1494 mnemonic, 1495 kTests[i].identifier); 1496 for (size_t j = 0; j < results[i]->output_size; j++) { 1497 printf(" { "); 1498 printf("0x%08" PRIx32, results[i]->outputs[j].apsr); 1499 printf(", "); 1500 printf("0x%08" PRIx32, results[i]->outputs[j].rd); 1501 printf(", "); 1502 printf("0x%08" PRIx32, results[i]->outputs[j].rn); 1503 printf(" },\n"); 1504 } 1505 printf("};\n"); 1506 } 1507 printf("const TestResult kReference%s[] = {\n", mnemonic); 1508 for (size_t i = 0; i < ARRAY_SIZE(kTests); i++) { 1509 printf(" {\n"); 1510 printf(" ARRAY_SIZE(kOutputs_%s_%s),\n", 1511 mnemonic, 1512 kTests[i].identifier); 1513 printf(" kOutputs_%s_%s,\n", mnemonic, kTests[i].identifier); 1514 printf(" },\n"); 1515 } 1516 printf("};\n"); 1517 } else if (kCheckSimulatorTestResults) { 1518 // Check the results. 1519 unsigned total_error_count = 0; 1520 for (size_t i = 0; i < ARRAY_SIZE(kTests); i++) { 1521 bool instruction_has_errors = false; 1522 for (size_t j = 0; j < kTests[i].input_size; j++) { 1523 uint32_t apsr = results[i]->outputs[j].apsr; 1524 uint32_t rd = results[i]->outputs[j].rd; 1525 uint32_t rn = results[i]->outputs[j].rn; 1526 uint32_t apsr_input = kTests[i].inputs[j].apsr; 1527 uint32_t rd_input = kTests[i].inputs[j].rd; 1528 uint32_t rn_input = kTests[i].inputs[j].rn; 1529 uint32_t apsr_ref = reference[i].outputs[j].apsr; 1530 uint32_t rd_ref = reference[i].outputs[j].rd; 1531 uint32_t rn_ref = reference[i].outputs[j].rn; 1532 1533 if (((apsr != apsr_ref) || (rd != rd_ref) || (rn != rn_ref)) && 1534 (++total_error_count <= kErrorReportLimit)) { 1535 // Print the instruction once even if it triggered multiple failures. 1536 if (!instruction_has_errors) { 1537 printf("Error(s) when testing \"%s %s\":\n", 1538 mnemonic, 1539 kTests[i].operands_description); 1540 instruction_has_errors = true; 1541 } 1542 // Print subsequent errors. 1543 printf(" Input: "); 1544 printf("0x%08" PRIx32, apsr_input); 1545 printf(", "); 1546 printf("0x%08" PRIx32, rd_input); 1547 printf(", "); 1548 printf("0x%08" PRIx32, rn_input); 1549 printf("\n"); 1550 printf(" Expected: "); 1551 printf("0x%08" PRIx32, apsr_ref); 1552 printf(", "); 1553 printf("0x%08" PRIx32, rd_ref); 1554 printf(", "); 1555 printf("0x%08" PRIx32, rn_ref); 1556 printf("\n"); 1557 printf(" Found: "); 1558 printf("0x%08" PRIx32, apsr); 1559 printf(", "); 1560 printf("0x%08" PRIx32, rd); 1561 printf(", "); 1562 printf("0x%08" PRIx32, rn); 1563 printf("\n\n"); 1564 } 1565 } 1566 } 1567 1568 if (total_error_count > kErrorReportLimit) { 1569 printf("%u other errors follow.\n", 1570 total_error_count - kErrorReportLimit); 1571 } 1572 VIXL_CHECK(total_error_count == 0); 1573 } else { 1574 VIXL_WARNING("Assembled the code, but did not run anything.\n"); 1575 } 1576 1577 for (size_t i = 0; i < ARRAY_SIZE(kTests); i++) { 1578 delete[] results[i]->outputs; 1579 delete results[i]; 1580 delete[] scratch_memory_buffers[i]; 1581 } 1582 1583 TEARDOWN(); 1584 } 1585 1586 // Instantiate tests for each instruction in the list. 1587 // TODO: Remove this limitation by having a sandboxing mechanism. 1588 #if defined(VIXL_HOST_POINTER_32) 1589 #define TEST(mnemonic) \ 1590 void Test_##mnemonic() { \ 1591 TestHelper(&MacroAssembler::mnemonic, #mnemonic, kReference##mnemonic); \ 1592 } \ 1593 Test test_##mnemonic( \ 1594 "AARCH32_SIMULATOR_COND_RDLOW_RNLOW_OPERAND_IMMEDIATE_T32_" #mnemonic, \ 1595 &Test_##mnemonic); 1596 #else 1597 #define TEST(mnemonic) \ 1598 void Test_##mnemonic() { \ 1599 VIXL_WARNING("This test can only run on a 32-bit host.\n"); \ 1600 USE(TestHelper); \ 1601 } \ 1602 Test test_##mnemonic( \ 1603 "AARCH32_SIMULATOR_COND_RDLOW_RNLOW_OPERAND_IMMEDIATE_T32_" #mnemonic, \ 1604 &Test_##mnemonic); 1605 #endif 1606 1607 FOREACH_INSTRUCTION(TEST) 1608 #undef TEST 1609 1610 } // namespace 1611 #endif 1612 1613 } // namespace aarch32 1614 } // namespace vixl 1615
