path: root/spec/compiler/unit/builtins.yml

SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
copyrights:
- Copyright (C) 2023 embedded brains GmbH & Co. KG
enabled-by: true
links:
- role: validation
  uid: /req/unit-test-compiler-builtins
test-actions:
- action-brief: |
    Check the return value of __builtin_clz() for a sample set of inputs.
  action-code: |
    volatile unsigned int n;

    n = 1U;
    T_eq_int( __builtin_clz( n ), 31 );

    n = 1U << 31;
    T_eq_int( __builtin_clz( n ), 0 );

    n = ~0U;
    T_eq_int( __builtin_clz( n ), 0 );
  checks: []
  links:
  - name: __builtin_clz
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_clzll() for a sample set of inputs.
  action-code: |
    volatile unsigned long long n;

    n = 1ULL;
    T_eq_int( __builtin_clzll( n ), 63 );

    n = 1ULL << 31;
    T_eq_int( __builtin_clzll( n ), 32 );

    n = 1ULL << 32;
    T_eq_int( __builtin_clzll( n ), 31 );

    n = 1ULL << 63;
    T_eq_int( __builtin_clzll( n ), 0 );

    n = ~0ULL;
    T_eq_int( __builtin_clzll( n ), 0 );
  checks: []
  links:
  - name: __builtin_clzll
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_ctz() for a sample set of inputs.
  action-code: |
    volatile unsigned int n;

    n = 1U;
    T_eq_int( __builtin_ctz( n ), 0 );

    n = 1U << 31;
    T_eq_int( __builtin_ctz( n ), 31 );

    n = ~0U;
    T_eq_int( __builtin_ctz( n ), 0 );
  checks: []
  links:
  - name: __builtin_ctz
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_ctzll() for a sample set of inputs.
  action-code: |
    volatile unsigned long long n;

    n = 1ULL;
    T_eq_int( __builtin_ctzll( n ), 0 );

    n = 1ULL << 31;
    T_eq_int( __builtin_ctzll( n ), 31 );

    n = 1ULL << 32;
    T_eq_int( __builtin_ctzll( n ), 32 );

    n = 1ULL << 63;
    T_eq_int( __builtin_ctzll( n ), 63 );

    n = ~0ULL;
    T_eq_int( __builtin_ctzll( n ), 0 );
  checks: []
  links:
  - name: __builtin_ctzll
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_ffs() for a sample set of inputs.
  action-code: |
    volatile unsigned int n;

    n = 1U;
    T_eq_int( __builtin_ffs( n ), 1 );

    n = 1U << 31;
    T_eq_int( __builtin_ffs( n ), 32 );

    n = 0U;
    T_eq_int( __builtin_ffs( n ), 0 );
  checks: []
  links:
  - name: __builtin_ffs
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_ffsll() for a sample set of inputs.
  action-code: |
    volatile unsigned long long n;

    n = 1ULL;
    T_eq_int( __builtin_ffsll( n ), 1 );

    n = 1ULL << 31;
    T_eq_int( __builtin_ffsll( n ), 32 );

    n = 1ULL << 32;
    T_eq_int( __builtin_ffsll( n ), 33 );

    n = 1ULL << 63;
    T_eq_int( __builtin_ffsll( n ), 64 );

    n = 0ULL;
    T_eq_int( __builtin_ffsll( n ), 0 );
  checks: []
  links:
  - name: __builtin_ffsll
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_parity() for a sample set of inputs.
  action-code: |
    volatile unsigned int n;

    n = 1U;
    T_eq_int( __builtin_parity( n ), 1 );

    n = ~0U;
    T_eq_int( __builtin_parity( n ), 0 );
  checks: []
  links:
  - name: __builtin_parity
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_parityll() for a sample set of inputs.
  action-code: |
    volatile unsigned long long n;

    n = 1ULL;
    T_eq_int( __builtin_parityll( n ), 1 );

    n = ~0ULL;
    T_eq_int( __builtin_parityll( n ), 0 );
  checks: []
  links:
  - name: __builtin_parityll
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_popcount() for a sample set of inputs.
  action-code: |
    volatile unsigned int n;

    n = 0U;
    T_eq_int( __builtin_popcount( n ), 0 );

    n = 1U;
    T_eq_int( __builtin_popcount( n ), 1 );

    n = ~0U;
    T_eq_int( __builtin_popcount( n ), 32 );
  checks: []
  links:
  - name: __builtin_popcount
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_popcountll() for a sample set of inputs.
  action-code: |
    volatile unsigned long long n;

    n = 0ULL;
    T_eq_int( __builtin_popcountll( n ), 0 );

    n = 1ULL;
    T_eq_int( __builtin_popcountll( n ), 1 );

    n = ~0ULL;
    T_eq_int( __builtin_popcountll( n ), 64 );
  checks: []
  links:
  - name: __builtin_popcountll
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_bswap32() for a sample set of inputs.
  action-code: |
    volatile uint32_t n;

    n = UINT32_C( 0 );
    T_eq_u32( __builtin_bswap32( n ), n );

    n = UINT32_C( 1 );
    T_eq_u32( __builtin_bswap32( n ), n << 24 );

    n = UINT32_C( 0x12345678 );
    T_eq_u32( __builtin_bswap32( n ), UINT32_C( 0x78563412 ) );

    n = ~UINT32_C( 0 );
    T_eq_u32( __builtin_bswap32( n ), n );
  checks: []
  links:
  - name: __builtin_bswap32
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check the return value of __builtin_bswap64() for a sample set of inputs.
  action-code: |
    volatile uint64_t n;

    n = UINT64_C( 0 );
    T_eq_u64( __builtin_bswap64( n ), n );

    n = UINT64_C( 1 );
    T_eq_u64( __builtin_bswap64( n ), n << 56 );

    n = UINT64_C( 0x123456789abcdef0 );
    T_eq_u64( __builtin_bswap64( n ), UINT64_C( 0xf0debc9a78563412 ) );

    n = ~UINT64_C( 0 );
    T_eq_u64( __builtin_bswap64( n ), n );
  checks: []
  links:
  - name: __builtin_popcount64
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit comparisons for a sample set of values.
  action-code: |
    volatile int64_t a;
    volatile int64_t b;

    a = INT64_C( 0 );
    b = INT64_C( 0 );
    T_false( a < b );

    a = INT64_C( 0 );
    b = INT64_C( 1 );
    T_true( a < b );

    a = INT64_C( 0x123456789abcdef0 );
    b = INT64_C( 0xf0debc9a78563412 );
    T_false( a < b );

    a = INT64_C( 0xf0debc9a78563412 );
    b = INT64_C( 0x123456789abcdef0 );
    T_true( a < b );
  checks: []
  links:
  - name: __cmpdi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check unsigned 64-bit comparisons for a sample set of values.
  action-code: |
    volatile uint64_t a;
    volatile uint64_t b;

    a = UINT64_C( 0 );
    b = UINT64_C( 0 );
    T_false( a < b );

    a = UINT64_C( 0 );
    b = UINT64_C( 1 );
    T_true( a < b );

    a = UINT64_C( 0x123456789abcdef0 );
    b = UINT64_C( 0xf0debc9a78563412 );
    T_true( a < b );

    a = UINT64_C( 0xf0debc9a78563412 );
    b = UINT64_C( 0x123456789abcdef0 );
    T_false( a < b );
  checks: []
  links:
  - name: __ucmpdi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit arithmetic left shift for a sample set of values.
  action-code: |
    volatile int64_t i;
    volatile int s;

    i = INT64_C( 1 );
    s = 0;
    T_eq_i64( i << s, INT64_C( 1 ) );

    i = -INT64_C( 1 );
    s = 0;
    T_eq_i64( i << s, -INT64_C( 1 ) );

    i = INT64_C( 1 );
    s = 1;
    T_eq_i64( i << s, INT64_C( 2 ) );

    i = -INT64_C( 1 );
    s = 1;
    T_eq_i64( i << s, -INT64_C( 2 ) );
  checks: []
  links:
  - name: __ashldi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit arithmetic right shift for a sample set of values.
  action-code: |
    volatile int64_t i;
    volatile int s;

    i = INT64_C( 1 );
    s = 0;
    T_eq_i64( i >> s, INT64_C( 1 ) );

    i = -INT64_C( 1 );
    s = 0;
    T_eq_i64( i >> s, -INT64_C( 1 ) );

    i = INT64_C( 2 );
    s = 1;
    T_eq_i64( i >> s, INT64_C( 1 ) );

    i = -INT64_C( 2 );
    s = 1;
    T_eq_i64( i >> s, -INT64_C( 1 ) );
  checks: []
  links:
  - name: __ashrdi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check unsigned 64-bit logical right shift for a sample set of values.
  action-code: |
    volatile uint64_t i;
    volatile int s;

    i = UINT64_C( 1 );
    s = 0;
    T_eq_u64( i >> s, UINT64_C( 1 ) );

    i = -UINT64_C( 1 );
    s = 0;
    T_eq_u64( i >> s, UINT64_C( 0xffffffffffffffff ) );

    i = UINT64_C( 2 );
    s = 1;
    T_eq_u64( i >> s, UINT64_C( 1 ) );

    i = -UINT64_C( 2 );
    s = 1;
    T_eq_u64( i >> s, UINT64_C( 0x7fffffffffffffff ) );
  checks: []
  links:
  - name: __lshrdi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit multiplication for a sample set of values.
  action-code: |
    volatile int64_t a;
    volatile int64_t b;

    a = INT64_C( 1 );
    b = INT64_C( 1 );
    T_eq_i64( a * b, INT64_C( 1 ) );

    a = INT64_C( 1 );
    b = INT64_C( 0 );
    T_eq_i64( a * b, INT64_C( 0 ) );

    a = INT64_C( 0 );
    b = INT64_C( 1 );
    T_eq_i64( a * b, INT64_C( 0 ) );
  checks: []
  links:
  - name: __negdi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit negation for a sample set of values.
  action-code: |
    volatile int64_t i;

    i = INT64_C( 1 );
    T_eq_i64( -i, -INT64_C( 1 ) );

    i = -INT64_C( 1 );
    T_eq_i64( -i, INT64_C( 1 ) );
  checks: []
  links:
  - name: __negdi2
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit divisions for a sample set of values.
  action-code: |
    volatile int64_t n;
    volatile int64_t d;

    n = INT64_C( 0 );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = INT64_C( 1 );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = INT64_C( 0x7fffffff00000000 );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = INT64_C( 0 );
    d = INT64_C( 1 );
    T_eq_i64( n / d, INT64_C( 0 ) );

    n = INT64_C( 1 );
    d = INT64_C( 1 );
    T_eq_i64( n / d, INT64_C( 1 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 1 );
    T_eq_i64( n / d, INT64_C( 9223372036854775807 ) );

    n = INT64_C( 2 );
    d = INT64_C( 1 );
    T_eq_i64( n / d, INT64_C( 2 ) );

    n = INT64_C( 2 );
    d = INT64_C( 1 );
    T_eq_i64( n / d, INT64_C( 2 ) );

    n = INT64_C( 1 );
    d = INT64_C( 0x7fffffffffffffff );
    T_eq_i64( n / d, INT64_C( 0 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x7fffffffffffffff );
    T_eq_i64( n / d, INT64_C( 1 ) );

    n = INT64_C( 1 );
    d = INT64_C( 0x7fffffff00000000 );
    T_eq_i64( n / d, INT64_C( 0 ) );

    n = INT64_C( 0x7fffffff00000000 );
    d = INT64_C( 0x7fffffff00000000 );
    T_eq_i64( n / d, INT64_C( 1 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x7fffffff00000000 );
    T_eq_i64( n / d, INT64_C( 1 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x8000000000000000 );
    T_eq_i64( n / d, INT64_C( 0 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x0000000080000000 );
    T_eq_i64( n / d, INT64_C( 0xffffffff ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x00000000f0000000 );
    T_eq_i64( n / d, INT64_C( 2290649224 ) );

    n = INT64_C( 0x00000001ffffffff );
    d = INT64_C( 0x00000000f0000000 );
    T_eq_i64( n / d, INT64_C( 2 ) );

    n = INT64_C( 0x0000000fffffffff );
    d = INT64_C( 0x000000000000000f );
    T_eq_i64( n / d, INT64_C( 4581298449 ) );

    n = INT64_C( 0x0000000100000001 );
    d = INT64_C( 0x0000000f00000000 );
    T_eq_i64( n / d, INT64_C( 0 ) );

    n = INT64_C( 0x0000000f0000000f );
    d = INT64_C( 0x000000ff0000000f );
    T_eq_i64( n / d, INT64_C( 0 ) );
  checks: []
  links:
  - name: __divdi3
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check unsigned 64-bit divisions for a sample set of values.
  action-code: |
    volatile uint64_t n;
    volatile uint64_t d;

    n = UINT64_C( 0 );
    d = UINT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = UINT64_C( 1 );
    d = UINT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = UINT64_C( 0x7fffffffffffffff );
    d = UINT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = UINT64_C( 0x7fffffff00000000 );
    d = UINT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n / d;
    }

    n = UINT64_C( 0 );
    d = UINT64_C( 1 );
    T_eq_u64( n / d, UINT64_C( 0 ) );

    n = UINT64_C( 1 );
    d = UINT64_C( 1 );
    T_eq_u64( n / d, UINT64_C( 1 ) );

    n = UINT64_C( 0xffffffffffffffff );
    d = UINT64_C( 1 );
    T_eq_u64( n / d, UINT64_C( 0xffffffffffffffff ) );

    n = UINT64_C( 2 );
    d = UINT64_C( 1 );
    T_eq_u64( n / d, UINT64_C( 2 ) );

    n = UINT64_C( 1 );
    d = UINT64_C( 0xffffffffffffffff );
    T_eq_u64( n / d, UINT64_C( 0 ) );

    n = UINT64_C( 0xffffffffffffffff );
    d = UINT64_C( 0xffffffffffffffff );
    T_eq_u64( n / d, UINT64_C( 1 ) );

    n = UINT64_C( 0xffffffffffffffff );
    d = UINT64_C( 0x8000000000000000 );
    T_eq_u64( n / d, UINT64_C( 1 ) );

    n = UINT64_C( 0x0000000100000001 );
    d = UINT64_C( 0x0000000f00000000 );
    T_eq_u64( n / d, UINT64_C( 0 ) );

    n = UINT64_C( 0xffffffff0000000f );
    d = UINT64_C( 0x000000010000000f );
    T_eq_u64( n / d, UINT64_C( 4294967280 ) );
  checks: []
  links:
  - name: __udivdi3
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check signed 64-bit modulo operations for a sample set of values.
  action-code: |
    volatile int64_t n;
    volatile int64_t d;

    n = INT64_C( 0 );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n % d;
    }

    n = INT64_C( 1 );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n % d;
    }

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n % d;
    }

    n = INT64_C( 0x7fffffff00000000 );
    d = INT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n % d;
    }

    n = INT64_C( 0 );
    d = INT64_C( 1 );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 1 );
    d = INT64_C( 1 );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 1 );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 2 );
    d = INT64_C( 1 );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 2 );
    d = INT64_C( 1 );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 1 );
    d = INT64_C( 0x7fffffffffffffff );
    T_eq_i64( n % d, INT64_C( 1 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x7fffffffffffffff );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 1 );
    d = INT64_C( 0x7fffffff00000000 );
    T_eq_i64( n % d, INT64_C( 1 ) );

    n = INT64_C( 0x7fffffff00000000 );
    d = INT64_C( 0x7fffffff00000000 );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x7fffffff00000000 );
    T_eq_i64( n % d, INT64_C( 0xffffffff ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x8000000000000000 );
    T_eq_i64( n % d, INT64_C( 0x7fffffffffffffff ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x0000000080000000 );
    T_eq_i64( n % d, INT64_C( 2147483647 ) );

    n = INT64_C( 0x7fffffffffffffff );
    d = INT64_C( 0x00000000f0000000 );
    T_eq_i64( n % d, INT64_C( 2147483647 ) );

    n = INT64_C( 0x00000001ffffffff );
    d = INT64_C( 0x00000000f0000000 );
    T_eq_i64( n % d, INT64_C( 536870911 ) );

    n = INT64_C( 0x0000000fffffffff );
    d = INT64_C( 0x000000000000000f );
    T_eq_i64( n % d, INT64_C( 0 ) );

    n = INT64_C( 0x0000000100000001 );
    d = INT64_C( 0x0000000f00000000 );
    T_eq_i64( n % d, INT64_C( 4294967297 ) );

    n = INT64_C( 0x0000000f0000000f );
    d = INT64_C( 0x000000ff0000000f );
    T_eq_i64( n % d, INT64_C( 64424509455 ) );

    #if defined(TEST_UDIVMODDI4)
    /*
     * The above test cases may use __udivmoddi4().  However, the below
     * parameter values for __udivmoddi4() cannot be obtained through the
     * signed modulo or division operations.  On some targets, calls to
     * __udivmoddi4() may result from complex optimizations.
     */
    n = INT64_C( 0xffffffff0000000f );
    d = INT64_C( 0x000000010000000f );
    T_eq_u64( __udivmoddi4( n, d, NULL ), INT64_C( 4294967280 ) );
    #endif
  checks: []
  links:
  - name: __moddi3
    role: unit-test
    uid: ../../if/domain
- action-brief: |
    Check unsigned 64-bit modulo operations for a sample set of values.
  action-code: |
    volatile uint64_t n;
    volatile uint64_t d;

    n = UINT64_C( 0 );
    d = UINT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n % d;
    }

    n = UINT64_C( 1 );
    d = UINT64_C( 0 );
    do_longjmp = true;

    if ( setjmp( exception_return_context ) == 0 ) {
      n = n % d;
    }

    n = UINT64_C( 0 );
    d = UINT64_C( 1 );
    T_eq_u64( n % d, UINT64_C( 0 ) );

    n = UINT64_C( 1 );
    d = UINT64_C( 1 );
    T_eq_u64( n % d, UINT64_C( 0 ) );

    n = UINT64_C( 0xffffffffffffffff );
    d = UINT64_C( 1 );
    T_eq_u64( n % d, UINT64_C( 0 ) );

    n = UINT64_C( 2 );
    d = UINT64_C( 1 );
    T_eq_u64( n % d, UINT64_C( 0 ) );

    n = UINT64_C( 1 );
    d = UINT64_C( 0xffffffffffffffff );
    T_eq_u64( n % d, UINT64_C( 1 ) );

    n = UINT64_C( 0xffffffffffffffff );
    d = UINT64_C( 0xffffffffffffffff );
    T_eq_u64( n % d, UINT64_C( 0 ) );
  checks: []
  links:
  - name: __umoddi3
    role: unit-test
    uid: ../../if/domain
test-brief: |
  These unit tests check compiler builtins.
test-context: []
test-context-support: null
test-description: |
  Explicitly test the 64-bit integer division and modulo operations.  They are
  essential for the timekeeping services.  On most 32-bit targets, they need a
  software implementation.
test-header: null
test-includes:
- stdint.h
- setjmp.h
test-local-includes:
- ../validation/tx-support.h
test-setup:
  brief: null
  code: |
    SetFatalHandler( Fatal, exception_return_context );
  description: null
test-stop: null
test-support: |
  #if __LONG_MAX__ == 0x7fffffffL && !defined(__aarch64__)
  #define TEST_UDIVMODDI4
  #endif

  #if defined(TEST_UDIVMODDI4)
  uint64_t __udivmoddi4( uint64_t n, uint64_t d, uint64_t *r );
  #endif

  static bool do_longjmp;

  static jmp_buf exception_return_context;

  static void Fatal(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    void              *arg
  )
  {
    (void) code;

    if ( source == RTEMS_FATAL_SOURCE_EXCEPTION && do_longjmp ) {
      do_longjmp = false;
      _ISR_Set_level( 0 );
      longjmp( arg, 1 );
    }
  }
test-target: testsuites/unit/tc-compiler-builtins.c
test-teardown:
  brief: null
  code: |
    SetFatalHandler( NULL, NULL );
  description: null
type: test-case