| #include <limits.h> |
| #include <float.h> |
| |
| #include "libgccjit.h" |
| |
| #include "harness.h" |
| |
| static void |
| make_test_of_constant (gcc_jit_context *ctxt, |
| gcc_jit_type *type, |
| gcc_jit_rvalue *rvalue, |
| const char *funcname) |
| { |
| /* Make a test function of the form: |
| T funcname (void) |
| { |
| return VALUE; |
| } |
| and return a debug dump of VALUE so that |
| the caller can sanity-check the debug dump implementation. |
| */ |
| gcc_jit_function *test_fn = |
| gcc_jit_context_new_function (ctxt, NULL, |
| GCC_JIT_FUNCTION_EXPORTED, |
| type, |
| funcname, |
| 0, NULL, |
| 0); |
| gcc_jit_block *initial = gcc_jit_function_new_block (test_fn, "initial"); |
| gcc_jit_block_end_with_return (initial, NULL, rvalue); |
| } |
| |
| /********************************************************************** |
| Tests of gcc_jit_context_new_rvalue_from_int. |
| **********************************************************************/ |
| |
| static const char * |
| make_test_of_int_constant (gcc_jit_context *ctxt, |
| gcc_jit_type *type, |
| int value, |
| const char *funcname) |
| { |
| /* Make a test function of the form: |
| int funcname (void) |
| { |
| return VALUE; |
| } |
| and return a debug dump of VALUE so that |
| the caller can sanity-check the debug dump implementation. |
| */ |
| gcc_jit_rvalue *rvalue = |
| gcc_jit_context_new_rvalue_from_int (ctxt, type, value); |
| make_test_of_constant (ctxt, type, rvalue, funcname); |
| return gcc_jit_object_get_debug_string ( |
| gcc_jit_rvalue_as_object (rvalue)); |
| } |
| |
| static void |
| make_tests_of_int_constants (gcc_jit_context *ctxt) |
| { |
| gcc_jit_type *int_type = |
| gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); |
| |
| CHECK_STRING_VALUE ( |
| make_test_of_int_constant (ctxt, |
| int_type, |
| 0, |
| "test_int_constant_0"), |
| "(int)0"); |
| make_test_of_int_constant (ctxt, |
| int_type, |
| INT_MAX, |
| "test_int_constant_INT_MAX"); |
| make_test_of_int_constant (ctxt, |
| int_type, |
| INT_MIN, |
| "test_int_constant_INT_MIN"); |
| } |
| |
| static void |
| verify_int_constants (gcc_jit_result *result) |
| { |
| typedef int (*test_fn) (void); |
| |
| test_fn test_int_constant_0 = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_int_constant_0"); |
| CHECK_NON_NULL (test_int_constant_0); |
| CHECK_VALUE (test_int_constant_0 (), 0); |
| |
| test_fn test_int_constant_INT_MAX = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_int_constant_INT_MAX"); |
| CHECK_NON_NULL (test_int_constant_INT_MAX); |
| CHECK_VALUE (test_int_constant_INT_MAX (), INT_MAX); |
| |
| test_fn test_int_constant_INT_MIN = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_int_constant_INT_MIN"); |
| CHECK_NON_NULL (test_int_constant_INT_MIN); |
| CHECK_VALUE (test_int_constant_INT_MIN (), INT_MIN); |
| } |
| |
| /********************************************************************** |
| Tests of gcc_jit_context_new_rvalue_from_long. |
| **********************************************************************/ |
| |
| static const char * |
| make_test_of_long_constant (gcc_jit_context *ctxt, |
| gcc_jit_type *type, |
| long value, |
| const char *funcname) |
| { |
| /* Make a test function of the form: |
| long funcname (void) |
| { |
| return VALUE; |
| } |
| and return a debug dump of VALUE so that |
| the caller can sanity-check the debug dump implementation. |
| */ |
| gcc_jit_rvalue *rvalue = |
| gcc_jit_context_new_rvalue_from_long (ctxt, type, value); |
| make_test_of_constant (ctxt, type, rvalue, funcname); |
| return gcc_jit_object_get_debug_string ( |
| gcc_jit_rvalue_as_object (rvalue)); |
| } |
| |
| static void |
| make_tests_of_long_constants (gcc_jit_context *ctxt) |
| { |
| gcc_jit_type *long_type = |
| gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG); |
| |
| CHECK_STRING_VALUE ( |
| make_test_of_long_constant (ctxt, |
| long_type, |
| 0, |
| "test_long_constant_0"), |
| "(long)0"); |
| make_test_of_long_constant (ctxt, |
| long_type, |
| LONG_MAX, |
| "test_long_constant_LONG_MAX"); |
| make_test_of_long_constant (ctxt, |
| long_type, |
| LONG_MIN, |
| "test_long_constant_LONG_MIN"); |
| } |
| |
| static void |
| verify_long_constants (gcc_jit_result *result) |
| { |
| typedef long (*test_fn) (void); |
| |
| test_fn test_long_constant_0 = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_long_constant_0"); |
| CHECK_NON_NULL (test_long_constant_0); |
| CHECK_VALUE (test_long_constant_0 (), 0); |
| |
| test_fn test_long_constant_LONG_MAX = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_long_constant_LONG_MAX"); |
| CHECK_NON_NULL (test_long_constant_LONG_MAX); |
| CHECK_VALUE (test_long_constant_LONG_MAX (), LONG_MAX); |
| |
| test_fn test_long_constant_LONG_MIN = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_long_constant_LONG_MIN"); |
| CHECK_NON_NULL (test_long_constant_LONG_MIN); |
| CHECK_VALUE (test_long_constant_LONG_MIN (), LONG_MIN); |
| } |
| |
| /********************************************************************** |
| Tests of gcc_jit_context_new_rvalue_from_double. |
| **********************************************************************/ |
| |
| static const char * |
| make_test_of_double_constant (gcc_jit_context *ctxt, |
| gcc_jit_type *type, |
| double value, |
| const char *funcname) |
| { |
| /* Make a test function of the form: |
| double funcname (void) |
| { |
| return VALUE; |
| } |
| and return a debug dump of VALUE so that |
| the caller can sanity-check the debug dump implementation. |
| */ |
| gcc_jit_rvalue *rvalue = |
| gcc_jit_context_new_rvalue_from_double (ctxt, type, value); |
| make_test_of_constant (ctxt, type, rvalue, funcname); |
| return gcc_jit_object_get_debug_string ( |
| gcc_jit_rvalue_as_object (rvalue)); |
| } |
| |
| static void |
| make_tests_of_double_constants (gcc_jit_context *ctxt) |
| { |
| gcc_jit_type *double_type = |
| gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE); |
| |
| make_test_of_double_constant (ctxt, |
| double_type, |
| 0.5, |
| "test_double_constant_0_5"); |
| make_test_of_double_constant (ctxt, |
| double_type, |
| 1e100, |
| "test_double_constant_1e100"); |
| make_test_of_double_constant (ctxt, |
| double_type, |
| DBL_MIN, |
| "test_double_constant_DBL_MIN"); |
| make_test_of_double_constant (ctxt, |
| double_type, |
| DBL_MAX, |
| "test_double_constant_DBL_MAX"); |
| } |
| |
| static void |
| verify_double_constants (gcc_jit_result *result) |
| { |
| typedef double (*test_fn) (void); |
| |
| test_fn test_double_constant_0_5 = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_double_constant_0_5"); |
| CHECK_NON_NULL (test_double_constant_0_5); |
| CHECK_VALUE (test_double_constant_0_5 (), 0.5); |
| |
| test_fn test_double_constant_1e100 = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_double_constant_1e100"); |
| CHECK_NON_NULL (test_double_constant_1e100); |
| CHECK_VALUE (test_double_constant_1e100 (), 1e100); |
| |
| test_fn test_double_constant_DBL_MIN = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_double_constant_DBL_MIN"); |
| CHECK_NON_NULL (test_double_constant_DBL_MIN); |
| CHECK_VALUE (test_double_constant_DBL_MIN (), DBL_MIN); |
| |
| test_fn test_double_constant_DBL_MAX = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_double_constant_DBL_MAX"); |
| CHECK_NON_NULL (test_double_constant_DBL_MAX); |
| CHECK_VALUE (test_double_constant_DBL_MAX (), DBL_MAX); |
| } |
| |
| /********************************************************************** |
| Tests of gcc_jit_context_new_rvalue_from_ptr. |
| **********************************************************************/ |
| |
| static const char * |
| make_test_of_ptr_constant (gcc_jit_context *ctxt, |
| gcc_jit_type *type, |
| void *value, |
| const char *funcname) |
| { |
| /* Make a test function of the form: |
| void *funcname (void) |
| { |
| return VALUE; |
| } |
| and return a debug dump of VALUE so that |
| the caller can sanity-check the debug dump implementation. |
| */ |
| gcc_jit_rvalue *rvalue = |
| gcc_jit_context_new_rvalue_from_ptr (ctxt, type, value); |
| make_test_of_constant (ctxt, type, rvalue, funcname); |
| return gcc_jit_object_get_debug_string ( |
| gcc_jit_rvalue_as_object (rvalue)); |
| } |
| |
| static void |
| make_tests_of_ptr_constants (gcc_jit_context *ctxt) |
| { |
| gcc_jit_type *ptr_type = |
| gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR); |
| |
| CHECK_STRING_VALUE ( |
| make_test_of_ptr_constant (ctxt, |
| ptr_type, |
| 0, |
| "test_ptr_constant_0"), |
| "(void *)NULL"); |
| CHECK_STRING_VALUE ( |
| make_test_of_ptr_constant (ctxt, |
| ptr_type, |
| (void *)0xdeadbeef, |
| "test_ptr_constant_0xdeadbeef"), |
| "(void *)0xdeadbeef"); |
| } |
| |
| static void |
| verify_ptr_constants (gcc_jit_result *result) |
| { |
| typedef void *(*test_fn) (void); |
| |
| test_fn test_ptr_constant_0 = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_ptr_constant_0"); |
| CHECK_NON_NULL (test_ptr_constant_0); |
| CHECK_VALUE (test_ptr_constant_0 (), 0); |
| |
| test_fn test_ptr_constant_0xdeadbeef = |
| (test_fn)gcc_jit_result_get_code (result, |
| "test_ptr_constant_0xdeadbeef"); |
| CHECK_NON_NULL (test_ptr_constant_0xdeadbeef); |
| CHECK_VALUE (test_ptr_constant_0xdeadbeef (), (void *)0xdeadbeef); |
| } |
| |
| /********************************************************************** |
| Code for harness |
| **********************************************************************/ |
| |
| void |
| create_code (gcc_jit_context *ctxt, void *user_data) |
| { |
| make_tests_of_int_constants (ctxt); |
| make_tests_of_long_constants (ctxt); |
| make_tests_of_double_constants (ctxt); |
| make_tests_of_ptr_constants (ctxt); |
| } |
| |
| void |
| verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) |
| { |
| CHECK_NON_NULL (result); |
| |
| verify_int_constants (result); |
| verify_long_constants (result); |
| verify_double_constants (result); |
| verify_ptr_constants (result); |
| } |
