LXR linux/tools/testing/selftests/bpf/progs/core_reloc

   1#include <stdint.h>
   2#include <stdbool.h>
   3
   4void preserce_ptr_sz_fn(long x) {}
   5
   6#define __bpf_aligned __attribute__((aligned(8)))
   7
   8/*
   9 * KERNEL
  10 */
  11
  12struct 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
  22struct 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 */
  38struct 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 */
  45struct 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 */
  55struct core_reloc_nesting_substruct {
  56        int a;
  57};
  58
  59union core_reloc_nesting_subunion {
  60        int b;
  61};
  62
  63struct 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 */
  73struct 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 */
  88struct 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 */
 108struct 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 */
 137struct 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
 153struct 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
 175struct 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 */
 191struct 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 */
 205struct 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 */
 219struct 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 */
 231struct 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 */
 245struct 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 */
 259struct 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
 272struct 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 */
 287struct core_reloc_nesting___err_partial_match_dups__a {
 288        struct {
 289                struct {
 290                        int a;
 291                } a;
 292        } a;
 293};
 294
 295struct core_reloc_nesting___err_partial_match_dups__b {
 296        struct {
 297                struct {
 298                        int b;
 299                } b;
 300        } b;
 301};
 302
 303struct 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 */
 347struct core_reloc_arrays_output {
 348        int a2;
 349        char b123;
 350        int c1c;
 351        int d00d;
 352        int f10c;
 353};
 354
 355struct core_reloc_arrays_substruct {
 356        int c;
 357        int d;
 358};
 359
 360struct 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 */
 369struct 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) */
 378struct 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
 398struct 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
 407struct 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
 416struct 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
 424struct 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
 432struct 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
 440struct 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
 448struct 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 */
 460enum core_reloc_primitives_enum {
 461        A = 0,
 462        B = 1,
 463};
 464
 465struct 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
 473struct 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
 484struct 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
 492struct 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
 500struct 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
 508struct 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
 516struct 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 */
 527struct core_reloc_mods_output {
 528        int a, b, c, d, e, f, g, h;
 529};
 530
 531typedef const int int_t;
 532typedef const char *char_ptr_t __bpf_aligned;
 533typedef const int arr_t[7];
 534
 535struct core_reloc_mods_substruct {
 536        int x;
 537        int y;
 538};
 539
 540typedef struct {
 541        int x;
 542        int y;
 543} core_reloc_mods_substruct_t;
 544
 545struct 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 */
 557struct 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
 571typedef int int1_t;
 572typedef int1_t int2_t;
 573typedef int2_t int3_t;
 574
 575typedef int arr1_t[5];
 576typedef arr1_t arr2_t;
 577typedef arr2_t arr3_t;
 578typedef arr3_t arr4_t;
 579
 580typedef const char * const volatile fancy_char_ptr_t __bpf_aligned;
 581
 582typedef core_reloc_mods_substruct_t core_reloc_mods_substruct_tt;
 583
 584/* we need more typedefs */
 585struct 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 */
 599struct core_reloc_ptr_as_arr {
 600        int a;
 601};
 602
 603struct 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 */
 612struct 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 */
 624struct 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
 635struct 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 */
 649struct core_reloc_misc_output {
 650        int a, b, c;
 651};
 652
 653struct core_reloc_misc___a {
 654        int a1;
 655        int a2;
 656};
 657
 658struct core_reloc_misc___b {
 659        int b1;
 660        int b2;
 661};
 662
 663/* this one extends core_reloc_misc_extensible struct from BPF prog */
 664struct core_reloc_misc_extensible {
 665        int a;
 666        int b;
 667        int c;
 668        int d;
 669};
 670
 671/*
 672 * FIELD EXISTENCE
 673 */
 674struct 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
 687struct 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
 699struct core_reloc_existence___minimal {
 700        int a;
 701};
 702
 703struct 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 */
 715struct 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
 725struct 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) */
 739struct 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 */
 753struct 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
 763struct 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
 773struct 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 */
 786struct core_reloc_size_output {
 787        int int_sz;
 788        int struct_sz;
 789        int union_sz;
 790        int arr_sz;
 791        int arr_elem_sz;
 792        int ptr_sz;
 793        int enum_sz;
 794        int float_sz;
 795};
 796
 797struct core_reloc_size {
 798        int int_field;
 799        struct { int x; } struct_field;
 800        union { int x; } union_field;
 801        int arr_field[4];
 802        void *ptr_field;
 803        enum { VALUE = 123 } enum_field;
 804        float float_field;
 805};
 806
 807struct core_reloc_size___diff_sz {
 808        uint64_t int_field;
 809        struct { int x; int y; int z; } struct_field;
 810        union { int x; char bla[123]; } union_field;
 811        char arr_field[10];
 812        void *ptr_field;
 813        enum { OTHER_VALUE = 0xFFFFFFFFFFFFFFFF } enum_field;
 814        double float_field;
 815};
 816
 817/* Error case of two candidates with the fields (int_field) at the same
 818 * offset, but with differing final relocation values: size 4 vs size 1
 819 */
 820struct core_reloc_size___err_ambiguous1 {
 821        /* int at offset 0 */
 822        int int_field;
 823
 824        struct { int x; } struct_field;
 825        union { int x; } union_field;
 826        int arr_field[4];
 827        void *ptr_field;
 828        enum { VALUE___1 = 123 } enum_field;
 829        float float_field;
 830};
 831
 832struct core_reloc_size___err_ambiguous2 {
 833        /* char at offset 0 */
 834        char int_field;
 835
 836        struct { int x; } struct_field;
 837        union { int x; } union_field;
 838        int arr_field[4];
 839        void *ptr_field;
 840        enum { VALUE___2 = 123 } enum_field;
 841        float float_field;
 842};
 843
 844/*
 845 * TYPE EXISTENCE & SIZE
 846 */
 847struct core_reloc_type_based_output {
 848        bool struct_exists;
 849        bool union_exists;
 850        bool enum_exists;
 851        bool typedef_named_struct_exists;
 852        bool typedef_anon_struct_exists;
 853        bool typedef_struct_ptr_exists;
 854        bool typedef_int_exists;
 855        bool typedef_enum_exists;
 856        bool typedef_void_ptr_exists;
 857        bool typedef_func_proto_exists;
 858        bool typedef_arr_exists;
 859
 860        int struct_sz;
 861        int union_sz;
 862        int enum_sz;
 863        int typedef_named_struct_sz;
 864        int typedef_anon_struct_sz;
 865        int typedef_struct_ptr_sz;
 866        int typedef_int_sz;
 867        int typedef_enum_sz;
 868        int typedef_void_ptr_sz;
 869        int typedef_func_proto_sz;
 870        int typedef_arr_sz;
 871};
 872
 873struct a_struct {
 874        int x;
 875};
 876
 877union a_union {
 878        int y;
 879        int z;
 880};
 881
 882typedef struct a_struct named_struct_typedef;
 883
 884typedef struct { int x, y, z; } anon_struct_typedef;
 885
 886typedef struct {
 887        int a, b, c;
 888} *struct_ptr_typedef;
 889
 890enum an_enum {
 891        AN_ENUM_VAL1 = 1,
 892        AN_ENUM_VAL2 = 2,
 893        AN_ENUM_VAL3 = 3,
 894};
 895
 896typedef int int_typedef;
 897
 898typedef enum { TYPEDEF_ENUM_VAL1, TYPEDEF_ENUM_VAL2 } enum_typedef;
 899
 900typedef void *void_ptr_typedef;
 901
 902typedef int (*func_proto_typedef)(long);
 903
 904typedef char arr_typedef[20];
 905
 906struct core_reloc_type_based {
 907        struct a_struct f1;
 908        union a_union f2;
 909        enum an_enum f3;
 910        named_struct_typedef f4;
 911        anon_struct_typedef f5;
 912        struct_ptr_typedef f6;
 913        int_typedef f7;
 914        enum_typedef f8;
 915        void_ptr_typedef f9;
 916        func_proto_typedef f10;
 917        arr_typedef f11;
 918};
 919
 920/* no types in target */
 921struct core_reloc_type_based___all_missing {
 922};
 923
 924/* different type sizes, extra modifiers, anon vs named enums, etc */
 925struct a_struct___diff_sz {
 926        long x;
 927        int y;
 928        char z;
 929};
 930
 931union a_union___diff_sz {
 932        char yy;
 933        char zz;
 934};
 935
 936typedef struct a_struct___diff_sz named_struct_typedef___diff_sz;
 937
 938typedef struct { long xx, yy, zzz; } anon_struct_typedef___diff_sz;
 939
 940typedef struct {
 941        char aa[1], bb[2], cc[3];
 942} *struct_ptr_typedef___diff_sz;
 943
 944enum an_enum___diff_sz {
 945        AN_ENUM_VAL1___diff_sz = 0x123412341234,
 946        AN_ENUM_VAL2___diff_sz = 2,
 947};
 948
 949typedef unsigned long int_typedef___diff_sz;
 950
 951typedef enum an_enum___diff_sz enum_typedef___diff_sz;
 952
 953typedef const void * const void_ptr_typedef___diff_sz;
 954
 955typedef int_typedef___diff_sz (*func_proto_typedef___diff_sz)(char);
 956
 957typedef int arr_typedef___diff_sz[2];
 958
 959struct core_reloc_type_based___diff_sz {
 960        struct a_struct___diff_sz f1;
 961        union a_union___diff_sz f2;
 962        enum an_enum___diff_sz f3;
 963        named_struct_typedef___diff_sz f4;
 964        anon_struct_typedef___diff_sz f5;
 965        struct_ptr_typedef___diff_sz f6;
 966        int_typedef___diff_sz f7;
 967        enum_typedef___diff_sz f8;
 968        void_ptr_typedef___diff_sz f9;
 969        func_proto_typedef___diff_sz f10;
 970        arr_typedef___diff_sz f11;
 971};
 972
 973/* incompatibilities between target and local types */
 974union a_struct___incompat { /* union instead of struct */
 975        int x;
 976};
 977
 978struct a_union___incompat { /* struct instead of union */
 979        int y;
 980        int z;
 981};
 982
 983/* typedef to union, not to struct */
 984typedef union a_struct___incompat named_struct_typedef___incompat;
 985
 986/* typedef to void pointer, instead of struct */
 987typedef void *anon_struct_typedef___incompat;
 988
 989/* extra pointer indirection */
 990typedef struct {
 991        int a, b, c;
 992} **struct_ptr_typedef___incompat;
 993
 994/* typedef of a struct with int, instead of int */
 995typedef struct { int x; } int_typedef___incompat;
 996
 997/* typedef to func_proto, instead of enum */
 998typedef int (*enum_typedef___incompat)(void);
 999
