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-assembler-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 45 #define BUF_SIZE (4096) 46 47 namespace vixl { 48 namespace aarch32 { 49 50 // List of instruction mnemonics. 51 #define FOREACH_INSTRUCTION(M) \ 52 M(vadd) \ 53 M(vsub) 54 55 56 // The following definitions are defined again in each generated test, therefore 57 // we need to place them in an anomymous namespace. It expresses that they are 58 // local to this file only, and the compiler is not allowed to share these types 59 // across test files during template instantiation. Specifically, `Operands` has 60 // various layouts across generated tests so it absolutely cannot be shared. 61 62 #ifdef VIXL_INCLUDE_TARGET_T32 63 namespace { 64 65 // Values to be passed to the assembler to produce the instruction under test. 66 struct Operands { 67 DataType dt; 68 DRegister rd; 69 DRegister rn; 70 DRegister rm; 71 }; 72 73 // This structure contains all data needed to test one specific 74 // instruction. 75 struct TestData { 76 // The `operands` field represents what to pass to the assembler to 77 // produce the instruction. 78 Operands operands; 79 // True if we need to generate an IT instruction for this test to be valid. 80 bool in_it_block; 81 // The condition to give the IT instruction, this will be set to "al" by 82 // default. 83 Condition it_condition; 84 // Description of the operands, used for error reporting. 85 const char* operands_description; 86 // Unique identifier, used for generating traces. 87 const char* identifier; 88 }; 89 90 struct TestResult { 91 size_t size; 92 const byte* encoding; 93 }; 94 95 // Each element of this array produce one instruction encoding. 96 const TestData kTests[] = 97 {{{F64, d16, d17, d14}, false, al, "F64 d16 d17 d14", "F64_d16_d17_d14"}, 98 {{F64, d21, d29, d16}, false, al, "F64 d21 d29 d16", "F64_d21_d29_d16"}, 99 {{F64, d19, d28, d12}, false, al, "F64 d19 d28 d12", "F64_d19_d28_d12"}, 100 {{F32, d5, d16, d12}, false, al, "F32 d5 d16 d12", "F32_d5_d16_d12"}, 101 {{F64, d31, d7, d1}, false, al, "F64 d31 d7 d1", "F64_d31_d7_d1"}, 102 {{F64, d22, d6, d1}, false, al, "F64 d22 d6 d1", "F64_d22_d6_d1"}, 103 {{F32, d22, d28, d12}, false, al, "F32 d22 d28 d12", "F32_d22_d28_d12"}, 104 {{F32, d15, d1, d6}, false, al, "F32 d15 d1 d6", "F32_d15_d1_d6"}, 105 {{F32, d18, d17, d23}, false, al, "F32 d18 d17 d23", "F32_d18_d17_d23"}, 106 {{F64, d29, d21, d18}, false, al, "F64 d29 d21 d18", "F64_d29_d21_d18"}, 107 {{F64, d28, d29, d29}, false, al, "F64 d28 d29 d29", "F64_d28_d29_d29"}, 108 {{F64, d26, d28, d26}, false, al, "F64 d26 d28 d26", "F64_d26_d28_d26"}, 109 {{F64, d2, d18, d10}, false, al, "F64 d2 d18 d10", "F64_d2_d18_d10"}, 110 {{F64, d4, d30, d6}, false, al, "F64 d4 d30 d6", "F64_d4_d30_d6"}, 111 {{F64, d11, d25, d14}, false, al, "F64 d11 d25 d14", "F64_d11_d25_d14"}, 112 {{F32, d4, d26, d15}, false, al, "F32 d4 d26 d15", "F32_d4_d26_d15"}, 113 {{F64, d9, d20, d30}, false, al, "F64 d9 d20 d30", "F64_d9_d20_d30"}, 114 {{F64, d18, d12, d20}, false, al, "F64 d18 d12 d20", "F64_d18_d12_d20"}, 115 {{F64, d1, d27, d15}, false, al, "F64 d1 d27 d15", "F64_d1_d27_d15"}, 116 {{F32, d22, d22, d3}, false, al, "F32 d22 d22 d3", "F32_d22_d22_d3"}, 117 {{F32, d29, d19, d6}, false, al, "F32 d29 d19 d6", "F32_d29_d19_d6"}, 118 {{F64, d9, d23, d8}, false, al, "F64 d9 d23 d8", "F64_d9_d23_d8"}, 119 {{F32, d12, d18, d29}, false, al, "F32 d12 d18 d29", "F32_d12_d18_d29"}, 120 {{F64, d0, d12, d13}, false, al, "F64 d0 d12 d13", "F64_d0_d12_d13"}, 121 {{F64, d9, d17, d17}, false, al, "F64 d9 d17 d17", "F64_d9_d17_d17"}, 122 {{F64, d11, d0, d29}, false, al, "F64 d11 d0 d29", "F64_d11_d0_d29"}, 123 {{F64, d24, d16, d28}, false, al, "F64 d24 d16 d28", "F64_d24_d16_d28"}, 124 {{F64, d22, d14, d26}, false, al, "F64 d22 d14 d26", "F64_d22_d14_d26"}, 125 {{F64, d11, d14, d22}, false, al, "F64 d11 d14 d22", "F64_d11_d14_d22"}, 126 {{F64, d19, d12, d6}, false, al, "F64 d19 d12 d6", "F64_d19_d12_d6"}, 127 {{F64, d29, d3, d28}, false, al, "F64 d29 d3 d28", "F64_d29_d3_d28"}, 128 {{F64, d21, d8, d3}, false, al, "F64 d21 d8 d3", "F64_d21_d8_d3"}, 129 {{F32, d1, d15, d25}, false, al, "F32 d1 d15 d25", "F32_d1_d15_d25"}, 130 {{F64, d22, d8, d8}, false, al, "F64 d22 d8 d8", "F64_d22_d8_d8"}, 131 {{F64, d29, d23, d10}, false, al, "F64 d29 d23 d10", "F64_d29_d23_d10"}, 132 {{F32, d3, d16, d8}, false, al, "F32 d3 d16 d8", "F32_d3_d16_d8"}, 133 {{F32, d1, d0, d13}, false, al, "F32 d1 d0 d13", "F32_d1_d0_d13"}, 134 {{F64, d11, d11, d4}, false, al, "F64 d11 d11 d4", "F64_d11_d11_d4"}, 135 {{F64, d10, d22, d24}, false, al, "F64 d10 d22 d24", "F64_d10_d22_d24"}, 136 {{F64, d16, d22, d3}, false, al, "F64 d16 d22 d3", "F64_d16_d22_d3"}, 137 {{F64, d1, d22, d17}, false, al, "F64 d1 d22 d17", "F64_d1_d22_d17"}, 138 {{F32, d5, d26, d24}, false, al, "F32 d5 d26 d24", "F32_d5_d26_d24"}, 139 {{F64, d17, d1, d18}, false, al, "F64 d17 d1 d18", "F64_d17_d1_d18"}, 140 {{F32, d19, d15, d0}, false, al, "F32 d19 d15 d0", "F32_d19_d15_d0"}, 141 {{F32, d22, d3, d3}, false, al, "F32 d22 d3 d3", "F32_d22_d3_d3"}, 142 {{F32, d30, d16, d4}, false, al, "F32 d30 d16 d4", "F32_d30_d16_d4"}, 143 {{F64, d31, d28, d16}, false, al, "F64 d31 d28 d16", "F64_d31_d28_d16"}, 144 {{F64, d9, d9, d26}, false, al, "F64 d9 d9 d26", "F64_d9_d9_d26"}, 145 {{F32, d18, d12, d5}, false, al, "F32 d18 d12 d5", "F32_d18_d12_d5"}, 146 {{F64, d1, d1, d14}, false, al, "F64 d1 d1 d14", "F64_d1_d1_d14"}, 147 {{F64, d10, d26, d27}, false, al, "F64 d10 d26 d27", "F64_d10_d26_d27"}, 148 {{F32, d4, d24, d28}, false, al, "F32 d4 d24 d28", "F32_d4_d24_d28"}, 149 {{F64, d5, d17, d1}, false, al, "F64 d5 d17 d1", "F64_d5_d17_d1"}, 150 {{F64, d20, d4, d8}, false, al, "F64 d20 d4 d8", "F64_d20_d4_d8"}, 151 {{F32, d14, d5, d27}, false, al, "F32 d14 d5 d27", "F32_d14_d5_d27"}, 152 {{F32, d19, d26, d13}, false, al, "F32 d19 d26 d13", "F32_d19_d26_d13"}, 153 {{F64, d26, d6, d19}, false, al, "F64 d26 d6 d19", "F64_d26_d6_d19"}, 154 {{F64, d5, d26, d31}, false, al, "F64 d5 d26 d31", "F64_d5_d26_d31"}, 155 {{F64, d7, d26, d7}, false, al, "F64 d7 d26 d7", "F64_d7_d26_d7"}, 156 {{F32, d14, d10, d17}, false, al, "F32 d14 d10 d17", "F32_d14_d10_d17"}, 157 {{F32, d4, d16, d30}, false, al, "F32 d4 d16 d30", "F32_d4_d16_d30"}, 158 {{F64, d10, d12, d2}, false, al, "F64 d10 d12 d2", "F64_d10_d12_d2"}, 159 {{F32, d15, d17, d10}, false, al, "F32 d15 d17 d10", "F32_d15_d17_d10"}, 160 {{F64, d20, d25, d20}, false, al, "F64 d20 d25 d20", "F64_d20_d25_d20"}, 161 {{F32, d12, d21, d28}, false, al, "F32 d12 d21 d28", "F32_d12_d21_d28"}, 162 {{F64, d20, d23, d16}, false, al, "F64 d20 d23 d16", "F64_d20_d23_d16"}, 163 {{F64, d11, d19, d18}, false, al, "F64 d11 d19 d18", "F64_d11_d19_d18"}, 164 {{F64, d3, d6, d7}, false, al, "F64 d3 d6 d7", "F64_d3_d6_d7"}, 165 {{F32, d23, d20, d7}, false, al, "F32 d23 d20 d7", "F32_d23_d20_d7"}, 166 {{F32, d3, d16, d19}, false, al, "F32 d3 d16 d19", "F32_d3_d16_d19"}, 167 {{F64, d2, d17, d31}, false, al, "F64 d2 d17 d31", "F64_d2_d17_d31"}, 168 {{F64, d10, d30, d23}, false, al, "F64 d10 d30 d23", "F64_d10_d30_d23"}, 169 {{F64, d27, d11, d2}, false, al, "F64 d27 d11 d2", "F64_d27_d11_d2"}, 170 {{F64, d19, d10, d19}, false, al, "F64 d19 d10 d19", "F64_d19_d10_d19"}, 171 {{F64, d16, d4, d15}, false, al, "F64 d16 d4 d15", "F64_d16_d4_d15"}, 172 {{F32, d8, d28, d1}, false, al, "F32 d8 d28 d1", "F32_d8_d28_d1"}, 173 {{F32, d13, d31, d5}, false, al, "F32 d13 d31 d5", "F32_d13_d31_d5"}, 174 {{F64, d17, d13, d29}, false, al, "F64 d17 d13 d29", "F64_d17_d13_d29"}, 175 {{F32, d27, d19, d10}, false, al, "F32 d27 d19 d10", "F32_d27_d19_d10"}, 176 {{F64, d8, d4, d0}, false, al, "F64 d8 d4 d0", "F64_d8_d4_d0"}, 177 {{F64, d31, d1, d29}, false, al, "F64 d31 d1 d29", "F64_d31_d1_d29"}, 178 {{F64, d6, d2, d12}, false, al, "F64 d6 d2 d12", "F64_d6_d2_d12"}, 179 {{F64, d25, d23, d24}, false, al, "F64 d25 d23 d24", "F64_d25_d23_d24"}, 180 {{F64, d3, d12, d1}, false, al, "F64 d3 d12 d1", "F64_d3_d12_d1"}, 181 {{F64, d24, d18, d16}, false, al, "F64 d24 d18 d16", "F64_d24_d18_d16"}, 182 {{F32, d13, d21, d16}, false, al, "F32 d13 d21 d16", "F32_d13_d21_d16"}, 183 {{F32, d9, d6, d23}, false, al, "F32 d9 d6 d23", "F32_d9_d6_d23"}, 184 {{F64, d14, d14, d13}, false, al, "F64 d14 d14 d13", "F64_d14_d14_d13"}, 185 {{F32, d25, d23, d17}, false, al, "F32 d25 d23 d17", "F32_d25_d23_d17"}, 186 {{F64, d13, d25, d3}, false, al, "F64 d13 d25 d3", "F64_d13_d25_d3"}, 187 {{F64, d9, d11, d8}, false, al, "F64 d9 d11 d8", "F64_d9_d11_d8"}, 188 {{F32, d18, d13, d26}, false, al, "F32 d18 d13 d26", "F32_d18_d13_d26"}, 189 {{F64, d16, d14, d15}, false, al, "F64 d16 d14 d15", "F64_d16_d14_d15"}, 190 {{F32, d5, d30, d13}, false, al, "F32 d5 d30 d13", "F32_d5_d30_d13"}, 191 {{F32, d4, d21, d14}, false, al, "F32 d4 d21 d14", "F32_d4_d21_d14"}, 192 {{F32, d7, d4, d5}, false, al, "F32 d7 d4 d5", "F32_d7_d4_d5"}, 193 {{F64, d2, d23, d13}, false, al, "F64 d2 d23 d13", "F64_d2_d23_d13"}, 194 {{F32, d16, d30, d23}, false, al, "F32 d16 d30 d23", "F32_d16_d30_d23"}, 195 {{F32, d18, d15, d28}, false, al, "F32 d18 d15 d28", "F32_d18_d15_d28"}, 196 {{F32, d6, d31, d23}, false, al, "F32 d6 d31 d23", "F32_d6_d31_d23"}}; 197 198 // These headers each contain an array of `TestResult` with the reference output 199 // values. The reference arrays are names `kReference{mnemonic}`. 200 #include "aarch32/traces/assembler-cond-dt-drt-drd-drn-drm-float-not-f16-vadd-t32.h" 201 #include "aarch32/traces/assembler-cond-dt-drt-drd-drn-drm-float-not-f16-vsub-t32.h" 202 203 204 // The maximum number of errors to report in detail for each test. 205 const unsigned kErrorReportLimit = 8; 206 207 typedef void (MacroAssembler::*Fn)(DataType dt, 208 DRegister rd, 209 DRegister rn, 210 DRegister rm); 211 212 void TestHelper(Fn instruction, 213 const char* mnemonic, 214 const TestResult reference[]) { 215 unsigned total_error_count = 0; 216 MacroAssembler masm(BUF_SIZE); 217 218 masm.UseT32(); 219 220 for (unsigned i = 0; i < ARRAY_SIZE(kTests); i++) { 221 // Values to pass to the macro-assembler. 222 DataType dt = kTests[i].operands.dt; 223 DRegister rd = kTests[i].operands.rd; 224 DRegister rn = kTests[i].operands.rn; 225 DRegister rm = kTests[i].operands.rm; 226 227 int32_t start = masm.GetCursorOffset(); 228 { 229 // We never generate more that 4 bytes, as IT instructions are only 230 // allowed for narrow encodings. 231 ExactAssemblyScope scope(&masm, 4, ExactAssemblyScope::kMaximumSize); 232 if (kTests[i].in_it_block) { 233 masm.it(kTests[i].it_condition); 234 } 235 (masm.*instruction)(dt, rd, rn, rm); 236 } 237 int32_t end = masm.GetCursorOffset(); 238 239 const byte* result_ptr = 240 masm.GetBuffer()->GetOffsetAddress<const byte*>(start); 241 VIXL_ASSERT(start < end); 242 uint32_t result_size = end - start; 243 244 if (Test::generate_test_trace()) { 245 // Print the result bytes. 246 printf("const byte kInstruction_%s_%s[] = {\n", 247 mnemonic, 248 kTests[i].identifier); 249 for (uint32_t j = 0; j < result_size; j++) { 250 if (j == 0) { 251 printf(" 0x%02" PRIx8, result_ptr[j]); 252 } else { 253 printf(", 0x%02" PRIx8, result_ptr[j]); 254 } 255 } 256 // This comment is meant to be used by external tools to validate 257 // the encoding. We can parse the comment to figure out what 258 // instruction this corresponds to. 259 if (kTests[i].in_it_block) { 260 printf(" // It %s; %s %s\n};\n", 261 kTests[i].it_condition.GetName(), 262 mnemonic, 263 kTests[i].operands_description); 264 } else { 265 printf(" // %s %s\n};\n", mnemonic, kTests[i].operands_description); 266 } 267 } else { 268 // Check we've emitted the exact same encoding as present in the 269 // trace file. Only print up to `kErrorReportLimit` errors. 270 if (((result_size != reference[i].size) || 271 (memcmp(result_ptr, reference[i].encoding, reference[i].size) != 272 0)) && 273 (++total_error_count <= kErrorReportLimit)) { 274 printf("Error when testing \"%s\" with operands \"%s\":\n", 275 mnemonic, 276 kTests[i].operands_description); 277 printf(" Expected: "); 278 for (uint32_t j = 0; j < reference[i].size; j++) { 279 if (j == 0) { 280 printf("0x%02" PRIx8, reference[i].encoding[j]); 281 } else { 282 printf(", 0x%02" PRIx8, reference[i].encoding[j]); 283 } 284 } 285 printf("\n"); 286 printf(" Found: "); 287 for (uint32_t j = 0; j < result_size; j++) { 288 if (j == 0) { 289 printf("0x%02" PRIx8, result_ptr[j]); 290 } else { 291 printf(", 0x%02" PRIx8, result_ptr[j]); 292 } 293 } 294 printf("\n"); 295 } 296 } 297 } 298 299 masm.FinalizeCode(); 300 301 if (Test::generate_test_trace()) { 302 // Finalize the trace file by writing the final `TestResult` array 303 // which links all generated instruction encodings. 304 printf("const TestResult kReference%s[] = {\n", mnemonic); 305 for (unsigned i = 0; i < ARRAY_SIZE(kTests); i++) { 306 printf(" {\n"); 307 printf(" ARRAY_SIZE(kInstruction_%s_%s),\n", 308 mnemonic, 309 kTests[i].identifier); 310 printf(" kInstruction_%s_%s,\n", mnemonic, kTests[i].identifier); 311 printf(" },\n"); 312 } 313 printf("};\n"); 314 } else { 315 if (total_error_count > kErrorReportLimit) { 316 printf("%u other errors follow.\n", 317 total_error_count - kErrorReportLimit); 318 } 319 // Crash if the test failed. 320 VIXL_CHECK(total_error_count == 0); 321 } 322 } 323 324 // Instantiate tests for each instruction in the list. 325 #define TEST(mnemonic) \ 326 void Test_##mnemonic() { \ 327 TestHelper(&MacroAssembler::mnemonic, #mnemonic, kReference##mnemonic); \ 328 } \ 329 Test test_##mnemonic( \ 330 "AARCH32_ASSEMBLER_COND_DT_DRT_DRD_DRN_DRM_FLOAT_NOT_F16_" #mnemonic \ 331 "_T32", \ 332 &Test_##mnemonic); 333 FOREACH_INSTRUCTION(TEST) 334 #undef TEST 335 336 } // namespace 337 #endif 338 339 } // namespace aarch32 340 } // namespace vixl 341
