gcc/testsuite/jit.dg/test-functions.c

   1 #include <math.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4
   5 #include "libgccjit.h"
   6
   7 #include "harness.h"
   8
   9 /**********************************************************************
  10  GCC_JIT_FUNCTION_ALWAYS_INLINE and GCC_JIT_FUNCTION_INTERNAL
  11  **********************************************************************/
  12 static void
  13 create_test_of_hidden_function (gcc_jit_context *ctxt,
  14                                 enum gcc_jit_function_kind hidden_kind,
  15                                 const char *hidden_func_name,
  16                                 const char *visible_func_name)
  17 {
  18   /* Let's try to inject the equivalent of:
  19      static double hidden_mult (double a, double b)
  20      {
  21        return x * x;
  22      }
  23      double my_square (double x)
  24      {
  25        return my_mult (x, x);
  26      }
  27
  28      where hidden_mult can potentially be
  29        inline  __attribute__((always_inline)).  */
  30   gcc_jit_type *double_type =
  31     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE);
  32
  33   /* Create "my_mult" */
  34   gcc_jit_param *param_a =
  35     gcc_jit_context_new_param (ctxt, NULL, double_type, "a");
  36   gcc_jit_param *param_b =
  37     gcc_jit_context_new_param (ctxt, NULL, double_type, "b");
  38   gcc_jit_param *params[2] = {param_a, param_b};
  39   gcc_jit_function *my_mult =
  40     gcc_jit_context_new_function (ctxt, NULL,
  41                                   hidden_kind,
  42                                   double_type,
  43                                   hidden_func_name,
  44                                   2, params,
  45                                   0);
  46   gcc_jit_block *body_of_my_mult =
  47     gcc_jit_function_new_block (my_mult, NULL);
  48   gcc_jit_block_end_with_return (
  49     body_of_my_mult, NULL,
  50     gcc_jit_context_new_binary_op (
  51       ctxt, NULL,
  52       GCC_JIT_BINARY_OP_MULT,
  53       double_type,
  54       gcc_jit_param_as_rvalue (param_a),
  55       gcc_jit_param_as_rvalue (param_b)));
  56
  57   /* Create "my_square" */
  58   gcc_jit_param *param_x =
  59     gcc_jit_context_new_param (ctxt, NULL, double_type, "x");
  60   gcc_jit_function *my_square =
  61     gcc_jit_context_new_function (ctxt, NULL,
  62                                   GCC_JIT_FUNCTION_EXPORTED,
  63                                   double_type,
  64                                   visible_func_name,
  65                                   1, &param_x,
  66                                   0);
  67   gcc_jit_block *body_of_my_square =
  68     gcc_jit_function_new_block (my_square, NULL);
  69   gcc_jit_rvalue *args[2] = {gcc_jit_param_as_rvalue (param_x),
  70                              gcc_jit_param_as_rvalue (param_x)};
  71   gcc_jit_block_end_with_return (
  72     body_of_my_square, NULL,
  73     gcc_jit_context_new_call (
  74       ctxt, NULL,
  75       my_mult,
  76       2, args));
  77 }
  78
  79 static void
  80 create_tests_of_hidden_functions (gcc_jit_context *ctxt)
  81 {
  82   create_test_of_hidden_function (ctxt,
  83                                   GCC_JIT_FUNCTION_INTERNAL,
  84                                   "my_internal_mult",
  85                                   "my_square_with_internal");
  86   create_test_of_hidden_function (ctxt,
  87                                   GCC_JIT_FUNCTION_ALWAYS_INLINE,
  88                                   "my_always_inline_mult",
  89                                   "my_square_with_always_inline");
  90 }
  91
  92 static void
  93 verify_hidden_functions (gcc_jit_context *ctxt, gcc_jit_result *result)
  94 {
  95   CHECK_NON_NULL (result);
  96
  97   /* GCC_JIT_FUNCTION_INTERNAL and GCC_JIT_FUNCTION_ALWAYS_INLINE
  98      functions should not be accessible in the result.  */
  99   CHECK_VALUE (NULL, gcc_jit_result_get_code (result, "my_internal_mult"));
 100   CHECK_VALUE (NULL, gcc_jit_result_get_code (result, "my_always_inline_mult"));
 101
 102   typedef double (*fn_type) (double);
 103   fn_type my_square_with_internal =
 104     (fn_type)gcc_jit_result_get_code (result, "my_square_with_internal");
 105   CHECK_NON_NULL (my_square_with_internal);
 106   CHECK_VALUE (my_square_with_internal (5.0), 25.0);
 107
 108   fn_type my_square_with_always_inline =
 109     (fn_type)gcc_jit_result_get_code (result, "my_square_with_always_inline");
 110   CHECK_NON_NULL (my_square_with_always_inline);
 111   CHECK_VALUE (my_square_with_always_inline (5.0), 25.0);
 112 }
 113
 114 /**********************************************************************
 115  Builtin functions
 116  **********************************************************************/
 117
 118 static void
 119 create_test_of_builtin_strcmp (gcc_jit_context *ctxt)
 120 {
 121   /* Let's try to inject the equivalent of:
 122        int
 123        test_of_builtin_strcmp (const char *a, const char *b)
 124        {
 125          return __builtin_strcmp (a, b);
 126        }
 127   */
 128   gcc_jit_type *int_type =
 129     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
 130   gcc_jit_type *const_char_ptr_type =
 131     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CONST_CHAR_PTR);
 132
 133   /* Get the built-in function.  */
 134   gcc_jit_function *builtin_fn =
 135     gcc_jit_context_get_builtin_function (ctxt, "strcmp");
 136
 137   CHECK_STRING_VALUE (
 138     gcc_jit_object_get_debug_string (gcc_jit_function_as_object (builtin_fn)),
 139     "strcmp");
 140
 141   /* Build the test_fn.  */
 142   gcc_jit_param *param_a =
 143     gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "a");
 144   gcc_jit_param *param_b =
 145     gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "b");
 146   gcc_jit_param *params[2] = {param_a, param_b};
 147   gcc_jit_function *test_fn =
 148     gcc_jit_context_new_function (ctxt, NULL,
 149                                   GCC_JIT_FUNCTION_EXPORTED,
 150                                   int_type,
 151                                   "test_of_builtin_strcmp",
 152                                   2, params,
 153                                   0);
 154   gcc_jit_rvalue *args[2] = {gcc_jit_param_as_rvalue (param_a),
 155                              gcc_jit_param_as_rvalue (param_b)};
 156   gcc_jit_rvalue *call =
 157     gcc_jit_context_new_call (ctxt,
 158                               NULL,
 159                               builtin_fn,
 160                               2, args);
 161   CHECK_STRING_VALUE (
 162     gcc_jit_object_get_debug_string (gcc_jit_rvalue_as_object (call)),
 163     "strcmp (a, b)");
 164
 165   gcc_jit_block *initial =
 166     gcc_jit_function_new_block (test_fn, "initial");
 167   gcc_jit_block_end_with_return (initial, NULL, call);
 168 }
 169
 170 static char *trig_sincos_dump;
 171 static char *trig_statistics_dump;
 172
 173 static void
 174 create_test_of_builtin_trig (gcc_jit_context *ctxt)
 175 {
 176   /* Let's try to inject the equivalent of:
 177        int
 178        test_of_builtin_trig (double theta)
 179        {
 180          return 2 * sin (theta) * cos (theta);
 181        }
 182        (in theory, optimizable to sin (2 * theta))
 183   */
 184
 185   gcc_jit_context_enable_dump (ctxt,
 186                                "tree-sincos",
 187                                &trig_sincos_dump);
 188   gcc_jit_context_enable_dump (ctxt,
 189                                "statistics",
 190                                &trig_statistics_dump);
 191
 192   gcc_jit_type *double_t =
 193     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE);
 194
 195   /* Get the built-in functions.  */
 196   gcc_jit_function *builtin_sin =
 197     gcc_jit_context_get_builtin_function (ctxt, "sin");
 198   gcc_jit_function *builtin_cos =
 199     gcc_jit_context_get_builtin_function (ctxt, "cos");
 200
 201   /* Build the test_fn.  */
 202   gcc_jit_param *param_theta =
 203     gcc_jit_context_new_param (ctxt, NULL, double_t, "theta");
 204   gcc_jit_function *test_fn =
 205     gcc_jit_context_new_function (ctxt, NULL,
 206                                   GCC_JIT_FUNCTION_EXPORTED,
 207                                   double_t,
 208                                   "test_of_builtin_trig",
 209                                   1, &param_theta,
 210                                   0);
 211   gcc_jit_rvalue *args[1] = {gcc_jit_param_as_rvalue (param_theta)};
 212   gcc_jit_rvalue *two =
 213     gcc_jit_context_new_rvalue_from_int (ctxt, double_t, 2);
 214   gcc_jit_rvalue *ret =
 215     gcc_jit_context_new_binary_op (
 216       ctxt, NULL,
 217       GCC_JIT_BINARY_OP_MULT,
 218       double_t,
 219       two,
 220       gcc_jit_context_new_binary_op (
 221         ctxt, NULL,
 222         GCC_JIT_BINARY_OP_MULT,
 223         double_t,
 224         gcc_jit_context_new_call (ctxt, NULL,
 225                                   builtin_sin,
 226                                   1, args),
 227         gcc_jit_context_new_call (ctxt, NULL,
 228                                   builtin_cos,
 229                                   1, args)));
 230   CHECK_STRING_VALUE (
 231     gcc_jit_object_get_debug_string (gcc_jit_rvalue_as_object (ret)),
 232     "(double)2 * sin (theta) * cos (theta)");
 233
 234   gcc_jit_block *initial =
 235     gcc_jit_function_new_block (test_fn, "initial");
 236   gcc_jit_block_end_with_return (initial, NULL, ret);
 237 }
 238
 239 static void
 240 create_use_of_builtins (gcc_jit_context *ctxt)
 241 {
 242   create_test_of_builtin_strcmp (ctxt);
 243   create_test_of_builtin_trig (ctxt);
 244 }
 245
 246 static void
 247 verify_test_of_builtin_strcmp (gcc_jit_context *ctxt, gcc_jit_result *result)
 248 {
 249   typedef int (*fn_type) (const char *, const char *);
 250   CHECK_NON_NULL (result);
 251
 252   fn_type test_of_builtin_strcmp =
 253     (fn_type)gcc_jit_result_get_code (result, "test_of_builtin_strcmp");
 254   CHECK_NON_NULL (test_of_builtin_strcmp);
 255
 256   /* Verify that it correctly called strcmp.  */
 257   CHECK_VALUE (test_of_builtin_strcmp ("foo", "foo"), 0);
 258   CHECK (test_of_builtin_strcmp ("foo", "bar") > 0);
 259   CHECK (test_of_builtin_strcmp ("bar", "foo") < 0);
 260 }
 261
 262 static void
 263 verify_test_of_builtin_trig (gcc_jit_context *ctxt, gcc_jit_result *result)
 264 {
 265   typedef double (*fn_type) (double);
 266   CHECK_NON_NULL (result);
 267
 268   fn_type test_of_builtin_trig =
 269     (fn_type)gcc_jit_result_get_code (result, "test_of_builtin_trig");
 270   CHECK_NON_NULL (test_of_builtin_trig);
 271
 272   /* Verify that it correctly computes
 273         sin (2 * theta)
 274      (perhaps calling sin and cos). */
 275   CHECK_DOUBLE_VALUE (test_of_builtin_trig (0.0         ),  0.0);
 276   CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI_4      ),  1.0);
 277   CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI_2      ),  0.0);
 278   CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI_4 * 3.0), -1.0);
 279   CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI        ),  0.0);
 280
 281   /* PR jit/64020:
 282      The "sincos" pass merges sin/cos calls into the cexpi builtin.
 283      Verify that a dump of the "sincos" pass was provided, and that it
 284      shows a call to the cexpi builtin on a SSA name of "theta".  */
 285   CHECK_NON_NULL (trig_sincos_dump);
 286   CHECK_STRING_CONTAINS (trig_sincos_dump, " = __builtin_cexpi (theta_");
 287   free (trig_sincos_dump);
 288
 289   /* Similarly, verify that the statistics dump was provided, and that
 290      it shows the sincos optimization.  */
 291   CHECK_NON_NULL (trig_statistics_dump);
 292   CHECK_STRING_CONTAINS (
 293     trig_statistics_dump,
 294     "sincos \"sincos statements inserted\" \"test_of_builtin_trig\" 1");
 295   free (trig_statistics_dump);
 296 }
 297
 298 static void
 299 verify_use_of_builtins (gcc_jit_context *ctxt, gcc_jit_result *result)
 300 {
 301   verify_test_of_builtin_strcmp (ctxt, result);
 302   verify_test_of_builtin_trig (ctxt, result);
 303 }
 304
 305 /**********************************************************************
 306  "void" return
 307  **********************************************************************/
 308
 309 static void
 310 create_use_of_void_return (gcc_jit_context *ctxt)
 311 {
 312   /* Let's try to inject the equivalent of:
 313        void
 314        test_of_void_return (int *out)
 315        {
 316          *out = 1;
 317          return;
 318        }
 319   */
 320   gcc_jit_type *void_t =
 321     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
 322   gcc_jit_type *int_t =
 323     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
 324   gcc_jit_type *int_ptr_t =
 325     gcc_jit_type_get_pointer (int_t);
 326
 327   /* Build the test_fn.  */
 328   gcc_jit_param *param_out =
 329     gcc_jit_context_new_param (ctxt, NULL, int_ptr_t, "out");
 330   gcc_jit_function *test_fn =
 331     gcc_jit_context_new_function (ctxt, NULL,
 332                                   GCC_JIT_FUNCTION_EXPORTED,
 333                                   void_t,
 334                                   "test_of_void_return",
 335                                   1, &param_out,
 336                                   0);
 337   gcc_jit_block *initial =
 338     gcc_jit_function_new_block (test_fn, "initial");
 339
 340   gcc_jit_block_add_assignment (
 341     initial, NULL,
 342     /* "*out = ..." */
 343     gcc_jit_rvalue_dereference (gcc_jit_param_as_rvalue (param_out),
 344                                 NULL),
 345     gcc_jit_context_one (ctxt, int_t));
 346   gcc_jit_block_end_with_void_return (initial, NULL);
 347 }
 348
 349 static void
 350 verify_void_return (gcc_jit_context *ctxt, gcc_jit_result *result)
 351 {
 352   typedef void (*fn_type) (int *);
 353   CHECK_NON_NULL (result);
 354
 355   fn_type test_of_void_return =
 356     (fn_type)gcc_jit_result_get_code (result, "test_of_void_return");
 357   CHECK_NON_NULL (test_of_void_return);
 358
 359   int i;
 360   test_of_void_return (&i);
 361   CHECK_VALUE (i, 1); /* ensure correct value was written back */
 362 }
 363
 364 /**********************************************************************
 365  Code for harness
 366  **********************************************************************/
 367
 368 void
 369 create_code (gcc_jit_context *ctxt, void *user_data)
 370 {
 371   create_tests_of_hidden_functions (ctxt);
 372   create_use_of_builtins (ctxt);
 373   create_use_of_void_return (ctxt);
 374 }
 375
 376
 377 void
 378 verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
 379 {
 380   verify_hidden_functions (ctxt, result);
 381   verify_use_of_builtins (ctxt, result);
 382   verify_void_return (ctxt, result);
 383 }