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___err_wrong_int_sz { 704 short a; 705 }; 706 707 struct core_reloc_existence___err_wrong_int_type { 708 int b[1]; 709 }; 710 711 struct core_reloc_existence___err_wrong_int_kind { 712 struct{ int x; } c; 713 }; 714 715 struct core_reloc_existence___err_wrong_arr_kind { 716 int arr; 717 }; 718 719 struct core_reloc_existence___err_wrong_arr_value_type { 720 short arr[1]; 721 }; 722 723 struct core_reloc_existence___err_wrong_struct_type { 724 int s; 725 }; 726 727 /* 728 * BITFIELDS 729 */ 730 /* bitfield read results, all as plain integers */ 731 struct core_reloc_bitfields_output { 732 int64_t ub1; 733 int64_t ub2; 734 int64_t ub7; 735 int64_t sb4; 736 int64_t sb20; 737 int64_t u32; 738 int64_t s32; 739 }; 740 741 struct core_reloc_bitfields { 742 /* unsigned bitfields */ 743 uint8_t ub1: 1; 744 uint8_t ub2: 2; 745 uint32_t ub7: 7; 746 /* signed bitfields */ 747 int8_t sb4: 4; 748 int32_t sb20: 20; 749 /* non-bitfields */ 750 uint32_t u32; 751 int32_t s32; 752 }; 753 754 /* different bit sizes (both up and down) */ 755 struct core_reloc_bitfields___bit_sz_change { 756 /* unsigned bitfields */ 757 uint16_t ub1: 3; /* 1 -> 3 */ 758 uint32_t ub2: 20; /* 2 -> 20 */ 759 uint8_t ub7: 1; /* 7 -> 1 */ 760 /* signed bitfields */ 761 int8_t sb4: 1; /* 4 -> 1 */ 762 int32_t sb20: 30; /* 20 -> 30 */ 763 /* non-bitfields */ 764 uint16_t u32; /* 32 -> 16 */ 765 int64_t s32 __bpf_aligned; /* 32 -> 64 */ 766 }; 767 768 /* turn bitfield into non-bitfield and vice versa */ 769 struct core_reloc_bitfields___bitfield_vs_int { 770 uint64_t ub1; /* 3 -> 64 non-bitfield */ 771 uint8_t ub2; /* 20 -> 8 non-bitfield */ 772 int64_t ub7 __bpf_aligned; /* 7 -> 64 non-bitfield signed */ 773 int64_t sb4 __bpf_aligned; /* 4 -> 64 non-bitfield signed */ 774 uint64_t sb20 __bpf_aligned; /* 20 -> 16 non-bitfield unsigned */ 775 int32_t u32: 20; /* 32 non-bitfield -> 20 bitfield */ 776 uint64_t s32: 60 __bpf_aligned; /* 32 non-bitfield -> 60 bitfield */ 777 }; 778 779 struct core_reloc_bitfields___just_big_enough { 780 uint64_t ub1: 4; 781 uint64_t ub2: 60; /* packed tightly */ 782 uint32_t ub7; 783 uint32_t sb4; 784 uint32_t sb20; 785 uint32_t u32; 786 uint32_t s32; 787 } __attribute__((packed)) ; 788 789 struct core_reloc_bitfields___err_too_big_bitfield { 790 uint64_t ub1: 4; 791 uint64_t ub2: 61; /* packed tightly */ 792 uint32_t ub7; 793 uint32_t sb4; 794 uint32_t sb20; 795 uint32_t u32; 796 uint32_t s32; 797 } __attribute__((packed)) ; 798 799 /* 800 * SIZE 801 */ 802 struct core_reloc_size_output { 803 int int_sz; 804 int struct_sz; 805 int union_sz; 806 int arr_sz; 807 int arr_elem_sz; 808 int ptr_sz; 809 int enum_sz; 810 }; 811 812 struct core_reloc_size { 813 int int_field; 814 struct { int x; } struct_field; 815 union { int x; } union_field; 816 int arr_field[4]; 817 void *ptr_field; 818 enum { VALUE = 123 } enum_field; 819 }; 820 821 struct core_reloc_size___diff_sz { 822 uint64_t int_field; 823 struct { int x; int y; int z; } struct_field; 824 union { int x; char bla[123]; } union_field; 825 char arr_field[10]; 826 void *ptr_field; 827 enum { OTHER_VALUE = 0xFFFFFFFFFFFFFFFF } enum_field; 828 }; 829 830 /* Error case of two candidates with the fields (int_field) at the same 831 * offset, but with differing final relocation values: size 4 vs size 1 832 */ 833 struct core_reloc_size___err_ambiguous1 { 834 /* int at offset 0 */ 835 int int_field; 836 837 struct { int x; } struct_field; 838 union { int x; } union_field; 839 int arr_field[4]; 840 void *ptr_field; 841 enum { VALUE___1 = 123 } enum_field; 842 }; 843 844 struct core_reloc_size___err_ambiguous2 { 845 /* char at offset 0 */ 846 char int_field; 847 848 struct { int x; } struct_field; 849 union { int x; } union_field; 850 int arr_field[4]; 851 void *ptr_field; 852 enum { VALUE___2 = 123 } enum_field; 853 }; 854 855 /* 856 * TYPE EXISTENCE & SIZE 857 */ 858 struct core_reloc_type_based_output { 859 bool struct_exists; 860 bool union_exists; 861 bool enum_exists; 862 bool typedef_named_struct_exists; 863 bool typedef_anon_struct_exists; 864 bool typedef_struct_ptr_exists; 865 bool typedef_int_exists; 866 bool typedef_enum_exists; 867 bool typedef_void_ptr_exists; 868 bool typedef_func_proto_exists; 869 bool typedef_arr_exists; 870 871 int struct_sz; 872 int union_sz; 873 int enum_sz; 874 int typedef_named_struct_sz; 875 int typedef_anon_struct_sz; 876 int typedef_struct_ptr_sz; 877 int typedef_int_sz; 878 int typedef_enum_sz; 879 int typedef_void_ptr_sz; 880 int typedef_func_proto_sz; 881 int typedef_arr_sz; 882 }; 883 884 struct a_struct { 885 int x; 886 }; 887 888 union a_union { 889 int y; 890 int z; 891 }; 892 893 typedef struct a_struct named_struct_typedef; 894 895 typedef struct { int x, y, z; } anon_struct_typedef; 896 897 typedef struct { 898 int a, b, c; 899 } *struct_ptr_typedef; 900 901 enum an_enum { 902 AN_ENUM_VAL1 = 1, 903 AN_ENUM_VAL2 = 2, 904 AN_ENUM_VAL3 = 3, 905 }; 906 907 typedef int int_typedef; 908 909 typedef enum { TYPEDEF_ENUM_VAL1, TYPEDEF_ENUM_VAL2 } enum_typedef; 910 911 typedef void *void_ptr_typedef; 912 913 typedef int (*func_proto_typedef)(long); 914 915 typedef char arr_typedef[20]; 916 917 struct core_reloc_type_based { 918 struct a_struct f1; 919 union a_union f2; 920 enum an_enum f3; 921 named_struct_typedef f4; 922 anon_struct_typedef f5; 923 struct_ptr_typedef f6; 924 int_typedef f7; 925 enum_typedef f8; 926 void_ptr_typedef f9; 927 func_proto_typedef f10; 928 arr_typedef f11; 929 }; 930 931 /* no types in target */ 932 struct core_reloc_type_based___all_missing { 933 }; 934 935 /* different type sizes, extra modifiers, anon vs named enums, etc */ 936 struct a_struct___diff_sz { 937 long x; 938 int y; 939 char z; 940 }; 941 942 union a_union___diff_sz { 943 char yy; 944 char zz; 945 }; 946 947 typedef struct a_struct___diff_sz named_struct_typedef___diff_sz; 948 949 typedef struct { long xx, yy, zzz; } anon_struct_typedef___diff_sz; 950 951 typedef struct { 952 char aa[1], bb[2], cc[3]; 953 } *struct_ptr_typedef___diff_sz; 954 955 enum an_enum___diff_sz { 956 AN_ENUM_VAL1___diff_sz = 0x123412341234, 957 AN_ENUM_VAL2___diff_sz = 2, 958 }; 959 960 typedef unsigned long int_typedef___diff_sz; 961 962 typedef enum an_enum___diff_sz enum_typedef___diff_sz; 963 964 typedef const void * const void_ptr_typedef___diff_sz; 965 966 typedef int_typedef___diff_sz (*func_proto_typedef___diff_sz)(char); 967 968 typedef int arr_typedef___diff_sz[2]; 969 970 struct core_reloc_type_based___diff_sz { 971 struct a_struct___diff_sz f1; 972 union a_union___diff_sz f2; 973 enum an_enum___diff_sz f3; 974 named_struct_typedef___diff_sz f4; 975 anon_struct_typedef___diff_sz f5; 976 struct_ptr_typedef___diff_sz f6; 977 int_typedef___diff_sz f7; 978 enum_typedef___diff_sz f8; 979 void_ptr_typedef___diff_sz f9; 980 func_proto_typedef___diff_sz f10; 981 arr_typedef___diff_sz f11; 982 }; 983 984 /* incompatibilities between target and local types */ 985 union a_struct___incompat { /* union instead of struct */ 986 int x; 987 }; 988 989 struct a_union___incompat { /* struct instead of union */ 990 int y; 991 int z; 992 }; 993 994 /* typedef to union, not to struct */ 995 typedef union a_struct___incompat named_struct_typedef___incompat; 996 997 /* typedef to void pointer, instead of struct */ 998 typedef void *anon_struct_typedef___incompat; 999 1000 /* extra pointer indirection */ 1001 typedef struct { 1002 int a, b, c; 1003 } **struct_ptr_typedef___incompat; 1004 1005 /* typedef of a struct with int, instead of int */ 1006 typedef struct { int x; } int_typedef___incompat; 1007 1008 /* typedef to func_proto, instead of enum */ 1009 typedef int (*enum_typedef___incompat)(void); 1010 1011 /* pointer to char instead of void */ 1012 typedef char *void_ptr_typedef___incompat; 1013 1014 /* void return type instead of int */ 1015 typedef void (*func_proto_typedef___incompat)(long); 1016 1017 /* multi-dimensional array instead of a single-dimensional */ 1018 typedef int arr_typedef___incompat[20][2]; 1019 1020 struct core_reloc_type_based___incompat { 1021 union a_struct___incompat f1; 1022 struct a_union___incompat f2; 1023 /* the only valid one is enum, to check that something still succeeds */ 1024 enum an_enum f3; 1025 named_struct_typedef___incompat f4; 1026 anon_struct_typedef___incompat f5; 1027 struct_ptr_typedef___incompat f6; 1028 int_typedef___incompat f7; 1029 enum_typedef___incompat f8; 1030 void_ptr_typedef___incompat f9; 1031 func_proto_typedef___incompat f10; 1032 arr_typedef___incompat f11; 1033 }; 1034 1035 /* func_proto with incompatible signature */ 1036 typedef void (*func_proto_typedef___fn_wrong_ret1)(long); 1037 typedef int * (*func_proto_typedef___fn_wrong_ret2)(long); 1038 typedef struct { int x; } int_struct_typedef; 1039 typedef int_struct_typedef (*func_proto_typedef___fn_wrong_ret3)(long); 1040 typedef int (*func_proto_typedef___fn_wrong_arg)(void *); 1041 typedef int (*func_proto_typedef___fn_wrong_arg_cnt1)(long, long); 1042 typedef int (*func_proto_typedef___fn_wrong_arg_cnt2)(void); 1043 1044 struct core_reloc_type_based___fn_wrong_args { 1045 /* one valid type to make sure relos still work */ 1046 struct a_struct f1; 1047 func_proto_typedef___fn_wrong_ret1 f2; 1048 func_proto_typedef___fn_wrong_ret2 f3; 1049 func_proto_typedef___fn_wrong_ret3 f4; 1050 func_proto_typedef___fn_wrong_arg f5; 1051 func_proto_typedef___fn_wrong_arg_cnt1 f6; 1052 func_proto_typedef___fn_wrong_arg_cnt2 f7; 1053 }; 1054 1055 /* 1056 * TYPE ID MAPPING (LOCAL AND TARGET) 1057 */ 1058 struct core_reloc_type_id_output { 1059 int local_anon_struct; 1060 int local_anon_union; 1061 int local_anon_enum; 1062 int local_anon_func_proto_ptr; 1063 int local_anon_void_ptr; 1064 int local_anon_arr; 1065 1066 int local_struct; 1067 int local_union; 1068 int local_enum; 1069 int local_int; 1070 int local_struct_typedef; 1071 int local_func_proto_typedef; 1072 int local_arr_typedef; 1073 1074 int targ_struct; 1075 int targ_union; 1076 int targ_enum; 1077 int targ_int; 1078 int targ_struct_typedef; 1079 int targ_func_proto_typedef; 1080 int targ_arr_typedef; 1081 }; 1082 1083 struct core_reloc_type_id { 1084 struct a_struct f1; 1085 union a_union f2; 1086 enum an_enum f3; 1087 named_struct_typedef f4; 1088 func_proto_typedef f5; 1089 arr_typedef f6; 1090 }; 1091 1092 struct core_reloc_type_id___missing_targets { 1093 /* nothing */ 1094 }; 1095 1096 /* 1097 * ENUMERATOR VALUE EXISTENCE AND VALUE RELOCATION 1098 */ 1099 struct core_reloc_enumval_output { 1100 bool named_val1_exists; 1101 bool named_val2_exists; 1102 bool named_val3_exists; 1103 bool anon_val1_exists; 1104 bool anon_val2_exists; 1105 bool anon_val3_exists; 1106 1107 int named_val1; 1108 int named_val2; 1109 int anon_val1; 1110 int anon_val2; 1111 }; 1112 1113 enum named_enum { 1114 NAMED_ENUM_VAL1 = 1, 1115 NAMED_ENUM_VAL2 = 2, 1116 NAMED_ENUM_VAL3 = 3, 1117 }; 1118 1119 typedef enum { 1120 ANON_ENUM_VAL1 = 0x10, 1121 ANON_ENUM_VAL2 = 0x20, 1122 ANON_ENUM_VAL3 = 0x30, 1123 } anon_enum; 1124 1125 struct core_reloc_enumval { 1126 enum named_enum f1; 1127 anon_enum f2; 1128 }; 1129 1130 /* differing enumerator values */ 1131 enum named_enum___diff { 1132 NAMED_ENUM_VAL1___diff = 101, 1133 NAMED_ENUM_VAL2___diff = 202, 1134 NAMED_ENUM_VAL3___diff = 303, 1135 }; 1136 1137 typedef enum { 1138 ANON_ENUM_VAL1___diff = 0x11, 1139 ANON_ENUM_VAL2___diff = 0x22, 1140 ANON_ENUM_VAL3___diff = 0x33, 1141 } anon_enum___diff; 1142 1143 struct core_reloc_enumval___diff { 1144 enum named_enum___diff f1; 1145 anon_enum___diff f2; 1146 }; 1147 1148 /* missing (optional) third enum value */ 1149 enum named_enum___val3_missing { 1150 NAMED_ENUM_VAL1___val3_missing = 111, 1151 NAMED_ENUM_VAL2___val3_missing = 222, 1152 }; 1153 1154 typedef enum { 1155 ANON_ENUM_VAL1___val3_missing = 0x111, 1156 ANON_ENUM_VAL2___val3_missing = 0x222, 1157 } anon_enum___val3_missing; 1158 1159 struct core_reloc_enumval___val3_missing { 1160 enum named_enum___val3_missing f1; 1161 anon_enum___val3_missing f2; 1162 }; 1163 1164 /* missing (mandatory) second enum value, should fail */ 1165 enum named_enum___err_missing { 1166 NAMED_ENUM_VAL1___err_missing = 1, 1167 NAMED_ENUM_VAL3___err_missing = 3, 1168 }; 1169 1170 typedef enum { 1171 ANON_ENUM_VAL1___err_missing = 0x111, 1172 ANON_ENUM_VAL3___err_missing = 0x222, 1173 } anon_enum___err_missing; 1174 1175 struct core_reloc_enumval___err_missing { 1176 enum named_enum___err_missing f1; 1177 anon_enum___err_missing f2; 1178 }; 1179