OSCL-LXR linux-6.0.1/​tools/​testing/​selftests/​bpf/​progs/​btf_dump_test_case_syntax.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
 
 /*
  * BTF-to-C dumper test for majority of C syntax quirks.
  *
  * Copyright (c) 2019 Facebook
  */
 /* ----- START-EXPECTED-OUTPUT ----- */
 enum e1 {
     A = 0,
     B = 1,
 };
 
 enum e2 {
     C = 100,
     D = 4294967295,
     E = 0,
 };
 
 typedef enum e2 e2_t;
 
 typedef enum {
     F = 0,
     G = 1,
     H = 2,
 } e3_t;
 
 typedef int int_t;
 
 typedef volatile const int * volatile const crazy_ptr_t;
 
 typedef int *****we_need_to_go_deeper_ptr_t;
 
 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;
 
 typedef int *ptr_arr_t[10];
 
 typedef void (*fn_ptr1_t)(int);
 
 typedef void (*printf_fn_t)(const char *, ...);
 
 /* ------ END-EXPECTED-OUTPUT ------ */
 /*
  * While previous function pointers are pretty trivial (C-syntax-level
  * trivial), the following are deciphered here for future generations:
  *
  * - `fn_ptr2_t`: function, taking anonymous struct as a first arg and pointer
  *   to a function, that takes int and returns int, as a second arg; returning
  *   a pointer to a const pointer to a char. Equivalent to:
  *  typedef struct { int a; } s_t;
  *  typedef int (*fn_t)(int);
  *  typedef char * const * (*fn_ptr2_t)(s_t, fn_t);
  *
  * - `fn_complext_t`: pointer to a function returning struct and accepting
  *   union and struct. All structs and enum are anonymous and defined inline.
  *
  * - `signal_t: pointer to a function accepting a pointer to a function as an
  *   argument and returning pointer to a function as a result. Sane equivalent:
  *  typedef void (*signal_handler_t)(int);
  *  typedef signal_handler_t (*signal_ptr_t)(int, signal_handler_t);
  *
  * - fn_ptr_arr1_t: array of pointers to a function accepting pointer to
  *   a pointer to an int and returning pointer to a char. Easy.
  *
  * - fn_ptr_arr2_t: array of const pointers to a function taking no arguments
  *   and returning a const pointer to a function, that takes pointer to a
  *   `int -> char *` function and returns pointer to a char. Equivalent:
  *   typedef char * (*fn_input_t)(int);
  *   typedef char * (*fn_output_outer_t)(fn_input_t);
  *   typedef const fn_output_outer_t (* fn_output_inner_t)();
  *   typedef const fn_output_inner_t fn_ptr_arr2_t[5];
  */
 /* ----- START-EXPECTED-OUTPUT ----- */
 typedef char * const * (*fn_ptr2_t)(struct {
     int a;
 }, int (*)(int));
 
 typedef struct {
     int a;
     void (*b)(int, struct {
         int c;
     }, union {
         char d;
         int e[5];
     });
 } (*fn_complex_t)(union {
     void *f;
     char g[16];
 }, struct {
     int h;
 });
 
 typedef void (* (*signal_t)(int, void (*)(int)))(int);
 
 typedef char * (*fn_ptr_arr1_t[10])(int **);
 
 typedef char * (* (* const fn_ptr_arr2_t[5])())(char * (*)(int));
 
 struct struct_w_typedefs {
     int_t a;
     crazy_ptr_t b;
     we_need_to_go_deeper_ptr_t c;
     how_about_this_ptr_t d;
     ptr_arr_t e;
     fn_ptr1_t f;
     printf_fn_t g;
     fn_ptr2_t h;
     fn_complex_t i;
     signal_t j;
     fn_ptr_arr1_t k;
     fn_ptr_arr2_t l;
 };
 
 typedef struct {
     int x;
     int y;
     int z;
 } anon_struct_t;
 
 struct struct_fwd;
 
 typedef struct struct_fwd struct_fwd_t;
 
 typedef struct struct_fwd *struct_fwd_ptr_t;
 
 union union_fwd;
 
 typedef union union_fwd union_fwd_t;
 
 typedef union union_fwd *union_fwd_ptr_t;
 
 struct struct_empty {};
 
 struct struct_simple {
     int a;
     char b;
     const int_t *p;
     struct struct_empty s;
     enum e2 e;
     enum {
         ANON_VAL1 = 1,
         ANON_VAL2 = 2,
     } f;
     int arr1[13];
     enum e2 arr2[5];
 };
 
 union union_empty {};
 
 union union_simple {
     void *ptr;
     int num;
     int_t num2;
     union union_empty u;
 };
 
 struct struct_in_struct {
     struct struct_simple simple;
     union union_simple also_simple;
     struct {
         int a;
     } not_so_hard_as_well;
     union {
         int b;
         int c;
     } anon_union_is_good;
     struct {
         int d;
         int e;
     };
     union {
         int f;
         int g;
     };
 };
 
 struct struct_in_array {};
 
 struct struct_in_array_typed {};
 
 typedef struct struct_in_array_typed struct_in_array_t[2];
 
 struct struct_with_embedded_stuff {
     int a;
     struct {
         int b;
         struct {
             struct struct_with_embedded_stuff *c;
             const char *d;
         } e;
         union {
             volatile long f;
             void * restrict g;
         };
     };
     union {
         const int_t *h;
         void (*i)(char, int, void *);
     } j;
     enum {
         K = 100,
         L = 200,
     } m;
     char n[16];
     struct {
         char o;
         int p;
         void (*q)(int);
     } r[5];
     struct struct_in_struct s[10];
     int t[11];
     struct struct_in_array (*u)[2];
     struct_in_array_t *v;
 };
 
 struct float_struct {
     float f;
     const double *d;
     volatile long double *ld;
 };
 
 struct root_struct {
     enum e1 _1;
     enum e2 _2;
     e2_t _2_1;
     e3_t _2_2;
     struct struct_w_typedefs _3;
     anon_struct_t _7;
     struct struct_fwd *_8;
     struct_fwd_t *_9;
     struct_fwd_ptr_t _10;
     union union_fwd *_11;
     union_fwd_t *_12;
     union_fwd_ptr_t _13;
     struct struct_with_embedded_stuff _14;
     struct float_struct _15;
 };
 
 /* ------ END-EXPECTED-OUTPUT ------ */
 
 int f(struct root_struct *s)
 {
     return 0;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team