duktape-1.5.2/src-separate/duk_selftest.c

Go to the documentation of this file.

/*
 *  Self tests to ensure execution environment is sane.  Intended to catch
 *  compiler/platform problems which cannot be detected at compile time.
 */
 
#include "duk_internal.h"
 
#if defined(DUK_USE_SELF_TESTS)
 
/*
 *  Unions and structs for self tests
 */
 
typedef union {
    double d;
    duk_uint8_t c[8];
} duk__test_double_union;
 
#define DUK__DBLUNION_CMP_TRUE(a,b)  do { \
        if (DUK_MEMCMP((const void *) (a), (const void *) (b), sizeof(duk__test_double_union)) != 0) { \
            DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares false (expected true)"); \
        } \
    } while (0)
 
#define DUK__DBLUNION_CMP_FALSE(a,b)  do { \
        if (DUK_MEMCMP((const void *) (a), (const void *) (b), sizeof(duk__test_double_union)) == 0) { \
            DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares true (expected false)"); \
        } \
    } while (0)
 
typedef union {
    duk_uint32_t i;
    duk_uint8_t c[8];
} duk__test_u32_union;
 
/*
 *  Various sanity checks for typing
 */
 
DUK_LOCAL void duk__selftest_types(void) {
    if (!(sizeof(duk_int8_t) == 1 &&
          sizeof(duk_uint8_t) == 1 &&
          sizeof(duk_int16_t) == 2 &&
          sizeof(duk_uint16_t) == 2 &&
          sizeof(duk_int32_t) == 4 &&
          sizeof(duk_uint32_t) == 4)) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_(u)int{8,16,32}_t size");
    }
#if defined(DUK_USE_64BIT_OPS)
    if (!(sizeof(duk_int64_t) == 8 &&
          sizeof(duk_uint64_t) == 8)) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_(u)int64_t size");
    }
#endif
 
    if (!(sizeof(duk_size_t) >= sizeof(duk_uint_t))) {
        /* Some internal code now assumes that all duk_uint_t values
         * can be expressed with a duk_size_t.
         */
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_size_t is smaller than duk_uint_t");
    }
    if (!(sizeof(duk_int_t) >= 4)) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_int_t is not 32 bits");
    }
}
 
/*
 *  Packed tval sanity
 */
 
DUK_LOCAL void duk__selftest_packed_tval(void) {
#if defined(DUK_USE_PACKED_TVAL)
    if (sizeof(void *) > 4) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: packed duk_tval in use but sizeof(void *) > 4");
    }
#endif
}
 
/*
 *  Two's complement arithmetic.
 */
 
DUK_LOCAL void duk__selftest_twos_complement(void) {
    volatile int test;
    test = -1;
 
    /* Note that byte order doesn't affect this test: all bytes in
     * 'test' will be 0xFF for two's complement.
     */
    if (((volatile duk_uint8_t *) &test)[0] != (duk_uint8_t) 0xff) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: two's complement arithmetic");
    }
}
 
/*
 *  Byte order.  Important to self check, because on some exotic platforms
 *  there is no actual detection but rather assumption based on platform
 *  defines.
 */
 
DUK_LOCAL void duk__selftest_byte_order(void) {
    duk__test_u32_union u1;
    duk__test_double_union u2;
 
    /*
     *  >>> struct.pack('>d', 102030405060).encode('hex')
     *  '4237c17c6dc40000'
     */
#if defined(DUK_USE_INTEGER_LE)
    u1.c[0] = 0xef; u1.c[1] = 0xbe; u1.c[2] = 0xad; u1.c[3] = 0xde;
#elif defined(DUK_USE_INTEGER_ME)
#error integer mixed endian not supported now
#elif defined(DUK_USE_INTEGER_BE)
    u1.c[0] = 0xde; u1.c[1] = 0xad; u1.c[2] = 0xbe; u1.c[3] = 0xef;
#else
#error unknown integer endianness
#endif
 
#if defined(DUK_USE_DOUBLE_LE)
    u2.c[0] = 0x00; u2.c[1] = 0x00; u2.c[2] = 0xc4; u2.c[3] = 0x6d;
    u2.c[4] = 0x7c; u2.c[5] = 0xc1; u2.c[6] = 0x37; u2.c[7] = 0x42;
#elif defined(DUK_USE_DOUBLE_ME)
    u2.c[0] = 0x7c; u2.c[1] = 0xc1; u2.c[2] = 0x37; u2.c[3] = 0x42;
    u2.c[4] = 0x00; u2.c[5] = 0x00; u2.c[6] = 0xc4; u2.c[7] = 0x6d;
#elif defined(DUK_USE_DOUBLE_BE)
    u2.c[0] = 0x42; u2.c[1] = 0x37; u2.c[2] = 0xc1; u2.c[3] = 0x7c;
    u2.c[4] = 0x6d; u2.c[5] = 0xc4; u2.c[6] = 0x00; u2.c[7] = 0x00;
#else
#error unknown double endianness
#endif
 
    if (u1.i != (duk_uint32_t) 0xdeadbeefUL) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_uint32_t byte order");
    }
 
    if (u2.d != (double) 102030405060.0) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double byte order");
    }
}
 
