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