1 /* This header is machine-generated. Its actual source is in 2 scripts/generate-fast-branches.in.m4sh 3 , within the Jitter source distribution. */ 4 5 #ifndef JITTER_FAST_BRANCH_MACHINE_GENERATED_H_ 6 #define JITTER_FAST_BRANCH_MACHINE_GENERATED_H_ 7 8 /* Condition-evaluating macros, expanding to C expressions. */ 9 #define _JITTER_C_CONDITION_NEVER_(x) \ 10 0 11 #define _JITTER_C_CONDITION_ALWAYS_(x) \ 12 1 13 #define _JITTER_C_CONDITION_ZERO_(x) \ 14 (! (x)) 15 #define _JITTER_C_CONDITION_NONZERO_(x) \ 16 (x) 17 #define _JITTER_C_CONDITION_POSITIVE_(x) \ 18 ((jitter_int) (x) > 0) 19 #define _JITTER_C_CONDITION_NONPOSITIVE_(x) \ 20 ((jitter_int) (x) <= 0) 21 #define _JITTER_C_CONDITION_NEGATIVE_(x) \ 22 ((jitter_int) (x) < 0) 23 #define _JITTER_C_CONDITION_NONNEGATIVE_(x) \ 24 ((jitter_int) (x) >= 0) 25 #define _JITTER_C_CONDITION_EQUAL_(x, y) \ 26 ((x) == (y)) 27 #define _JITTER_C_CONDITION_NOTEQUAL_(x, y) \ 28 ((x) != (y)) 29 #define _JITTER_C_CONDITION_LESS_UNSIGNED_(x, y) \ 30 ((x) < (y)) 31 #define _JITTER_C_CONDITION_LESS_SIGNED_(x, y) \ 32 ((x) < (y)) 33 #define _JITTER_C_CONDITION_GREATER_UNSIGNED_(x, y) \ 34 ((x) > (y)) 35 #define _JITTER_C_CONDITION_GREATER_SIGNED_(x, y) \ 36 ((x) > (y)) 37 #define _JITTER_C_CONDITION_NOTLESS_UNSIGNED_(x, y) \ 38 ((x) >= (y)) 39 #define _JITTER_C_CONDITION_NOTLESS_SIGNED_(x, y) \ 40 ((x) >= (y)) 41 #define _JITTER_C_CONDITION_NOTGREATER_UNSIGNED_(x, y) \ 42 ((x) <= (y)) 43 #define _JITTER_C_CONDITION_NOTGREATER_SIGNED_(x, y) \ 44 ((x) <= (y)) 45 #define _JITTER_C_CONDITION_AND_(x, y) \ 46 ((x) & (y)) 47 #define _JITTER_C_CONDITION_NOTAND_(x, y) \ 48 (! ((x) & (y))) 49 50 /* Add missing low-level conditional fast branch definitions. */ 51 #if ! defined (JITTER_DISPATCH_NO_THREADING) 52 /* Forget any machine-specific definition unless the dispatch is 53 no-threading; this makes each port simpler, since machine-specific 54 headers can define low-level fast branches unconditionally. */ 55 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEVER_ 56 #endif 57 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEVER_ 58 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEVER_(x, _jitter_tgt) \ 59 /* Never branch. */ 60 #endif 61 62 #if ! defined (JITTER_DISPATCH_NO_THREADING) 63 /* Forget any machine-specific definition unless the dispatch is 64 no-threading; this makes each port simpler, since machine-specific 65 headers can define low-level fast branches unconditionally. */ 66 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ALWAYS_ 67 #endif 68 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ALWAYS_ 69 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ALWAYS_(x, _jitter_tgt) \ 70 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt) 71 #endif 72 73 #if ! defined (JITTER_DISPATCH_NO_THREADING) 74 /* Forget any machine-specific definition unless the dispatch is 75 no-threading; this makes each port simpler, since machine-specific 76 headers can define low-level fast branches unconditionally. */ 77 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ 78 #endif 79 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ 80 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_(x, _jitter_tgt) \ 81 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_ZERO_ ((x)), _jitter_tgt) 82 #endif 83 84 #if ! defined (JITTER_DISPATCH_NO_THREADING) 85 /* Forget any machine-specific definition unless the dispatch is 86 no-threading; this makes each port simpler, since machine-specific 87 headers can define low-level fast branches unconditionally. */ 88 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ 89 #endif 90 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ 91 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_(x, _jitter_tgt) \ 92 if ((x)) \ 93 { \ 94 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 95 } 96 #endif 97 98 #if ! defined (JITTER_DISPATCH_NO_THREADING) 99 /* Forget any machine-specific definition unless the dispatch is 100 no-threading; this makes each port simpler, since machine-specific 101 headers can define low-level fast branches unconditionally. */ 102 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ 103 #endif 104 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ 105 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_(x, _jitter_tgt) \ 106 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_POSITIVE_ ((x)), _jitter_tgt) 107 #endif 108 109 #if ! defined (JITTER_DISPATCH_NO_THREADING) 110 /* Forget any machine-specific definition unless the dispatch is 111 no-threading; this makes each port simpler, since machine-specific 112 headers can define low-level fast branches unconditionally. */ 113 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ 114 #endif 115 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ 116 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_(x, _jitter_tgt) \ 117 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NONPOSITIVE_ ((x)), _jitter_tgt) 118 #endif 119 120 #if ! defined (JITTER_DISPATCH_NO_THREADING) 121 /* Forget any machine-specific definition unless the dispatch is 122 no-threading; this makes each port simpler, since machine-specific 123 headers can define low-level fast branches unconditionally. */ 124 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ 125 #endif 126 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ 127 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_(x, _jitter_tgt) \ 128 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NEGATIVE_ ((x)), _jitter_tgt) 129 #endif 130 131 #if ! defined (JITTER_DISPATCH_NO_THREADING) 132 /* Forget any machine-specific definition unless the dispatch is 133 no-threading; this makes each port simpler, since machine-specific 134 headers can define low-level fast branches unconditionally. */ 135 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ 136 #endif 137 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ 138 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_(x, _jitter_tgt) \ 139 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NONNEGATIVE_ ((x)), _jitter_tgt) 140 #endif 141 142 #if ! defined (JITTER_DISPATCH_NO_THREADING) 143 /* Forget any machine-specific definition unless the dispatch is 144 no-threading; this makes each port simpler, since machine-specific 145 headers can define low-level fast branches unconditionally. */ 146 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_EQUAL_ 147 #endif 148 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_EQUAL_ 149 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_EQUAL_(x, y, _jitter_tgt) \ 150 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_EQUAL_ ((x), (y)), _jitter_tgt) 151 #endif 152 153 #if ! defined (JITTER_DISPATCH_NO_THREADING) 154 /* Forget any machine-specific definition unless the dispatch is 155 no-threading; this makes each port simpler, since machine-specific 156 headers can define low-level fast branches unconditionally. */ 157 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTEQUAL_ 158 #endif 159 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTEQUAL_ 160 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTEQUAL_(x, y, _jitter_tgt) \ 161 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NOTEQUAL_ ((x), (y)), _jitter_tgt) 162 #endif 163 164 #if ! defined (JITTER_DISPATCH_NO_THREADING) 165 /* Forget any machine-specific definition unless the dispatch is 166 no-threading; this makes each port simpler, since machine-specific 167 headers can define low-level fast branches unconditionally. */ 168 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_UNSIGNED_ 169 #endif 170 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_UNSIGNED_ 171 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_UNSIGNED_(x, y, _jitter_tgt) \ 172 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_LESS_UNSIGNED_ ((x), (y)), _jitter_tgt) 173 #endif 174 175 #if ! defined (JITTER_DISPATCH_NO_THREADING) 176 /* Forget any machine-specific definition unless the dispatch is 177 no-threading; this makes each port simpler, since machine-specific 178 headers can define low-level fast branches unconditionally. */ 179 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_SIGNED_ 180 #endif 181 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_SIGNED_ 182 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_SIGNED_(x, y, _jitter_tgt) \ 183 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_LESS_SIGNED_ ((x), (y)), _jitter_tgt) 184 #endif 185 186 #if ! defined (JITTER_DISPATCH_NO_THREADING) 187 /* Forget any machine-specific definition unless the dispatch is 188 no-threading; this makes each port simpler, since machine-specific 189 headers can define low-level fast branches unconditionally. */ 190 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_UNSIGNED_ 191 #endif 192 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_UNSIGNED_ 193 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_UNSIGNED_(x, y, _jitter_tgt) \ 194 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_GREATER_UNSIGNED_ ((x), (y)), _jitter_tgt) 195 #endif 196 197 #if ! defined (JITTER_DISPATCH_NO_THREADING) 198 /* Forget any machine-specific definition unless the dispatch is 199 no-threading; this makes each port simpler, since machine-specific 200 headers can define low-level fast branches unconditionally. */ 201 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_SIGNED_ 202 #endif 203 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_SIGNED_ 204 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_SIGNED_(x, y, _jitter_tgt) \ 205 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_GREATER_SIGNED_ ((x), (y)), _jitter_tgt) 206 #endif 207 208 #if ! defined (JITTER_DISPATCH_NO_THREADING) 209 /* Forget any machine-specific definition unless the dispatch is 210 no-threading; this makes each port simpler, since machine-specific 211 headers can define low-level fast branches unconditionally. */ 212 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_UNSIGNED_ 213 #endif 214 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_UNSIGNED_ 215 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_UNSIGNED_(x, y, _jitter_tgt) \ 216 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NOTLESS_UNSIGNED_ ((x), (y)), _jitter_tgt) 217 #endif 218 219 #if ! defined (JITTER_DISPATCH_NO_THREADING) 220 /* Forget any machine-specific definition unless the dispatch is 221 no-threading; this makes each port simpler, since machine-specific 222 headers can define low-level fast branches unconditionally. */ 223 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_SIGNED_ 224 #endif 225 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_SIGNED_ 226 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_SIGNED_(x, y, _jitter_tgt) \ 227 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NOTLESS_SIGNED_ ((x), (y)), _jitter_tgt) 228 #endif 229 230 #if ! defined (JITTER_DISPATCH_NO_THREADING) 231 /* Forget any machine-specific definition unless the dispatch is 232 no-threading; this makes each port simpler, since machine-specific 233 headers can define low-level fast branches unconditionally. */ 234 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_UNSIGNED_ 235 #endif 236 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_UNSIGNED_ 237 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_UNSIGNED_(x, y, _jitter_tgt) \ 238 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NOTGREATER_UNSIGNED_ ((x), (y)), _jitter_tgt) 239 #endif 240 241 #if ! defined (JITTER_DISPATCH_NO_THREADING) 242 /* Forget any machine-specific definition unless the dispatch is 243 no-threading; this makes each port simpler, since machine-specific 244 headers can define low-level fast branches unconditionally. */ 245 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_SIGNED_ 246 #endif 247 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_SIGNED_ 248 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_SIGNED_(x, y, _jitter_tgt) \ 249 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_NOTGREATER_SIGNED_ ((x), (y)), _jitter_tgt) 250 #endif 251 252 #if ! defined (JITTER_DISPATCH_NO_THREADING) 253 /* Forget any machine-specific definition unless the dispatch is 254 no-threading; this makes each port simpler, since machine-specific 255 headers can define low-level fast branches unconditionally. */ 256 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_AND_ 257 #endif 258 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_AND_ 259 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_AND_(x, y, _jitter_tgt) \ 260 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ ((jitter_uint) _JITTER_C_CONDITION_AND_ ((x), (y)), _jitter_tgt) 261 #endif 262 263 #if ! defined (JITTER_DISPATCH_NO_THREADING) 264 /* Forget any machine-specific definition unless the dispatch is 265 no-threading; this makes each port simpler, since machine-specific 266 headers can define low-level fast branches unconditionally. */ 267 # undef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTAND_ 268 #endif 269 #ifndef _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTAND_ 270 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTAND_(x, y, _jitter_tgt) \ 271 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ (_JITTER_C_CONDITION_AND_ ((x), (y)), _jitter_tgt) 272 #endif 273 274 275 /* High-level conditional fast branches. */ 276 #define _JITTER_BRANCH_FAST_IF_NEVER(x, _jitter_tgt) \ 277 do \ 278 { \ 279 /* Evaluate arguments, once and for all. */ \ 280 const jitter_uint _jitter_x = (jitter_uint) (x); \ 281 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 282 The condition of this if statement is a constant expression, and will \ 283 be optimized away in either case. */ \ 284 const bool _jitter_condition \ 285 = _JITTER_C_CONDITION_NEVER_ (_jitter_x); \ 286 const bool _jitter_condition_known \ 287 = __builtin_constant_p (_jitter_condition); \ 288 if (_jitter_condition_known) \ 289 { \ 290 /* The condition is a known constant, so this if will turn into \ 291 either nothing or an unconditional branch. */ \ 292 if (_jitter_condition) \ 293 { \ 294 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 295 } \ 296 } \ 297 else \ 298 { \ 299 /* The condition is not a known constant. */ \ 300 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEVER_ \ 301 (_jitter_x, _jitter_tgt); \ 302 } \ 303 } \ 304 while (0) 305 #define _JITTER_BRANCH_FAST_IF_ALWAYS(x, _jitter_tgt) \ 306 do \ 307 { \ 308 /* Evaluate arguments, once and for all. */ \ 309 const jitter_uint _jitter_x = (jitter_uint) (x); \ 310 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 311 The condition of this if statement is a constant expression, and will \ 312 be optimized away in either case. */ \ 313 const bool _jitter_condition \ 314 = _JITTER_C_CONDITION_ALWAYS_ (_jitter_x); \ 315 const bool _jitter_condition_known \ 316 = __builtin_constant_p (_jitter_condition); \ 317 if (_jitter_condition_known) \ 318 { \ 319 /* The condition is a known constant, so this if will turn into \ 320 either nothing or an unconditional branch. */ \ 321 if (_jitter_condition) \ 322 { \ 323 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 324 } \ 325 } \ 326 else \ 327 { \ 328 /* The condition is not a known constant. */ \ 329 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ALWAYS_ \ 330 (_jitter_x, _jitter_tgt); \ 331 } \ 332 } \ 333 while (0) 334 #define _JITTER_BRANCH_FAST_IF_ZERO(x, _jitter_tgt) \ 335 do \ 336 { \ 337 /* Evaluate arguments, once and for all. */ \ 338 const jitter_uint _jitter_x = (jitter_uint) (x); \ 339 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 340 The condition of this if statement is a constant expression, and will \ 341 be optimized away in either case. */ \ 342 const bool _jitter_condition \ 343 = _JITTER_C_CONDITION_ZERO_ (_jitter_x); \ 344 const bool _jitter_condition_known \ 345 = __builtin_constant_p (_jitter_condition); \ 346 if (_jitter_condition_known) \ 347 { \ 348 /* The condition is a known constant, so this if will turn into \ 349 either nothing or an unconditional branch. */ \ 350 if (_jitter_condition) \ 351 { \ 352 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 353 } \ 354 } \ 355 else \ 356 { \ 357 /* The condition is not a known constant. */ \ 358 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 359 (_jitter_x, _jitter_tgt); \ 360 } \ 361 } \ 362 while (0) 363 #define _JITTER_BRANCH_FAST_IF_NONZERO(x, _jitter_tgt) \ 364 do \ 365 { \ 366 /* Evaluate arguments, once and for all. */ \ 367 const jitter_uint _jitter_x = (jitter_uint) (x); \ 368 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 369 The condition of this if statement is a constant expression, and will \ 370 be optimized away in either case. */ \ 371 const bool _jitter_condition \ 372 = _JITTER_C_CONDITION_NONZERO_ (_jitter_x); \ 373 const bool _jitter_condition_known \ 374 = __builtin_constant_p (_jitter_condition); \ 375 if (_jitter_condition_known) \ 376 { \ 377 /* The condition is a known constant, so this if will turn into \ 378 either nothing or an unconditional branch. */ \ 379 if (_jitter_condition) \ 380 { \ 381 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 382 } \ 383 } \ 384 else \ 385 { \ 386 /* The condition is not a known constant. */ \ 387 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 388 (_jitter_x, _jitter_tgt); \ 389 } \ 390 } \ 391 while (0) 392 #define _JITTER_BRANCH_FAST_IF_POSITIVE(x, _jitter_tgt) \ 393 do \ 394 { \ 395 /* Evaluate arguments, once and for all. */ \ 396 const jitter_uint _jitter_x = (jitter_uint) (x); \ 397 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 398 The condition of this if statement is a constant expression, and will \ 399 be optimized away in either case. */ \ 400 const bool _jitter_condition \ 401 = _JITTER_C_CONDITION_POSITIVE_ (_jitter_x); \ 402 const bool _jitter_condition_known \ 403 = __builtin_constant_p (_jitter_condition); \ 404 if (_jitter_condition_known) \ 405 { \ 406 /* The condition is a known constant, so this if will turn into \ 407 either nothing or an unconditional branch. */ \ 408 if (_jitter_condition) \ 409 { \ 410 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 411 } \ 412 } \ 413 else \ 414 { \ 415 /* The condition is not a known constant. */ \ 416 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ \ 417 (_jitter_x, _jitter_tgt); \ 418 } \ 419 } \ 420 while (0) 421 #define _JITTER_BRANCH_FAST_IF_NONPOSITIVE(x, _jitter_tgt) \ 422 do \ 423 { \ 424 /* Evaluate arguments, once and for all. */ \ 425 const jitter_uint _jitter_x = (jitter_uint) (x); \ 426 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 427 The condition of this if statement is a constant expression, and will \ 428 be optimized away in either case. */ \ 429 const bool _jitter_condition \ 430 = _JITTER_C_CONDITION_NONPOSITIVE_ (_jitter_x); \ 431 const bool _jitter_condition_known \ 432 = __builtin_constant_p (_jitter_condition); \ 433 if (_jitter_condition_known) \ 434 { \ 435 /* The condition is a known constant, so this if will turn into \ 436 either nothing or an unconditional branch. */ \ 437 if (_jitter_condition) \ 438 { \ 439 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 440 } \ 441 } \ 442 else \ 443 { \ 444 /* The condition is not a known constant. */ \ 445 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ \ 446 (_jitter_x, _jitter_tgt); \ 447 } \ 448 } \ 449 while (0) 450 #define _JITTER_BRANCH_FAST_IF_NEGATIVE(x, _jitter_tgt) \ 451 do \ 452 { \ 453 /* Evaluate arguments, once and for all. */ \ 454 const jitter_uint _jitter_x = (jitter_uint) (x); \ 455 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 456 The condition of this if statement is a constant expression, and will \ 457 be optimized away in either case. */ \ 458 const bool _jitter_condition \ 459 = _JITTER_C_CONDITION_NEGATIVE_ (_jitter_x); \ 460 const bool _jitter_condition_known \ 461 = __builtin_constant_p (_jitter_condition); \ 462 if (_jitter_condition_known) \ 463 { \ 464 /* The condition is a known constant, so this if will turn into \ 465 either nothing or an unconditional branch. */ \ 466 if (_jitter_condition) \ 467 { \ 468 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 469 } \ 470 } \ 471 else \ 472 { \ 473 /* The condition is not a known constant. */ \ 474 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ \ 475 (_jitter_x, _jitter_tgt); \ 476 } \ 477 } \ 478 while (0) 479 #define _JITTER_BRANCH_FAST_IF_NONNEGATIVE(x, _jitter_tgt) \ 480 do \ 481 { \ 482 /* Evaluate arguments, once and for all. */ \ 483 const jitter_uint _jitter_x = (jitter_uint) (x); \ 484 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 485 The condition of this if statement is a constant expression, and will \ 486 be optimized away in either case. */ \ 487 const bool _jitter_condition \ 488 = _JITTER_C_CONDITION_NONNEGATIVE_ (_jitter_x); \ 489 const bool _jitter_condition_known \ 490 = __builtin_constant_p (_jitter_condition); \ 491 if (_jitter_condition_known) \ 492 { \ 493 /* The condition is a known constant, so this if will turn into \ 494 either nothing or an unconditional branch. */ \ 495 if (_jitter_condition) \ 496 { \ 497 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 498 } \ 499 } \ 500 else \ 501 { \ 502 /* The condition is not a known constant. */ \ 503 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ \ 504 (_jitter_x, _jitter_tgt); \ 505 } \ 506 } \ 507 while (0) 508 #define _JITTER_BRANCH_FAST_IF_EQUAL(x, y, _jitter_tgt) \ 509 do \ 510 { \ 511 /* Evaluate arguments, once and for all. */ \ 512 const jitter_uint _jitter_x = (jitter_uint) (x); \ 513 const jitter_uint _jitter_y = (jitter_uint) (y); \ 514 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 515 The condition of this if statement is a constant expression, and will \ 516 be optimized away in either case. */ \ 517 const bool _jitter_condition \ 518 = _JITTER_C_CONDITION_EQUAL_ (_jitter_x, _jitter_y); \ 519 const bool _jitter_condition_known \ 520 = __builtin_constant_p (_jitter_condition); \ 521 if (_jitter_condition_known) \ 522 { \ 523 /* The condition is a known constant, so this if will turn into \ 524 either nothing or an unconditional branch. */ \ 525 if (_jitter_condition) \ 526 { \ 527 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 528 } \ 529 } \ 530 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 531 { \ 532 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 533 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 534 (_jitter_y, _jitter_tgt); \ 535 } \ 536 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 537 { \ 538 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 539 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 540 (_jitter_x, _jitter_tgt); \ 541 } \ 542 else \ 543 { \ 544 /* The condition is not a known constant. */ \ 545 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_EQUAL_ \ 546 (_jitter_x, _jitter_y, _jitter_tgt); \ 547 } \ 548 } \ 549 while (0) 550 #define _JITTER_BRANCH_FAST_IF_NOTEQUAL(x, y, _jitter_tgt) \ 551 do \ 552 { \ 553 /* Evaluate arguments, once and for all. */ \ 554 const jitter_uint _jitter_x = (jitter_uint) (x); \ 555 const jitter_uint _jitter_y = (jitter_uint) (y); \ 556 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 557 The condition of this if statement is a constant expression, and will \ 558 be optimized away in either case. */ \ 559 const bool _jitter_condition \ 560 = _JITTER_C_CONDITION_NOTEQUAL_ (_jitter_x, _jitter_y); \ 561 const bool _jitter_condition_known \ 562 = __builtin_constant_p (_jitter_condition); \ 563 if (_jitter_condition_known) \ 564 { \ 565 /* The condition is a known constant, so this if will turn into \ 566 either nothing or an unconditional branch. */ \ 567 if (_jitter_condition) \ 568 { \ 569 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 570 } \ 571 } \ 572 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 573 { \ 574 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 575 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 576 (_jitter_y, _jitter_tgt); \ 577 } \ 578 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 579 { \ 580 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 581 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 582 (_jitter_x, _jitter_tgt); \ 583 } \ 584 else \ 585 { \ 586 /* The condition is not a known constant. */ \ 587 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTEQUAL_ \ 588 (_jitter_x, _jitter_y, _jitter_tgt); \ 589 } \ 590 } \ 591 while (0) 592 #define _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED(x, y, _jitter_tgt) \ 593 do \ 594 { \ 595 /* Evaluate arguments, once and for all. */ \ 596 const jitter_uint _jitter_x = (jitter_uint) (x); \ 597 const jitter_uint _jitter_y = (jitter_uint) (y); \ 598 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 599 The condition of this if statement is a constant expression, and will \ 600 be optimized away in either case. */ \ 601 const bool _jitter_condition \ 602 = _JITTER_C_CONDITION_LESS_UNSIGNED_ (_jitter_x, _jitter_y); \ 603 const bool _jitter_condition_known \ 604 = __builtin_constant_p (_jitter_condition); \ 605 if (_jitter_condition_known) \ 606 { \ 607 /* The condition is a known constant, so this if will turn into \ 608 either nothing or an unconditional branch. */ \ 609 if (_jitter_condition) \ 610 { \ 611 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 612 } \ 613 } \ 614 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 615 { \ 616 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 617 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ \ 618 (_jitter_y, _jitter_tgt); \ 619 } \ 620 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 621 { \ 622 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 623 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ \ 624 (_jitter_x, _jitter_tgt); \ 625 } \ 626 else \ 627 { \ 628 /* The condition is not a known constant. */ \ 629 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_UNSIGNED_ \ 630 (_jitter_x, _jitter_y, _jitter_tgt); \ 631 } \ 632 } \ 633 while (0) 634 #define _JITTER_BRANCH_FAST_IF_LESS_SIGNED(x, y, _jitter_tgt) \ 635 do \ 636 { \ 637 /* Evaluate arguments, once and for all. */ \ 638 const jitter_int _jitter_x = (jitter_int) (x); \ 639 const jitter_int _jitter_y = (jitter_int) (y); \ 640 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 641 The condition of this if statement is a constant expression, and will \ 642 be optimized away in either case. */ \ 643 const bool _jitter_condition \ 644 = _JITTER_C_CONDITION_LESS_SIGNED_ (_jitter_x, _jitter_y); \ 645 const bool _jitter_condition_known \ 646 = __builtin_constant_p (_jitter_condition); \ 647 if (_jitter_condition_known) \ 648 { \ 649 /* The condition is a known constant, so this if will turn into \ 650 either nothing or an unconditional branch. */ \ 651 if (_jitter_condition) \ 652 { \ 653 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 654 } \ 655 } \ 656 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 657 { \ 658 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 659 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ \ 660 (_jitter_y, _jitter_tgt); \ 661 } \ 662 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 663 { \ 664 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 665 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ \ 666 (_jitter_x, _jitter_tgt); \ 667 } \ 668 else \ 669 { \ 670 /* The condition is not a known constant. */ \ 671 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_LESS_SIGNED_ \ 672 (_jitter_x, _jitter_y, _jitter_tgt); \ 673 } \ 674 } \ 675 while (0) 676 #define _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED(x, y, _jitter_tgt) \ 677 do \ 678 { \ 679 /* Evaluate arguments, once and for all. */ \ 680 const jitter_uint _jitter_x = (jitter_uint) (x); \ 681 const jitter_uint _jitter_y = (jitter_uint) (y); \ 682 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 683 The condition of this if statement is a constant expression, and will \ 684 be optimized away in either case. */ \ 685 const bool _jitter_condition \ 686 = _JITTER_C_CONDITION_GREATER_UNSIGNED_ (_jitter_x, _jitter_y); \ 687 const bool _jitter_condition_known \ 688 = __builtin_constant_p (_jitter_condition); \ 689 if (_jitter_condition_known) \ 690 { \ 691 /* The condition is a known constant, so this if will turn into \ 692 either nothing or an unconditional branch. */ \ 693 if (_jitter_condition) \ 694 { \ 695 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 696 } \ 697 } \ 698 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 699 { \ 700 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 701 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ \ 702 (_jitter_y, _jitter_tgt); \ 703 } \ 704 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 705 { \ 706 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 707 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ \ 708 (_jitter_x, _jitter_tgt); \ 709 } \ 710 else \ 711 { \ 712 /* The condition is not a known constant. */ \ 713 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_UNSIGNED_ \ 714 (_jitter_x, _jitter_y, _jitter_tgt); \ 715 } \ 716 } \ 717 while (0) 718 #define _JITTER_BRANCH_FAST_IF_GREATER_SIGNED(x, y, _jitter_tgt) \ 719 do \ 720 { \ 721 /* Evaluate arguments, once and for all. */ \ 722 const jitter_int _jitter_x = (jitter_int) (x); \ 723 const jitter_int _jitter_y = (jitter_int) (y); \ 724 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 725 The condition of this if statement is a constant expression, and will \ 726 be optimized away in either case. */ \ 727 const bool _jitter_condition \ 728 = _JITTER_C_CONDITION_GREATER_SIGNED_ (_jitter_x, _jitter_y); \ 729 const bool _jitter_condition_known \ 730 = __builtin_constant_p (_jitter_condition); \ 731 if (_jitter_condition_known) \ 732 { \ 733 /* The condition is a known constant, so this if will turn into \ 734 either nothing or an unconditional branch. */ \ 735 if (_jitter_condition) \ 736 { \ 737 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 738 } \ 739 } \ 740 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 741 { \ 742 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 743 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEGATIVE_ \ 744 (_jitter_y, _jitter_tgt); \ 745 } \ 746 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 747 { \ 748 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 749 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_POSITIVE_ \ 750 (_jitter_x, _jitter_tgt); \ 751 } \ 752 else \ 753 { \ 754 /* The condition is not a known constant. */ \ 755 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_GREATER_SIGNED_ \ 756 (_jitter_x, _jitter_y, _jitter_tgt); \ 757 } \ 758 } \ 759 while (0) 760 #define _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED(x, y, _jitter_tgt) \ 761 do \ 762 { \ 763 /* Evaluate arguments, once and for all. */ \ 764 const jitter_uint _jitter_x = (jitter_uint) (x); \ 765 const jitter_uint _jitter_y = (jitter_uint) (y); \ 766 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 767 The condition of this if statement is a constant expression, and will \ 768 be optimized away in either case. */ \ 769 const bool _jitter_condition \ 770 = _JITTER_C_CONDITION_NOTLESS_UNSIGNED_ (_jitter_x, _jitter_y); \ 771 const bool _jitter_condition_known \ 772 = __builtin_constant_p (_jitter_condition); \ 773 if (_jitter_condition_known) \ 774 { \ 775 /* The condition is a known constant, so this if will turn into \ 776 either nothing or an unconditional branch. */ \ 777 if (_jitter_condition) \ 778 { \ 779 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 780 } \ 781 } \ 782 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 783 { \ 784 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 785 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ \ 786 (_jitter_y, _jitter_tgt); \ 787 } \ 788 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 789 { \ 790 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 791 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ \ 792 (_jitter_x, _jitter_tgt); \ 793 } \ 794 else \ 795 { \ 796 /* The condition is not a known constant. */ \ 797 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_UNSIGNED_ \ 798 (_jitter_x, _jitter_y, _jitter_tgt); \ 799 } \ 800 } \ 801 while (0) 802 #define _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED(x, y, _jitter_tgt) \ 803 do \ 804 { \ 805 /* Evaluate arguments, once and for all. */ \ 806 const jitter_int _jitter_x = (jitter_int) (x); \ 807 const jitter_int _jitter_y = (jitter_int) (y); \ 808 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 809 The condition of this if statement is a constant expression, and will \ 810 be optimized away in either case. */ \ 811 const bool _jitter_condition \ 812 = _JITTER_C_CONDITION_NOTLESS_SIGNED_ (_jitter_x, _jitter_y); \ 813 const bool _jitter_condition_known \ 814 = __builtin_constant_p (_jitter_condition); \ 815 if (_jitter_condition_known) \ 816 { \ 817 /* The condition is a known constant, so this if will turn into \ 818 either nothing or an unconditional branch. */ \ 819 if (_jitter_condition) \ 820 { \ 821 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 822 } \ 823 } \ 824 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 825 { \ 826 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 827 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ \ 828 (_jitter_y, _jitter_tgt); \ 829 } \ 830 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 831 { \ 832 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 833 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ \ 834 (_jitter_x, _jitter_tgt); \ 835 } \ 836 else \ 837 { \ 838 /* The condition is not a known constant. */ \ 839 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTLESS_SIGNED_ \ 840 (_jitter_x, _jitter_y, _jitter_tgt); \ 841 } \ 842 } \ 843 while (0) 844 #define _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED(x, y, _jitter_tgt) \ 845 do \ 846 { \ 847 /* Evaluate arguments, once and for all. */ \ 848 const jitter_uint _jitter_x = (jitter_uint) (x); \ 849 const jitter_uint _jitter_y = (jitter_uint) (y); \ 850 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 851 The condition of this if statement is a constant expression, and will \ 852 be optimized away in either case. */ \ 853 const bool _jitter_condition \ 854 = _JITTER_C_CONDITION_NOTGREATER_UNSIGNED_ (_jitter_x, _jitter_y); \ 855 const bool _jitter_condition_known \ 856 = __builtin_constant_p (_jitter_condition); \ 857 if (_jitter_condition_known) \ 858 { \ 859 /* The condition is a known constant, so this if will turn into \ 860 either nothing or an unconditional branch. */ \ 861 if (_jitter_condition) \ 862 { \ 863 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 864 } \ 865 } \ 866 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 867 { \ 868 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 869 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ \ 870 (_jitter_y, _jitter_tgt); \ 871 } \ 872 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 873 { \ 874 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 875 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ \ 876 (_jitter_x, _jitter_tgt); \ 877 } \ 878 else \ 879 { \ 880 /* The condition is not a known constant. */ \ 881 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_UNSIGNED_ \ 882 (_jitter_x, _jitter_y, _jitter_tgt); \ 883 } \ 884 } \ 885 while (0) 886 #define _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED(x, y, _jitter_tgt) \ 887 do \ 888 { \ 889 /* Evaluate arguments, once and for all. */ \ 890 const jitter_int _jitter_x = (jitter_int) (x); \ 891 const jitter_int _jitter_y = (jitter_int) (y); \ 892 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 893 The condition of this if statement is a constant expression, and will \ 894 be optimized away in either case. */ \ 895 const bool _jitter_condition \ 896 = _JITTER_C_CONDITION_NOTGREATER_SIGNED_ (_jitter_x, _jitter_y); \ 897 const bool _jitter_condition_known \ 898 = __builtin_constant_p (_jitter_condition); \ 899 if (_jitter_condition_known) \ 900 { \ 901 /* The condition is a known constant, so this if will turn into \ 902 either nothing or an unconditional branch. */ \ 903 if (_jitter_condition) \ 904 { \ 905 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 906 } \ 907 } \ 908 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 909 { \ 910 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 911 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONNEGATIVE_ \ 912 (_jitter_y, _jitter_tgt); \ 913 } \ 914 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 915 { \ 916 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 917 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONPOSITIVE_ \ 918 (_jitter_x, _jitter_tgt); \ 919 } \ 920 else \ 921 { \ 922 /* The condition is not a known constant. */ \ 923 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTGREATER_SIGNED_ \ 924 (_jitter_x, _jitter_y, _jitter_tgt); \ 925 } \ 926 } \ 927 while (0) 928 #define _JITTER_BRANCH_FAST_IF_AND(x, y, _jitter_tgt) \ 929 do \ 930 { \ 931 /* Evaluate arguments, once and for all. */ \ 932 const jitter_uint _jitter_x = (jitter_uint) (x); \ 933 const jitter_uint _jitter_y = (jitter_uint) (y); \ 934 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 935 The condition of this if statement is a constant expression, and will \ 936 be optimized away in either case. */ \ 937 const bool _jitter_condition \ 938 = _JITTER_C_CONDITION_AND_ (_jitter_x, _jitter_y); \ 939 const bool _jitter_condition_known \ 940 = __builtin_constant_p (_jitter_condition); \ 941 if (_jitter_condition_known) \ 942 { \ 943 /* The condition is a known constant, so this if will turn into \ 944 either nothing or an unconditional branch. */ \ 945 if (_jitter_condition) \ 946 { \ 947 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 948 } \ 949 } \ 950 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 951 { \ 952 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 953 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEVER_ \ 954 (_jitter_y, _jitter_tgt); \ 955 } \ 956 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 957 { \ 958 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 959 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NEVER_ \ 960 (_jitter_x, _jitter_tgt); \ 961 } \ 962 else \ 963 { \ 964 /* The condition is not a known constant. */ \ 965 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_AND_ \ 966 (_jitter_x, _jitter_y, _jitter_tgt); \ 967 } \ 968 } \ 969 while (0) 970 #define _JITTER_BRANCH_FAST_IF_NOTAND(x, y, _jitter_tgt) \ 971 do \ 972 { \ 973 /* Evaluate arguments, once and for all. */ \ 974 const jitter_uint _jitter_x = (jitter_uint) (x); \ 975 const jitter_uint _jitter_y = (jitter_uint) (y); \ 976 /* "Evaluate" the condition in C, just to see if it's a known constant. \ 977 The condition of this if statement is a constant expression, and will \ 978 be optimized away in either case. */ \ 979 const bool _jitter_condition \ 980 = _JITTER_C_CONDITION_NOTAND_ (_jitter_x, _jitter_y); \ 981 const bool _jitter_condition_known \ 982 = __builtin_constant_p (_jitter_condition); \ 983 if (_jitter_condition_known) \ 984 { \ 985 /* The condition is a known constant, so this if will turn into \ 986 either nothing or an unconditional branch. */ \ 987 if (_jitter_condition) \ 988 { \ 989 _JITTER_LOW_LEVEL_BRANCH_FAST_ (_jitter_tgt); \ 990 } \ 991 } \ 992 else if (__builtin_constant_p (_jitter_x) && _jitter_x == 0) \ 993 { \ 994 /* _jitter_x is known to be zero, but _jitter_y is unknown. */ \ 995 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ALWAYS_ \ 996 (_jitter_y, _jitter_tgt); \ 997 } \ 998 else if (__builtin_constant_p (_jitter_y) && _jitter_y == 0) \ 999 { \ 1000 /* _jitter_y is known to be zero, but _jitter_x is unknown. */ \ 1001 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ALWAYS_ \ 1002 (_jitter_x, _jitter_tgt); \ 1003 } \ 1004 else \ 1005 { \ 1006 /* The condition is not a known constant. */ \ 1007 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NOTAND_ \ 1008 (_jitter_x, _jitter_y, _jitter_tgt); \ 1009 } \ 1010 } \ 1011 while (0) 1012 1013 /* High-level operate-and-branch-on-overflow operations. */ 1014 /* The operation which may overflow, in C. */ 1015 #define _JITTER_C_OPERATION_PLUS_(x, y) \ 1016 (((jitter_int) (x) + (jitter_int) (y))) 1017 1018 /* The overflow condition, in C. */ 1019 #define _JITTER_C_CONDITION_PLUS_OVERFLOWS_(x, y) \ 1020 ((jitter_uint) \ 1021 JITTER_WOULD_PLUS_OVERFLOW \ 1022 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1023 1024 /* The negative overflow (which is to say non-overflow) condition, in C, only 1025 defined if we have a macro available for it; it will be available for the 1026 operations where computing the negative condition is more efficient. 1027 Example: remainder. 1028 BRANCH_FAST_IF_NONZERO (b == 0, label) 1029 is slower than 1030 BRANCH_FAST_IF_ZERO (b, label) 1031 ; notice that the first macro argument is an assembly operand, which GCC has 1032 to compile as is. */ 1033 #if defined (JITTER_WOULD_PLUS_NOT_OVERFLOW) 1034 # define _JITTER_C_CONDITION_PLUS_DOES_NOT_OVERFLOW_(x, y) \ 1035 ((jitter_uint) \ 1036 JITTER_WOULD_PLUS_NOT_OVERFLOW \ 1037 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1038 #endif 1039 1040 /* If the branch-on-overflow and operate-and-branch-on-overflow low-level 1041 primitives are both missing for PLUS , define one. */ 1042 #if (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_) \ 1043 && ! defined (_JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_)) 1044 /* Use the negative condition if available. It is only available when it is 1045 preferable; see the comment above. */ 1046 # if defined (_JITTER_C_CONDITION_PLUS_DOES_NOT_OVERFLOW_) 1047 /* Use the negative condition. */ 1048 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_(opd0, opd1, tgt) \ 1049 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 1050 (_JITTER_C_CONDITION_PLUS_DOES_NOT_OVERFLOW_ (opd0, opd1), \ 1051 (tgt)) 1052 # else 1053 /* Use the positive condition. */ 1054 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_(opd0, opd1, tgt) \ 1055 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 1056 (_JITTER_C_CONDITION_PLUS_OVERFLOWS_ (opd0, opd1), \ 1057 (tgt)) 1058 # endif /* positive or negative */ 1059 #endif 1060 1061 /* At this point we definitely have one of the branch-on-overflow and 1062 operate-and-branch-on-overflow low-level primitives for PLUS . 1063 Using the one we have, define the other. */ 1064 #if (defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_) \ 1065 && defined (_JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_)) 1066 # error "both _JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_ and" 1067 # error "_JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_ are defined." 1068 # error "The machine-specific header should define only one: the other" 1069 # error "will be automatically defined here, based on the one supplied by you." 1070 #elif (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_) \ 1071 && defined (_JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_)) 1072 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_(opd0, opd1, tgt) \ 1073 /* Use the operate-and-branch-on-overflow primitive and just throw away \ 1074 the result. */ \ 1075 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1076 /* Prevent uninitialized-variable warnings. */ \ 1077 asm ("": "=X" (_jitter_unused_result)); \ 1078 _JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_ \ 1079 (_jitter_unused_result, (opd0), (opd1), (tgt)) 1080 #elif (! defined (_JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_) \ 1081 && defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_)) 1082 # define _JITTER_LOW_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_(res, opd0, opd1, tgt) \ 1083 /* Fast-branch away if the operation would overflow. */ \ 1084 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_PLUS_OVERFLOWS_ \ 1085 ((opd0), (opd1), (tgt)); \ 1086 /* If we are still here the operation will not overflow. Do it. */ \ 1087 (res) = _JITTER_C_OPERATION_PLUS_ ((opd0), (opd1)) 1088 #else 1089 # error "impossible" 1090 #endif // which PLUS_OVERFLOWS low-level primitive is defined 1091 1092 /* This is the operate-and-branch-on-overflow high-level primitive for 1093 PLUS . */ 1094 #define _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW(res, opd0, opd1, tgt) \ 1095 do \ 1096 { \ 1097 /* Evaluate the arguments, once and for all. */ \ 1098 const jitter_int _jitter_x = (jitter_int) (opd0); \ 1099 const jitter_int _jitter_y = (jitter_int) (opd1); \ 1100 \ 1101 /* Check if the condition's value is a known constant, before actually \ 1102 computing it. I have my own macros for this which appear to be more \ 1103 accurate than just __builtin_constant_p (will the thing overflow); \ 1104 when my macros say that the condition is a known constant it always \ 1105 appears to actually be for GCC as well -- making the fast branch \ 1106 either disappear or become unconditional. This helps with \ 1107 performance, but is not required for correctness. */ \ 1108 const bool _jitter_condition_known \ 1109 = JITTER_PLUS_OVERFLOWS_KNOWN_CONSTANT_GCC (_jitter_x, _jitter_y); \ 1110 if (_jitter_condition_known) \ 1111 { \ 1112 /* The condition is a known constant, so this if will turn into \ 1113 either nothing or an unconditional branch. If we do not branch \ 1114 then we have to assign the result. */ \ 1115 if (_JITTER_C_CONDITION_PLUS_OVERFLOWS_ (_jitter_x, _jitter_y)) \ 1116 { \ 1117 _JITTER_LOW_LEVEL_BRANCH_FAST_ (tgt); \ 1118 } \ 1119 else \ 1120 (res) = _JITTER_C_OPERATION_PLUS_ (_jitter_x, _jitter_y); \ 1121 } \ 1122 else \ 1123 { \ 1124 /* The condition is not a known constant. The overflow check \ 1125 will not be optimized away, but the operation might still be \ 1126 rewritable into a cheaper one (with overflow checking); this \ 1127 is why the expansion uses a middle-level, instead of a low-level, \ 1128 primitive. */ \ 1129 _JITTER_MIDDLE_LEVEL_PLUS_BRANCH_FAST_IF_OVERFLOW_ \ 1130 ((res), _jitter_x, _jitter_y, (tgt)); \ 1131 } \ 1132 } \ 1133 while (false) 1134 1135 /* This is the branch-on-overflow high-level primitive for PLUS 1136 , which conditionally branches but does not yield a result. */ 1137 #define _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS(opd0, opd1, tgt) \ 1138 do \ 1139 { \ 1140 /* Here we are only interested in branching or not branching; compute a \ 1141 useless result, to be ignored. GCC will be able to optimize that away, \ 1142 unless the result is required for computing the overflow condition \ 1143 itself. */ \ 1144 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1145 _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW \ 1146 (_jitter_unused_result, (opd0), (opd1), (tgt)); \ 1147 } \ 1148 while (0) 1149 1150 /* The operation which may overflow, in C. */ 1151 #define _JITTER_C_OPERATION_MINUS_(x, y) \ 1152 (((jitter_int) (x) - (jitter_int) (y))) 1153 1154 /* The overflow condition, in C. */ 1155 #define _JITTER_C_CONDITION_MINUS_OVERFLOWS_(x, y) \ 1156 ((jitter_uint) \ 1157 JITTER_WOULD_MINUS_OVERFLOW \ 1158 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1159 1160 /* The negative overflow (which is to say non-overflow) condition, in C, only 1161 defined if we have a macro available for it; it will be available for the 1162 operations where computing the negative condition is more efficient. 1163 Example: remainder. 1164 BRANCH_FAST_IF_NONZERO (b == 0, label) 1165 is slower than 1166 BRANCH_FAST_IF_ZERO (b, label) 1167 ; notice that the first macro argument is an assembly operand, which GCC has 1168 to compile as is. */ 1169 #if defined (JITTER_WOULD_MINUS_NOT_OVERFLOW) 1170 # define _JITTER_C_CONDITION_MINUS_DOES_NOT_OVERFLOW_(x, y) \ 1171 ((jitter_uint) \ 1172 JITTER_WOULD_MINUS_NOT_OVERFLOW \ 1173 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1174 #endif 1175 1176 /* If the branch-on-overflow and operate-and-branch-on-overflow low-level 1177 primitives are both missing for MINUS , define one. */ 1178 #if (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_) \ 1179 && ! defined (_JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_)) 1180 /* Use the negative condition if available. It is only available when it is 1181 preferable; see the comment above. */ 1182 # if defined (_JITTER_C_CONDITION_MINUS_DOES_NOT_OVERFLOW_) 1183 /* Use the negative condition. */ 1184 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_(opd0, opd1, tgt) \ 1185 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 1186 (_JITTER_C_CONDITION_MINUS_DOES_NOT_OVERFLOW_ (opd0, opd1), \ 1187 (tgt)) 1188 # else 1189 /* Use the positive condition. */ 1190 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_(opd0, opd1, tgt) \ 1191 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 1192 (_JITTER_C_CONDITION_MINUS_OVERFLOWS_ (opd0, opd1), \ 1193 (tgt)) 1194 # endif /* positive or negative */ 1195 #endif 1196 1197 /* At this point we definitely have one of the branch-on-overflow and 1198 operate-and-branch-on-overflow low-level primitives for MINUS . 1199 Using the one we have, define the other. */ 1200 #if (defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_) \ 1201 && defined (_JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_)) 1202 # error "both _JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_ and" 1203 # error "_JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_ are defined." 1204 # error "The machine-specific header should define only one: the other" 1205 # error "will be automatically defined here, based on the one supplied by you." 1206 #elif (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_) \ 1207 && defined (_JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_)) 1208 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_(opd0, opd1, tgt) \ 1209 /* Use the operate-and-branch-on-overflow primitive and just throw away \ 1210 the result. */ \ 1211 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1212 /* Prevent uninitialized-variable warnings. */ \ 1213 asm ("": "=X" (_jitter_unused_result)); \ 1214 _JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_ \ 1215 (_jitter_unused_result, (opd0), (opd1), (tgt)) 1216 #elif (! defined (_JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_) \ 1217 && defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_)) 1218 # define _JITTER_LOW_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_(res, opd0, opd1, tgt) \ 1219 /* Fast-branch away if the operation would overflow. */ \ 1220 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_MINUS_OVERFLOWS_ \ 1221 ((opd0), (opd1), (tgt)); \ 1222 /* If we are still here the operation will not overflow. Do it. */ \ 1223 (res) = _JITTER_C_OPERATION_MINUS_ ((opd0), (opd1)) 1224 #else 1225 # error "impossible" 1226 #endif // which MINUS_OVERFLOWS low-level primitive is defined 1227 1228 /* This is the operate-and-branch-on-overflow high-level primitive for 1229 MINUS . */ 1230 #define _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW(res, opd0, opd1, tgt) \ 1231 do \ 1232 { \ 1233 /* Evaluate the arguments, once and for all. */ \ 1234 const jitter_int _jitter_x = (jitter_int) (opd0); \ 1235 const jitter_int _jitter_y = (jitter_int) (opd1); \ 1236 \ 1237 /* Check if the condition's value is a known constant, before actually \ 1238 computing it. I have my own macros for this which appear to be more \ 1239 accurate than just __builtin_constant_p (will the thing overflow); \ 1240 when my macros say that the condition is a known constant it always \ 1241 appears to actually be for GCC as well -- making the fast branch \ 1242 either disappear or become unconditional. This helps with \ 1243 performance, but is not required for correctness. */ \ 1244 const bool _jitter_condition_known \ 1245 = JITTER_MINUS_OVERFLOWS_KNOWN_CONSTANT_GCC (_jitter_x, _jitter_y); \ 1246 if (_jitter_condition_known) \ 1247 { \ 1248 /* The condition is a known constant, so this if will turn into \ 1249 either nothing or an unconditional branch. If we do not branch \ 1250 then we have to assign the result. */ \ 1251 if (_JITTER_C_CONDITION_MINUS_OVERFLOWS_ (_jitter_x, _jitter_y)) \ 1252 { \ 1253 _JITTER_LOW_LEVEL_BRANCH_FAST_ (tgt); \ 1254 } \ 1255 else \ 1256 (res) = _JITTER_C_OPERATION_MINUS_ (_jitter_x, _jitter_y); \ 1257 } \ 1258 else \ 1259 { \ 1260 /* The condition is not a known constant. The overflow check \ 1261 will not be optimized away, but the operation might still be \ 1262 rewritable into a cheaper one (with overflow checking); this \ 1263 is why the expansion uses a middle-level, instead of a low-level, \ 1264 primitive. */ \ 1265 _JITTER_MIDDLE_LEVEL_MINUS_BRANCH_FAST_IF_OVERFLOW_ \ 1266 ((res), _jitter_x, _jitter_y, (tgt)); \ 1267 } \ 1268 } \ 1269 while (false) 1270 1271 /* This is the branch-on-overflow high-level primitive for MINUS 1272 , which conditionally branches but does not yield a result. */ 1273 #define _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS(opd0, opd1, tgt) \ 1274 do \ 1275 { \ 1276 /* Here we are only interested in branching or not branching; compute a \ 1277 useless result, to be ignored. GCC will be able to optimize that away, \ 1278 unless the result is required for computing the overflow condition \ 1279 itself. */ \ 1280 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1281 _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW \ 1282 (_jitter_unused_result, (opd0), (opd1), (tgt)); \ 1283 } \ 1284 while (0) 1285 1286 /* The operation which may overflow, in C. */ 1287 #define _JITTER_C_OPERATION_TIMES_(x, y) \ 1288 (((jitter_int) (x) * (jitter_int) (y))) 1289 1290 /* The overflow condition, in C. */ 1291 #define _JITTER_C_CONDITION_TIMES_OVERFLOWS_(x, y) \ 1292 ((jitter_uint) \ 1293 JITTER_WOULD_TIMES_OVERFLOW \ 1294 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1295 1296 /* The negative overflow (which is to say non-overflow) condition, in C, only 1297 defined if we have a macro available for it; it will be available for the 1298 operations where computing the negative condition is more efficient. 1299 Example: remainder. 1300 BRANCH_FAST_IF_NONZERO (b == 0, label) 1301 is slower than 1302 BRANCH_FAST_IF_ZERO (b, label) 1303 ; notice that the first macro argument is an assembly operand, which GCC has 1304 to compile as is. */ 1305 #if defined (JITTER_WOULD_TIMES_NOT_OVERFLOW) 1306 # define _JITTER_C_CONDITION_TIMES_DOES_NOT_OVERFLOW_(x, y) \ 1307 ((jitter_uint) \ 1308 JITTER_WOULD_TIMES_NOT_OVERFLOW \ 1309 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1310 #endif 1311 1312 /* If the branch-on-overflow and operate-and-branch-on-overflow low-level 1313 primitives are both missing for TIMES , define one. */ 1314 #if (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_) \ 1315 && ! defined (_JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_)) 1316 /* Use the negative condition if available. It is only available when it is 1317 preferable; see the comment above. */ 1318 # if defined (_JITTER_C_CONDITION_TIMES_DOES_NOT_OVERFLOW_) 1319 /* Use the negative condition. */ 1320 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_(opd0, opd1, tgt) \ 1321 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 1322 (_JITTER_C_CONDITION_TIMES_DOES_NOT_OVERFLOW_ (opd0, opd1), \ 1323 (tgt)) 1324 # else 1325 /* Use the positive condition. */ 1326 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_(opd0, opd1, tgt) \ 1327 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 1328 (_JITTER_C_CONDITION_TIMES_OVERFLOWS_ (opd0, opd1), \ 1329 (tgt)) 1330 # endif /* positive or negative */ 1331 #endif 1332 1333 /* At this point we definitely have one of the branch-on-overflow and 1334 operate-and-branch-on-overflow low-level primitives for TIMES . 1335 Using the one we have, define the other. */ 1336 #if (defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_) \ 1337 && defined (_JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_)) 1338 # error "both _JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_ and" 1339 # error "_JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_ are defined." 1340 # error "The machine-specific header should define only one: the other" 1341 # error "will be automatically defined here, based on the one supplied by you." 1342 #elif (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_) \ 1343 && defined (_JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_)) 1344 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_(opd0, opd1, tgt) \ 1345 /* Use the operate-and-branch-on-overflow primitive and just throw away \ 1346 the result. */ \ 1347 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1348 /* Prevent uninitialized-variable warnings. */ \ 1349 asm ("": "=X" (_jitter_unused_result)); \ 1350 _JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_ \ 1351 (_jitter_unused_result, (opd0), (opd1), (tgt)) 1352 #elif (! defined (_JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_) \ 1353 && defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_)) 1354 # define _JITTER_LOW_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_(res, opd0, opd1, tgt) \ 1355 /* Fast-branch away if the operation would overflow. */ \ 1356 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_TIMES_OVERFLOWS_ \ 1357 ((opd0), (opd1), (tgt)); \ 1358 /* If we are still here the operation will not overflow. Do it. */ \ 1359 (res) = _JITTER_C_OPERATION_TIMES_ ((opd0), (opd1)) 1360 #else 1361 # error "impossible" 1362 #endif // which TIMES_OVERFLOWS low-level primitive is defined 1363 1364 /* This is the operate-and-branch-on-overflow high-level primitive for 1365 TIMES . */ 1366 #define _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW(res, opd0, opd1, tgt) \ 1367 do \ 1368 { \ 1369 /* Evaluate the arguments, once and for all. */ \ 1370 const jitter_int _jitter_x = (jitter_int) (opd0); \ 1371 const jitter_int _jitter_y = (jitter_int) (opd1); \ 1372 \ 1373 /* Check if the condition's value is a known constant, before actually \ 1374 computing it. I have my own macros for this which appear to be more \ 1375 accurate than just __builtin_constant_p (will the thing overflow); \ 1376 when my macros say that the condition is a known constant it always \ 1377 appears to actually be for GCC as well -- making the fast branch \ 1378 either disappear or become unconditional. This helps with \ 1379 performance, but is not required for correctness. */ \ 1380 const bool _jitter_condition_known \ 1381 = JITTER_TIMES_OVERFLOWS_KNOWN_CONSTANT_GCC (_jitter_x, _jitter_y); \ 1382 if (_jitter_condition_known) \ 1383 { \ 1384 /* The condition is a known constant, so this if will turn into \ 1385 either nothing or an unconditional branch. If we do not branch \ 1386 then we have to assign the result. */ \ 1387 if (_JITTER_C_CONDITION_TIMES_OVERFLOWS_ (_jitter_x, _jitter_y)) \ 1388 { \ 1389 _JITTER_LOW_LEVEL_BRANCH_FAST_ (tgt); \ 1390 } \ 1391 else \ 1392 (res) = _JITTER_C_OPERATION_TIMES_ (_jitter_x, _jitter_y); \ 1393 } \ 1394 else \ 1395 { \ 1396 /* The condition is not a known constant. The overflow check \ 1397 will not be optimized away, but the operation might still be \ 1398 rewritable into a cheaper one (with overflow checking); this \ 1399 is why the expansion uses a middle-level, instead of a low-level, \ 1400 primitive. */ \ 1401 _JITTER_MIDDLE_LEVEL_TIMES_BRANCH_FAST_IF_OVERFLOW_ \ 1402 ((res), _jitter_x, _jitter_y, (tgt)); \ 1403 } \ 1404 } \ 1405 while (false) 1406 1407 /* This is the branch-on-overflow high-level primitive for TIMES 1408 , which conditionally branches but does not yield a result. */ 1409 #define _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS(opd0, opd1, tgt) \ 1410 do \ 1411 { \ 1412 /* Here we are only interested in branching or not branching; compute a \ 1413 useless result, to be ignored. GCC will be able to optimize that away, \ 1414 unless the result is required for computing the overflow condition \ 1415 itself. */ \ 1416 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1417 _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW \ 1418 (_jitter_unused_result, (opd0), (opd1), (tgt)); \ 1419 } \ 1420 while (0) 1421 1422 /* The operation which may overflow, in C. */ 1423 #define _JITTER_C_OPERATION_DIVIDED_(x, y) \ 1424 (((jitter_int) (x) / (jitter_int) (y))) 1425 1426 /* The overflow condition, in C. */ 1427 #define _JITTER_C_CONDITION_DIVIDED_OVERFLOWS_(x, y) \ 1428 ((jitter_uint) \ 1429 JITTER_WOULD_DIVIDED_OVERFLOW \ 1430 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1431 1432 /* The negative overflow (which is to say non-overflow) condition, in C, only 1433 defined if we have a macro available for it; it will be available for the 1434 operations where computing the negative condition is more efficient. 1435 Example: remainder. 1436 BRANCH_FAST_IF_NONZERO (b == 0, label) 1437 is slower than 1438 BRANCH_FAST_IF_ZERO (b, label) 1439 ; notice that the first macro argument is an assembly operand, which GCC has 1440 to compile as is. */ 1441 #if defined (JITTER_WOULD_DIVIDED_NOT_OVERFLOW) 1442 # define _JITTER_C_CONDITION_DIVIDED_DOES_NOT_OVERFLOW_(x, y) \ 1443 ((jitter_uint) \ 1444 JITTER_WOULD_DIVIDED_NOT_OVERFLOW \ 1445 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1446 #endif 1447 1448 /* If the branch-on-overflow and operate-and-branch-on-overflow low-level 1449 primitives are both missing for DIVIDED , define one. */ 1450 #if (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_) \ 1451 && ! defined (_JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_)) 1452 /* Use the negative condition if available. It is only available when it is 1453 preferable; see the comment above. */ 1454 # if defined (_JITTER_C_CONDITION_DIVIDED_DOES_NOT_OVERFLOW_) 1455 /* Use the negative condition. */ 1456 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_(opd0, opd1, tgt) \ 1457 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 1458 (_JITTER_C_CONDITION_DIVIDED_DOES_NOT_OVERFLOW_ (opd0, opd1), \ 1459 (tgt)) 1460 # else 1461 /* Use the positive condition. */ 1462 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_(opd0, opd1, tgt) \ 1463 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 1464 (_JITTER_C_CONDITION_DIVIDED_OVERFLOWS_ (opd0, opd1), \ 1465 (tgt)) 1466 # endif /* positive or negative */ 1467 #endif 1468 1469 /* At this point we definitely have one of the branch-on-overflow and 1470 operate-and-branch-on-overflow low-level primitives for DIVIDED . 1471 Using the one we have, define the other. */ 1472 #if (defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_) \ 1473 && defined (_JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_)) 1474 # error "both _JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_ and" 1475 # error "_JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_ are defined." 1476 # error "The machine-specific header should define only one: the other" 1477 # error "will be automatically defined here, based on the one supplied by you." 1478 #elif (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_) \ 1479 && defined (_JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_)) 1480 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_(opd0, opd1, tgt) \ 1481 /* Use the operate-and-branch-on-overflow primitive and just throw away \ 1482 the result. */ \ 1483 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1484 /* Prevent uninitialized-variable warnings. */ \ 1485 asm ("": "=X" (_jitter_unused_result)); \ 1486 _JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_ \ 1487 (_jitter_unused_result, (opd0), (opd1), (tgt)) 1488 #elif (! defined (_JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_) \ 1489 && defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_)) 1490 # define _JITTER_LOW_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_(res, opd0, opd1, tgt) \ 1491 /* Fast-branch away if the operation would overflow. */ \ 1492 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_DIVIDED_OVERFLOWS_ \ 1493 ((opd0), (opd1), (tgt)); \ 1494 /* If we are still here the operation will not overflow. Do it. */ \ 1495 (res) = _JITTER_C_OPERATION_DIVIDED_ ((opd0), (opd1)) 1496 #else 1497 # error "impossible" 1498 #endif // which DIVIDED_OVERFLOWS low-level primitive is defined 1499 1500 /* This is the operate-and-branch-on-overflow high-level primitive for 1501 DIVIDED . */ 1502 #define _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW(res, opd0, opd1, tgt) \ 1503 do \ 1504 { \ 1505 /* Evaluate the arguments, once and for all. */ \ 1506 const jitter_int _jitter_x = (jitter_int) (opd0); \ 1507 const jitter_int _jitter_y = (jitter_int) (opd1); \ 1508 \ 1509 /* Check if the condition's value is a known constant, before actually \ 1510 computing it. I have my own macros for this which appear to be more \ 1511 accurate than just __builtin_constant_p (will the thing overflow); \ 1512 when my macros say that the condition is a known constant it always \ 1513 appears to actually be for GCC as well -- making the fast branch \ 1514 either disappear or become unconditional. This helps with \ 1515 performance, but is not required for correctness. */ \ 1516 const bool _jitter_condition_known \ 1517 = JITTER_DIVIDED_OVERFLOWS_KNOWN_CONSTANT_GCC (_jitter_x, _jitter_y); \ 1518 if (_jitter_condition_known) \ 1519 { \ 1520 /* The condition is a known constant, so this if will turn into \ 1521 either nothing or an unconditional branch. If we do not branch \ 1522 then we have to assign the result. */ \ 1523 if (_JITTER_C_CONDITION_DIVIDED_OVERFLOWS_ (_jitter_x, _jitter_y)) \ 1524 { \ 1525 _JITTER_LOW_LEVEL_BRANCH_FAST_ (tgt); \ 1526 } \ 1527 else \ 1528 (res) = _JITTER_C_OPERATION_DIVIDED_ (_jitter_x, _jitter_y); \ 1529 } \ 1530 else \ 1531 { \ 1532 /* The condition is not a known constant. The overflow check \ 1533 will not be optimized away, but the operation might still be \ 1534 rewritable into a cheaper one (with overflow checking); this \ 1535 is why the expansion uses a middle-level, instead of a low-level, \ 1536 primitive. */ \ 1537 _JITTER_MIDDLE_LEVEL_DIVIDED_BRANCH_FAST_IF_OVERFLOW_ \ 1538 ((res), _jitter_x, _jitter_y, (tgt)); \ 1539 } \ 1540 } \ 1541 while (false) 1542 1543 /* This is the branch-on-overflow high-level primitive for DIVIDED 1544 , which conditionally branches but does not yield a result. */ 1545 #define _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS(opd0, opd1, tgt) \ 1546 do \ 1547 { \ 1548 /* Here we are only interested in branching or not branching; compute a \ 1549 useless result, to be ignored. GCC will be able to optimize that away, \ 1550 unless the result is required for computing the overflow condition \ 1551 itself. */ \ 1552 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1553 _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW \ 1554 (_jitter_unused_result, (opd0), (opd1), (tgt)); \ 1555 } \ 1556 while (0) 1557 1558 /* The operation which may overflow, in C. */ 1559 #define _JITTER_C_OPERATION_REMAINDER_(x, y) \ 1560 (((jitter_int) (x) % (jitter_int) (y))) 1561 1562 /* The overflow condition, in C. */ 1563 #define _JITTER_C_CONDITION_REMAINDER_OVERFLOWS_(x, y) \ 1564 ((jitter_uint) \ 1565 JITTER_WOULD_REMAINDER_OVERFLOW \ 1566 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1567 1568 /* The negative overflow (which is to say non-overflow) condition, in C, only 1569 defined if we have a macro available for it; it will be available for the 1570 operations where computing the negative condition is more efficient. 1571 Example: remainder. 1572 BRANCH_FAST_IF_NONZERO (b == 0, label) 1573 is slower than 1574 BRANCH_FAST_IF_ZERO (b, label) 1575 ; notice that the first macro argument is an assembly operand, which GCC has 1576 to compile as is. */ 1577 #if defined (JITTER_WOULD_REMAINDER_NOT_OVERFLOW) 1578 # define _JITTER_C_CONDITION_REMAINDER_DOES_NOT_OVERFLOW_(x, y) \ 1579 ((jitter_uint) \ 1580 JITTER_WOULD_REMAINDER_NOT_OVERFLOW \ 1581 (jitter_uint, jitter_int, (x), (y), JITTER_BITS_PER_WORD)) 1582 #endif 1583 1584 /* If the branch-on-overflow and operate-and-branch-on-overflow low-level 1585 primitives are both missing for REMAINDER , define one. */ 1586 #if (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_) \ 1587 && ! defined (_JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_)) 1588 /* Use the negative condition if available. It is only available when it is 1589 preferable; see the comment above. */ 1590 # if defined (_JITTER_C_CONDITION_REMAINDER_DOES_NOT_OVERFLOW_) 1591 /* Use the negative condition. */ 1592 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_(opd0, opd1, tgt) \ 1593 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_ZERO_ \ 1594 (_JITTER_C_CONDITION_REMAINDER_DOES_NOT_OVERFLOW_ (opd0, opd1), \ 1595 (tgt)) 1596 # else 1597 /* Use the positive condition. */ 1598 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_(opd0, opd1, tgt) \ 1599 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_NONZERO_ \ 1600 (_JITTER_C_CONDITION_REMAINDER_OVERFLOWS_ (opd0, opd1), \ 1601 (tgt)) 1602 # endif /* positive or negative */ 1603 #endif 1604 1605 /* At this point we definitely have one of the branch-on-overflow and 1606 operate-and-branch-on-overflow low-level primitives for REMAINDER . 1607 Using the one we have, define the other. */ 1608 #if (defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_) \ 1609 && defined (_JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_)) 1610 # error "both _JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_ and" 1611 # error "_JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_ are defined." 1612 # error "The machine-specific header should define only one: the other" 1613 # error "will be automatically defined here, based on the one supplied by you." 1614 #elif (! defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_) \ 1615 && defined (_JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_)) 1616 # define _JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_(opd0, opd1, tgt) \ 1617 /* Use the operate-and-branch-on-overflow primitive and just throw away \ 1618 the result. */ \ 1619 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1620 /* Prevent uninitialized-variable warnings. */ \ 1621 asm ("": "=X" (_jitter_unused_result)); \ 1622 _JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_ \ 1623 (_jitter_unused_result, (opd0), (opd1), (tgt)) 1624 #elif (! defined (_JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_) \ 1625 && defined (_JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_)) 1626 # define _JITTER_LOW_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_(res, opd0, opd1, tgt) \ 1627 /* Fast-branch away if the operation would overflow. */ \ 1628 _JITTER_LOW_LEVEL_BRANCH_FAST_IF_REMAINDER_OVERFLOWS_ \ 1629 ((opd0), (opd1), (tgt)); \ 1630 /* If we are still here the operation will not overflow. Do it. */ \ 1631 (res) = _JITTER_C_OPERATION_REMAINDER_ ((opd0), (opd1)) 1632 #else 1633 # error "impossible" 1634 #endif // which REMAINDER_OVERFLOWS low-level primitive is defined 1635 1636 /* This is the operate-and-branch-on-overflow high-level primitive for 1637 REMAINDER . */ 1638 #define _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW(res, opd0, opd1, tgt) \ 1639 do \ 1640 { \ 1641 /* Evaluate the arguments, once and for all. */ \ 1642 const jitter_int _jitter_x = (jitter_int) (opd0); \ 1643 const jitter_int _jitter_y = (jitter_int) (opd1); \ 1644 \ 1645 /* Check if the condition's value is a known constant, before actually \ 1646 computing it. I have my own macros for this which appear to be more \ 1647 accurate than just __builtin_constant_p (will the thing overflow); \ 1648 when my macros say that the condition is a known constant it always \ 1649 appears to actually be for GCC as well -- making the fast branch \ 1650 either disappear or become unconditional. This helps with \ 1651 performance, but is not required for correctness. */ \ 1652 const bool _jitter_condition_known \ 1653 = JITTER_REMAINDER_OVERFLOWS_KNOWN_CONSTANT_GCC (_jitter_x, _jitter_y); \ 1654 if (_jitter_condition_known) \ 1655 { \ 1656 /* The condition is a known constant, so this if will turn into \ 1657 either nothing or an unconditional branch. If we do not branch \ 1658 then we have to assign the result. */ \ 1659 if (_JITTER_C_CONDITION_REMAINDER_OVERFLOWS_ (_jitter_x, _jitter_y)) \ 1660 { \ 1661 _JITTER_LOW_LEVEL_BRANCH_FAST_ (tgt); \ 1662 } \ 1663 else \ 1664 (res) = _JITTER_C_OPERATION_REMAINDER_ (_jitter_x, _jitter_y); \ 1665 } \ 1666 else \ 1667 { \ 1668 /* The condition is not a known constant. The overflow check \ 1669 will not be optimized away, but the operation might still be \ 1670 rewritable into a cheaper one (with overflow checking); this \ 1671 is why the expansion uses a middle-level, instead of a low-level, \ 1672 primitive. */ \ 1673 _JITTER_MIDDLE_LEVEL_REMAINDER_BRANCH_FAST_IF_OVERFLOW_ \ 1674 ((res), _jitter_x, _jitter_y, (tgt)); \ 1675 } \ 1676 } \ 1677 while (false) 1678 1679 /* This is the branch-on-overflow high-level primitive for REMAINDER 1680 , which conditionally branches but does not yield a result. */ 1681 #define _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS(opd0, opd1, tgt) \ 1682 do \ 1683 { \ 1684 /* Here we are only interested in branching or not branching; compute a \ 1685 useless result, to be ignored. GCC will be able to optimize that away, \ 1686 unless the result is required for computing the overflow condition \ 1687 itself. */ \ 1688 jitter_int _jitter_unused_result __attribute__ ((unused)); \ 1689 _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW \ 1690 (_jitter_unused_result, (opd0), (opd1), (tgt)); \ 1691 } \ 1692 while (0) 1693 1694 1695 1696 #endif // #ifndef JITTER_FAST_BRANCH_MACHINE_GENERATED_H_ 1697