1 // Copyright 2014, 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 #ifndef TEST_TEST_H_ 28 #define TEST_TEST_H_ 29 30 #include "utils-vixl.h" 31 #include "aarch64/instructions-aarch64.h" 32 33 namespace vixl { 34 35 // Each actual test is represented by a Test instance. 36 // Tests are appended to a static linked list upon creation. 37 class Test { 38 public: 39 // Most tests require no per-test configuration, and so take no arguments. A 40 // few tests require dynamic configuration, and are passed a `Test` object. 41 template <typename Fn> Test(const char * name,Fn * callback)42 Test(const char* name, Fn* callback) 43 : name_(name), sve_vl_(aarch64::kZRegMinSize), next_(NULL) { 44 set_callback(callback); 45 // Append this test to the linked list. 46 if (first_ == NULL) { 47 VIXL_ASSERT(last_ == NULL); 48 first_ = this; 49 } else { 50 last_->next_ = this; 51 } 52 last_ = this; 53 } 54 name()55 const char* name() { return name_; } 56 void run(); 57 58 // The SVE vector length can be configured by each test, based on either 59 // hardware feature detection (in the test itself) or Simulator configuration. sve_vl_in_bits()60 int sve_vl_in_bits() const { return sve_vl_; } set_sve_vl_in_bits(unsigned sve_vl)61 void set_sve_vl_in_bits(unsigned sve_vl) { 62 VIXL_ASSERT(sve_vl >= aarch64::kZRegMinSize); 63 VIXL_ASSERT(sve_vl <= aarch64::kZRegMaxSize); 64 VIXL_ASSERT((sve_vl % aarch64::kZRegMinSize) == 0); 65 sve_vl_ = sve_vl; 66 } 67 sve_vl_in_bytes()68 int sve_vl_in_bytes() const { 69 VIXL_ASSERT((sve_vl_ % kBitsPerByte) == 0); 70 return sve_vl_ / kBitsPerByte; 71 } 72 first()73 static Test* first() { return first_; } last()74 static Test* last() { return last_; } next()75 Test* next() { return next_; } verbose()76 static bool verbose() { return verbose_; } set_verbose(bool value)77 static void set_verbose(bool value) { verbose_ = value; } trace_sim()78 static bool trace_sim() { return trace_sim_; } set_trace_sim(bool value)79 static void set_trace_sim(bool value) { trace_sim_ = value; } trace_reg()80 static bool trace_reg() { return trace_reg_; } set_trace_reg(bool value)81 static void set_trace_reg(bool value) { trace_reg_ = value; } trace_write()82 static bool trace_write() { return trace_write_; } set_trace_write(bool value)83 static void set_trace_write(bool value) { trace_write_ = value; } trace_branch()84 static bool trace_branch() { return trace_branch_; } set_trace_branch(bool value)85 static void set_trace_branch(bool value) { trace_branch_ = value; } disassemble()86 static bool disassemble() { return disassemble_; } set_disassemble(bool value)87 static void set_disassemble(bool value) { disassemble_ = value; } disassemble_infrastructure()88 static bool disassemble_infrastructure() { 89 return disassemble_infrastructure_; 90 } set_disassemble_infrastructure(bool value)91 static void set_disassemble_infrastructure(bool value) { 92 disassemble_infrastructure_ = value; 93 } coloured_trace()94 static bool coloured_trace() { return coloured_trace_; } set_coloured_trace(bool value)95 static void set_coloured_trace(bool value) { coloured_trace_ = value; } generate_test_trace()96 static bool generate_test_trace() { return generate_test_trace_; } set_generate_test_trace(bool value)97 static void set_generate_test_trace(bool value) { 98 generate_test_trace_ = value; 99 } 100 101 typedef void(TestFunction)(); 102 typedef void(TestFunctionWithConfig)(Test* config); 103 104 private: 105 const char* name_; 106 107 TestFunction* callback_; 108 TestFunctionWithConfig* callback_with_config_; 109 110 void set_callback(TestFunction* callback); 111 void set_callback(TestFunctionWithConfig* callback); 112 113 int sve_vl_; 114 115 static Test* first_; 116 static Test* last_; 117 Test* next_; 118 static bool verbose_; 119 static bool trace_sim_; 120 static bool trace_reg_; 121 static bool trace_write_; 122 static bool trace_branch_; 123 static bool disassemble_; 124 static bool disassemble_infrastructure_; 125 static bool coloured_trace_; 126 static bool generate_test_trace_; 127 }; 128 129 // Define helper macros for test files. 130 131 // Macro to register a test. It instantiates a Test and registers its 132 // callback function. 133 #define TEST_(Name) \ 134 void Test##Name(); \ 135 Test test_##Name(#Name, &Test##Name); \ 136 void Test##Name() 137 } // namespace vixl 138 139 #endif // TEST_TEST_H_ 140