github.com/bir3/gocompiler@v0.9.2202/src/cmd/cgo/internal/test/test.go (about) 1 // Copyright 2010 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Test cases for cgo. 6 // Both the import "C" prologue and the main file are sorted by issue number. 7 // This file contains C definitions (not just declarations) 8 // and so it must NOT contain any //export directives on Go functions. 9 // See testx.go for exports. 10 11 package cgotest 12 13 /* 14 #include <complex.h> 15 #include <math.h> 16 #include <stdarg.h> 17 #include <stdbool.h> 18 #include <stddef.h> 19 #include <stdint.h> 20 #include <stdio.h> 21 #include <stdlib.h> 22 #include <string.h> 23 #include <unistd.h> 24 #include <sys/stat.h> 25 #include <errno.h> 26 #cgo !darwin LDFLAGS: -lm 27 28 #ifndef WIN32 29 #include <pthread.h> 30 #include <signal.h> 31 #endif 32 33 // alignment tests 34 35 typedef unsigned char Uint8; 36 typedef unsigned short Uint16; 37 38 typedef enum { 39 MOD1 = 0x0000, 40 MODX = 0x8000 41 } SDLMod; 42 43 typedef enum { 44 A1 = 1, 45 B1 = 322, 46 SDLK_LAST 47 } SDLKey; 48 49 typedef struct SDL_keysym { 50 Uint8 scancode; 51 SDLKey sym; 52 SDLMod mod; 53 Uint16 unicode; 54 } SDL_keysym; 55 56 typedef struct SDL_KeyboardEvent { 57 Uint8 typ; 58 Uint8 which; 59 Uint8 state; 60 SDL_keysym keysym; 61 } SDL_KeyboardEvent; 62 63 void makeEvent(SDL_KeyboardEvent *event) { 64 unsigned char *p; 65 int i; 66 67 p = (unsigned char*)event; 68 for (i=0; i<sizeof *event; i++) { 69 p[i] = i; 70 } 71 } 72 73 int same(SDL_KeyboardEvent* e, Uint8 typ, Uint8 which, Uint8 state, Uint8 scan, SDLKey sym, SDLMod mod, Uint16 uni) { 74 return e->typ == typ && e->which == which && e->state == state && e->keysym.scancode == scan && e->keysym.sym == sym && e->keysym.mod == mod && e->keysym.unicode == uni; 75 } 76 77 void cTest(SDL_KeyboardEvent *event) { 78 printf("C: %#x %#x %#x %#x %#x %#x %#x\n", event->typ, event->which, event->state, 79 event->keysym.scancode, event->keysym.sym, event->keysym.mod, event->keysym.unicode); 80 fflush(stdout); 81 } 82 83 // api 84 85 const char *greeting = "hello, world"; 86 87 // basic test cases 88 89 #define SHIFT(x, y) ((x)<<(y)) 90 #define KILO SHIFT(1, 10) 91 #define UINT32VAL 0xc008427bU 92 93 enum E { 94 Enum1 = 1, 95 Enum2 = 2, 96 }; 97 98 typedef unsigned char cgo_uuid_t[20]; 99 100 void uuid_generate(cgo_uuid_t x) { 101 x[0] = 0; 102 } 103 104 struct S { 105 int x; 106 }; 107 108 const char *cstr = "abcefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890"; 109 110 extern enum E myConstFunc(struct S* const ctx, int const id, struct S **const filter); 111 112 enum E myConstFunc(struct S *const ctx, int const id, struct S **const filter) { return 0; } 113 114 int add(int x, int y) { 115 return x+y; 116 }; 117 118 // escape vs noescape 119 120 // TODO(#56378): enable in Go 1.23: 121 // #cgo noescape handleGoStringPointerNoescape 122 void handleGoStringPointerNoescape(void *s) {} 123 124 void handleGoStringPointerEscape(void *s) {} 125 126 // Following mimics vulkan complex definitions for benchmarking cgocheck overhead. 127 128 typedef uint32_t VkFlags; 129 typedef VkFlags VkDeviceQueueCreateFlags; 130 typedef uint32_t VkStructureType; 131 132 typedef struct VkDeviceQueueCreateInfo { 133 VkStructureType sType; 134 const void* pNext; 135 VkDeviceQueueCreateFlags flags; 136 uint32_t queueFamilyIndex; 137 uint32_t queueCount; 138 const float* pQueuePriorities; 139 } VkDeviceQueueCreateInfo; 140 141 typedef struct VkPhysicalDeviceFeatures { 142 uint32_t bools[56]; 143 } VkPhysicalDeviceFeatures; 144 145 typedef struct VkDeviceCreateInfo { 146 VkStructureType sType; 147 const void* pNext; 148 VkFlags flags; 149 uint32_t queueCreateInfoCount; 150 const VkDeviceQueueCreateInfo* pQueueCreateInfos; 151 uint32_t enabledLayerCount; 152 const char* const* ppEnabledLayerNames; 153 uint32_t enabledExtensionCount; 154 const char* const* ppEnabledExtensionNames; 155 const VkPhysicalDeviceFeatures* pEnabledFeatures; 156 } VkDeviceCreateInfo; 157 158 void handleComplexPointer(VkDeviceCreateInfo *a0) {} 159 void handleComplexPointer8( 160 VkDeviceCreateInfo *a0, VkDeviceCreateInfo *a1, VkDeviceCreateInfo *a2, VkDeviceCreateInfo *a3, 161 VkDeviceCreateInfo *a4, VkDeviceCreateInfo *a5, VkDeviceCreateInfo *a6, VkDeviceCreateInfo *a7 162 ) {} 163 164 // complex alignment 165 166 struct { 167 float x; 168 _Complex float y; 169 } cplxAlign = { 3.14, 2.17 }; 170 171 // constants and pointer checking 172 173 #define CheckConstVal 0 174 175 typedef struct { 176 int *p; 177 } CheckConstStruct; 178 179 static void CheckConstFunc(CheckConstStruct *p, int e) {} 180 181 // duplicate symbol 182 183 int base_symbol = 0; 184 #define alias_one base_symbol 185 #define alias_two base_symbol 186 187 // function pointer variables 188 189 typedef int (*intFunc) (); 190 191 int 192 bridge_int_func(intFunc f) 193 { 194 return f(); 195 } 196 197 int fortytwo() 198 { 199 return 42; 200 } 201 202 // issue 1222 203 typedef union { 204 long align; 205 } xxpthread_mutex_t; 206 struct ibv_async_event { 207 union { 208 int x; 209 } element; 210 }; 211 struct ibv_context { 212 xxpthread_mutex_t mutex; 213 }; 214 215 // issue 1635 216 // Mac OS X's gcc will generate scattered relocation 2/1 for 217 // this function on Darwin/386, and 8l couldn't handle it. 218 // this example is in issue 1635 219 void scatter() { 220 void *p = scatter; 221 printf("scatter = %p\n", p); 222 } 223 224 // Adding this explicit extern declaration makes this a test for 225 // https://gcc.gnu.org/PR68072 aka https://golang.org/issue/13344 . 226 // It used to cause a cgo error when building with GCC 6. 227 extern int hola; 228 229 // this example is in issue 3253 230 int hola = 0; 231 int testHola() { return hola; } 232 233 // issue 3250 234 #ifdef WIN32 235 void testSendSIG() {} 236 #else 237 static void *thread(void *p) { 238 const int M = 100; 239 int i; 240 (void)p; 241 for (i = 0; i < M; i++) { 242 pthread_kill(pthread_self(), SIGCHLD); 243 usleep(rand() % 20 + 5); 244 } 245 return NULL; 246 } 247 void testSendSIG() { 248 const int N = 20; 249 int i; 250 pthread_t tid[N]; 251 for (i = 0; i < N; i++) { 252 usleep(rand() % 200 + 100); 253 pthread_create(&tid[i], 0, thread, NULL); 254 } 255 for (i = 0; i < N; i++) 256 pthread_join(tid[i], 0); 257 } 258 #endif 259 260 // issue 3261 261 // libgcc on ARM might be compiled as thumb code, but our 5l 262 // can't handle that, so we have to disable this test on arm. 263 #ifdef __ARMEL__ 264 int vabs(int x) { 265 puts("testLibgcc is disabled on ARM because 5l cannot handle thumb library."); 266 return (x < 0) ? -x : x; 267 } 268 #elif defined(__arm64__) && defined(__clang__) 269 int vabs(int x) { 270 puts("testLibgcc is disabled on ARM64 with clang due to lack of libgcc."); 271 return (x < 0) ? -x : x; 272 } 273 #else 274 int __absvsi2(int); // dummy prototype for libgcc function 275 // we shouldn't name the function abs, as gcc might use 276 // the builtin one. 277 int vabs(int x) { return __absvsi2(x); } 278 #endif 279 280 281 // issue 3729 282 // access errno from void C function 283 const char _expA = 0x42; 284 const float _expB = 3.14159; 285 const short _expC = 0x55aa; 286 const int _expD = 0xdeadbeef; 287 288 #ifdef WIN32 289 void g(void) {} 290 void g2(int x, char a, float b, short c, int d) {} 291 #else 292 293 void g(void) { 294 errno = E2BIG; 295 } 296 297 // try to pass some non-trivial arguments to function g2 298 void g2(int x, char a, float b, short c, int d) { 299 if (a == _expA && b == _expB && c == _expC && d == _expD) 300 errno = x; 301 else 302 errno = -1; 303 } 304 #endif 305 306 // issue 3945 307 // Test that cgo reserves enough stack space during cgo call. 308 // See https://golang.org/issue/3945 for details. 309 void say() { 310 printf("%s from C\n", "hello"); 311 } 312 313 // issue 4054 part 1 - other half in testx.go 314 315 typedef enum { 316 A = 0, 317 B, 318 C, 319 D, 320 E, 321 F, 322 G, 323 H, 324 II, 325 J, 326 } issue4054a; 327 328 // issue 4339 329 // We've historically permitted #include <>, so test it here. Issue 29333. 330 // Also see issue 41059. 331 #include <issue4339.h> 332 333 // issue 4417 334 // cmd/cgo: bool alignment/padding issue. 335 // bool alignment is wrong and causing wrong arguments when calling functions. 336 static int c_bool(bool a, bool b, int c, bool d, bool e) { 337 return c; 338 } 339 340 // issue 4857 341 #cgo CFLAGS: -Werror 342 const struct { int a; } *issue4857() { return (void *)0; } 343 344 // issue 5224 345 // Test that the #cgo CFLAGS directive works, 346 // with and without platform filters. 347 #cgo CFLAGS: -DCOMMON_VALUE=123 348 #cgo windows CFLAGS: -DIS_WINDOWS=1 349 #cgo !windows CFLAGS: -DIS_WINDOWS=0 350 int common = COMMON_VALUE; 351 int is_windows = IS_WINDOWS; 352 353 // issue 5227 354 // linker incorrectly treats common symbols and 355 // leaves them undefined. 356 357 typedef struct { 358 int Count; 359 } Fontinfo; 360 361 Fontinfo SansTypeface; 362 363 extern void init(); 364 365 Fontinfo loadfont() { 366 Fontinfo f = {0}; 367 return f; 368 } 369 370 void init() { 371 SansTypeface = loadfont(); 372 } 373 374 // issue 5242 375 // Cgo incorrectly computed the alignment of structs 376 // with no Go accessible fields as 0, and then panicked on 377 // modulo-by-zero computations. 378 379 // issue 50987 380 // disable arm64 GCC warnings 381 #cgo CFLAGS: -Wno-psabi -Wno-unknown-warning-option 382 383 typedef struct { 384 } foo; 385 386 typedef struct { 387 int x : 1; 388 } bar; 389 390 int issue5242(foo f, bar b) { 391 return 5242; 392 } 393 394 // issue 5337 395 // Verify that we can withstand SIGPROF received on foreign threads 396 397 #ifdef WIN32 398 void test5337() {} 399 #else 400 static void *thread1(void *p) { 401 (void)p; 402 pthread_kill(pthread_self(), SIGPROF); 403 return NULL; 404 } 405 void test5337() { 406 pthread_t tid; 407 pthread_create(&tid, 0, thread1, NULL); 408 pthread_join(tid, 0); 409 } 410 #endif 411 412 // issue 5603 413 414 const long long issue5603exp = 0x12345678; 415 long long issue5603foo0() { return issue5603exp; } 416 long long issue5603foo1(void *p) { return issue5603exp; } 417 long long issue5603foo2(void *p, void *q) { return issue5603exp; } 418 long long issue5603foo3(void *p, void *q, void *r) { return issue5603exp; } 419 long long issue5603foo4(void *p, void *q, void *r, void *s) { return issue5603exp; } 420 421 // issue 5740 422 423 int test5740a(void), test5740b(void); 424 425 // issue 5986 426 static void output5986() 427 { 428 int current_row = 0, row_count = 0; 429 double sum_squares = 0; 430 double d; 431 do { 432 if (current_row == 10) { 433 current_row = 0; 434 } 435 ++row_count; 436 } 437 while (current_row++ != 1); 438 d = sqrt(sum_squares / row_count); 439 printf("sqrt is: %g\n", d); 440 } 441 442 // issue 6128 443 // Test handling of #defined names in clang. 444 // NOTE: Must use hex, or else a shortcut for decimals 445 // in cgo avoids trying to pass this to clang. 446 #define X 0x1 447 448 // issue 6472 449 typedef struct 450 { 451 struct 452 { 453 int x; 454 } y[16]; 455 } z; 456 457 // issue 6612 458 // Test new scheme for deciding whether C.name is an expression, type, constant. 459 // Clang silences some warnings when the name is a #defined macro, so test those too 460 // (even though we now use errors exclusively, not warnings). 461 462 void myfunc(void) {} 463 int myvar = 5; 464 const char *mytext = "abcdef"; 465 typedef int mytype; 466 enum { 467 myenum = 1234, 468 }; 469 470 #define myfunc_def myfunc 471 #define myvar_def myvar 472 #define mytext_def mytext 473 #define mytype_def mytype 474 #define myenum_def myenum 475 #define myint_def 12345 476 #define myfloat_def 1.5 477 #define mystring_def "hello" 478 479 // issue 6907 480 char* Issue6907CopyString(_GoString_ s) { 481 size_t n; 482 const char *p; 483 char *r; 484 485 n = _GoStringLen(s); 486 p = _GoStringPtr(s); 487 r = malloc(n + 1); 488 memmove(r, p, n); 489 r[n] = '\0'; 490 return r; 491 } 492 493 // issue 7560 494 typedef struct { 495 char x; 496 long y; 497 } __attribute__((__packed__)) misaligned; 498 499 int 500 offset7560(void) 501 { 502 return (uintptr_t)&((misaligned*)0)->y; 503 } 504 505 // issue 7786 506 // No runtime test, just make sure that typedef and struct/union/class are interchangeable at compile time. 507 508 struct test7786; 509 typedef struct test7786 typedef_test7786; 510 void f7786(struct test7786 *ctx) {} 511 void g7786(typedef_test7786 *ctx) {} 512 513 typedef struct body7786 typedef_body7786; 514 struct body7786 { int x; }; 515 void b7786(struct body7786 *ctx) {} 516 void c7786(typedef_body7786 *ctx) {} 517 518 typedef union union7786 typedef_union7786; 519 void u7786(union union7786 *ctx) {} 520 void v7786(typedef_union7786 *ctx) {} 521 522 // issue 8092 523 // Test that linker defined symbols (e.g., text, data) don't 524 // conflict with C symbols. 525 char text[] = "text"; 526 char data[] = "data"; 527 char *ctext(void) { return text; } 528 char *cdata(void) { return data; } 529 530 // issue 8428 531 // Cgo inconsistently translated zero size arrays. 532 533 struct issue8428one { 534 char b; 535 char rest[]; 536 }; 537 538 struct issue8428two { 539 void *p; 540 char b; 541 char rest[0]; 542 char pad; 543 }; 544 545 struct issue8428three { 546 char w[1][2][3][0]; 547 char x[2][3][0][1]; 548 char y[3][0][1][2]; 549 char z[0][1][2][3]; 550 }; 551 552 // issue 8331 part 1 - part 2 in testx.go 553 // A typedef of an unnamed struct is the same struct when 554 // #include'd twice. No runtime test; just make sure it compiles. 555 #include "issue8331.h" 556 557 // issue 8368 and 8441 558 // Recursive struct definitions didn't work. 559 // No runtime test; just make sure it compiles. 560 typedef struct one one; 561 typedef struct two two; 562 struct one { 563 two *x; 564 }; 565 struct two { 566 one *x; 567 }; 568 569 // issue 8811 570 571 extern int issue8811Initialized; 572 extern void issue8811Init(); 573 574 void issue8811Execute() { 575 if(!issue8811Initialized) 576 issue8811Init(); 577 } 578 579 // issue 8945 580 581 typedef void (*PFunc8945)(); 582 PFunc8945 func8945; 583 584 // issue 9557 585 586 struct issue9557_t { 587 int a; 588 } test9557bar = { 42 }; 589 struct issue9557_t *issue9557foo = &test9557bar; 590 591 // issue 10303 592 // Pointers passed to C were not marked as escaping (bug in cgo). 593 594 typedef int *intptr; 595 596 void setintstar(int *x) { 597 *x = 1; 598 } 599 600 void setintptr(intptr x) { 601 *x = 1; 602 } 603 604 void setvoidptr(void *x) { 605 *(int*)x = 1; 606 } 607 608 typedef struct Struct Struct; 609 struct Struct { 610 int *P; 611 }; 612 613 void setstruct(Struct s) { 614 *s.P = 1; 615 } 616 617 // issue 11925 618 // Structs with zero-length trailing fields are now padded by the Go compiler. 619 620 struct a11925 { 621 int i; 622 char a[0]; 623 char b[0]; 624 }; 625 626 struct b11925 { 627 int i; 628 char a[0]; 629 char b[]; 630 }; 631 632 // issue 12030 633 void issue12030conv(char *buf, double x) { 634 sprintf(buf, "d=%g", x); 635 } 636 637 // issue 14838 638 639 int check_cbytes(char *b, size_t l) { 640 int i; 641 for (i = 0; i < l; i++) { 642 if (b[i] != i) { 643 return 0; 644 } 645 } 646 return 1; 647 } 648 649 // issue 17065 650 // Test that C symbols larger than a page play nicely with the race detector. 651 int ii[65537]; 652 653 // issue 17537 654 // The void* cast introduced by cgo to avoid problems 655 // with const/volatile qualifiers breaks C preprocessor macros that 656 // emulate functions. 657 658 typedef struct { 659 int i; 660 } S17537; 661 662 int I17537(S17537 *p); 663 664 #define I17537(p) ((p)->i) 665 666 // Calling this function used to fail without the cast. 667 const int F17537(const char **p) { 668 return **p; 669 } 670 671 // issue 17723 672 // API compatibility checks 673 674 typedef char *cstring_pointer; 675 static void cstring_pointer_fun(cstring_pointer dummy) { } 676 const char *api_hello = "hello!"; 677 678 // Calling this function used to trigger an error from the C compiler 679 // (issue 18298). 680 void F18298(const void *const *p) { 681 } 682 683 // Test that conversions between typedefs work as they used to. 684 typedef const void *T18298_1; 685 struct S18298 { int i; }; 686 typedef const struct S18298 *T18298_2; 687 void G18298(T18298_1 t) { 688 } 689 690 // issue 18126 691 // cgo check of void function returning errno. 692 void Issue18126C(void **p) {} 693 694 // issue 18720 695 696 #define HELLO "hello" 697 #define WORLD "world" 698 #define HELLO_WORLD HELLO "\000" WORLD 699 700 struct foo { char c; }; 701 #define SIZE_OF(x) sizeof(x) 702 #define SIZE_OF_FOO SIZE_OF(struct foo) 703 #define VAR1 VAR 704 #define VAR var 705 int var = 5; 706 707 #define ADDR &var 708 709 #define CALL fn() 710 int fn(void) { 711 return ++var; 712 } 713 714 // issue 20129 715 716 int issue20129 = 0; 717 typedef void issue20129Void; 718 issue20129Void issue20129Foo() { 719 issue20129 = 1; 720 } 721 typedef issue20129Void issue20129Void2; 722 issue20129Void2 issue20129Bar() { 723 issue20129 = 2; 724 } 725 726 // issue 20369 727 #define XUINT64_MAX 18446744073709551615ULL 728 729 // issue 21668 730 // Fail to guess the kind of the constant "x". 731 // No runtime test; just make sure it compiles. 732 const int x21668 = 42; 733 734 // issue 21708 735 #define CAST_TO_INT64 (int64_t)(-1) 736 737 // issue 21809 738 // Compile C `typedef` to go type aliases. 739 740 typedef long MySigned_t; 741 // tests alias-to-alias 742 typedef MySigned_t MySigned2_t; 743 long takes_long(long x) { return x * x; } 744 MySigned_t takes_typedef(MySigned_t x) { return x * x; } 745 746 // issue 22906 747 748 // It's going to be hard to include a whole real JVM to test this. 749 // So we'll simulate a really easy JVM using just the parts we need. 750 // This is the relevant part of jni.h. 751 752 struct _jobject; 753 754 typedef struct _jobject *jobject; 755 typedef jobject jclass; 756 typedef jobject jthrowable; 757 typedef jobject jstring; 758 typedef jobject jarray; 759 typedef jarray jbooleanArray; 760 typedef jarray jbyteArray; 761 typedef jarray jcharArray; 762 typedef jarray jshortArray; 763 typedef jarray jintArray; 764 typedef jarray jlongArray; 765 typedef jarray jfloatArray; 766 typedef jarray jdoubleArray; 767 typedef jarray jobjectArray; 768 769 typedef jobject jweak; 770 771 // Note: jvalue is already a non-pointer type due to it being a C union. 772 773 // issue 22958 774 775 typedef struct { 776 unsigned long long f8 : 8; 777 unsigned long long f16 : 16; 778 unsigned long long f24 : 24; 779 unsigned long long f32 : 32; 780 unsigned long long f40 : 40; 781 unsigned long long f48 : 48; 782 unsigned long long f56 : 56; 783 unsigned long long f64 : 64; 784 } issue22958Type; 785 786 // issue 23356 787 int a(void) { return 5; }; 788 int r(void) { return 3; }; 789 790 // issue 23720 791 typedef int *issue23720A; 792 typedef const int *issue23720B; 793 void issue23720F(issue23720B a) {} 794 795 // issue 24206 796 #if defined(__linux__) && defined(__x86_64__) 797 #include <sys/mman.h> 798 // Returns string with null byte at the last valid address 799 char* dangerousString1() { 800 int pageSize = 4096; 801 char *data = mmap(0, 2 * pageSize, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0); 802 mprotect(data + pageSize,pageSize,PROT_NONE); 803 int start = pageSize - 123 - 1; // last 123 bytes of first page + 1 null byte 804 int i = start; 805 for (; i < pageSize; i++) { 806 data[i] = 'x'; 807 } 808 data[pageSize -1 ] = 0; 809 return data+start; 810 } 811 812 char* dangerousString2() { 813 int pageSize = 4096; 814 char *data = mmap(0, 3 * pageSize, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0); 815 mprotect(data + 2 * pageSize,pageSize,PROT_NONE); 816 int start = pageSize - 123 - 1; // last 123 bytes of first page + 1 null byte 817 int i = start; 818 for (; i < 2 * pageSize; i++) { 819 data[i] = 'x'; 820 } 821 data[2*pageSize -1 ] = 0; 822 return data+start; 823 } 824 #else 825 char *dangerousString1() { return NULL; } 826 char *dangerousString2() { return NULL; } 827 #endif 828 829 // issue 26066 830 const unsigned long long int issue26066 = (const unsigned long long) -1; 831 832 // issue 26517 833 // Introduce two pointer types which are distinct, but have the same 834 // base type. Make sure that both of those pointer types get resolved 835 // correctly. Before the fix for 26517 if one of these pointer types 836 // was resolved before the other one was processed, the second one 837 // would never be resolved. 838 // Before this issue was fixed this test failed on Windows, 839 // where va_list expands to a named char* type. 840 typedef va_list TypeOne; 841 typedef char *TypeTwo; 842 843 // issue 28540 844 845 static void twoargs1(void *p, int n) {} 846 static void *twoargs2() { return 0; } 847 static int twoargs3(void * p) { return 0; } 848 849 // issue 28545 850 // Failed to add type conversion for negative constant. 851 852 static void issue28545F(char **p, int n, complex double a) {} 853 854 // issue 28772 part 1 - part 2 in testx.go 855 // Failed to add type conversion for Go constant set to C constant. 856 // No runtime test; just make sure it compiles. 857 858 #define issue28772Constant 1 859 860 // issue 28896 861 // cgo was incorrectly adding padding after a packed struct. 862 typedef struct { 863 void *f1; 864 uint32_t f2; 865 } __attribute__((__packed__)) innerPacked; 866 867 typedef struct { 868 innerPacked g1; 869 uint64_t g2; 870 } outerPacked; 871 872 typedef struct { 873 void *f1; 874 uint32_t f2; 875 } innerUnpacked; 876 877 typedef struct { 878 innerUnpacked g1; 879 uint64_t g2; 880 } outerUnpacked; 881 882 size_t offset(int x) { 883 switch (x) { 884 case 0: 885 return offsetof(innerPacked, f2); 886 case 1: 887 return offsetof(outerPacked, g2); 888 case 2: 889 return offsetof(innerUnpacked, f2); 890 case 3: 891 return offsetof(outerUnpacked, g2); 892 default: 893 abort(); 894 } 895 } 896 897 // issue 29748 898 899 typedef struct { char **p; } S29748; 900 static int f29748(S29748 *p) { return 0; } 901 902 // issue 29781 903 // Error with newline inserted into constant expression. 904 // Compilation test only, nothing to run. 905 906 static void issue29781F(char **p, int n) {} 907 #define ISSUE29781C 0 908 909 // issue 31093 910 static uint16_t issue31093F(uint16_t v) { return v; } 911 912 // issue 32579 913 typedef struct S32579 { unsigned char data[1]; } S32579; 914 915 // issue 37033, cgo.Handle 916 extern void GoFunc37033(uintptr_t handle); 917 void cFunc37033(uintptr_t handle) { GoFunc37033(handle); } 918 919 // issue 38649 920 // Test that #define'd type aliases work. 921 #define netbsd_gid unsigned int 922 923 // issue 40494 924 // Inconsistent handling of tagged enum and union types. 925 enum Enum40494 { X_40494 }; 926 union Union40494 { int x; }; 927 void issue40494(enum Enum40494 e, union Union40494* up) {} 928 929 // Issue 45451, bad handling of go:notinheap types. 930 typedef struct issue45451Undefined issue45451; 931 932 // Issue 49633, example of cgo.Handle with void*. 933 extern void GoFunc49633(void*); 934 void cfunc49633(void *context) { GoFunc49633(context); } 935 936 */ 937 import "C" 938 939 import ( 940 "context" 941 "fmt" 942 "math" 943 "math/rand" 944 "os" 945 "os/signal" 946 "reflect" 947 "runtime" 948 "runtime/cgo" 949 "sync" 950 "syscall" 951 "testing" 952 "time" 953 "unsafe" 954 ) 955 956 // alignment 957 958 func testAlign(t *testing.T) { 959 var evt C.SDL_KeyboardEvent 960 C.makeEvent(&evt) 961 if C.same(&evt, evt.typ, evt.which, evt.state, evt.keysym.scancode, evt.keysym.sym, evt.keysym.mod, evt.keysym.unicode) == 0 { 962 t.Error("*** bad alignment") 963 C.cTest(&evt) 964 t.Errorf("Go: %#x %#x %#x %#x %#x %#x %#x\n", 965 evt.typ, evt.which, evt.state, evt.keysym.scancode, 966 evt.keysym.sym, evt.keysym.mod, evt.keysym.unicode) 967 t.Error(evt) 968 } 969 } 970 971 // api 972 973 const greeting = "hello, world" 974 975 type testPair struct { 976 Name string 977 Got, Want interface{} 978 } 979 980 var testPairs = []testPair{ 981 {"GoString", C.GoString(C.greeting), greeting}, 982 {"GoStringN", C.GoStringN(C.greeting, 5), greeting[:5]}, 983 {"GoBytes", C.GoBytes(unsafe.Pointer(C.greeting), 5), []byte(greeting[:5])}, 984 } 985 986 func testHelpers(t *testing.T) { 987 for _, pair := range testPairs { 988 if !reflect.DeepEqual(pair.Got, pair.Want) { 989 t.Errorf("%s: got %#v, want %#v", pair.Name, pair.Got, pair.Want) 990 } 991 } 992 } 993 994 // basic test cases 995 996 const EINVAL = C.EINVAL /* test #define */ 997 998 var KILO = C.KILO 999 1000 func uuidgen() { 1001 var uuid C.cgo_uuid_t 1002 C.uuid_generate(&uuid[0]) 1003 } 1004 1005 func Strtol(s string, base int) (int, error) { 1006 p := C.CString(s) 1007 n, err := C.strtol(p, nil, C.int(base)) 1008 C.free(unsafe.Pointer(p)) 1009 return int(n), err 1010 } 1011 1012 func Atol(s string) int { 1013 p := C.CString(s) 1014 n := C.atol(p) 1015 C.free(unsafe.Pointer(p)) 1016 return int(n) 1017 } 1018 1019 func testConst(t *testing.T) { 1020 C.myConstFunc(nil, 0, nil) 1021 } 1022 1023 func testEnum(t *testing.T) { 1024 if C.Enum1 != 1 || C.Enum2 != 2 { 1025 t.Error("bad enum", C.Enum1, C.Enum2) 1026 } 1027 } 1028 1029 func testNamedEnum(t *testing.T) { 1030 e := new(C.enum_E) 1031 1032 *e = C.Enum1 1033 if *e != 1 { 1034 t.Error("bad enum", C.Enum1) 1035 } 1036 1037 *e = C.Enum2 1038 if *e != 2 { 1039 t.Error("bad enum", C.Enum2) 1040 } 1041 } 1042 1043 func testCastToEnum(t *testing.T) { 1044 e := C.enum_E(C.Enum1) 1045 if e != 1 { 1046 t.Error("bad enum", C.Enum1) 1047 } 1048 1049 e = C.enum_E(C.Enum2) 1050 if e != 2 { 1051 t.Error("bad enum", C.Enum2) 1052 } 1053 } 1054 1055 func testAtol(t *testing.T) { 1056 l := Atol("123") 1057 if l != 123 { 1058 t.Error("Atol 123: ", l) 1059 } 1060 } 1061 1062 func testErrno(t *testing.T) { 1063 p := C.CString("no-such-file") 1064 m := C.CString("r") 1065 f, err := C.fopen(p, m) 1066 C.free(unsafe.Pointer(p)) 1067 C.free(unsafe.Pointer(m)) 1068 if err == nil { 1069 C.fclose(f) 1070 t.Fatalf("C.fopen: should fail") 1071 } 1072 if err != syscall.ENOENT { 1073 t.Fatalf("C.fopen: unexpected error: %v", err) 1074 } 1075 } 1076 1077 func testMultipleAssign(t *testing.T) { 1078 p := C.CString("234") 1079 n, m := C.strtol(p, nil, 345), C.strtol(p, nil, 10) 1080 if runtime.GOOS == "openbsd" { 1081 // Bug in OpenBSD strtol(3) - base > 36 succeeds. 1082 if (n != 0 && n != 239089) || m != 234 { 1083 t.Fatal("Strtol x2: ", n, m) 1084 } 1085 } else if n != 0 || m != 234 { 1086 t.Fatal("Strtol x2: ", n, m) 1087 } 1088 C.free(unsafe.Pointer(p)) 1089 } 1090 1091 var ( 1092 cuint = (C.uint)(0) 1093 culong C.ulong 1094 cchar C.char 1095 ) 1096 1097 type Context struct { 1098 ctx *C.struct_ibv_context 1099 } 1100 1101 func benchCgoCall(b *testing.B) { 1102 b.Run("add-int", func(b *testing.B) { 1103 const x = C.int(2) 1104 const y = C.int(3) 1105 1106 for i := 0; i < b.N; i++ { 1107 C.add(x, y) 1108 } 1109 }) 1110 1111 b.Run("one-pointer", func(b *testing.B) { 1112 var a0 C.VkDeviceCreateInfo 1113 for i := 0; i < b.N; i++ { 1114 C.handleComplexPointer(&a0) 1115 } 1116 }) 1117 b.Run("string-pointer-escape", func(b *testing.B) { 1118 for i := 0; i < b.N; i++ { 1119 var s string 1120 C.handleGoStringPointerEscape(unsafe.Pointer(&s)) 1121 } 1122 }) 1123 b.Run("string-pointer-noescape", func(b *testing.B) { 1124 for i := 0; i < b.N; i++ { 1125 var s string 1126 C.handleGoStringPointerNoescape(unsafe.Pointer(&s)) 1127 } 1128 }) 1129 b.Run("eight-pointers", func(b *testing.B) { 1130 var a0, a1, a2, a3, a4, a5, a6, a7 C.VkDeviceCreateInfo 1131 for i := 0; i < b.N; i++ { 1132 C.handleComplexPointer8(&a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7) 1133 } 1134 }) 1135 b.Run("eight-pointers-nil", func(b *testing.B) { 1136 var a0, a1, a2, a3, a4, a5, a6, a7 *C.VkDeviceCreateInfo 1137 for i := 0; i < b.N; i++ { 1138 C.handleComplexPointer8(a0, a1, a2, a3, a4, a5, a6, a7) 1139 } 1140 }) 1141 b.Run("eight-pointers-array", func(b *testing.B) { 1142 var a [8]C.VkDeviceCreateInfo 1143 for i := 0; i < b.N; i++ { 1144 C.handleComplexPointer8(&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7]) 1145 } 1146 }) 1147 b.Run("eight-pointers-slice", func(b *testing.B) { 1148 a := make([]C.VkDeviceCreateInfo, 8) 1149 for i := 0; i < b.N; i++ { 1150 C.handleComplexPointer8(&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7]) 1151 } 1152 }) 1153 } 1154 1155 // Benchmark measuring overhead from Go to C and back to Go (via a callback) 1156 func benchCallback(b *testing.B) { 1157 var x = false 1158 for i := 0; i < b.N; i++ { 1159 nestedCall(func() { x = true }) 1160 } 1161 if !x { 1162 b.Fatal("nestedCall was not invoked") 1163 } 1164 } 1165 1166 var sinkString string 1167 1168 func benchGoString(b *testing.B) { 1169 for i := 0; i < b.N; i++ { 1170 sinkString = C.GoString(C.cstr) 1171 } 1172 const want = "abcefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890" 1173 if sinkString != want { 1174 b.Fatalf("%q != %q", sinkString, want) 1175 } 1176 } 1177 1178 // Static (build-time) test that syntax traversal visits all operands of s[i:j:k]. 1179 func sliceOperands(array [2000]int) { 1180 _ = array[C.KILO:C.KILO:C.KILO] // no type error 1181 } 1182 1183 // set in cgo_thread_lock.go init 1184 var testThreadLockFunc = func(*testing.T) {} 1185 1186 // complex alignment 1187 1188 func TestComplexAlign(t *testing.T) { 1189 if C.cplxAlign.x != 3.14 { 1190 t.Errorf("got %v, expected 3.14", C.cplxAlign.x) 1191 } 1192 if C.cplxAlign.y != 2.17 { 1193 t.Errorf("got %v, expected 2.17", C.cplxAlign.y) 1194 } 1195 } 1196 1197 // constants and pointer checking 1198 1199 func testCheckConst(t *testing.T) { 1200 // The test is that this compiles successfully. 1201 p := C.malloc(C.size_t(unsafe.Sizeof(C.int(0)))) 1202 defer C.free(p) 1203 C.CheckConstFunc(&C.CheckConstStruct{(*C.int)(p)}, C.CheckConstVal) 1204 } 1205 1206 // duplicate symbol 1207 1208 func duplicateSymbols() { 1209 fmt.Printf("%v %v %v\n", C.base_symbol, C.alias_one, C.alias_two) 1210 } 1211 1212 // environment 1213 1214 // This is really an os package test but here for convenience. 1215 func testSetEnv(t *testing.T) { 1216 if runtime.GOOS == "windows" { 1217 // Go uses SetEnvironmentVariable on windows. However, 1218 // C runtime takes a *copy* at process startup of the 1219 // OS environment, and stores it in environ/envp. 1220 // It is this copy that getenv/putenv manipulate. 1221 t.Logf("skipping test") 1222 return 1223 } 1224 const key = "CGO_OS_TEST_KEY" 1225 const val = "CGO_OS_TEST_VALUE" 1226 os.Setenv(key, val) 1227 keyc := C.CString(key) 1228 defer C.free(unsafe.Pointer(keyc)) 1229 v := C.getenv(keyc) 1230 if uintptr(unsafe.Pointer(v)) == 0 { 1231 t.Fatal("getenv returned NULL") 1232 } 1233 vs := C.GoString(v) 1234 if vs != val { 1235 t.Fatalf("getenv() = %q; want %q", vs, val) 1236 } 1237 } 1238 1239 // function pointer variables 1240 1241 func callBridge(f C.intFunc) int { 1242 return int(C.bridge_int_func(f)) 1243 } 1244 1245 func callCBridge(f C.intFunc) C.int { 1246 return C.bridge_int_func(f) 1247 } 1248 1249 func testFpVar(t *testing.T) { 1250 const expected = 42 1251 f := C.intFunc(C.fortytwo) 1252 res1 := C.bridge_int_func(f) 1253 if r1 := int(res1); r1 != expected { 1254 t.Errorf("got %d, want %d", r1, expected) 1255 } 1256 res2 := callCBridge(f) 1257 if r2 := int(res2); r2 != expected { 1258 t.Errorf("got %d, want %d", r2, expected) 1259 } 1260 r3 := callBridge(f) 1261 if r3 != expected { 1262 t.Errorf("got %d, want %d", r3, expected) 1263 } 1264 } 1265 1266 // issue 1222 1267 type AsyncEvent struct { 1268 event C.struct_ibv_async_event 1269 } 1270 1271 // issue 1635 1272 1273 func test1635(t *testing.T) { 1274 C.scatter() 1275 if v := C.hola; v != 0 { 1276 t.Fatalf("C.hola is %d, should be 0", v) 1277 } 1278 if v := C.testHola(); v != 0 { 1279 t.Fatalf("C.testHola() is %d, should be 0", v) 1280 } 1281 } 1282 1283 // issue 2470 1284 1285 func testUnsignedInt(t *testing.T) { 1286 a := (int64)(C.UINT32VAL) 1287 b := (int64)(0xc008427b) 1288 if a != b { 1289 t.Errorf("Incorrect unsigned int - got %x, want %x", a, b) 1290 } 1291 } 1292 1293 // issue 3250 1294 1295 func test3250(t *testing.T) { 1296 if runtime.GOOS == "windows" { 1297 t.Skip("not applicable on windows") 1298 } 1299 1300 t.Skip("skipped, see golang.org/issue/5885") 1301 var ( 1302 thres = 1 1303 sig = syscall_dot_SIGCHLD 1304 ) 1305 type result struct { 1306 n int 1307 sig os.Signal 1308 } 1309 var ( 1310 sigCh = make(chan os.Signal, 10) 1311 waitStart = make(chan struct{}) 1312 waitDone = make(chan result) 1313 ) 1314 1315 signal.Notify(sigCh, sig) 1316 1317 go func() { 1318 n := 0 1319 alarm := time.After(time.Second * 3) 1320 for { 1321 select { 1322 case <-waitStart: 1323 waitStart = nil 1324 case v := <-sigCh: 1325 n++ 1326 if v != sig || n > thres { 1327 waitDone <- result{n, v} 1328 return 1329 } 1330 case <-alarm: 1331 waitDone <- result{n, sig} 1332 return 1333 } 1334 } 1335 }() 1336 1337 waitStart <- struct{}{} 1338 C.testSendSIG() 1339 r := <-waitDone 1340 if r.sig != sig { 1341 t.Fatalf("received signal %v, but want %v", r.sig, sig) 1342 } 1343 t.Logf("got %d signals\n", r.n) 1344 if r.n <= thres { 1345 t.Fatalf("expected more than %d", thres) 1346 } 1347 } 1348 1349 // issue 3261 1350 1351 func testLibgcc(t *testing.T) { 1352 var table = []struct { 1353 in, out C.int 1354 }{ 1355 {0, 0}, 1356 {1, 1}, 1357 {-42, 42}, 1358 {1000300, 1000300}, 1359 {1 - 1<<31, 1<<31 - 1}, 1360 } 1361 for _, v := range table { 1362 if o := C.vabs(v.in); o != v.out { 1363 t.Fatalf("abs(%d) got %d, should be %d", v.in, o, v.out) 1364 return 1365 } 1366 } 1367 } 1368 1369 // issue 3729 1370 1371 func test3729(t *testing.T) { 1372 if runtime.GOOS == "windows" { 1373 t.Skip("skipping on windows") 1374 } 1375 1376 _, e := C.g() 1377 if e != syscall.E2BIG { 1378 t.Errorf("got %q, expect %q", e, syscall.E2BIG) 1379 } 1380 _, e = C.g2(C.EINVAL, C._expA, C._expB, C._expC, C._expD) 1381 if e != syscall.EINVAL { 1382 t.Errorf("got %q, expect %q", e, syscall.EINVAL) 1383 } 1384 } 1385 1386 // issue 3945 1387 1388 func testPrintf(t *testing.T) { 1389 C.say() 1390 } 1391 1392 // issue 4054 1393 1394 var issue4054a = []int{C.A, C.B, C.C, C.D, C.E, C.F, C.G, C.H, C.I, C.J} 1395 1396 // issue 4339 1397 1398 func test4339(t *testing.T) { 1399 C.handle4339(&C.exported4339) 1400 } 1401 1402 // issue 4417 1403 1404 func testBoolAlign(t *testing.T) { 1405 b := C.c_bool(true, true, 10, true, false) 1406 if b != 10 { 1407 t.Fatalf("found %d expected 10\n", b) 1408 } 1409 b = C.c_bool(true, true, 5, true, true) 1410 if b != 5 { 1411 t.Fatalf("found %d expected 5\n", b) 1412 } 1413 b = C.c_bool(true, true, 3, true, false) 1414 if b != 3 { 1415 t.Fatalf("found %d expected 3\n", b) 1416 } 1417 b = C.c_bool(false, false, 1, true, false) 1418 if b != 1 { 1419 t.Fatalf("found %d expected 1\n", b) 1420 } 1421 b = C.c_bool(false, true, 200, true, false) 1422 if b != 200 { 1423 t.Fatalf("found %d expected 200\n", b) 1424 } 1425 } 1426 1427 // issue 4857 1428 1429 func test4857() { 1430 _ = C.issue4857() 1431 } 1432 1433 // issue 5224 1434 1435 func testCflags(t *testing.T) { 1436 is_windows := C.is_windows == 1 1437 if is_windows != (runtime.GOOS == "windows") { 1438 t.Errorf("is_windows: %v, runtime.GOOS: %s", is_windows, runtime.GOOS) 1439 } 1440 if C.common != 123 { 1441 t.Errorf("common: %v (expected 123)", C.common) 1442 } 1443 } 1444 1445 // issue 5227 1446 1447 func test5227(t *testing.T) { 1448 C.init() 1449 } 1450 1451 func selectfont() C.Fontinfo { 1452 return C.SansTypeface 1453 } 1454 1455 // issue 5242 1456 1457 func test5242(t *testing.T) { 1458 if got := C.issue5242(C.foo{}, C.bar{}); got != 5242 { 1459 t.Errorf("got %v", got) 1460 } 1461 } 1462 1463 func test5603(t *testing.T) { 1464 var x [5]int64 1465 exp := int64(C.issue5603exp) 1466 x[0] = int64(C.issue5603foo0()) 1467 x[1] = int64(C.issue5603foo1(nil)) 1468 x[2] = int64(C.issue5603foo2(nil, nil)) 1469 x[3] = int64(C.issue5603foo3(nil, nil, nil)) 1470 x[4] = int64(C.issue5603foo4(nil, nil, nil, nil)) 1471 for i, v := range x { 1472 if v != exp { 1473 t.Errorf("issue5603foo%d() returns %v, expected %v", i, v, exp) 1474 } 1475 } 1476 } 1477 1478 // issue 5337 1479 1480 func test5337(t *testing.T) { 1481 C.test5337() 1482 } 1483 1484 // issue 5740 1485 1486 func test5740(t *testing.T) { 1487 if v := C.test5740a() + C.test5740b(); v != 5 { 1488 t.Errorf("expected 5, got %v", v) 1489 } 1490 } 1491 1492 // issue 5986 1493 1494 func test5986(t *testing.T) { 1495 C.output5986() 1496 } 1497 1498 // issue 6128 1499 1500 func test6128() { 1501 // nothing to run, just make sure this compiles. 1502 _ = C.X 1503 } 1504 1505 // issue 6390 1506 1507 func test6390(t *testing.T) { 1508 p1 := C.malloc(1024) 1509 if p1 == nil { 1510 t.Fatalf("C.malloc(1024) returned nil") 1511 } 1512 p2 := C.malloc(0) 1513 if p2 == nil { 1514 t.Fatalf("C.malloc(0) returned nil") 1515 } 1516 C.free(p1) 1517 C.free(p2) 1518 } 1519 1520 func test6472() { 1521 // nothing to run, just make sure this compiles 1522 s := new(C.z) 1523 println(s.y[0].x) 1524 } 1525 1526 // issue 6506 1527 1528 func test6506() { 1529 // nothing to run, just make sure this compiles 1530 var x C.size_t 1531 1532 C.calloc(x, x) 1533 C.malloc(x) 1534 C.realloc(nil, x) 1535 C.memcpy(nil, nil, x) 1536 C.memcmp(nil, nil, x) 1537 C.memmove(nil, nil, x) 1538 C.strncpy(nil, nil, x) 1539 C.strncmp(nil, nil, x) 1540 C.strncat(nil, nil, x) 1541 x = C.strxfrm(nil, nil, x) 1542 C.memchr(nil, 0, x) 1543 x = C.strcspn(nil, nil) 1544 x = C.strspn(nil, nil) 1545 C.memset(nil, 0, x) 1546 x = C.strlen(nil) 1547 _ = x 1548 } 1549 1550 // issue 6612 1551 1552 func testNaming(t *testing.T) { 1553 C.myfunc() 1554 C.myfunc_def() 1555 if v := C.myvar; v != 5 { 1556 t.Errorf("C.myvar = %d, want 5", v) 1557 } 1558 if v := C.myvar_def; v != 5 { 1559 t.Errorf("C.myvar_def = %d, want 5", v) 1560 } 1561 if s := C.GoString(C.mytext); s != "abcdef" { 1562 t.Errorf("C.mytext = %q, want %q", s, "abcdef") 1563 } 1564 if s := C.GoString(C.mytext_def); s != "abcdef" { 1565 t.Errorf("C.mytext_def = %q, want %q", s, "abcdef") 1566 } 1567 if c := C.myenum; c != 1234 { 1568 t.Errorf("C.myenum = %v, want 1234", c) 1569 } 1570 if c := C.myenum_def; c != 1234 { 1571 t.Errorf("C.myenum_def = %v, want 1234", c) 1572 } 1573 { 1574 const c = C.myenum 1575 if c != 1234 { 1576 t.Errorf("C.myenum as const = %v, want 1234", c) 1577 } 1578 } 1579 { 1580 const c = C.myenum_def 1581 if c != 1234 { 1582 t.Errorf("C.myenum as const = %v, want 1234", c) 1583 } 1584 } 1585 if c := C.myint_def; c != 12345 { 1586 t.Errorf("C.myint_def = %v, want 12345", c) 1587 } 1588 { 1589 const c = C.myint_def 1590 if c != 12345 { 1591 t.Errorf("C.myint as const = %v, want 12345", c) 1592 } 1593 } 1594 1595 if c := C.myfloat_def; c != 1.5 { 1596 t.Errorf("C.myint_def = %v, want 1.5", c) 1597 } 1598 { 1599 const c = C.myfloat_def 1600 if c != 1.5 { 1601 t.Errorf("C.myint as const = %v, want 1.5", c) 1602 } 1603 } 1604 1605 if s := C.mystring_def; s != "hello" { 1606 t.Errorf("C.mystring_def = %q, want %q", s, "hello") 1607 } 1608 } 1609 1610 // issue 6907 1611 1612 func test6907(t *testing.T) { 1613 want := "yarn" 1614 if got := C.GoString(C.Issue6907CopyString(want)); got != want { 1615 t.Errorf("C.GoString(C.Issue6907CopyString(%q)) == %q, want %q", want, got, want) 1616 } 1617 } 1618 1619 // issue 7560 1620 1621 func test7560(t *testing.T) { 1622 // some mingw don't implement __packed__ correctly. 1623 if C.offset7560() != 1 { 1624 t.Skip("C compiler did not pack struct") 1625 } 1626 1627 // C.misaligned should have x but then a padding field to get to the end of the struct. 1628 // There should not be a field named 'y'. 1629 var v C.misaligned 1630 rt := reflect.TypeOf(&v).Elem() 1631 if rt.NumField() != 2 || rt.Field(0).Name != "x" || rt.Field(1).Name != "_" { 1632 t.Errorf("unexpected fields in C.misaligned:\n") 1633 for i := 0; i < rt.NumField(); i++ { 1634 t.Logf("%+v\n", rt.Field(i)) 1635 } 1636 } 1637 } 1638 1639 // issue 7786 1640 1641 func f() { 1642 var x1 *C.typedef_test7786 1643 var x2 *C.struct_test7786 1644 x1 = x2 1645 x2 = x1 1646 C.f7786(x1) 1647 C.f7786(x2) 1648 C.g7786(x1) 1649 C.g7786(x2) 1650 1651 var b1 *C.typedef_body7786 1652 var b2 *C.struct_body7786 1653 b1 = b2 1654 b2 = b1 1655 C.b7786(b1) 1656 C.b7786(b2) 1657 C.c7786(b1) 1658 C.c7786(b2) 1659 1660 var u1 *C.typedef_union7786 1661 var u2 *C.union_union7786 1662 u1 = u2 1663 u2 = u1 1664 C.u7786(u1) 1665 C.u7786(u2) 1666 C.v7786(u1) 1667 C.v7786(u2) 1668 } 1669 1670 // issue 8092 1671 1672 func test8092(t *testing.T) { 1673 tests := []struct { 1674 s string 1675 a, b *C.char 1676 }{ 1677 {"text", &C.text[0], C.ctext()}, 1678 {"data", &C.data[0], C.cdata()}, 1679 } 1680 for _, test := range tests { 1681 if test.a != test.b { 1682 t.Errorf("%s: pointer mismatch: %v != %v", test.s, test.a, test.b) 1683 } 1684 if got := C.GoString(test.a); got != test.s { 1685 t.Errorf("%s: points at %#v, want %#v", test.s, got, test.s) 1686 } 1687 } 1688 } 1689 1690 // issues 8368 and 8441 1691 1692 func issue8368(one *C.struct_one, two *C.struct_two) { 1693 } 1694 1695 func issue8441(one *C.one, two *C.two) { 1696 issue8441(two.x, one.x) 1697 } 1698 1699 // issue 8428 1700 1701 var _ = C.struct_issue8428one{ 1702 b: C.char(0), 1703 // The trailing rest field is not available in cgo. 1704 // See issue 11925. 1705 // rest: [0]C.char{}, 1706 } 1707 1708 var _ = C.struct_issue8428two{ 1709 p: unsafe.Pointer(nil), 1710 b: C.char(0), 1711 rest: [0]C.char{}, 1712 } 1713 1714 var _ = C.struct_issue8428three{ 1715 w: [1][2][3][0]C.char{}, 1716 x: [2][3][0][1]C.char{}, 1717 y: [3][0][1][2]C.char{}, 1718 z: [0][1][2][3]C.char{}, 1719 } 1720 1721 // issue 8811 1722 1723 func test8811(t *testing.T) { 1724 C.issue8811Execute() 1725 } 1726 1727 // issue 9557 1728 1729 func test9557(t *testing.T) { 1730 // implicitly dereference a Go variable 1731 foo := C.issue9557foo 1732 if v := foo.a; v != 42 { 1733 t.Fatalf("foo.a expected 42, but got %d", v) 1734 } 1735 1736 // explicitly dereference a C variable 1737 if v := (*C.issue9557foo).a; v != 42 { 1738 t.Fatalf("(*C.issue9557foo).a expected 42, but is %d", v) 1739 } 1740 1741 // implicitly dereference a C variable 1742 if v := C.issue9557foo.a; v != 42 { 1743 t.Fatalf("C.issue9557foo.a expected 42, but is %d", v) 1744 } 1745 } 1746 1747 // issue 8331 part 1 1748 1749 func issue8331a() C.issue8331 { 1750 return issue8331Var 1751 } 1752 1753 // issue 10303 1754 1755 func test10303(t *testing.T, n int) { 1756 if runtime.Compiler == "gccgo" { 1757 t.Skip("gccgo permits C pointers on the stack") 1758 } 1759 1760 // Run at a few different stack depths just to avoid an unlucky pass 1761 // due to variables ending up on different pages. 1762 if n > 0 { 1763 test10303(t, n-1) 1764 } 1765 if t.Failed() { 1766 return 1767 } 1768 var x, y, z, v, si C.int 1769 var s C.Struct 1770 C.setintstar(&x) 1771 C.setintptr(&y) 1772 C.setvoidptr(unsafe.Pointer(&v)) 1773 s.P = &si 1774 C.setstruct(s) 1775 1776 if uintptr(unsafe.Pointer(&x))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff { 1777 t.Error("C int* argument on stack") 1778 } 1779 if uintptr(unsafe.Pointer(&y))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff { 1780 t.Error("C intptr argument on stack") 1781 } 1782 if uintptr(unsafe.Pointer(&v))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff { 1783 t.Error("C void* argument on stack") 1784 } 1785 if uintptr(unsafe.Pointer(&si))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff { 1786 t.Error("C struct field pointer on stack") 1787 } 1788 } 1789 1790 // issue 11925 1791 1792 func test11925(t *testing.T) { 1793 if C.sizeof_struct_a11925 != unsafe.Sizeof(C.struct_a11925{}) { 1794 t.Errorf("size of a changed: C %d, Go %d", C.sizeof_struct_a11925, unsafe.Sizeof(C.struct_a11925{})) 1795 } 1796 if C.sizeof_struct_b11925 != unsafe.Sizeof(C.struct_b11925{}) { 1797 t.Errorf("size of b changed: C %d, Go %d", C.sizeof_struct_b11925, unsafe.Sizeof(C.struct_b11925{})) 1798 } 1799 } 1800 1801 // issue 12030 1802 1803 func test12030(t *testing.T) { 1804 buf := (*C.char)(C.malloc(256)) 1805 defer C.free(unsafe.Pointer(buf)) 1806 for _, f := range []float64{1.0, 2.0, 3.14} { 1807 C.issue12030conv(buf, C.double(f)) 1808 got := C.GoString(buf) 1809 if want := fmt.Sprintf("d=%g", f); got != want { 1810 t.Fatalf("C.sprintf failed for %g: %q != %q", f, got, want) 1811 } 1812 } 1813 } 1814 1815 // issue 13402 1816 1817 var _ C.complexfloat 1818 var _ C.complexdouble 1819 1820 // issue 13930 1821 // Test that cgo's multiple-value special form for 1822 // C function calls works in variable declaration statements. 1823 1824 var _, _ = C.abs(0) 1825 1826 // issue 14838 1827 1828 func test14838(t *testing.T) { 1829 data := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 1830 cData := C.CBytes(data) 1831 defer C.free(cData) 1832 1833 if C.check_cbytes((*C.char)(cData), C.size_t(len(data))) == 0 { 1834 t.Fatalf("mismatched data: expected %v, got %v", data, (*(*[10]byte)(unsafe.Pointer(cData)))[:]) 1835 } 1836 } 1837 1838 // issue 17065 1839 1840 var sink C.int 1841 1842 func test17065(t *testing.T) { 1843 if runtime.GOOS == "darwin" || runtime.GOOS == "ios" { 1844 t.Skip("broken on darwin; issue 17065") 1845 } 1846 for i := range C.ii { 1847 sink = C.ii[i] 1848 } 1849 } 1850 1851 // issue 17537 1852 1853 func test17537(t *testing.T) { 1854 v := C.S17537{i: 17537} 1855 if got, want := C.I17537(&v), C.int(17537); got != want { 1856 t.Errorf("got %d, want %d", got, want) 1857 } 1858 1859 p := (*C.char)(C.malloc(1)) 1860 *p = 17 1861 if got, want := C.F17537(&p), C.int(17); got != want { 1862 t.Errorf("got %d, want %d", got, want) 1863 } 1864 1865 C.F18298(nil) 1866 var v18298 C.T18298_2 1867 C.G18298(C.T18298_1(v18298)) 1868 } 1869 1870 // issue 17723 1871 1872 func testAPI() { 1873 var cs *C.char 1874 cs = C.CString("hello") 1875 defer C.free(unsafe.Pointer(cs)) 1876 var s string 1877 s = C.GoString((*C.char)(C.api_hello)) 1878 s = C.GoStringN((*C.char)(C.api_hello), C.int(6)) 1879 var b []byte 1880 b = C.GoBytes(unsafe.Pointer(C.api_hello), C.int(6)) 1881 _, _ = s, b 1882 C.cstring_pointer_fun(nil) 1883 } 1884 1885 // issue 18126 1886 1887 func test18126(t *testing.T) { 1888 p := C.malloc(1) 1889 _, err := C.Issue18126C(&p) 1890 C.free(p) 1891 _ = err 1892 } 1893 1894 // issue 18720 1895 1896 func test18720(t *testing.T) { 1897 if got, want := C.HELLO_WORLD, "hello\000world"; got != want { 1898 t.Errorf("C.HELLO_WORLD == %q, expected %q", got, want) 1899 } 1900 1901 if got, want := C.VAR1, C.int(5); got != want { 1902 t.Errorf("C.VAR1 == %v, expected %v", got, want) 1903 } 1904 1905 if got, want := *C.ADDR, C.int(5); got != want { 1906 t.Errorf("*C.ADDR == %v, expected %v", got, want) 1907 } 1908 1909 if got, want := C.CALL, C.int(6); got != want { 1910 t.Errorf("C.CALL == %v, expected %v", got, want) 1911 } 1912 1913 if got, want := C.CALL, C.int(7); got != want { 1914 t.Errorf("C.CALL == %v, expected %v", got, want) 1915 } 1916 1917 // Issue 20125. 1918 if got, want := C.SIZE_OF_FOO, 1; got != want { 1919 t.Errorf("C.SIZE_OF_FOO == %v, expected %v", got, want) 1920 } 1921 } 1922 1923 // issue 20129 1924 1925 func test20129(t *testing.T) { 1926 if C.issue20129 != 0 { 1927 t.Fatal("test is broken") 1928 } 1929 C.issue20129Foo() 1930 if C.issue20129 != 1 { 1931 t.Errorf("got %v but expected %v", C.issue20129, 1) 1932 } 1933 C.issue20129Bar() 1934 if C.issue20129 != 2 { 1935 t.Errorf("got %v but expected %v", C.issue20129, 2) 1936 } 1937 } 1938 1939 // issue 20369 1940 1941 func test20369(t *testing.T) { 1942 if C.XUINT64_MAX != math.MaxUint64 { 1943 t.Fatalf("got %v, want %v", uint64(C.XUINT64_MAX), uint64(math.MaxUint64)) 1944 } 1945 } 1946 1947 // issue 21668 1948 1949 var issue21668_X = C.x21668 1950 1951 // issue 21708 1952 1953 func test21708(t *testing.T) { 1954 if got, want := C.CAST_TO_INT64, -1; got != want { 1955 t.Errorf("C.CAST_TO_INT64 == %v, expected %v", got, want) 1956 } 1957 } 1958 1959 // issue 21809 1960 1961 func test21809(t *testing.T) { 1962 longVar := C.long(3) 1963 typedefVar := C.MySigned_t(4) 1964 typedefTypedefVar := C.MySigned2_t(5) 1965 1966 // all three should be considered identical to `long` 1967 if ret := C.takes_long(longVar); ret != 9 { 1968 t.Errorf("got %v but expected %v", ret, 9) 1969 } 1970 if ret := C.takes_long(typedefVar); ret != 16 { 1971 t.Errorf("got %v but expected %v", ret, 16) 1972 } 1973 if ret := C.takes_long(typedefTypedefVar); ret != 25 { 1974 t.Errorf("got %v but expected %v", ret, 25) 1975 } 1976 1977 // They should also be identical to the typedef'd type 1978 if ret := C.takes_typedef(longVar); ret != 9 { 1979 t.Errorf("got %v but expected %v", ret, 9) 1980 } 1981 if ret := C.takes_typedef(typedefVar); ret != 16 { 1982 t.Errorf("got %v but expected %v", ret, 16) 1983 } 1984 if ret := C.takes_typedef(typedefTypedefVar); ret != 25 { 1985 t.Errorf("got %v but expected %v", ret, 25) 1986 } 1987 } 1988 1989 // issue 22906 1990 1991 func test22906(t *testing.T) { 1992 var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types. 1993 _ = x1 1994 var x2 C.jclass = 0 1995 _ = x2 1996 var x3 C.jthrowable = 0 1997 _ = x3 1998 var x4 C.jstring = 0 1999 _ = x4 2000 var x5 C.jarray = 0 2001 _ = x5 2002 var x6 C.jbooleanArray = 0 2003 _ = x6 2004 var x7 C.jbyteArray = 0 2005 _ = x7 2006 var x8 C.jcharArray = 0 2007 _ = x8 2008 var x9 C.jshortArray = 0 2009 _ = x9 2010 var x10 C.jintArray = 0 2011 _ = x10 2012 var x11 C.jlongArray = 0 2013 _ = x11 2014 var x12 C.jfloatArray = 0 2015 _ = x12 2016 var x13 C.jdoubleArray = 0 2017 _ = x13 2018 var x14 C.jobjectArray = 0 2019 _ = x14 2020 var x15 C.jweak = 0 2021 _ = x15 2022 } 2023 2024 // issue 22958 2025 // Nothing to run, just make sure this compiles. 2026 var Vissue22958 C.issue22958Type 2027 2028 func test23356(t *testing.T) { 2029 if got, want := C.a(), C.int(5); got != want { 2030 t.Errorf("C.a() == %v, expected %v", got, want) 2031 } 2032 if got, want := C.r(), C.int(3); got != want { 2033 t.Errorf("C.r() == %v, expected %v", got, want) 2034 } 2035 } 2036 2037 // issue 23720 2038 2039 func Issue23720F() { 2040 var x C.issue23720A 2041 C.issue23720F(x) 2042 } 2043 2044 // issue 24206 2045 2046 func test24206(t *testing.T) { 2047 if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" { 2048 t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH) 2049 } 2050 2051 if l := len(C.GoString(C.dangerousString1())); l != 123 { 2052 t.Errorf("Incorrect string length - got %d, want 123", l) 2053 } 2054 if l := len(C.GoString(C.dangerousString2())); l != 4096+123 { 2055 t.Errorf("Incorrect string length - got %d, want %d", l, 4096+123) 2056 } 2057 } 2058 2059 // issue 25143 2060 2061 func issue25143sum(ns ...C.int) C.int { 2062 total := C.int(0) 2063 for _, n := range ns { 2064 total += n 2065 } 2066 return total 2067 } 2068 2069 func test25143(t *testing.T) { 2070 if got, want := issue25143sum(1, 2, 3), C.int(6); got != want { 2071 t.Errorf("issue25143sum(1, 2, 3) == %v, expected %v", got, want) 2072 } 2073 } 2074 2075 // issue 26066 2076 // Wrong type of constant with GCC 8 and newer. 2077 2078 func test26066(t *testing.T) { 2079 var i = int64(C.issue26066) 2080 if i != -1 { 2081 t.Errorf("got %d, want -1", i) 2082 } 2083 } 2084 2085 // issue 26517 2086 var a C.TypeOne 2087 var b C.TypeTwo 2088 2089 // issue 27660 2090 // Stress the interaction between the race detector and cgo in an 2091 // attempt to reproduce the memory corruption described in #27660. 2092 // The bug was very timing sensitive; at the time of writing this 2093 // test would only trigger the bug about once out of every five runs. 2094 2095 func test27660(t *testing.T) { 2096 ctx, cancel := context.WithCancel(context.Background()) 2097 defer cancel() 2098 ints := make([]int, 100) 2099 locks := make([]sync.Mutex, 100) 2100 // Slowly create threads so that ThreadSanitizer is forced to 2101 // frequently resize its SyncClocks. 2102 for i := 0; i < 100; i++ { 2103 go func() { 2104 for ctx.Err() == nil { 2105 // Sleep in C for long enough that it is likely that the runtime 2106 // will retake this goroutine's currently wired P. 2107 C.usleep(1000 /* 1ms */) 2108 runtime.Gosched() // avoid starvation (see #28701) 2109 } 2110 }() 2111 go func() { 2112 // Trigger lots of synchronization and memory reads/writes to 2113 // increase the likelihood that the race described in #27660 2114 // results in corruption of ThreadSanitizer's internal state 2115 // and thus an assertion failure or segfault. 2116 i := 0 2117 for ctx.Err() == nil { 2118 j := rand.Intn(100) 2119 locks[j].Lock() 2120 ints[j]++ 2121 locks[j].Unlock() 2122 // needed for gccgo, to avoid creation of an 2123 // unpreemptible "fast path" in this loop. Choice 2124 // of (1<<24) is somewhat arbitrary. 2125 if i%(1<<24) == 0 { 2126 runtime.Gosched() 2127 } 2128 i++ 2129 2130 } 2131 }() 2132 time.Sleep(time.Millisecond) 2133 } 2134 } 2135 2136 // issue 28540 2137 2138 func twoargsF() { 2139 var v struct{ p *byte } 2140 C.twoargs1(C.twoargs2(), C.twoargs3(unsafe.Pointer(&v))) 2141 } 2142 2143 // issue 28545 2144 2145 func issue28545G(p **C.char) { 2146 C.issue28545F(p, -1, (0)) 2147 C.issue28545F(p, 2+3, complex(1, 1)) 2148 C.issue28545F(p, issue28772Constant, issue28772Constant2) 2149 } 2150 2151 // issue 28772 part 1 - part 2 in testx.go 2152 2153 const issue28772Constant = C.issue28772Constant 2154 2155 // issue 28896 2156 2157 func offset(i int) uintptr { 2158 var pi C.innerPacked 2159 var po C.outerPacked 2160 var ui C.innerUnpacked 2161 var uo C.outerUnpacked 2162 switch i { 2163 case 0: 2164 return unsafe.Offsetof(pi.f2) 2165 case 1: 2166 return unsafe.Offsetof(po.g2) 2167 case 2: 2168 return unsafe.Offsetof(ui.f2) 2169 case 3: 2170 return unsafe.Offsetof(uo.g2) 2171 default: 2172 panic("can't happen") 2173 } 2174 } 2175 2176 func test28896(t *testing.T) { 2177 for i := 0; i < 4; i++ { 2178 c := uintptr(C.offset(C.int(i))) 2179 g := offset(i) 2180 if c != g { 2181 t.Errorf("%d: C: %d != Go %d", i, c, g) 2182 } 2183 } 2184 } 2185 2186 // issue 29383 2187 // cgo's /*line*/ comments failed when inserted after '/', 2188 // because the result looked like a "//" comment. 2189 // No runtime test; just make sure it compiles. 2190 2191 func Issue29383(n, size uint) int { 2192 if ^C.size_t(0)/C.size_t(n) < C.size_t(size) { 2193 return 0 2194 } 2195 return 0 2196 } 2197 2198 // issue 29748 2199 // Error handling a struct initializer that requires pointer checking. 2200 // Compilation test only, nothing to run. 2201 2202 var Vissue29748 = C.f29748(&C.S29748{ 2203 nil, 2204 }) 2205 2206 func Fissue299748() { 2207 C.f29748(&C.S29748{ 2208 nil, 2209 }) 2210 } 2211 2212 // issue 29781 2213 2214 var issue29781X struct{ X int } 2215 2216 func issue29781F(...int) int { return 0 } 2217 2218 func issue29781G() { 2219 var p *C.char 2220 C.issue29781F(&p, C.ISSUE29781C+1) 2221 C.issue29781F(nil, (C.int)( 2222 0)) 2223 C.issue29781F(&p, (C.int)(0)) 2224 C.issue29781F(&p, (C.int)( 2225 0)) 2226 C.issue29781F(&p, (C.int)(issue29781X. 2227 X)) 2228 } 2229 2230 // issue 30065 2231 2232 func test30065(t *testing.T) { 2233 var a [256]byte 2234 b := []byte("a") 2235 C.memcpy(unsafe.Pointer(&a), unsafe.Pointer(&b[0]), 1) 2236 if a[0] != 'a' { 2237 t.Errorf("&a failed: got %c, want %c", a[0], 'a') 2238 } 2239 2240 b = []byte("b") 2241 C.memcpy(unsafe.Pointer(&a[0]), unsafe.Pointer(&b[0]), 1) 2242 if a[0] != 'b' { 2243 t.Errorf("&a[0] failed: got %c, want %c", a[0], 'b') 2244 } 2245 2246 d := make([]byte, 256) 2247 b = []byte("c") 2248 C.memcpy(unsafe.Pointer(&d[0]), unsafe.Pointer(&b[0]), 1) 2249 if d[0] != 'c' { 2250 t.Errorf("&d[0] failed: got %c, want %c", d[0], 'c') 2251 } 2252 } 2253 2254 // issue 31093 2255 // No runtime test; just make sure it compiles. 2256 2257 func Issue31093() { 2258 C.issue31093F(C.ushort(0)) 2259 } 2260 2261 // issue 32579 2262 2263 func test32579(t *testing.T) { 2264 var s [1]C.struct_S32579 2265 C.memset(unsafe.Pointer(&s[0].data[0]), 1, 1) 2266 if s[0].data[0] != 1 { 2267 t.Errorf("&s[0].data[0] failed: got %d, want %d", s[0].data[0], 1) 2268 } 2269 } 2270 2271 // issue 37033, check if cgo.Handle works properly 2272 2273 func testHandle(t *testing.T) { 2274 ch := make(chan int) 2275 2276 for i := 0; i < 42; i++ { 2277 h := cgo.NewHandle(ch) 2278 go func() { 2279 C.cFunc37033(C.uintptr_t(h)) 2280 }() 2281 if v := <-ch; issue37033 != v { 2282 t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033) 2283 } 2284 h.Delete() 2285 } 2286 } 2287 2288 // issue 38649 2289 2290 var issue38649 C.netbsd_gid = 42 2291 2292 // issue 39877 2293 2294 var issue39877 *C.void = nil 2295 2296 // issue 40494 2297 // No runtime test; just make sure it compiles. 2298 2299 func Issue40494() { 2300 C.issue40494(C.enum_Enum40494(C.X_40494), (*C.union_Union40494)(nil)) 2301 } 2302 2303 // Issue 45451. 2304 func test45451(t *testing.T) { 2305 var u *C.issue45451 2306 typ := reflect.ValueOf(u).Type().Elem() 2307 2308 // The type is undefined in C so allocating it should panic. 2309 defer func() { 2310 if r := recover(); r == nil { 2311 t.Error("expected panic") 2312 } 2313 }() 2314 2315 _ = reflect.New(typ) 2316 t.Errorf("reflect.New(%v) should have panicked", typ) 2317 } 2318 2319 // issue 52542 2320 2321 func func52542[T ~[]C.int]() {} 2322 2323 type type52542[T ~*C.float] struct{}