1000/* pointer to char instead of void */

1001typedef char *void_ptr_typedef___incompat;
1002
1003/* void return type instead of int */
1004typedef void (*func_proto_typedef___incompat)(long);
1005
1006/* multi-dimensional array instead of a single-dimensional */
1007typedef int arr_typedef___incompat[20][2];
1008
1009struct core_reloc_type_based___incompat {
1010        union a_struct___incompat f1;
1011        struct a_union___incompat f2;
1012        /* the only valid one is enum, to check that something still succeeds */
1013        enum an_enum f3;
1014        named_struct_typedef___incompat f4;
1015        anon_struct_typedef___incompat f5;
1016        struct_ptr_typedef___incompat f6;
1017        int_typedef___incompat f7;
1018        enum_typedef___incompat f8;
1019        void_ptr_typedef___incompat f9;
1020        func_proto_typedef___incompat f10;
1021        arr_typedef___incompat f11;
1022};
1023
1024/* func_proto with incompatible signature */
1025typedef void (*func_proto_typedef___fn_wrong_ret1)(long);
1026typedef int * (*func_proto_typedef___fn_wrong_ret2)(long);
1027typedef struct { int x; } int_struct_typedef;
1028typedef int_struct_typedef (*func_proto_typedef___fn_wrong_ret3)(long);
1029typedef int (*func_proto_typedef___fn_wrong_arg)(void *);
1030typedef int (*func_proto_typedef___fn_wrong_arg_cnt1)(long, long);
1031typedef int (*func_proto_typedef___fn_wrong_arg_cnt2)(void);
1032
1033struct core_reloc_type_based___fn_wrong_args {
1034        /* one valid type to make sure relos still work */
1035        struct a_struct f1;
1036        func_proto_typedef___fn_wrong_ret1 f2;
1037        func_proto_typedef___fn_wrong_ret2 f3;
1038        func_proto_typedef___fn_wrong_ret3 f4;
1039        func_proto_typedef___fn_wrong_arg f5;
1040        func_proto_typedef___fn_wrong_arg_cnt1 f6;
1041        func_proto_typedef___fn_wrong_arg_cnt2 f7;
1042};
1043
1044/*
1045 * TYPE ID MAPPING (LOCAL AND TARGET)
1046 */
1047struct core_reloc_type_id_output {
1048        int local_anon_struct;
1049        int local_anon_union;
1050        int local_anon_enum;
1051        int local_anon_func_proto_ptr;
1052        int local_anon_void_ptr;
1053        int local_anon_arr;
1054
1055        int local_struct;
1056        int local_union;
1057        int local_enum;
1058        int local_int;
1059        int local_struct_typedef;
1060        int local_func_proto_typedef;
1061        int local_arr_typedef;
1062
1063        int targ_struct;
1064        int targ_union;
1065        int targ_enum;
1066        int targ_int;
1067        int targ_struct_typedef;
1068        int targ_func_proto_typedef;
1069        int targ_arr_typedef;
1070};
1071
1072struct core_reloc_type_id {
1073        struct a_struct f1;
1074        union a_union f2;
1075        enum an_enum f3;
1076        named_struct_typedef f4;
1077        func_proto_typedef f5;
1078        arr_typedef f6;
1079};
1080
1081struct core_reloc_type_id___missing_targets {
1082        /* nothing */
1083};
1084
1085/*
1086 * ENUMERATOR VALUE EXISTENCE AND VALUE RELOCATION
1087 */
1088struct core_reloc_enumval_output {
1089        bool named_val1_exists;
1090        bool named_val2_exists;
1091        bool named_val3_exists;
1092        bool anon_val1_exists;
1093        bool anon_val2_exists;
1094        bool anon_val3_exists;
1095
1096        int named_val1;
1097        int named_val2;
1098        int anon_val1;
1099        int anon_val2;
1100};
1101
1102enum named_enum {
1103        NAMED_ENUM_VAL1 = 1,
1104        NAMED_ENUM_VAL2 = 2,
1105        NAMED_ENUM_VAL3 = 3,
1106};
1107
1108typedef enum {
1109        ANON_ENUM_VAL1 = 0x10,
1110        ANON_ENUM_VAL2 = 0x20,
1111        ANON_ENUM_VAL3 = 0x30,
1112} anon_enum;
1113
1114struct core_reloc_enumval {
1115        enum named_enum f1;
1116        anon_enum f2;
1117};
1118
1119/* differing enumerator values */
1120enum named_enum___diff {
1121        NAMED_ENUM_VAL1___diff = 101,
1122        NAMED_ENUM_VAL2___diff = 202,
1123        NAMED_ENUM_VAL3___diff = 303,
1124};
1125
1126typedef enum {
1127        ANON_ENUM_VAL1___diff = 0x11,
1128        ANON_ENUM_VAL2___diff = 0x22,
1129        ANON_ENUM_VAL3___diff = 0x33,
1130} anon_enum___diff;
1131
1132struct core_reloc_enumval___diff {
1133        enum named_enum___diff f1;
1134        anon_enum___diff f2;
1135};
1136
1137/* missing (optional) third enum value */
1138enum named_enum___val3_missing {
1139        NAMED_ENUM_VAL1___val3_missing = 111,
1140        NAMED_ENUM_VAL2___val3_missing = 222,
1141};
1142
1143typedef enum {
1144        ANON_ENUM_VAL1___val3_missing = 0x111,
1145        ANON_ENUM_VAL2___val3_missing = 0x222,
1146} anon_enum___val3_missing;
1147
1148struct core_reloc_enumval___val3_missing {
1149        enum named_enum___val3_missing f1;
1150        anon_enum___val3_missing f2;
1151};
1152
1153/* missing (mandatory) second enum value, should fail */
1154enum named_enum___err_missing {
1155        NAMED_ENUM_VAL1___err_missing = 1,
1156        NAMED_ENUM_VAL3___err_missing = 3,
1157};
1158
1159typedef enum {
1160        ANON_ENUM_VAL1___err_missing = 0x111,
1161        ANON_ENUM_VAL3___err_missing = 0x222,
1162} anon_enum___err_missing;
1163
1164struct core_reloc_enumval___err_missing {
1165        enum named_enum___err_missing f1;
1166        anon_enum___err_missing f2;
1167};
1168