github.com/ethereum/go-ethereum@v1.16.1/crypto/secp256k1/libsecp256k1/src/assumptions.h (about)

     1  /***********************************************************************
     2   * Copyright (c) 2020 Pieter Wuille                                    *
     3   * Distributed under the MIT software license, see the accompanying    *
     4   * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
     5   ***********************************************************************/
     6  
     7  #ifndef SECP256K1_ASSUMPTIONS_H
     8  #define SECP256K1_ASSUMPTIONS_H
     9  
    10  #include <limits.h>
    11  
    12  #include "util.h"
    13  #if defined(SECP256K1_INT128_NATIVE)
    14  #include "int128_native.h"
    15  #endif
    16  
    17  /* This library, like most software, relies on a number of compiler implementation defined (but not undefined)
    18     behaviours. Although the behaviours we require are essentially universal we test them specifically here to
    19     reduce the odds of experiencing an unwelcome surprise.
    20  */
    21  
    22  #if defined(__has_attribute)
    23  # if __has_attribute(__unavailable__)
    24  __attribute__((__unavailable__("Don't call this function. It only exists because STATIC_ASSERT cannot be used outside a function.")))
    25  # endif
    26  #endif
    27  static void secp256k1_assumption_checker(void) {
    28      /* Bytes are 8 bits. */
    29      STATIC_ASSERT(CHAR_BIT == 8);
    30  
    31      /* No integer promotion for uint32_t. This ensures that we can multiply uintXX_t values where XX >= 32
    32         without signed overflow, which would be undefined behaviour. */
    33      STATIC_ASSERT(UINT_MAX <= UINT32_MAX);
    34  
    35      /* Conversions from unsigned to signed outside of the bounds of the signed type are
    36         implementation-defined. Verify that they function as reinterpreting the lower
    37         bits of the input in two's complement notation. Do this for conversions:
    38         - from uint(N)_t to int(N)_t with negative result
    39         - from uint(2N)_t to int(N)_t with negative result
    40         - from int(2N)_t to int(N)_t with negative result
    41         - from int(2N)_t to int(N)_t with positive result */
    42  
    43      /* To int8_t. */
    44      STATIC_ASSERT(((int8_t)(uint8_t)0xAB == (int8_t)-(int8_t)0x55));
    45      STATIC_ASSERT((int8_t)(uint16_t)0xABCD == (int8_t)-(int8_t)0x33);
    46      STATIC_ASSERT((int8_t)(int16_t)(uint16_t)0xCDEF == (int8_t)(uint8_t)0xEF);
    47      STATIC_ASSERT((int8_t)(int16_t)(uint16_t)0x9234 == (int8_t)(uint8_t)0x34);
    48  
    49      /* To int16_t. */
    50      STATIC_ASSERT((int16_t)(uint16_t)0xBCDE == (int16_t)-(int16_t)0x4322);
    51      STATIC_ASSERT((int16_t)(uint32_t)0xA1B2C3D4 == (int16_t)-(int16_t)0x3C2C);
    52      STATIC_ASSERT((int16_t)(int32_t)(uint32_t)0xC1D2E3F4 == (int16_t)(uint16_t)0xE3F4);
    53      STATIC_ASSERT((int16_t)(int32_t)(uint32_t)0x92345678 == (int16_t)(uint16_t)0x5678);
    54  
    55      /* To int32_t. */
    56      STATIC_ASSERT((int32_t)(uint32_t)0xB2C3D4E5 == (int32_t)-(int32_t)0x4D3C2B1B);
    57      STATIC_ASSERT((int32_t)(uint64_t)0xA123B456C789D012ULL == (int32_t)-(int32_t)0x38762FEE);
    58      STATIC_ASSERT((int32_t)(int64_t)(uint64_t)0xC1D2E3F4A5B6C7D8ULL == (int32_t)(uint32_t)0xA5B6C7D8);
    59      STATIC_ASSERT((int32_t)(int64_t)(uint64_t)0xABCDEF0123456789ULL == (int32_t)(uint32_t)0x23456789);
    60  
    61      /* To int64_t. */
    62      STATIC_ASSERT((int64_t)(uint64_t)0xB123C456D789E012ULL == (int64_t)-(int64_t)0x4EDC3BA928761FEEULL);
    63  #if defined(SECP256K1_INT128_NATIVE)
    64      STATIC_ASSERT((int64_t)(((uint128_t)0xA1234567B8901234ULL << 64) + 0xC5678901D2345678ULL) == (int64_t)-(int64_t)0x3A9876FE2DCBA988ULL);
    65      STATIC_ASSERT(((int64_t)(int128_t)(((uint128_t)0xB1C2D3E4F5A6B7C8ULL << 64) + 0xD9E0F1A2B3C4D5E6ULL)) == (int64_t)(uint64_t)0xD9E0F1A2B3C4D5E6ULL);
    66      STATIC_ASSERT(((int64_t)(int128_t)(((uint128_t)0xABCDEF0123456789ULL << 64) + 0x0123456789ABCDEFULL)) == (int64_t)(uint64_t)0x0123456789ABCDEFULL);
    67  
    68      /* To int128_t. */
    69      STATIC_ASSERT((int128_t)(((uint128_t)0xB1234567C8901234ULL << 64) + 0xD5678901E2345678ULL) == (int128_t)(-(int128_t)0x8E1648B3F50E80DCULL * 0x8E1648B3F50E80DDULL + 0x5EA688D5482F9464ULL));
    70  #endif
    71  
    72      /* Right shift on negative signed values is implementation defined. Verify that it
    73         acts as a right shift in two's complement with sign extension (i.e duplicating
    74         the top bit into newly added bits). */
    75      STATIC_ASSERT((((int8_t)0xE8) >> 2) == (int8_t)(uint8_t)0xFA);
    76      STATIC_ASSERT((((int16_t)0xE9AC) >> 4) == (int16_t)(uint16_t)0xFE9A);
    77      STATIC_ASSERT((((int32_t)0x937C918A) >> 9) == (int32_t)(uint32_t)0xFFC9BE48);
    78      STATIC_ASSERT((((int64_t)0xA8B72231DF9CF4B9ULL) >> 19) == (int64_t)(uint64_t)0xFFFFF516E4463BF3ULL);
    79  #if defined(SECP256K1_INT128_NATIVE)
    80      STATIC_ASSERT((((int128_t)(((uint128_t)0xCD833A65684A0DBCULL << 64) + 0xB349312F71EA7637ULL)) >> 39) == (int128_t)(((uint128_t)0xFFFFFFFFFF9B0674ULL << 64) + 0xCAD0941B79669262ULL));
    81  #endif
    82  
    83      /* This function is not supposed to be called. */
    84      VERIFY_CHECK(0);
    85  }
    86  
    87  #endif /* SECP256K1_ASSUMPTIONS_H */