gcc/testsuite/jit.dg/test-compound-assignment.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3
   4 #include "libgccjit.h"
   5
   6 #include "harness.h"
   7
   8 struct assignable_struct
   9 {
  10   int a;
  11   char b;
  12   float c;
  13 };
  14
  15 union assignable_union
  16 {
  17   int a;
  18   char b;
  19   float c;
  20 };
  21
  22 /* Verify that compound assignment works; let's try to inject the
  23    equivalent of:
  24
  25      struct assignable_struct
  26      test_struct_assignment (struct assignable_struct x)
  27      {
  28        struct assignable_struct y, z;
  29        y = x;
  30        z = y;
  31        return z;
  32      }
  33
  34    and the same, for "union assignable_union".  */
  35
  36 /* Make the type "struct assignable_struct" or "union assignable_union".  */
  37
  38 static gcc_jit_type *
  39 make_type (gcc_jit_context *ctxt, int make_union)
  40 {
  41   gcc_jit_type *t_int =
  42     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
  43   gcc_jit_type *t_char =
  44     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CHAR);
  45   gcc_jit_type *t_float =
  46     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_FLOAT);
  47
  48   gcc_jit_field *a =
  49     gcc_jit_context_new_field (ctxt,
  50                                NULL,
  51                                t_int,
  52                                "a");
  53   gcc_jit_field *b =
  54     gcc_jit_context_new_field (ctxt,
  55                                NULL,
  56                                t_char,
  57                                "b");
  58   gcc_jit_field *c =
  59     gcc_jit_context_new_field (ctxt,
  60                                NULL,
  61                                t_float,
  62                                "c");
  63   gcc_jit_field *fields[] = {a, b, c};
  64   if (make_union)
  65       return gcc_jit_context_new_union_type (ctxt, NULL,
  66                                              "assignable_union",
  67                                              3, fields);
  68   else
  69     return gcc_jit_struct_as_type (
  70       gcc_jit_context_new_struct_type (ctxt, NULL,
  71                                        "assignable_struct",
  72                                        3, fields));
  73 }
  74
  75 static void
  76 make_function (gcc_jit_context *ctxt, int make_union, const char *funcname)
  77 {
  78   gcc_jit_type *test_type = make_type (ctxt, make_union);
  79   gcc_jit_param *x =
  80     gcc_jit_context_new_param (ctxt, NULL,
  81                                test_type, "x");
  82   gcc_jit_function *fn =
  83     gcc_jit_context_new_function (ctxt, NULL,
  84                                   GCC_JIT_FUNCTION_EXPORTED,
  85                                   test_type,
  86                                   funcname,
  87                                   1, &x,
  88                                   0);
  89   gcc_jit_lvalue *y =
  90     gcc_jit_function_new_local (fn, NULL, test_type, "y");
  91   gcc_jit_lvalue *z =
  92     gcc_jit_function_new_local (fn, NULL, test_type, "z");
  93   gcc_jit_block *block =
  94     gcc_jit_function_new_block (fn, NULL);
  95   gcc_jit_block_add_assignment (block, NULL,
  96                                 y, gcc_jit_param_as_rvalue (x));
  97   gcc_jit_block_add_assignment (block, NULL,
  98                                 z, gcc_jit_lvalue_as_rvalue (y));
  99   gcc_jit_block_end_with_return (block, NULL,
 100                                  gcc_jit_lvalue_as_rvalue (z));
 101 }
 102
 103 void
 104 create_code (gcc_jit_context *ctxt, void *user_data)
 105 {
 106   make_function (ctxt, 0, "test_struct_assignment");
 107   make_function (ctxt, 1, "test_union_assignment");
 108 }
 109
 110 static void
 111 verify_test_struct_assignment (gcc_jit_result *result)
 112 {
 113   typedef struct assignable_struct (*fn_type) (struct assignable_struct);
 114   fn_type test_struct_assignment =
 115     (fn_type)gcc_jit_result_get_code (result, "test_struct_assignment");
 116   CHECK_NON_NULL (test_struct_assignment);
 117
 118   struct assignable_struct s, t;
 119   s.a = 500;
 120   s.b = 'A';
 121   s.c = 1.0;
 122   t = test_struct_assignment (s);
 123   CHECK_VALUE (t.a, 500);
 124   CHECK_VALUE (t.b, 'A');
 125   CHECK_VALUE (t.c, 1.0);
 126 }
 127
 128 static void
 129 verify_test_union_assignment (gcc_jit_result *result)
 130 {
 131   typedef union assignable_union (*fn_type) (union assignable_union);
 132   fn_type test_union_assignment =
 133     (fn_type)gcc_jit_result_get_code (result, "test_union_assignment");
 134   CHECK_NON_NULL (test_union_assignment);
 135
 136   union assignable_union p, q;
 137
 138   p.a = 500;
 139   q = test_union_assignment (p);
 140   CHECK_VALUE (q.a, 500);
 141
 142   p.b = 'A';
 143   q = test_union_assignment (p);
 144   CHECK_VALUE (q.b, 'A');
 145
 146   p.c = 1.0;
 147   q = test_union_assignment (p);
 148   CHECK_VALUE (q.c, 1.0);
 149 }
 150
 151 void
 152 verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
 153 {
 154   CHECK_NON_NULL (result);
 155   verify_test_struct_assignment (result);
 156   verify_test_union_assignment (result);
 157 }