tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c

   1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
   2
   3 /*
   4  * BTF-to-C dumper test for majority of C syntax quirks.
   5  *
   6  * Copyright (c) 2019 Facebook
   7  */
   8 /* ----- START-EXPECTED-OUTPUT ----- */
   9 enum e1 {
  10         A = 0,
  11         B = 1,
  12 };
  13
  14 enum e2 {
  15         C = 100,
  16         D = 4294967295,
  17         E = 0,
  18 };
  19
  20 typedef enum e2 e2_t;
  21
  22 typedef enum {
  23         F = 0,
  24         G = 1,
  25         H = 2,
  26 } e3_t;
  27
  28 /* ----- START-EXPECTED-OUTPUT ----- */
  29 /*
  30  *enum e_byte {
  31  *      EBYTE_1 = 0,
  32  *      EBYTE_2 = 1,
  33  *} __attribute__((mode(byte)));
  34  *
  35  */
  36 /* ----- END-EXPECTED-OUTPUT ----- */
  37 enum e_byte {
  38         EBYTE_1,
  39         EBYTE_2,
  40 } __attribute__((mode(byte)));
  41
  42 /* ----- START-EXPECTED-OUTPUT ----- */
  43 /*
  44  *enum e_word {
  45  *      EWORD_1 = 0LL,
  46  *      EWORD_2 = 1LL,
  47  *} __attribute__((mode(word)));
  48  *
  49  */
  50 /* ----- END-EXPECTED-OUTPUT ----- */
  51 enum e_word {
  52         EWORD_1,
  53         EWORD_2,
  54 } __attribute__((mode(word))); /* force to use 8-byte backing for this enum */
  55
  56 /* ----- START-EXPECTED-OUTPUT ----- */
  57 enum e_big {
  58         EBIG_1 = 1000000000000ULL,
  59 };
  60
  61 typedef int int_t;
  62
  63 typedef volatile const int * volatile const crazy_ptr_t;
  64
  65 typedef int *****we_need_to_go_deeper_ptr_t;
  66
  67 typedef volatile const we_need_to_go_deeper_ptr_t * restrict * volatile * const * restrict volatile * restrict const * volatile const * restrict volatile const how_about_this_ptr_t;
  68
  69 typedef int *ptr_arr_t[10];
  70
  71 typedef void (*fn_ptr1_t)(int);
  72
  73 typedef void (*printf_fn_t)(const char *, ...);
  74
  75 /* ------ END-EXPECTED-OUTPUT ------ */
  76 /*
  77  * While previous function pointers are pretty trivial (C-syntax-level
  78  * trivial), the following are deciphered here for future generations:
  79  *
  80  * - `fn_ptr2_t`: function, taking anonymous struct as a first arg and pointer
  81  *   to a function, that takes int and returns int, as a second arg; returning
  82  *   a pointer to a const pointer to a char. Equivalent to:
  83  *      typedef struct { int a; } s_t;
  84  *      typedef int (*fn_t)(int);
  85  *      typedef char * const * (*fn_ptr2_t)(s_t, fn_t);
  86  *
  87  * - `fn_complex_t`: pointer to a function returning struct and accepting
  88  *   union and struct. All structs and enum are anonymous and defined inline.
  89  *
  90  * - `signal_t: pointer to a function accepting a pointer to a function as an
  91  *   argument and returning pointer to a function as a result. Sane equivalent:
  92  *      typedef void (*signal_handler_t)(int);
  93  *      typedef signal_handler_t (*signal_ptr_t)(int, signal_handler_t);
  94  *
  95  * - fn_ptr_arr1_t: array of pointers to a function accepting pointer to
  96  *   a pointer to an int and returning pointer to a char. Easy.
  97  *
  98  * - fn_ptr_arr2_t: array of const pointers to a function taking no arguments
  99  *   and returning a const pointer to a function, that takes pointer to a
 100  *   `int -> char *` function and returns pointer to a char. Equivalent:
 101  *   typedef char * (*fn_input_t)(int);
 102  *   typedef char * (*fn_output_outer_t)(fn_input_t);
 103  *   typedef const fn_output_outer_t (* fn_output_inner_t)(void);
 104  *   typedef const fn_output_inner_t fn_ptr_arr2_t[5];
 105  */
 106 /* ----- START-EXPECTED-OUTPUT ----- */
 107 typedef char * const * (*fn_ptr2_t)(struct {
 108         int a;
 109 }, int (*)(int));
 110
 111 typedef struct {
 112         int a;
 113         void (*b)(int, struct {
 114                 int c;
 115         }, union {
 116                 char d;
 117                 int e[5];
 118         });
 119 } (*fn_complex_t)(union {
 120         void *f;
 121         char g[16];
 122 }, struct {
 123         int h;
 124 });
 125
 126 typedef void (* (*signal_t)(int, void (*)(int)))(int);
 127
 128 typedef char * (*fn_ptr_arr1_t[10])(int **);
 129
 130 typedef char * (* (* const fn_ptr_arr2_t[5])(void))(char * (*)(int));
 131
 132 struct struct_w_typedefs {
 133         int_t a;
 134         crazy_ptr_t b;
 135         we_need_to_go_deeper_ptr_t c;
 136         how_about_this_ptr_t d;
 137         ptr_arr_t e;
 138         fn_ptr1_t f;
 139         printf_fn_t g;
 140         fn_ptr2_t h;
 141         fn_complex_t i;
 142         signal_t j;
 143         fn_ptr_arr1_t k;
 144         fn_ptr_arr2_t l;
 145 };
 146
 147 typedef struct {
 148         int x;
 149         int y;
 150         int z;
 151 } anon_struct_t;
 152
 153 struct struct_fwd;
 154
 155 typedef struct struct_fwd struct_fwd_t;
 156
 157 typedef struct struct_fwd *struct_fwd_ptr_t;
 158
 159 union union_fwd;
 160
 161 typedef union union_fwd union_fwd_t;
 162
 163 typedef union union_fwd *union_fwd_ptr_t;
 164
 165 struct struct_empty {};
 166
 167 struct struct_simple {
 168         int a;
 169         char b;
 170         const int_t *p;
 171         struct struct_empty s;
 172         enum e2 e;
 173         enum {
 174                 ANON_VAL1 = 1,
 175                 ANON_VAL2 = 2,
 176         } f;
 177         int arr1[13];
 178         enum e2 arr2[5];
 179 };
 180
 181 union union_empty {};
 182
 183 union union_simple {
 184         void *ptr;
 185         int num;
 186         int_t num2;
 187         union union_empty u;
 188 };
 189
 190 struct struct_in_struct {
 191         struct struct_simple simple;
 192         union union_simple also_simple;
 193         struct {
 194                 int a;
 195         } not_so_hard_as_well;
 196         union {
 197                 int b;
 198                 int c;
 199         } anon_union_is_good;
 200         struct {
 201                 int d;
 202                 int e;
 203         };
 204         union {
 205                 int f;
 206                 int g;
 207         };
 208 };
 209
 210 struct struct_in_array {};
 211
 212 struct struct_in_array_typed {};
 213
 214 typedef struct struct_in_array_typed struct_in_array_t[2];
 215
 216 struct struct_with_embedded_stuff {
 217         int a;
 218         struct {
 219                 int b;
 220                 struct {
 221                         struct struct_with_embedded_stuff *c;
 222                         const char *d;
 223                 } e;
 224                 union {
 225                         volatile long f;
 226                         void * restrict g;
 227                 };
 228         };
 229         union {
 230                 const int_t *h;
 231                 void (*i)(char, int, void *);
 232         } j;
 233         enum {
 234                 K = 100,
 235                 L = 200,
 236         } m;
 237         char n[16];
 238         struct {
 239                 char o;
 240                 int p;
 241                 void (*q)(int);
 242         } r[5];
 243         struct struct_in_struct s[10];
 244         int t[11];
 245         struct struct_in_array (*u)[2];
 246         struct_in_array_t *v;
 247 };
 248
 249 struct float_struct {
 250         float f;
 251         const double *d;
 252         volatile long double *ld;
 253 };
 254
 255 struct root_struct {
 256         enum e1 _1;
 257         enum e2 _2;
 258         e2_t _2_1;
 259         e3_t _2_2;
 260         enum e_byte _100;
 261         enum e_word _101;
 262         enum e_big _102;
 263         struct struct_w_typedefs _3;
 264         anon_struct_t _7;
 265         struct struct_fwd *_8;
 266         struct_fwd_t *_9;
 267         struct_fwd_ptr_t _10;
 268         union union_fwd *_11;
 269         union_fwd_t *_12;
 270         union_fwd_ptr_t _13;
 271         struct struct_with_embedded_stuff _14;
 272         struct float_struct _15;
 273 };
 274
 275 /* ------ END-EXPECTED-OUTPUT ------ */
 276
 277 int f(struct root_struct *s)
 278 {
 279         return 0;
 280 }