/*
 *  DUK_BSWAP macros
 */
 
DUK_LOCAL void duk__selftest_bswap_macros(void) {
    duk_uint32_t x32;
    duk_uint16_t x16;
    duk_double_union du;
    duk_double_t du_diff;
 
    x16 = 0xbeefUL;
    x16 = DUK_BSWAP16(x16);
    if (x16 != (duk_uint16_t) 0xefbeUL) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_BSWAP16");
    }
 
    x32 = 0xdeadbeefUL;
    x32 = DUK_BSWAP32(x32);
    if (x32 != (duk_uint32_t) 0xefbeaddeUL) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_BSWAP32");
    }
 
    /* >>> struct.unpack('>d', '4000112233445566'.decode('hex'))
     * (2.008366013071895,)
     */
 
    du.uc[0] = 0x40; du.uc[1] = 0x00; du.uc[2] = 0x11; du.uc[3] = 0x22;
    du.uc[4] = 0x33; du.uc[5] = 0x44; du.uc[6] = 0x55; du.uc[7] = 0x66;
    DUK_DBLUNION_DOUBLE_NTOH(&du);
    du_diff = du.d - 2.008366013071895;
#if 0
    DUK_FPRINTF(DUK_STDERR, "du_diff: %lg\n", (double) du_diff);
#endif
    if (du_diff > 1e-15) {
        /* Allow very small lenience because some compilers won't parse
         * exact IEEE double constants (happened in matrix testing with
         * Linux gcc-4.8 -m32 at least).
         */
#if 0
        DUK_FPRINTF(DUK_STDERR, "Result of DUK_DBLUNION_DOUBLE_NTOH: %02x %02x %02x %02x %02x %02x %02x %02x\n",
                    (unsigned int) du.uc[0], (unsigned int) du.uc[1],
                    (unsigned int) du.uc[2], (unsigned int) du.uc[3],
                    (unsigned int) du.uc[4], (unsigned int) du.uc[5],
                    (unsigned int) du.uc[6], (unsigned int) du.uc[7]);
#endif
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_DBLUNION_DOUBLE_NTOH");
    }
}
 
/*
 *  Basic double / byte union memory layout.
 */
 
DUK_LOCAL void duk__selftest_double_union_size(void) {
    if (sizeof(duk__test_double_union) != 8) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: invalid union size");
    }
}
 
/*
 *  Union aliasing, see misc/clang_aliasing.c.
 */
 
DUK_LOCAL void duk__selftest_double_aliasing(void) {
    duk__test_double_union a, b;
 
    /* This testcase fails when Emscripten-generated code runs on Firefox.
     * It's not an issue because the failure should only affect packed
     * duk_tval representation, which is not used with Emscripten.
     */
#if !defined(DUK_USE_PACKED_TVAL)
    DUK_D(DUK_DPRINT("skip double aliasing self test when duk_tval is not packed"));
    return;
#endif
 
    /* Test signaling NaN and alias assignment in all endianness combinations.
     */
 
    /* little endian */
    a.c[0] = 0x11; a.c[1] = 0x22; a.c[2] = 0x33; a.c[3] = 0x44;
    a.c[4] = 0x00; a.c[5] = 0x00; a.c[6] = 0xf1; a.c[7] = 0xff;
    b = a;
    DUK__DBLUNION_CMP_TRUE(&a, &b);
 
    /* big endian */
    a.c[0] = 0xff; a.c[1] = 0xf1; a.c[2] = 0x00; a.c[3] = 0x00;
    a.c[4] = 0x44; a.c[5] = 0x33; a.c[6] = 0x22; a.c[7] = 0x11;
    b = a;
    DUK__DBLUNION_CMP_TRUE(&a, &b);
 
    /* mixed endian */
    a.c[0] = 0x00; a.c[1] = 0x00; a.c[2] = 0xf1; a.c[3] = 0xff;
    a.c[4] = 0x11; a.c[5] = 0x22; a.c[6] = 0x33; a.c[7] = 0x44;
    b = a;
    DUK__DBLUNION_CMP_TRUE(&a, &b);
}
 
