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 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 797 struct 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 807 struct 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 */ 820 struct 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 832 struct 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 */ 847 struct 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 873 struct a_struct { 874 int x; 875 }; 876 877 union a_union { 878 int y; 879 int z; 880 }; 881 882 typedef struct a_struct named_struct_typedef; 883 884 typedef struct { int x, y, z; } anon_struct_typedef; 885 886 typedef struct { 887 int a, b, c; 888 } *struct_ptr_typedef; 889 890 enum an_enum { 891 AN_ENUM_VAL1 = 1, 892 AN_ENUM_VAL2 = 2, 893 AN_ENUM_VAL3 = 3, 894 }; 895 896 typedef int int_typedef; 897 898 typedef enum { TYPEDEF_ENUM_VAL1, TYPEDEF_ENUM_VAL2 } enum_typedef; 899 900 typedef void *void_ptr_typedef; 901 902 typedef int (*func_proto_typedef)(long); 903 904 typedef char arr_typedef[20]; 905 906 struct 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 */ 921 struct core_reloc_type_based___all_missing { 922 }; 923 924 /* different type sizes, extra modifiers, anon vs named enums, etc */ 925 struct a_struct___diff_sz { 926 long x; 927 int y; 928 char z; 929 }; 930 931 union a_union___diff_sz { 932 char yy; 933 char zz; 934 }; 935 936 typedef struct a_struct___diff_sz named_struct_typedef___diff_sz; 937 938 typedef struct { long xx, yy, zzz; } anon_struct_typedef___diff_sz; 939 940 typedef struct { 941 char aa[1], bb[2], cc[3]; 942 } *struct_ptr_typedef___diff_sz; 943 944 enum an_enum___diff_sz { 945 AN_ENUM_VAL1___diff_sz = 0x123412341234, 946 AN_ENUM_VAL2___diff_sz = 2, 947 }; 948 949 typedef unsigned long int_typedef___diff_sz; 950 951 typedef enum an_enum___diff_sz enum_typedef___diff_sz; 952 953 typedef const void * const void_ptr_typedef___diff_sz; 954 955 typedef int_typedef___diff_sz (*func_proto_typedef___diff_sz)(char); 956 957 typedef int arr_typedef___diff_sz[2]; 958 959 struct 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 */ 974 union a_struct___incompat { /* union instead of struct */ 975 int x; 976 }; 977 978 struct a_union___incompat { /* struct instead of union */ 979 int y; 980 int z; 981 }; 982 983 /* typedef to union, not to struct */ 984 typedef union a_struct___incompat named_struct_typedef___incompat; 985 986 /* typedef to void pointer, instead of struct */ 987 typedef void *anon_struct_typedef___incompat; 988 989 /* extra pointer indirection */ 990 typedef struct { 991 int a, b, c; 992 } **struct_ptr_typedef___incompat; 993 994 /* typedef of a struct with int, instead of int */ 995 typedef struct { int x; } int_typedef___incompat; 996 997 /* typedef to func_proto, instead of enum */ 998 typedef int (*enum_typedef___incompat)(void); 999 1000 /* pointer to char instead of void */ 1001 typedef char *void_ptr_typedef___incompat; 1002 1003 /* void return type instead of int */ 1004 typedef void (*func_proto_typedef___incompat)(long); 1005 1006 /* multi-dimensional array instead of a single-dimensional */ 1007 typedef int arr_typedef___incompat[20][2]; 1008 1009 struct 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 */ 1025 typedef void (*func_proto_typedef___fn_wrong_ret1)(long); 1026 typedef int * (*func_proto_typedef___fn_wrong_ret2)(long); 1027 typedef struct { int x; } int_struct_typedef; 1028 typedef int_struct_typedef (*func_proto_typedef___fn_wrong_ret3)(long); 1029 typedef int (*func_proto_typedef___fn_wrong_arg)(void *); 1030 typedef int (*func_proto_typedef___fn_wrong_arg_cnt1)(long, long); 1031 typedef int (*func_proto_typedef___fn_wrong_arg_cnt2)(void); 1032 1033 struct 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 */ 1047 struct 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 1072 struct 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 1081 struct core_reloc_type_id___missing_targets { 1082 /* nothing */ 1083 }; 1084 1085 /* 1086 * ENUMERATOR VALUE EXISTENCE AND VALUE RELOCATION 1087 */ 1088 struct 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 1102 enum named_enum { 1103 NAMED_ENUM_VAL1 = 1, 1104 NAMED_ENUM_VAL2 = 2, 1105 NAMED_ENUM_VAL3 = 3, 1106 }; 1107 1108 typedef enum { 1109 ANON_ENUM_VAL1 = 0x10, 1110 ANON_ENUM_VAL2 = 0x20, 1111 ANON_ENUM_VAL3 = 0x30, 1112 } anon_enum; 1113 1114 struct core_reloc_enumval { 1115 enum named_enum f1; 1116 anon_enum f2; 1117 }; 1118 1119 /* differing enumerator values */ 1120 enum named_enum___diff { 1121 NAMED_ENUM_VAL1___diff = 101, 1122 NAMED_ENUM_VAL2___diff = 202, 1123 NAMED_ENUM_VAL3___diff = 303, 1124 }; 1125 1126 typedef enum { 1127 ANON_ENUM_VAL1___diff = 0x11, 1128 ANON_ENUM_VAL2___diff = 0x22, 1129 ANON_ENUM_VAL3___diff = 0x33, 1130 } anon_enum___diff; 1131 1132 struct core_reloc_enumval___diff { 1133 enum named_enum___diff f1; 1134 anon_enum___diff f2; 1135 }; 1136 1137 /* missing (optional) third enum value */ 1138 enum named_enum___val3_missing { 1139 NAMED_ENUM_VAL1___val3_missing = 111, 1140 NAMED_ENUM_VAL2___val3_missing = 222, 1141 }; 1142 1143 typedef enum { 1144 ANON_ENUM_VAL1___val3_missing = 0x111, 1145 ANON_ENUM_VAL2___val3_missing = 0x222, 1146 } anon_enum___val3_missing; 1147 1148 struct 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 */ 1154 enum named_enum___err_missing { 1155 NAMED_ENUM_VAL1___err_missing = 1, 1156 NAMED_ENUM_VAL3___err_missing = 3, 1157 }; 1158 1159 typedef enum { 1160 ANON_ENUM_VAL1___err_missing = 0x111, 1161 ANON_ENUM_VAL3___err_missing = 0x222, 1162 } anon_enum___err_missing; 1163 1164 struct core_reloc_enumval___err_missing { 1165 enum named_enum___err_missing f1; 1166 anon_enum___err_missing f2; 1167 }; 1168