1 // Copyright 2012 the V8 project authors. All rights reserved. 2 // Redistribution and use in source and binary forms, with or without 3 // modification, are permitted provided that the following conditions are 4 // met: 5 // 6 // * Redistributions of source code must retain the above copyright 7 // notice, this list of conditions and the following disclaimer. 8 // * Redistributions in binary form must reproduce the above 9 // copyright notice, this list of conditions and the following 10 // disclaimer in the documentation and/or other materials provided 11 // with the distribution. 12 // * Neither the name of Google Inc. nor the names of its 13 // contributors may be used to endorse or promote products derived 14 // from this software without specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28 #ifndef V8_CHECKS_H_ 29 #define V8_CHECKS_H_ 30 31 #include <string.h> 32 33 #include "../include/v8stdint.h" 34 extern "C" void V8_Fatal(const char* file, int line, const char* format, ...); 35 36 // The FATAL, UNREACHABLE and UNIMPLEMENTED macros are useful during 37 // development, but they should not be relied on in the final product. 38 #ifdef DEBUG 39 #define FATAL(msg) \ 40 V8_Fatal(__FILE__, __LINE__, "%s", (msg)) 41 #define UNIMPLEMENTED() \ 42 V8_Fatal(__FILE__, __LINE__, "unimplemented code") 43 #define UNREACHABLE() \ 44 V8_Fatal(__FILE__, __LINE__, "unreachable code") 45 #else 46 #define FATAL(msg) \ 47 V8_Fatal("", 0, "%s", (msg)) 48 #define UNIMPLEMENTED() \ 49 V8_Fatal("", 0, "unimplemented code") 50 #define UNREACHABLE() ((void) 0) 51 #endif 52 53 54 // The CHECK macro checks that the given condition is true; if not, it 55 // prints a message to stderr and aborts. 56 #define CHECK(condition) do { \ 57 if (!(condition)) { \ 58 V8_Fatal(__FILE__, __LINE__, "CHECK(%s) failed", #condition); \ 59 } \ 60 } while (0) 61 62 63 // Helper function used by the CHECK_EQ function when given int 64 // arguments. Should not be called directly. 65 inline void CheckEqualsHelper(const char* file, int line, 66 const char* expected_source, int expected, 67 const char* value_source, int value) { 68 if (expected != value) { 69 V8_Fatal(file, line, 70 "CHECK_EQ(%s, %s) failed\n# Expected: %i\n# Found: %i", 71 expected_source, value_source, expected, value); 72 } 73 } 74 75 76 // Helper function used by the CHECK_EQ function when given int64_t 77 // arguments. Should not be called directly. 78 inline void CheckEqualsHelper(const char* file, int line, 79 const char* expected_source, 80 int64_t expected, 81 const char* value_source, 82 int64_t value) { 83 if (expected != value) { 84 // Print int64_t values in hex, as two int32s, 85 // to avoid platform-dependencies. 86 V8_Fatal(file, line, 87 "CHECK_EQ(%s, %s) failed\n#" 88 " Expected: 0x%08x%08x\n# Found: 0x%08x%08x", 89 expected_source, value_source, 90 static_cast<uint32_t>(expected >> 32), 91 static_cast<uint32_t>(expected), 92 static_cast<uint32_t>(value >> 32), 93 static_cast<uint32_t>(value)); 94 } 95 } 96 97 98 // Helper function used by the CHECK_NE function when given int 99 // arguments. Should not be called directly. 100 inline void CheckNonEqualsHelper(const char* file, 101 int line, 102 const char* unexpected_source, 103 int unexpected, 104 const char* value_source, 105 int value) { 106 if (unexpected == value) { 107 V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %i", 108 unexpected_source, value_source, value); 109 } 110 } 111 112 113 // Helper function used by the CHECK function when given string 114 // arguments. Should not be called directly. 115 inline void CheckEqualsHelper(const char* file, 116 int line, 117 const char* expected_source, 118 const char* expected, 119 const char* value_source, 120 const char* value) { 121 if ((expected == NULL && value != NULL) || 122 (expected != NULL && value == NULL) || 123 (expected != NULL && value != NULL && strcmp(expected, value) != 0)) { 124 V8_Fatal(file, line, 125 "CHECK_EQ(%s, %s) failed\n# Expected: %s\n# Found: %s", 126 expected_source, value_source, expected, value); 127 } 128 } 129 130 131 inline void CheckNonEqualsHelper(const char* file, 132 int line, 133 const char* expected_source, 134 const char* expected, 135 const char* value_source, 136 const char* value) { 137 if (expected == value || 138 (expected != NULL && value != NULL && strcmp(expected, value) == 0)) { 139 V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %s", 140 expected_source, value_source, value); 141 } 142 } 143 144 145 // Helper function used by the CHECK function when given pointer 146 // arguments. Should not be called directly. 147 inline void CheckEqualsHelper(const char* file, 148 int line, 149 const char* expected_source, 150 const void* expected, 151 const char* value_source, 152 const void* value) { 153 if (expected != value) { 154 V8_Fatal(file, line, 155 "CHECK_EQ(%s, %s) failed\n# Expected: %p\n# Found: %p", 156 expected_source, value_source, 157 expected, value); 158 } 159 } 160 161 162 inline void CheckNonEqualsHelper(const char* file, 163 int line, 164 const char* expected_source, 165 const void* expected, 166 const char* value_source, 167 const void* value) { 168 if (expected == value) { 169 V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %p", 170 expected_source, value_source, value); 171 } 172 } 173 174 175 // Helper function used by the CHECK function when given floating 176 // point arguments. Should not be called directly. 177 inline void CheckEqualsHelper(const char* file, 178 int line, 179 const char* expected_source, 180 double expected, 181 const char* value_source, 182 double value) { 183 // Force values to 64 bit memory to truncate 80 bit precision on IA32. 184 volatile double* exp = new double[1]; 185 *exp = expected; 186 volatile double* val = new double[1]; 187 *val = value; 188 if (*exp != *val) { 189 V8_Fatal(file, line, 190 "CHECK_EQ(%s, %s) failed\n# Expected: %f\n# Found: %f", 191 expected_source, value_source, *exp, *val); 192 } 193 delete[] exp; 194 delete[] val; 195 } 196 197 198 inline void CheckNonEqualsHelper(const char* file, 199 int line, 200 const char* expected_source, 201 double expected, 202 const char* value_source, 203 double value) { 204 // Force values to 64 bit memory to truncate 80 bit precision on IA32. 205 volatile double* exp = new double[1]; 206 *exp = expected; 207 volatile double* val = new double[1]; 208 *val = value; 209 if (*exp == *val) { 210 V8_Fatal(file, line, 211 "CHECK_NE(%s, %s) failed\n# Value: %f", 212 expected_source, value_source, *val); 213 } 214 delete[] exp; 215 delete[] val; 216 } 217 218 219 #define CHECK_EQ(expected, value) CheckEqualsHelper(__FILE__, __LINE__, \ 220 #expected, expected, #value, value) 221 222 223 #define CHECK_NE(unexpected, value) CheckNonEqualsHelper(__FILE__, __LINE__, \ 224 #unexpected, unexpected, #value, value) 225 226 227 #define CHECK_GT(a, b) CHECK((a) > (b)) 228 #define CHECK_GE(a, b) CHECK((a) >= (b)) 229 #define CHECK_LT(a, b) CHECK((a) < (b)) 230 #define CHECK_LE(a, b) CHECK((a) <= (b)) 231 232 233 // This is inspired by the static assertion facility in boost. This 234 // is pretty magical. If it causes you trouble on a platform you may 235 // find a fix in the boost code. 236 template <bool> class StaticAssertion; 237 template <> class StaticAssertion<true> { }; 238 // This macro joins two tokens. If one of the tokens is a macro the 239 // helper call causes it to be resolved before joining. 240 #define SEMI_STATIC_JOIN(a, b) SEMI_STATIC_JOIN_HELPER(a, b) 241 #define SEMI_STATIC_JOIN_HELPER(a, b) a##b 242 // Causes an error during compilation of the condition is not 243 // statically known to be true. It is formulated as a typedef so that 244 // it can be used wherever a typedef can be used. Beware that this 245 // actually causes each use to introduce a new defined type with a 246 // name depending on the source line. 247 template <int> class StaticAssertionHelper { }; 248 #define STATIC_CHECK(test) \ 249 typedef \ 250 StaticAssertionHelper<sizeof(StaticAssertion<static_cast<bool>((test))>)> \ 251 SEMI_STATIC_JOIN(__StaticAssertTypedef__, __LINE__) 252 253 254 extern bool FLAG_enable_slow_asserts; 255 256 257 // The ASSERT macro is equivalent to CHECK except that it only 258 // generates code in debug builds. 259 #ifdef DEBUG 260 #define ASSERT_RESULT(expr) CHECK(expr) 261 #define ASSERT(condition) CHECK(condition) 262 #define ASSERT_EQ(v1, v2) CHECK_EQ(v1, v2) 263 #define ASSERT_NE(v1, v2) CHECK_NE(v1, v2) 264 #define ASSERT_GE(v1, v2) CHECK_GE(v1, v2) 265 #define ASSERT_LT(v1, v2) CHECK_LT(v1, v2) 266 #define ASSERT_LE(v1, v2) CHECK_LE(v1, v2) 267 #define SLOW_ASSERT(condition) CHECK(!FLAG_enable_slow_asserts || (condition)) 268 #else 269 #define ASSERT_RESULT(expr) (expr) 270 #define ASSERT(condition) ((void) 0) 271 #define ASSERT_EQ(v1, v2) ((void) 0) 272 #define ASSERT_NE(v1, v2) ((void) 0) 273 #define ASSERT_GE(v1, v2) ((void) 0) 274 #define ASSERT_LT(v1, v2) ((void) 0) 275 #define ASSERT_LE(v1, v2) ((void) 0) 276 #define SLOW_ASSERT(condition) ((void) 0) 277 #endif 278 // Static asserts has no impact on runtime performance, so they can be 279 // safely enabled in release mode. Moreover, the ((void) 0) expression 280 // obeys different syntax rules than typedef's, e.g. it can't appear 281 // inside class declaration, this leads to inconsistency between debug 282 // and release compilation modes behavior. 283 #define STATIC_ASSERT(test) STATIC_CHECK(test) 284 285 #define ASSERT_NOT_NULL(p) ASSERT_NE(NULL, p) 286 287 #endif // V8_CHECKS_H_ 288
