tools/testing/selftests/bpf/progs/core_reloc_types.h

   1 #include <stdint.h>
   2 #include <stdbool.h>
   3
   4 void preserce_ptr_sz_fn(long x) {}
   5
   6 #define __bpf_aligned __attribute__((aligned(8)))
   7
   8 /*
   9  * KERNEL
  10  */
  11
  12 struct core_reloc_kernel_output {
  13         int valid[10];
  14         char comm[sizeof("test_progs")];
  15         int comm_len;
  16 };
  17
  18 /*
  19  * MODULE
  20  */
  21
  22 struct core_reloc_module_output {
  23         long long len;
  24         long long off;
  25         int read_ctx_sz;
  26         bool read_ctx_exists;
  27         bool buf_exists;
  28         bool len_exists;
  29         bool off_exists;
  30         /* we have test_progs[-flavor], so cut flavor part */
  31         char comm[sizeof("test_progs")];
  32         int comm_len;
  33 };
  34
  35 /*
  36  * FLAVORS
  37  */
  38 struct core_reloc_flavors {
  39         int a;
  40         int b;
  41         int c;
  42 };
  43
  44 /* this is not a flavor, as it doesn't have triple underscore */
  45 struct core_reloc_flavors__err_wrong_name {
  46         int a;
  47         int b;
  48         int c;
  49 };
  50
  51 /*
  52  * NESTING
  53  */
  54 /* original set up, used to record relocations in BPF program */
  55 struct core_reloc_nesting_substruct {
  56         int a;
  57 };
  58
  59 union core_reloc_nesting_subunion {
  60         int b;
  61 };
  62
  63 struct core_reloc_nesting {
  64         union {
  65                 struct core_reloc_nesting_substruct a;
  66         } a;
  67         struct {
  68                 union core_reloc_nesting_subunion b;
  69         } b;
  70 };
  71
  72 /* inlined anonymous struct/union instead of named structs in original */
  73 struct core_reloc_nesting___anon_embed {
  74         int __just_for_padding;
  75         union {
  76                 struct {
  77                         int a;
  78                 } a;
  79         } a;
  80         struct {
  81                 union {
  82                         int b;
  83                 } b;
  84         } b;
  85 };
  86
  87 /* different mix of nested structs/unions than in original */
  88 struct core_reloc_nesting___struct_union_mixup {
  89         int __a;
  90         struct {
  91                 int __a;
  92                 union {
  93                         char __a;
  94                         int a;
  95                 } a;
  96         } a;
  97         int __b;
  98         union {
  99                 int __b;
 100                 union {
 101                         char __b;
 102                         int b;
 103                 } b;
 104         } b;
 105 };
 106
 107 /* extra anon structs/unions, but still valid a.a.a and b.b.b accessors */
 108 struct core_reloc_nesting___extra_nesting {
 109         int __padding;
 110         struct {
 111                 struct {
 112                         struct {
 113                                 struct {
 114                                         union {
 115                                                 int a;
 116                                         } a;
 117                                 };
 118                         };
 119                 } a;
 120                 int __some_more;
 121                 struct {
 122                         union {
 123                                 union {
 124                                         union {
 125                                                 struct {
 126                                                         int b;
 127                                                 };
 128                                         } b;
 129                                 };
 130                         } b;
 131                 };
 132         };
 133 };
 134
 135 /* three flavors of same struct with different structure but same layout for
 136  * a.a.a and b.b.b, thus successfully resolved and relocatable */
 137 struct core_reloc_nesting___dup_compat_types {
 138         char __just_for_padding;
 139         /* 3 more bytes of padding */
 140         struct {
 141                 struct {
 142                         int a; /* offset 4 */
 143                 } a;
 144         } a;
 145         long long __more_padding;
 146         struct {
 147                 struct {
 148                         int b; /* offset 16 */
 149                 } b;
 150         } b;
 151 };
 152
 153 struct core_reloc_nesting___dup_compat_types__2 {
 154         int __aligned_padding;
 155         struct {
 156                 int __trickier_noop[0];
 157                 struct {
 158                         char __some_more_noops[0];
 159                         int a; /* offset 4 */
 160                 } a;
 161         } a;
 162         int __more_padding;
 163         struct {
 164                 struct {
 165                         struct {
 166                                 int __critical_padding;
 167                                 int b; /* offset 16 */
 168                         } b;
 169                         int __does_not_matter;
 170                 };
 171         } b;
 172         int __more_irrelevant_stuff;
 173 };
 174
 175 struct core_reloc_nesting___dup_compat_types__3 {
 176         char __correct_padding[4];
 177         struct {
 178                 struct {
 179                         int a; /* offset 4 */
 180                 } a;
 181         } a;
 182         /* 8 byte padding due to next struct's alignment */
 183         struct {
 184                 struct {
 185                         int b;
 186                 } b;
 187         } b __attribute__((aligned(16)));
 188 };
 189
 190 /* b.b.b field is missing */
 191 struct core_reloc_nesting___err_missing_field {
 192         struct {
 193                 struct {
 194                         int a;
 195                 } a;
 196         } a;
 197         struct {
 198                 struct {
 199                         int x;
 200                 } b;
 201         } b;
 202 };
 203
 204 /* b.b.b field is an array of integers instead of plain int */
 205 struct core_reloc_nesting___err_array_field {
 206         struct {
 207                 struct {
 208                         int a;
 209                 } a;
 210         } a;
 211         struct {
 212                 struct {
 213                         int b[1];
 214                 } b;
 215         } b;
 216 };
 217
 218 /* middle b container is missing */
 219 struct core_reloc_nesting___err_missing_container {
 220         struct {
 221                 struct {
 222                         int a;
 223                 } a;
 224         } a;
 225         struct {
 226                 int x;
 227         } b;
 228 };
 229
 230 /* middle b container is referenced through pointer instead of being embedded */
 231 struct core_reloc_nesting___err_nonstruct_container {
 232         struct {
 233                 struct {
 234                         int a;
 235                 } a;
 236         } a;
 237         struct {
 238                 struct {
 239                         int b;
 240                 } *b;
 241         } b;
 242 };
 243
 244 /* middle b container is an array of structs instead of plain struct */
 245 struct core_reloc_nesting___err_array_container {
 246         struct {
 247                 struct {
 248                         int a;
 249                 } a;
 250         } a;
 251         struct {
 252                 struct {
 253                         int b;
 254                 } b[1];
 255         } b;
 256 };
 257
 258 /* two flavors of same struct with incompatible layout for b.b.b */
 259 struct core_reloc_nesting___err_dup_incompat_types__1 {
 260         struct {
 261                 struct {
 262                         int a; /* offset 0 */
 263                 } a;
 264         } a;
 265         struct {
 266                 struct {
 267                         int b; /* offset 4 */
 268                 } b;
 269         } b;
 270 };
 271
 272 struct core_reloc_nesting___err_dup_incompat_types__2 {
 273         struct {
 274                 struct {
 275                         int a; /* offset 0 */
 276                 } a;
 277         } a;
 278         int __extra_padding;
 279         struct {
 280                 struct {
 281                         int b; /* offset 8 (!) */
 282                 } b;
 283         } b;
 284 };
 285
 286 /* two flavors of same struct having one of a.a.a and b.b.b, but not both */
 287 struct core_reloc_nesting___err_partial_match_dups__a {
 288         struct {
 289                 struct {
 290                         int a;
 291                 } a;
 292         } a;
 293 };
 294
 295 struct core_reloc_nesting___err_partial_match_dups__b {
 296         struct {
 297                 struct {
 298                         int b;
 299                 } b;
 300         } b;
 301 };
 302
 303 struct core_reloc_nesting___err_too_deep {
 304         struct {
 305                 struct {
 306                         int a;
 307                 } a;
 308         } a;
 309         /* 65 levels of nestedness for b.b.b */
 310         struct {
 311                 struct {
 312                         struct { struct { struct { struct { struct {
 313                         struct { struct { struct { struct { struct {
 314                         struct { struct { struct { struct { struct {
 315                         struct { struct { struct { struct { struct {
 316                         struct { struct { struct { struct { struct {
 317                         struct { struct { struct { struct { struct {
 318                         struct { struct { struct { struct { struct {
 319                         struct { struct { struct { struct { struct {
 320                         struct { struct { struct { struct { struct {
 321                         struct { struct { struct { struct { struct {
 322                         struct { struct { struct { struct { struct {
 323                         struct { struct { struct { struct { struct {
 324                                 /* this one is one too much */
 325                                 struct {
 326                                         int b;
 327                                 };
 328                         }; }; }; }; };
 329                         }; }; }; }; };
 330                         }; }; }; }; };
 331                         }; }; }; }; };
 332                         }; }; }; }; };
 333                         }; }; }; }; };
 334                         }; }; }; }; };
 335                         }; }; }; }; };
 336                         }; }; }; }; };
 337                         }; }; }; }; };
 338                         }; }; }; }; };
 339                         }; }; }; }; };
 340                 } b;
 341         } b;
 342 };
 343
 344 /*
 345  * ARRAYS
 346  */
 347 struct core_reloc_arrays_output {
 348         int a2;
 349         char b123;
 350         int c1c;
 351         int d00d;
 352         int f10c;
 353 };
 354
 355 struct core_reloc_arrays_substruct {
 356         int c;
 357         int d;
 358 };
 359
 360 struct core_reloc_arrays {
 361         int a[5];
 362         char b[2][3][4];
 363         struct core_reloc_arrays_substruct c[3];
 364         struct core_reloc_arrays_substruct d[1][2];
 365         struct core_reloc_arrays_substruct f[][2];
 366 };
 367
 368 /* bigger array dimensions */
 369 struct core_reloc_arrays___diff_arr_dim {
 370         int a[7];
 371         char b[3][4][5];
 372         struct core_reloc_arrays_substruct c[4];
 373         struct core_reloc_arrays_substruct d[2][3];
 374         struct core_reloc_arrays_substruct f[1][3];
 375 };
 376
 377 /* different size of array's value (struct) */
 378 struct core_reloc_arrays___diff_arr_val_sz {
 379         int a[5];
 380         char b[2][3][4];
 381         struct {
 382                 int __padding1;
 383                 int c;
 384                 int __padding2;
 385         } c[3];
 386         struct {
 387                 int __padding1;
 388                 int d;
 389                 int __padding2;
 390         } d[1][2];
 391         struct {
 392                 int __padding1;
 393                 int c;
 394                 int __padding2;
 395         } f[][2];
 396 };
 397
 398 struct core_reloc_arrays___equiv_zero_sz_arr {
 399         int a[5];
 400         char b[2][3][4];
 401         struct core_reloc_arrays_substruct c[3];
 402         struct core_reloc_arrays_substruct d[1][2];
 403         /* equivalent to flexible array */
 404         struct core_reloc_arrays_substruct f[][2];
 405 };
 406
 407 struct core_reloc_arrays___fixed_arr {
 408         int a[5];
 409         char b[2][3][4];
 410         struct core_reloc_arrays_substruct c[3];
 411         struct core_reloc_arrays_substruct d[1][2];
 412         /* not a flexible array anymore, but within access bounds */
 413         struct core_reloc_arrays_substruct f[1][2];
 414 };
 415
 416 struct core_reloc_arrays___err_too_small {
 417         int a[2]; /* this one is too small */
 418         char b[2][3][4];
 419         struct core_reloc_arrays_substruct c[3];
 420         struct core_reloc_arrays_substruct d[1][2];
 421         struct core_reloc_arrays_substruct f[][2];
 422 };
 423
 424 struct core_reloc_arrays___err_too_shallow {
 425         int a[5];
 426         char b[2][3]; /* this one lacks one dimension */
 427         struct core_reloc_arrays_substruct c[3];
 428         struct core_reloc_arrays_substruct d[1][2];
 429         struct core_reloc_arrays_substruct f[][2];
 430 };
 431
 432 struct core_reloc_arrays___err_non_array {
 433         int a; /* not an array */
 434         char b[2][3][4];
 435         struct core_reloc_arrays_substruct c[3];
 436         struct core_reloc_arrays_substruct d[1][2];
 437         struct core_reloc_arrays_substruct f[][2];
 438 };
 439
 440 struct core_reloc_arrays___err_wrong_val_type {
 441         int a[5];
 442         char b[2][3][4];
 443         int c[3]; /* value is not a struct */
 444         struct core_reloc_arrays_substruct d[1][2];
 445         struct core_reloc_arrays_substruct f[][2];
 446 };
 447
 448 struct core_reloc_arrays___err_bad_zero_sz_arr {
 449         /* zero-sized array, but not at the end */
 450         struct core_reloc_arrays_substruct f[0][2];
 451         int a[5];
 452         char b[2][3][4];
 453         struct core_reloc_arrays_substruct c[3];
 454         struct core_reloc_arrays_substruct d[1][2];
 455 };
 456
 457 /*
 458  * PRIMITIVES
 459  */
 460 enum core_reloc_primitives_enum {
 461         A = 0,
 462         B = 1,
 463 };
 464
 465 struct core_reloc_primitives {
 466         char a;
 467         int b;
 468         enum core_reloc_primitives_enum c;
 469         void *d __bpf_aligned;
 470         int (*f)(const char *) __bpf_aligned;
 471 };
 472
 473 struct core_reloc_primitives___diff_enum_def {
 474         char a;
 475         int b;
 476         void *d __bpf_aligned;
 477         int (*f)(const char *) __bpf_aligned;
 478         enum {
 479                 X = 100,
 480                 Y = 200,
 481         } c __bpf_aligned; /* inline enum def with differing set of values */
 482 };
 483
 484 struct core_reloc_primitives___diff_func_proto {
 485         void (*f)(int) __bpf_aligned; /* incompatible function prototype */
 486         void *d __bpf_aligned;
 487         enum core_reloc_primitives_enum c __bpf_aligned;
 488         int b;
 489         char a;
 490 };
 491
 492 struct core_reloc_primitives___diff_ptr_type {
 493         const char * const d __bpf_aligned; /* different pointee type + modifiers */
 494         char a __bpf_aligned;
 495         int b;
 496         enum core_reloc_primitives_enum c;
 497         int (*f)(const char *) __bpf_aligned;
 498 };
 499
 500 struct core_reloc_primitives___err_non_enum {
 501         char a[1];
 502         int b;
 503         int c; /* int instead of enum */
 504         void *d __bpf_aligned;
 505         int (*f)(const char *) __bpf_aligned;
 506 };
 507
 508 struct core_reloc_primitives___err_non_int {
 509         char a[1];
 510         int *b __bpf_aligned; /* ptr instead of int */
 511         enum core_reloc_primitives_enum c __bpf_aligned;
 512         void *d __bpf_aligned;
 513         int (*f)(const char *) __bpf_aligned;
 514 };
 515
 516 struct core_reloc_primitives___err_non_ptr {
 517         char a[1];
 518         int b;
 519         enum core_reloc_primitives_enum c;
 520         int d; /* int instead of ptr */
 521         int (*f)(const char *) __bpf_aligned;
 522 };
 523
 524 /*
 525  * MODS
 526  */
 527 struct core_reloc_mods_output {
 528         int a, b, c, d, e, f, g, h;
 529 };
 530
 531 typedef const int int_t;
 532 typedef const char *char_ptr_t __bpf_aligned;
 533 typedef const int arr_t[7];
 534
 535 struct core_reloc_mods_substruct {
 536         int x;
 537         int y;
 538 };
 539
 540 typedef struct {
 541         int x;
 542         int y;
 543 } core_reloc_mods_substruct_t;
 544
 545 struct core_reloc_mods {
 546         int a;
 547         int_t b;
 548         char *c __bpf_aligned;
 549         char_ptr_t d;
 550         int e[3] __bpf_aligned;
 551         arr_t f;
 552         struct core_reloc_mods_substruct g;
 553         core_reloc_mods_substruct_t h;
 554 };
 555
 556 /* a/b, c/d, e/f, and g/h pairs are swapped */
 557 struct core_reloc_mods___mod_swap {
 558         int b;
 559         int_t a;
 560         char *d __bpf_aligned;
 561         char_ptr_t c;
 562         int f[3] __bpf_aligned;
 563         arr_t e;
 564         struct {
 565                 int y;
 566                 int x;
 567         } h;
 568         core_reloc_mods_substruct_t g;
 569 };
 570
 571 typedef int int1_t;
 572 typedef int1_t int2_t;
 573 typedef int2_t int3_t;
 574
 575 typedef int arr1_t[5];
 576 typedef arr1_t arr2_t;
 577 typedef arr2_t arr3_t;
 578 typedef arr3_t arr4_t;
 579
 580 typedef const char * const volatile fancy_char_ptr_t __bpf_aligned;
 581
 582 typedef core_reloc_mods_substruct_t core_reloc_mods_substruct_tt;
 583
 584 /* we need more typedefs */
 585 struct core_reloc_mods___typedefs {
 586         core_reloc_mods_substruct_tt g;
 587         core_reloc_mods_substruct_tt h;
 588         arr4_t f;
 589         arr4_t e;
 590         fancy_char_ptr_t d;
 591         fancy_char_ptr_t c;
 592         int3_t b __bpf_aligned;
 593         int3_t a;
 594 };
 595
 596 /*
 597  * PTR_AS_ARR
 598  */
 599 struct core_reloc_ptr_as_arr {
 600         int a;
 601 };
 602
 603 struct core_reloc_ptr_as_arr___diff_sz {
 604         int :32; /* padding */
 605         char __some_more_padding;
 606         int a;
 607 };
 608
 609 /*
 610  * INTS
 611  */
 612 struct core_reloc_ints {
 613         uint8_t         u8_field;
 614         int8_t          s8_field;
 615         uint16_t        u16_field;
 616         int16_t         s16_field;
 617         uint32_t        u32_field;
 618         int32_t         s32_field;
 619         uint64_t        u64_field;
 620         int64_t         s64_field;
 621 };
 622
 623 /* signed/unsigned types swap */
 624 struct core_reloc_ints___reverse_sign {
 625         int8_t          u8_field;
 626         uint8_t         s8_field;
 627         int16_t         u16_field;
 628         uint16_t        s16_field;
 629         int32_t         u32_field;
 630         uint32_t        s32_field;
 631         int64_t         u64_field;
 632         uint64_t        s64_field;
 633 };
 634
 635 struct core_reloc_ints___bool {
 636         bool            u8_field; /* bool instead of uint8 */
 637         int8_t          s8_field;
 638         uint16_t        u16_field;
 639         int16_t         s16_field;
 640         uint32_t        u32_field;
 641         int32_t         s32_field;
 642         uint64_t        u64_field;
 643         int64_t         s64_field;
 644 };
 645
 646 /*
 647  * MISC
 648  */
 649 struct core_reloc_misc_output {
 650         int a, b, c;
 651 };
 652
 653 struct core_reloc_misc___a {
 654         int a1;
 655         int a2;
 656 };
 657
 658 struct core_reloc_misc___b {
 659         int b1;
 660         int b2;
 661 };
 662
 663 /* this one extends core_reloc_misc_extensible struct from BPF prog */
 664 struct core_reloc_misc_extensible {
 665         int a;
 666         int b;
 667         int c;
 668         int d;
 669 };
 670
 671 /*
 672  * FIELD EXISTENCE
 673  */
 674 struct core_reloc_existence_output {
 675         int a_exists;
 676         int a_value;
 677         int b_exists;
 678         int b_value;
 679         int c_exists;
 680         int c_value;
 681         int arr_exists;
 682         int arr_value;
 683         int s_exists;
 684         int s_value;
 685 };
 686
 687 struct core_reloc_existence {
 688         int a;
 689         struct {
 690                 int b;
 691         };
 692         int c;
 693         int arr[1];
 694         struct {
 695                 int x;
 696         } s;
 697 };
 698
 699 struct core_reloc_existence___minimal {
 700         int a;
 701 };
 702
 703 struct core_reloc_existence___wrong_field_defs {
 704         void *a;
 705         int b[1];
 706         struct{ int x; } c;
 707         int arr;
 708         int s;
 709 };
 710
 711 /*
 712  * BITFIELDS
 713  */
 714 /* bitfield read results, all as plain integers */
 715 struct core_reloc_bitfields_output {
 716         int64_t         ub1;
 717         int64_t         ub2;
 718         int64_t         ub7;
 719         int64_t         sb4;
 720         int64_t         sb20;
 721         int64_t         u32;
 722         int64_t         s32;
 723 };
 724
 725 struct core_reloc_bitfields {
 726         /* unsigned bitfields */
 727         uint8_t         ub1: 1;
 728         uint8_t         ub2: 2;
 729         uint32_t        ub7: 7;
 730         /* signed bitfields */
 731         int8_t          sb4: 4;
 732         int32_t         sb20: 20;
 733         /* non-bitfields */
 734         uint32_t        u32;
 735         int32_t         s32;
 736 };
 737
 738 /* different bit sizes (both up and down) */
 739 struct core_reloc_bitfields___bit_sz_change {
 740         /* unsigned bitfields */
 741         uint16_t        ub1: 3;         /*  1 ->  3 */
 742         uint32_t        ub2: 20;        /*  2 -> 20 */
 743         uint8_t         ub7: 1;         /*  7 ->  1 */
 744         /* signed bitfields */
 745         int8_t          sb4: 1;         /*  4 ->  1 */
 746         int32_t         sb20: 30;       /* 20 -> 30 */
 747         /* non-bitfields */
 748         uint16_t        u32;                    /* 32 -> 16 */
 749         int64_t         s32 __bpf_aligned;      /* 32 -> 64 */
 750 };
 751
 752 /* turn bitfield into non-bitfield and vice versa */
 753 struct core_reloc_bitfields___bitfield_vs_int {
 754         uint64_t        ub1;            /*  3 -> 64 non-bitfield */
 755         uint8_t         ub2;            /* 20 ->  8 non-bitfield */
 756         int64_t         ub7 __bpf_aligned;      /*  7 -> 64 non-bitfield signed */
 757         int64_t         sb4 __bpf_aligned;      /*  4 -> 64 non-bitfield signed */
 758         uint64_t        sb20 __bpf_aligned;     /* 20 -> 16 non-bitfield unsigned */
 759         int32_t         u32: 20;                /* 32 non-bitfield -> 20 bitfield */
 760         uint64_t        s32: 60 __bpf_aligned;  /* 32 non-bitfield -> 60 bitfield */
 761 };
 762
 763 struct core_reloc_bitfields___just_big_enough {
 764         uint64_t        ub1: 4;
 765         uint64_t        ub2: 60; /* packed tightly */
 766         uint32_t        ub7;
 767         uint32_t        sb4;
 768         uint32_t        sb20;
 769         uint32_t        u32;
 770         uint32_t        s32;
 771 } __attribute__((packed)) ;
 772
 773 struct core_reloc_bitfields___err_too_big_bitfield {
 774         uint64_t        ub1: 4;
 775         uint64_t        ub2: 61; /* packed tightly */
 776         uint32_t        ub7;
 777         uint32_t        sb4;
 778         uint32_t        sb20;
 779         uint32_t        u32;
 780         uint32_t        s32;
 781 } __attribute__((packed)) ;
 782
 783 /*
 784  * SIZE
 785  */
 786 struct core_reloc_size_output {
 787         int int_sz;
 788         int int_off;
 789         int struct_sz;
 790         int struct_off;
 791         int union_sz;
 792         int union_off;
 793         int arr_sz;
 794         int arr_off;
 795         int arr_elem_sz;
 796         int arr_elem_off;
 797         int ptr_sz;
 798         int ptr_off;
 799         int enum_sz;
 800         int enum_off;
 801         int float_sz;
 802         int float_off;
 803 };
 804
 805 struct core_reloc_size {
 806         int int_field;
 807         struct { int x; } struct_field;
 808         union { int x; } union_field;
 809         int arr_field[4];
 810         void *ptr_field;
 811         enum { VALUE = 123 } enum_field;
 812         float float_field;
 813 };
 814
 815 struct core_reloc_size___diff_sz {
 816         uint64_t int_field;
 817         struct { int x; int y; int z; } struct_field;
 818         union { int x; char bla[123]; } union_field;
 819         char arr_field[10];
 820         void *ptr_field;
 821         enum { OTHER_VALUE = 0xFFFFFFFFFFFFFFFF } enum_field;
 822         double float_field;
 823 };
 824
 825 struct core_reloc_size___diff_offs {
 826         float float_field;
 827         enum { YET_OTHER_VALUE = 123 } enum_field;
 828         void *ptr_field;
 829         int arr_field[4];
 830         union { int x; } union_field;
 831         struct { int x; } struct_field;
 832         int int_field;
 833 };
 834
 835 /* Error case of two candidates with the fields (int_field) at the same
 836  * offset, but with differing final relocation values: size 4 vs size 1
 837  */
 838 struct core_reloc_size___err_ambiguous1 {
 839         /* int at offset 0 */
 840         int int_field;
 841
 842         struct { int x; } struct_field;
 843         union { int x; } union_field;
 844         int arr_field[4];
 845         void *ptr_field;
 846         enum { VALUE___1 = 123 } enum_field;
 847         float float_field;
 848 };
 849
 850 struct core_reloc_size___err_ambiguous2 {
 851         /* char at offset 0 */
 852         char int_field;
 853
 854         struct { int x; } struct_field;
 855         union { int x; } union_field;
 856         int arr_field[4];
 857         void *ptr_field;
 858         enum { VALUE___2 = 123 } enum_field;
 859         float float_field;
 860 };
 861
 862 /*
 863  * TYPE EXISTENCE, MATCH & SIZE
 864  */
 865 struct core_reloc_type_based_output {
 866         bool struct_exists;
 867         bool union_exists;
 868         bool enum_exists;
 869         bool typedef_named_struct_exists;
 870         bool typedef_anon_struct_exists;
 871         bool typedef_struct_ptr_exists;
 872         bool typedef_int_exists;
 873         bool typedef_enum_exists;
 874         bool typedef_void_ptr_exists;
 875         bool typedef_func_proto_exists;
 876         bool typedef_arr_exists;
 877
 878         bool struct_matches;
 879         bool union_matches;
 880         bool enum_matches;
 881         bool typedef_named_struct_matches;
 882         bool typedef_anon_struct_matches;
 883         bool typedef_struct_ptr_matches;
 884         bool typedef_int_matches;
 885         bool typedef_enum_matches;
 886         bool typedef_void_ptr_matches;
 887         bool typedef_func_proto_matches;
 888         bool typedef_arr_matches;
 889
 890         int struct_sz;
 891         int union_sz;
 892         int enum_sz;
 893         int typedef_named_struct_sz;
 894         int typedef_anon_struct_sz;
 895         int typedef_struct_ptr_sz;
 896         int typedef_int_sz;
 897         int typedef_enum_sz;
 898         int typedef_void_ptr_sz;
 899         int typedef_func_proto_sz;
 900         int typedef_arr_sz;
 901 };
 902
 903 struct a_struct {
 904         int x;
 905 };
 906
 907 union a_union {
 908         int y;
 909         int z;
 910 };
 911
 912 typedef struct a_struct named_struct_typedef;
 913
 914 typedef struct { int x, y, z; } anon_struct_typedef;
 915
 916 typedef struct {
 917         int a, b, c;
 918 } *struct_ptr_typedef;
 919
 920 enum an_enum {
 921         AN_ENUM_VAL1 = 1,
 922         AN_ENUM_VAL2 = 2,
 923         AN_ENUM_VAL3 = 3,
 924 };
 925
 926 typedef int int_typedef;
 927
 928 typedef enum { TYPEDEF_ENUM_VAL1, TYPEDEF_ENUM_VAL2 } enum_typedef;
 929
 930 typedef void *void_ptr_typedef;
 931
 932 typedef int (*func_proto_typedef)(long);
 933
 934 typedef char arr_typedef[20];
 935
 936 struct core_reloc_type_based {
 937         struct a_struct f1;
 938         union a_union f2;
 939         enum an_enum f3;
 940         named_struct_typedef f4;
 941         anon_struct_typedef f5;
 942         struct_ptr_typedef f6;
 943         int_typedef f7;
 944         enum_typedef f8;
 945         void_ptr_typedef f9;
 946         func_proto_typedef f10;
 947         arr_typedef f11;
 948 };
 949
 950 /* no types in target */
 951 struct core_reloc_type_based___all_missing {
 952 };
 953
 954 /* different member orders, enum variant values, signedness, etc */
 955 struct a_struct___diff {
 956         int x;
 957         int a;
 958 };
 959
 960 union a_union___diff {
 961         int z;
 962         int y;
 963 };
 964
 965 typedef struct a_struct___diff named_struct_typedef___diff;
 966
 967 typedef struct { int z, x, y; } anon_struct_typedef___diff;
 968
 969 typedef struct {
 970         int c;
 971         int b;
 972         int a;
 973 } *struct_ptr_typedef___diff;
 974
 975 enum an_enum___diff {
 976         AN_ENUM_VAL2___diff = 0,
 977         AN_ENUM_VAL1___diff = 42,
 978         AN_ENUM_VAL3___diff = 1,
 979 };
 980
 981 typedef unsigned int int_typedef___diff;
 982
 983 typedef enum { TYPEDEF_ENUM_VAL2___diff, TYPEDEF_ENUM_VAL1___diff = 50 } enum_typedef___diff;
 984
 985 typedef const void *void_ptr_typedef___diff;
 986
 987 typedef int_typedef___diff (*func_proto_typedef___diff)(long);
 988
 989 typedef char arr_typedef___diff[3];
 990
 991 struct core_reloc_type_based___diff {
 992         struct a_struct___diff f1;
 993         union a_union___diff f2;
 994         enum an_enum___diff f3;
 995         named_struct_typedef___diff f4;
 996         anon_struct_typedef___diff f5;
 997         struct_ptr_typedef___diff f6;
 998         int_typedef___diff f7;
 999         enum_typedef___diff f8;
1000         void_ptr_typedef___diff f9;
1001         func_proto_typedef___diff f10;
1002         arr_typedef___diff f11;
1003 };
1004
1005 /* different type sizes, extra modifiers, anon vs named enums, etc */
1006 struct a_struct___diff_sz {
1007         long x;
1008         int y;
1009         char z;
1010 };
1011
1012 union a_union___diff_sz {
1013         char yy;
1014         char zz;
1015 };
1016
1017 typedef struct a_struct___diff_sz named_struct_typedef___diff_sz;
1018
1019 typedef struct { long xx, yy, zzz; } anon_struct_typedef___diff_sz;
1020
1021 typedef struct {
1022         char aa[1], bb[2], cc[3];
1023 } *struct_ptr_typedef___diff_sz;
1024
1025 enum an_enum___diff_sz {
1026         AN_ENUM_VAL1___diff_sz = 0x123412341234,
1027         AN_ENUM_VAL2___diff_sz = 2,
1028 };
1029
1030 typedef unsigned long int_typedef___diff_sz;
1031
1032 typedef enum an_enum___diff_sz enum_typedef___diff_sz;
1033
1034 typedef const void * const void_ptr_typedef___diff_sz;
1035
1036 typedef int_typedef___diff_sz (*func_proto_typedef___diff_sz)(char);
1037
1038 typedef int arr_typedef___diff_sz[2];
1039
1040 struct core_reloc_type_based___diff_sz {
1041         struct a_struct___diff_sz f1;
1042         union a_union___diff_sz f2;
1043         enum an_enum___diff_sz f3;
1044         named_struct_typedef___diff_sz f4;
1045         anon_struct_typedef___diff_sz f5;
1046         struct_ptr_typedef___diff_sz f6;
1047         int_typedef___diff_sz f7;
1048         enum_typedef___diff_sz f8;
1049         void_ptr_typedef___diff_sz f9;
1050         func_proto_typedef___diff_sz f10;
1051         arr_typedef___diff_sz f11;
1052 };
1053
1054 /* incompatibilities between target and local types */
1055 union a_struct___incompat { /* union instead of struct */
1056         int x;
1057 };
1058
1059 struct a_union___incompat { /* struct instead of union */
1060         int y;
1061         int z;
1062 };
1063
1064 /* typedef to union, not to struct */
1065 typedef union a_struct___incompat named_struct_typedef___incompat;
1066
1067 /* typedef to void pointer, instead of struct */
1068 typedef void *anon_struct_typedef___incompat;
1069
1070 /* extra pointer indirection */
1071 typedef struct {
1072         int a, b, c;
1073 } **struct_ptr_typedef___incompat;
1074
1075 /* typedef of a struct with int, instead of int */
1076 typedef struct { int x; } int_typedef___incompat;
1077
1078 /* typedef to func_proto, instead of enum */
1079 typedef int (*enum_typedef___incompat)(void);
1080
1081 /* pointer to char instead of void */
1082 typedef char *void_ptr_typedef___incompat;
1083
1084 /* void return type instead of int */
1085 typedef void (*func_proto_typedef___incompat)(long);
1086
1087 /* multi-dimensional array instead of a single-dimensional */
1088 typedef int arr_typedef___incompat[20][2];
1089
1090 struct core_reloc_type_based___incompat {
1091         union a_struct___incompat f1;
1092         struct a_union___incompat f2;
1093         /* the only valid one is enum, to check that something still succeeds */
1094         enum an_enum f3;
1095         named_struct_typedef___incompat f4;
1096         anon_struct_typedef___incompat f5;
1097         struct_ptr_typedef___incompat f6;
1098         int_typedef___incompat f7;
1099         enum_typedef___incompat f8;
1100         void_ptr_typedef___incompat f9;
1101         func_proto_typedef___incompat f10;
1102         arr_typedef___incompat f11;
1103 };
1104
1105 /* func_proto with incompatible signature */
1106 typedef void (*func_proto_typedef___fn_wrong_ret1)(long);
1107 typedef int * (*func_proto_typedef___fn_wrong_ret2)(long);
1108 typedef struct { int x; } int_struct_typedef;
1109 typedef int_struct_typedef (*func_proto_typedef___fn_wrong_ret3)(long);
1110 typedef int (*func_proto_typedef___fn_wrong_arg)(void *);
1111 typedef int (*func_proto_typedef___fn_wrong_arg_cnt1)(long, long);
1112 typedef int (*func_proto_typedef___fn_wrong_arg_cnt2)(void);
1113
1114 struct core_reloc_type_based___fn_wrong_args {
1115         /* one valid type to make sure relos still work */
1116         struct a_struct f1;
1117         func_proto_typedef___fn_wrong_ret1 f2;
1118         func_proto_typedef___fn_wrong_ret2 f3;
1119         func_proto_typedef___fn_wrong_ret3 f4;
1120         func_proto_typedef___fn_wrong_arg f5;
1121         func_proto_typedef___fn_wrong_arg_cnt1 f6;
1122         func_proto_typedef___fn_wrong_arg_cnt2 f7;
1123 };
1124
1125 /*
1126  * TYPE ID MAPPING (LOCAL AND TARGET)
1127  */
1128 struct core_reloc_type_id_output {
1129         int local_anon_struct;
1130         int local_anon_union;
1131         int local_anon_enum;
1132         int local_anon_func_proto_ptr;
1133         int local_anon_void_ptr;
1134         int local_anon_arr;
1135
1136         int local_struct;
1137         int local_union;
1138         int local_enum;
1139         int local_int;
1140         int local_struct_typedef;
1141         int local_func_proto_typedef;
1142         int local_arr_typedef;
1143
1144         int targ_struct;
1145         int targ_union;
1146         int targ_enum;
1147         int targ_int;
1148         int targ_struct_typedef;
1149         int targ_func_proto_typedef;
1150         int targ_arr_typedef;
1151 };
1152
1153 struct core_reloc_type_id {
1154         struct a_struct f1;
1155         union a_union f2;
1156         enum an_enum f3;
1157         named_struct_typedef f4;
1158         func_proto_typedef f5;
1159         arr_typedef f6;
1160 };
1161
1162 struct core_reloc_type_id___missing_targets {
1163         /* nothing */
1164 };
1165
1166 /*
1167  * ENUMERATOR VALUE EXISTENCE AND VALUE RELOCATION
1168  */
1169 struct core_reloc_enumval_output {
1170         bool named_val1_exists;
1171         bool named_val2_exists;
1172         bool named_val3_exists;
1173         bool anon_val1_exists;
1174         bool anon_val2_exists;
1175         bool anon_val3_exists;
1176
1177         int named_val1;
1178         int named_val2;
1179         int anon_val1;
1180         int anon_val2;
1181 };
1182
1183 struct core_reloc_enum64val_output {
1184         bool unsigned_val1_exists;
1185         bool unsigned_val2_exists;
1186         bool unsigned_val3_exists;
1187         bool signed_val1_exists;
1188         bool signed_val2_exists;
1189         bool signed_val3_exists;
1190
1191         long unsigned_val1;
1192         long unsigned_val2;
1193         long signed_val1;
1194         long signed_val2;
1195 };
1196
1197 enum named_enum {
1198         NAMED_ENUM_VAL1 = 1,
1199         NAMED_ENUM_VAL2 = 2,
1200         NAMED_ENUM_VAL3 = 3,
1201 };
1202
1203 typedef enum {
1204         ANON_ENUM_VAL1 = 0x10,
1205         ANON_ENUM_VAL2 = 0x20,
1206         ANON_ENUM_VAL3 = 0x30,
1207 } anon_enum;
1208
1209 struct core_reloc_enumval {
1210         enum named_enum f1;
1211         anon_enum f2;
1212 };
1213
1214 enum named_unsigned_enum64 {
1215         UNSIGNED_ENUM64_VAL1 = 0x1ffffffffULL,
1216         UNSIGNED_ENUM64_VAL2 = 0x2,
1217         UNSIGNED_ENUM64_VAL3 = 0x3ffffffffULL,
1218 };
1219
1220 enum named_signed_enum64 {
1221         SIGNED_ENUM64_VAL1 = 0x1ffffffffLL,
1222         SIGNED_ENUM64_VAL2 = -2,
1223         SIGNED_ENUM64_VAL3 = 0x3ffffffffLL,
1224 };
1225
1226 struct core_reloc_enum64val {
1227         enum named_unsigned_enum64 f1;
1228         enum named_signed_enum64 f2;
1229 };
1230
1231 /* differing enumerator values */
1232 enum named_enum___diff {
1233         NAMED_ENUM_VAL1___diff = 101,
1234         NAMED_ENUM_VAL2___diff = 202,
1235         NAMED_ENUM_VAL3___diff = 303,
1236 };
1237
1238 typedef enum {
1239         ANON_ENUM_VAL1___diff = 0x11,
1240         ANON_ENUM_VAL2___diff = 0x22,
1241         ANON_ENUM_VAL3___diff = 0x33,
1242 } anon_enum___diff;
1243
1244 struct core_reloc_enumval___diff {
1245         enum named_enum___diff f1;
1246         anon_enum___diff f2;
1247 };
1248
1249 enum named_unsigned_enum64___diff {
1250         UNSIGNED_ENUM64_VAL1___diff = 0x101ffffffffULL,
1251         UNSIGNED_ENUM64_VAL2___diff = 0x202ffffffffULL,
1252         UNSIGNED_ENUM64_VAL3___diff = 0x303ffffffffULL,
1253 };
1254
1255 enum named_signed_enum64___diff {
1256         SIGNED_ENUM64_VAL1___diff = -101,
1257         SIGNED_ENUM64_VAL2___diff = -202,
1258         SIGNED_ENUM64_VAL3___diff = -303,
1259 };
1260
1261 struct core_reloc_enum64val___diff {
1262         enum named_unsigned_enum64___diff f1;
1263         enum named_signed_enum64___diff f2;
1264 };
1265
1266 /* missing (optional) third enum value */
1267 enum named_enum___val3_missing {
1268         NAMED_ENUM_VAL1___val3_missing = 111,
1269         NAMED_ENUM_VAL2___val3_missing = 222,
1270 };
1271
1272 typedef enum {
1273         ANON_ENUM_VAL1___val3_missing = 0x111,
1274         ANON_ENUM_VAL2___val3_missing = 0x222,
1275 } anon_enum___val3_missing;
1276
1277 struct core_reloc_enumval___val3_missing {
1278         enum named_enum___val3_missing f1;
1279         anon_enum___val3_missing f2;
1280 };
1281
1282 enum named_unsigned_enum64___val3_missing {
1283         UNSIGNED_ENUM64_VAL1___val3_missing = 0x111ffffffffULL,
1284         UNSIGNED_ENUM64_VAL2___val3_missing = 0x222,
1285 };
1286
1287 enum named_signed_enum64___val3_missing {
1288         SIGNED_ENUM64_VAL1___val3_missing = 0x111ffffffffLL,
1289         SIGNED_ENUM64_VAL2___val3_missing = -222,
1290 };
1291
1292 struct core_reloc_enum64val___val3_missing {
1293         enum named_unsigned_enum64___val3_missing f1;
1294         enum named_signed_enum64___val3_missing f2;
1295 };
1296
1297 /* missing (mandatory) second enum value, should fail */
1298 enum named_enum___err_missing {
1299         NAMED_ENUM_VAL1___err_missing = 1,
1300         NAMED_ENUM_VAL3___err_missing = 3,
1301 };
1302
1303 typedef enum {
1304         ANON_ENUM_VAL1___err_missing = 0x111,
1305         ANON_ENUM_VAL3___err_missing = 0x222,
1306 } anon_enum___err_missing;
1307
1308 struct core_reloc_enumval___err_missing {
1309         enum named_enum___err_missing f1;
1310         anon_enum___err_missing f2;
1311 };
1312
1313 enum named_unsigned_enum64___err_missing {
1314         UNSIGNED_ENUM64_VAL1___err_missing = 0x1ffffffffULL,
1315         UNSIGNED_ENUM64_VAL3___err_missing = 0x3ffffffffULL,
1316 };
1317
1318 enum named_signed_enum64___err_missing {
1319         SIGNED_ENUM64_VAL1___err_missing = 0x1ffffffffLL,
1320         SIGNED_ENUM64_VAL3___err_missing = -3,
1321 };
1322
1323 struct core_reloc_enum64val___err_missing {
1324         enum named_unsigned_enum64___err_missing f1;
1325         enum named_signed_enum64___err_missing f2;
1326 };