/*
 *  Zero sign, see misc/tcc_zerosign2.c.
 */
 
DUK_LOCAL void duk__selftest_double_zero_sign(void) {
    duk__test_double_union a, b;
 
    a.d = 0.0;
    b.d = -a.d;
    DUK__DBLUNION_CMP_FALSE(&a, &b);
}
 
/*
 *  Struct size/alignment if platform requires it
 *
 *  There are some compiler specific struct padding pragmas etc in use, this
 *  selftest ensures they're correctly detected and used.
 */
 
DUK_LOCAL void duk__selftest_struct_align(void) {
#if (DUK_USE_ALIGN_BY == 4)
    if ((sizeof(duk_hbuffer_fixed) % 4) != 0) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 4");
    }
#elif (DUK_USE_ALIGN_BY == 8)
    if ((sizeof(duk_hbuffer_fixed) % 8) != 0) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 8");
    }
#elif (DUK_USE_ALIGN_BY == 1)
    /* no check */
#else
#error invalid DUK_USE_ALIGN_BY
#endif
}
 
/*
 *  64-bit arithmetic
 *
 *  There are some platforms/compilers where 64-bit types are available
 *  but don't work correctly.  Test for known cases.
 */
 
DUK_LOCAL void duk__selftest_64bit_arithmetic(void) {
#if defined(DUK_USE_64BIT_OPS)
    volatile duk_int64_t i;
    volatile duk_double_t d;
 
    /* Catch a double-to-int64 cast issue encountered in practice. */
    d = 2147483648.0;
    i = (duk_int64_t) d;
    if (i != 0x80000000LL) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: casting 2147483648.0 to duk_int64_t failed");
    }
#else
    /* nop */
#endif
}
 
/*
 *  Casting
 */
 
DUK_LOCAL void duk__selftest_cast_double_to_small_uint(void) {
    /*
     *  https://github.com/svaarala/duktape/issues/127#issuecomment-77863473
     */
 
    duk_double_t d1, d2;
    duk_small_uint_t u;
 
    duk_double_t d1v, d2v;
    duk_small_uint_t uv;
 
    /* Test without volatiles */
 
    d1 = 1.0;
    u = (duk_small_uint_t) d1;
    d2 = (duk_double_t) u;
 
    if (!(d1 == 1.0 && u == 1 && d2 == 1.0 && d1 == d2)) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_small_uint_t cast failed");
    }
 
    /* Same test with volatiles */
 
    d1v = 1.0;
    uv = (duk_small_uint_t) d1v;
    d2v = (duk_double_t) uv;
 
    if (!(d1v == 1.0 && uv == 1 && d2v == 1.0 && d1v == d2v)) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_small_uint_t cast failed");
    }
}
 
DUK_LOCAL void duk__selftest_cast_double_to_uint32(void) {
    /*
     *  This test fails on an exotic ARM target; double-to-uint
     *  cast is incorrectly clamped to -signed- int highest value.
     *
     *  https://github.com/svaarala/duktape/issues/336
     */
 
    duk_double_t dv;
    duk_uint32_t uv;
 
    dv = 3735928559.0;  /* 0xdeadbeef in decimal */
    uv = (duk_uint32_t) dv;
 
    if (uv != 0xdeadbeefUL) {
        DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_uint32_t cast failed");
    }
}
 
/*
 *  Self test main
 */
 
DUK_INTERNAL void duk_selftest_run_tests(void) {
    duk__selftest_types();
    duk__selftest_packed_tval();
    duk__selftest_twos_complement();
    duk__selftest_byte_order();
    duk__selftest_bswap_macros();
    duk__selftest_double_union_size();
    duk__selftest_double_aliasing();
    duk__selftest_double_zero_sign();
    duk__selftest_struct_align();
    duk__selftest_64bit_arithmetic();
    duk__selftest_cast_double_to_small_uint();
    duk__selftest_cast_double_to_uint32();
}
 
#undef DUK__DBLUNION_CMP_TRUE
#undef DUK__DBLUNION_CMP_FALSE
 
#endif  /* DUK_USE_SELF_TESTS */