1 /* Darwin support needed only by C/C++ frontends. 2 Copyright (C) 2001-2019 Free Software Foundation, Inc. 3 Contributed by Apple Computer Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "target.h" 25 #include "c-family/c-target.h" 26 #include "c-family/c-target-def.h" 27 #include "memmodel.h" 28 #include "tm_p.h" 29 #include "cgraph.h" 30 #include "incpath.h" 31 #include "c-family/c-pragma.h" 32 #include "c-family/c-format.h" 33 #include "cppdefault.h" 34 #include "prefix.h" 35 #include "../../libcpp/internal.h" 36 37 /* Pragmas. */ 38 39 #define BAD(gmsgid) do { warning (OPT_Wpragmas, gmsgid); return; } while (0) 40 #define BAD2(msgid, arg) do { warning (OPT_Wpragmas, msgid, arg); return; } while (0) 41 42 static bool using_frameworks = false; 43 44 static const char *find_subframework_header (cpp_reader *pfile, const char *header, 45 cpp_dir **dirp); 46 47 typedef struct align_stack 48 { 49 int alignment; 50 struct align_stack * prev; 51 } align_stack; 52 53 static struct align_stack * field_align_stack = NULL; 54 55 /* Maintain a small stack of alignments. This is similar to pragma 56 pack's stack, but simpler. */ 57 58 static void 59 push_field_alignment (int bit_alignment) 60 { 61 align_stack *entry = XNEW (align_stack); 62 63 entry->alignment = maximum_field_alignment; 64 entry->prev = field_align_stack; 65 field_align_stack = entry; 66 67 maximum_field_alignment = bit_alignment; 68 } 69 70 static void 71 pop_field_alignment (void) 72 { 73 if (field_align_stack) 74 { 75 align_stack *entry = field_align_stack; 76 77 maximum_field_alignment = entry->alignment; 78 field_align_stack = entry->prev; 79 free (entry); 80 } 81 else 82 error ("too many #pragma options align=reset"); 83 } 84 85 /* Handlers for Darwin-specific pragmas. */ 86 87 void 88 darwin_pragma_ignore (cpp_reader *pfile ATTRIBUTE_UNUSED) 89 { 90 /* Do nothing. */ 91 } 92 93 /* #pragma options align={mac68k|power|reset} */ 94 95 void 96 darwin_pragma_options (cpp_reader *pfile ATTRIBUTE_UNUSED) 97 { 98 const char *arg; 99 tree t, x; 100 101 if (pragma_lex (&t) != CPP_NAME) 102 BAD ("malformed %<#pragma options%>, ignoring"); 103 arg = IDENTIFIER_POINTER (t); 104 if (strcmp (arg, "align")) 105 BAD ("malformed %<#pragma options%>, ignoring"); 106 if (pragma_lex (&t) != CPP_EQ) 107 BAD ("malformed %<#pragma options%>, ignoring"); 108 if (pragma_lex (&t) != CPP_NAME) 109 BAD ("malformed %<#pragma options%>, ignoring"); 110 111 if (pragma_lex (&x) != CPP_EOF) 112 warning (OPT_Wpragmas, "junk at end of %<#pragma options%>"); 113 114 arg = IDENTIFIER_POINTER (t); 115 if (!strcmp (arg, "mac68k")) 116 push_field_alignment (16); 117 else if (!strcmp (arg, "power")) 118 push_field_alignment (0); 119 else if (!strcmp (arg, "reset")) 120 pop_field_alignment (); 121 else 122 BAD ("malformed %<#pragma options align={mac68k|power|reset}%>, ignoring"); 123 } 124 125 /* #pragma unused ([var {, var}*]) */ 126 127 void 128 darwin_pragma_unused (cpp_reader *pfile ATTRIBUTE_UNUSED) 129 { 130 tree decl, x; 131 int tok; 132 133 if (pragma_lex (&x) != CPP_OPEN_PAREN) 134 BAD ("missing %<(%> after %<#pragma unused%>, ignoring"); 135 136 while (1) 137 { 138 tok = pragma_lex (&decl); 139 if (tok == CPP_NAME && decl) 140 { 141 tree local = lookup_name (decl); 142 if (local && (TREE_CODE (local) == PARM_DECL 143 || TREE_CODE (local) == VAR_DECL)) 144 { 145 TREE_USED (local) = 1; 146 DECL_READ_P (local) = 1; 147 } 148 tok = pragma_lex (&x); 149 if (tok != CPP_COMMA) 150 break; 151 } 152 } 153 154 if (tok != CPP_CLOSE_PAREN) 155 BAD ("missing %<)%> after %<#pragma unused%>, ignoring"); 156 157 if (pragma_lex (&x) != CPP_EOF) 158 BAD ("junk at end of %<#pragma unused%>"); 159 } 160 161 /* Parse the ms_struct pragma. */ 162 void 163 darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED) 164 { 165 const char *arg; 166 tree t; 167 168 if (pragma_lex (&t) != CPP_NAME) 169 BAD ("malformed %<#pragma ms_struct%>, ignoring"); 170 arg = IDENTIFIER_POINTER (t); 171 172 if (!strcmp (arg, "on")) 173 darwin_ms_struct = true; 174 else if (!strcmp (arg, "off") || !strcmp (arg, "reset")) 175 darwin_ms_struct = false; 176 else 177 BAD ("malformed %<#pragma ms_struct {on|off|reset}%>, ignoring"); 178 179 if (pragma_lex (&t) != CPP_EOF) 180 BAD ("junk at end of %<#pragma ms_struct%>"); 181 } 182 183 static struct frameworks_in_use { 184 size_t len; 185 const char *name; 186 cpp_dir* dir; 187 } *frameworks_in_use; 188 static int num_frameworks = 0; 189 static int max_frameworks = 0; 190 191 192 /* Remember which frameworks have been seen, so that we can ensure 193 that all uses of that framework come from the same framework. DIR 194 is the place where the named framework NAME, which is of length 195 LEN, was found. We copy the directory name from NAME, as it will be 196 freed by others. */ 197 198 static void 199 add_framework (const char *name, size_t len, cpp_dir *dir) 200 { 201 char *dir_name; 202 int i; 203 for (i = 0; i < num_frameworks; ++i) 204 { 205 if (len == frameworks_in_use[i].len 206 && strncmp (name, frameworks_in_use[i].name, len) == 0) 207 { 208 return; 209 } 210 } 211 if (i >= max_frameworks) 212 { 213 max_frameworks = i*2; 214 max_frameworks += i == 0; 215 frameworks_in_use = XRESIZEVEC (struct frameworks_in_use, 216 frameworks_in_use, max_frameworks); 217 } 218 dir_name = XNEWVEC (char, len + 1); 219 memcpy (dir_name, name, len); 220 dir_name[len] = '\0'; 221 frameworks_in_use[num_frameworks].name = dir_name; 222 frameworks_in_use[num_frameworks].len = len; 223 frameworks_in_use[num_frameworks].dir = dir; 224 ++num_frameworks; 225 } 226 227 /* Recall if we have seen the named framework NAME, before, and where 228 we saw it. NAME is LEN bytes long. The return value is the place 229 where it was seen before. */ 230 231 static struct cpp_dir* 232 find_framework (const char *name, size_t len) 233 { 234 int i; 235 for (i = 0; i < num_frameworks; ++i) 236 { 237 if (len == frameworks_in_use[i].len 238 && strncmp (name, frameworks_in_use[i].name, len) == 0) 239 { 240 return frameworks_in_use[i].dir; 241 } 242 } 243 return 0; 244 } 245 246 /* There are two directories in a framework that contain header files, 247 Headers and PrivateHeaders. We search Headers first as it is more 248 common to upgrade a header from PrivateHeaders to Headers and when 249 that is done, the old one might hang around and be out of data, 250 causing grief. */ 251 252 struct framework_header {const char * dirName; int dirNameLen; }; 253 static struct framework_header framework_header_dirs[] = { 254 { "Headers", 7 }, 255 { "PrivateHeaders", 14 }, 256 { NULL, 0 } 257 }; 258 259 /* Returns a pointer to a malloced string that contains the real pathname 260 to the file, given the base name and the name. */ 261 262 static char * 263 framework_construct_pathname (const char *fname, cpp_dir *dir) 264 { 265 const char *buf; 266 size_t fname_len, frname_len; 267 cpp_dir *fast_dir; 268 char *frname; 269 struct stat st; 270 int i; 271 272 /* Framework names must have a / in them. */ 273 buf = strchr (fname, '/'); 274 if (buf) 275 fname_len = buf - fname; 276 else 277 return 0; 278 279 fast_dir = find_framework (fname, fname_len); 280 281 /* Framework includes must all come from one framework. */ 282 if (fast_dir && dir != fast_dir) 283 return 0; 284 285 frname = XNEWVEC (char, strlen (fname) + dir->len + 2 286 + strlen(".framework/") + strlen("PrivateHeaders")); 287 memcpy (&frname[0], dir->name, dir->len); 288 frname_len = dir->len; 289 if (frname_len && frname[frname_len-1] != '/') 290 frname[frname_len++] = '/'; 291 memcpy (&frname[frname_len], fname, fname_len); 292 frname_len += fname_len; 293 memcpy (&frname[frname_len], ".framework/", strlen (".framework/")); 294 frname_len += strlen (".framework/"); 295 296 if (fast_dir == 0) 297 { 298 frname[frname_len-1] = 0; 299 if (stat (frname, &st) == 0) 300 { 301 /* As soon as we find the first instance of the framework, 302 we stop and never use any later instance of that 303 framework. */ 304 add_framework (fname, fname_len, dir); 305 } 306 else 307 { 308 /* If we can't find the parent directory, no point looking 309 further. */ 310 free (frname); 311 return 0; 312 } 313 frname[frname_len-1] = '/'; 314 } 315 316 /* Append framework_header_dirs and header file name */ 317 for (i = 0; framework_header_dirs[i].dirName; i++) 318 { 319 memcpy (&frname[frname_len], 320 framework_header_dirs[i].dirName, 321 framework_header_dirs[i].dirNameLen); 322 strcpy (&frname[frname_len + framework_header_dirs[i].dirNameLen], 323 &fname[fname_len]); 324 325 if (stat (frname, &st) == 0) 326 return frname; 327 } 328 329 free (frname); 330 return 0; 331 } 332 333 /* Search for FNAME in sub-frameworks. pname is the context that we 334 wish to search in. Return the path the file was found at, 335 otherwise return 0. */ 336 337 static const char* 338 find_subframework_file (const char *fname, const char *pname) 339 { 340 char *sfrname; 341 const char *dot_framework = ".framework/"; 342 const char *bufptr; 343 int sfrname_len, i, fname_len; 344 struct cpp_dir *fast_dir; 345 static struct cpp_dir subframe_dir; 346 struct stat st; 347 348 bufptr = strchr (fname, '/'); 349 350 /* Subframework files must have / in the name. */ 351 if (bufptr == 0) 352 return 0; 353 354 fname_len = bufptr - fname; 355 fast_dir = find_framework (fname, fname_len); 356 357 /* Sub framework header filename includes parent framework name and 358 header name in the "CarbonCore/OSUtils.h" form. If it does not 359 include slash it is not a sub framework include. */ 360 bufptr = strstr (pname, dot_framework); 361 362 /* If the parent header is not of any framework, then this header 363 cannot be part of any subframework. */ 364 if (!bufptr) 365 return 0; 366 367 /* Now translate. For example, +- bufptr 368 fname = CarbonCore/OSUtils.h | 369 pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h 370 into 371 sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */ 372 373 sfrname = XNEWVEC (char, strlen (pname) + strlen (fname) + 2 + 374 strlen ("Frameworks/") + strlen (".framework/") 375 + strlen ("PrivateHeaders")); 376 377 bufptr += strlen (dot_framework); 378 379 sfrname_len = bufptr - pname; 380 381 memcpy (&sfrname[0], pname, sfrname_len); 382 383 memcpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/")); 384 sfrname_len += strlen("Frameworks/"); 385 386 memcpy (&sfrname[sfrname_len], fname, fname_len); 387 sfrname_len += fname_len; 388 389 memcpy (&sfrname[sfrname_len], ".framework/", strlen (".framework/")); 390 sfrname_len += strlen (".framework/"); 391 392 /* Append framework_header_dirs and header file name */ 393 for (i = 0; framework_header_dirs[i].dirName; i++) 394 { 395 memcpy (&sfrname[sfrname_len], 396 framework_header_dirs[i].dirName, 397 framework_header_dirs[i].dirNameLen); 398 strcpy (&sfrname[sfrname_len + framework_header_dirs[i].dirNameLen], 399 &fname[fname_len]); 400 401 if (stat (sfrname, &st) == 0) 402 { 403 if (fast_dir != &subframe_dir) 404 { 405 if (fast_dir) 406 warning (0, "subframework include %s conflicts with framework include", 407 fname); 408 else 409 add_framework (fname, fname_len, &subframe_dir); 410 } 411 412 return sfrname; 413 } 414 } 415 free (sfrname); 416 417 return 0; 418 } 419 420 /* Add PATH to the system includes. PATH must be malloc-ed and 421 NUL-terminated. System framework paths are C++ aware. */ 422 423 static void 424 add_system_framework_path (char *path) 425 { 426 int cxx_aware = 1; 427 cpp_dir *p; 428 429 p = XNEW (cpp_dir); 430 p->next = NULL; 431 p->name = path; 432 p->sysp = 1 + !cxx_aware; 433 p->construct = framework_construct_pathname; 434 using_frameworks = 1; 435 436 add_cpp_dir_path (p, INC_SYSTEM); 437 } 438 439 /* Add PATH to the bracket includes. PATH must be malloc-ed and 440 NUL-terminated. */ 441 442 void 443 add_framework_path (char *path) 444 { 445 cpp_dir *p; 446 447 p = XNEW (cpp_dir); 448 p->next = NULL; 449 p->name = path; 450 p->sysp = 0; 451 p->construct = framework_construct_pathname; 452 using_frameworks = 1; 453 454 add_cpp_dir_path (p, INC_BRACKET); 455 } 456 457 static const char *framework_defaults [] = 458 { 459 "/System/Library/Frameworks", 460 "/Library/Frameworks", 461 }; 462 463 /* Register the GNU objective-C runtime include path if STDINC. */ 464 465 void 466 darwin_register_objc_includes (const char *sysroot ATTRIBUTE_UNUSED, 467 const char *iprefix, int stdinc) 468 { 469 /* If we want standard includes; Register the GNU OBJC runtime include 470 path if we are compiling OBJC with GNU-runtime. 471 This path is compiler-relative, we don't want to prepend the sysroot 472 since it's not expected to find the headers there. */ 473 474 if (stdinc && c_dialect_objc () && !flag_next_runtime) 475 { 476 const char *fname = GCC_INCLUDE_DIR "-gnu-runtime"; 477 char *str; 478 size_t len; 479 480 /* See if our directory starts with the standard prefix. 481 "Translate" them, i.e. replace /usr/local/lib/gcc... with 482 IPREFIX and search them first. */ 483 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 484 && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len)) 485 { 486 str = concat (iprefix, fname + len, NULL); 487 add_path (str, INC_SYSTEM, /*c++aware=*/true, false); 488 } 489 490 str = update_path (fname, ""); 491 add_path (str, INC_SYSTEM, /*c++aware=*/true, false); 492 } 493 } 494 495 496 /* Register all the system framework paths if STDINC is true and setup 497 the missing_header callback for subframework searching if any 498 frameworks had been registered. */ 499 500 void 501 darwin_register_frameworks (const char *sysroot, 502 const char *iprefix ATTRIBUTE_UNUSED, int stdinc) 503 { 504 if (stdinc) 505 { 506 size_t i; 507 508 /* Setup default search path for frameworks. */ 509 for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i) 510 { 511 char *str; 512 if (sysroot) 513 str = concat (sysroot, xstrdup (framework_defaults [i]), NULL); 514 else 515 str = xstrdup (framework_defaults[i]); 516 /* System Framework headers are cxx aware. */ 517 add_system_framework_path (str); 518 } 519 } 520 521 if (using_frameworks) 522 cpp_get_callbacks (parse_in)->missing_header = find_subframework_header; 523 } 524 525 /* Search for HEADER in context dependent way. The return value is 526 the malloced name of a header to try and open, if any, or NULL 527 otherwise. This is called after normal header lookup processing 528 fails to find a header. We search each file in the include stack, 529 using FUNC, starting from the most deeply nested include and 530 finishing with the main input file. We stop searching when FUNC 531 returns nonzero. */ 532 533 static const char* 534 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp) 535 { 536 const char *fname = header; 537 struct cpp_buffer *b; 538 const char *n; 539 540 for (b = cpp_get_buffer (pfile); 541 b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b)); 542 b = cpp_get_prev (b)) 543 { 544 n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b))); 545 if (n) 546 { 547 /* Logically, the place where we found the subframework is 548 the place where we found the Framework that contains the 549 subframework. This is useful for tracking wether or not 550 we are in a system header. */ 551 *dirp = cpp_get_dir (cpp_get_file (b)); 552 return n; 553 } 554 } 555 556 return 0; 557 } 558 559 /* Given an OS X version VERSION_STR, return it as a statically-allocated array 560 of three integers. If VERSION_STR is invalid, return NULL. 561 562 VERSION_STR must consist of one, two, or three tokens, each separated by 563 a single period. Each token must contain only the characters '0' through 564 '9' and is converted to an equivalent non-negative decimal integer. Omitted 565 tokens become zeros. For example: 566 567 "10" becomes {10,0,0} 568 "10.10" becomes {10,10,0} 569 "10.10.1" becomes {10,10,1} 570 "10.000010.1" becomes {10,10,1} 571 "10.010.001" becomes {10,10,1} 572 "000010.10.00001" becomes {10,10,1} 573 ".9.1" is invalid 574 "10..9" is invalid 575 "10.10." is invalid */ 576 577 enum version_components { MAJOR, MINOR, TINY }; 578 579 static const unsigned long * 580 parse_version (const char *version_str) 581 { 582 size_t version_len; 583 char *end; 584 static unsigned long version_array[3]; 585 586 version_len = strlen (version_str); 587 if (version_len < 1) 588 return NULL; 589 590 /* Version string must consist of digits and periods only. */ 591 if (strspn (version_str, "0123456789.") != version_len) 592 return NULL; 593 594 if (!ISDIGIT (version_str[0]) || !ISDIGIT (version_str[version_len - 1])) 595 return NULL; 596 597 version_array[MAJOR] = strtoul (version_str, &end, 10); 598 version_str = end + ((*end == '.') ? 1 : 0); 599 600 /* Version string must not contain adjacent periods. */ 601 if (*version_str == '.') 602 return NULL; 603 604 version_array[MINOR] = strtoul (version_str, &end, 10); 605 version_str = end + ((*end == '.') ? 1 : 0); 606 607 version_array[TINY] = strtoul (version_str, &end, 10); 608 609 /* Version string must contain no more than three tokens. */ 610 if (*end != '\0') 611 return NULL; 612 613 return version_array; 614 } 615 616 /* Given VERSION -- a three-component OS X version represented as an array of 617 non-negative integers -- return a statically-allocated string suitable for 618 the legacy __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro. If VERSION 619 is invalid and cannot be coerced into a valid form, return NULL. 620 621 The legacy format is a four-character string -- two chars for the major 622 number and one each for the minor and tiny numbers. Minor and tiny numbers 623 from 10 through 99 are permitted but are clamped to 9 (for example, {10,9,10} 624 produces "1099"). If VERSION contains numbers greater than 99, it is 625 rejected. */ 626 627 static const char * 628 version_as_legacy_macro (const unsigned long *version) 629 { 630 unsigned long major, minor, tiny; 631 static char result[5]; 632 633 major = version[MAJOR]; 634 minor = version[MINOR]; 635 tiny = version[TINY]; 636 637 if (major > 99 || minor > 99 || tiny > 99) 638 return NULL; 639 640 minor = ((minor > 9) ? 9 : minor); 641 tiny = ((tiny > 9) ? 9 : tiny); 642 643 if (sprintf (result, "%lu%lu%lu", major, minor, tiny) != 4) 644 return NULL; 645 646 return result; 647 } 648 649 /* Given VERSION -- a three-component OS X version represented as an array of 650 non-negative integers -- return a statically-allocated string suitable for 651 the modern __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro. If VERSION 652 is invalid, return NULL. 653 654 The modern format is a six-character string -- two chars for each component, 655 with zero-padding if necessary (for example, {10,10,1} produces "101001"). If 656 VERSION contains numbers greater than 99, it is rejected. */ 657 658 static const char * 659 version_as_modern_macro (const unsigned long *version) 660 { 661 unsigned long major, minor, tiny; 662 static char result[7]; 663 664 major = version[MAJOR]; 665 minor = version[MINOR]; 666 tiny = version[TINY]; 667 668 if (major > 99 || minor > 99 || tiny > 99) 669 return NULL; 670 671 if (sprintf (result, "%02lu%02lu%02lu", major, minor, tiny) != 6) 672 return NULL; 673 674 return result; 675 } 676 677 /* Return the value of darwin_macosx_version_min, suitably formatted for the 678 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro. Values representing 679 OS X 10.9 and earlier are encoded using the legacy four-character format, 680 while 10.10 and later use a modern six-character format. (For example, 681 "10.9" produces "1090", and "10.10.1" produces "101001".) If 682 darwin_macosx_version_min is invalid and cannot be coerced into a valid 683 form, print a warning and return "1000". */ 684 685 static const char * 686 macosx_version_as_macro (void) 687 { 688 const unsigned long *version_array; 689 const char *version_macro; 690 691 version_array = parse_version (darwin_macosx_version_min); 692 if (!version_array) 693 goto fail; 694 695 if (version_array[MAJOR] != 10) 696 goto fail; 697 698 if (version_array[MINOR] < 10) 699 version_macro = version_as_legacy_macro (version_array); 700 else 701 version_macro = version_as_modern_macro (version_array); 702 703 if (!version_macro) 704 goto fail; 705 706 return version_macro; 707 708 fail: 709 error ("unknown value %qs of %<-mmacosx-version-min%>", 710 darwin_macosx_version_min); 711 return "1000"; 712 } 713 714 /* Define additional CPP flags for Darwin. */ 715 716 #define builtin_define(TXT) cpp_define (pfile, TXT) 717 718 void 719 darwin_cpp_builtins (cpp_reader *pfile) 720 { 721 builtin_define ("__MACH__"); 722 builtin_define ("__APPLE__"); 723 724 /* __APPLE_CC__ is defined as some old Apple include files expect it 725 to be defined and won't work if it isn't. */ 726 builtin_define_with_value ("__APPLE_CC__", "1", false); 727 728 if (darwin_constant_cfstrings) 729 builtin_define ("__CONSTANT_CFSTRINGS__"); 730 731 builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", 732 macosx_version_as_macro(), false); 733 734 /* Since we do not (at 4.6) support ObjC gc for the NeXT runtime, the 735 following will cause a syntax error if one tries to compile gc attributed 736 items. However, without this, NeXT system headers cannot be parsed 737 properly (on systems >= darwin 9). */ 738 if (flag_objc_gc) 739 { 740 builtin_define ("__strong=__attribute__((objc_gc(strong)))"); 741 builtin_define ("__weak=__attribute__((objc_gc(weak)))"); 742 builtin_define ("__OBJC_GC__"); 743 } 744 else 745 { 746 builtin_define ("__strong="); 747 builtin_define ("__weak="); 748 } 749 750 if (CPP_OPTION (pfile, objc) && flag_objc_abi == 2) 751 builtin_define ("__OBJC2__"); 752 } 753 754 /* Handle C family front-end options. */ 755 756 static bool 757 handle_c_option (size_t code, 758 const char *arg, 759 int value ATTRIBUTE_UNUSED) 760 { 761 switch (code) 762 { 763 default: 764 /* Unrecognized options that we said we'd handle turn into 765 errors if not listed here. */ 766 return false; 767 768 case OPT_iframework: 769 add_system_framework_path (xstrdup (arg)); 770 break; 771 772 case OPT_fapple_kext: 773 ; 774 } 775 776 /* We recognized the option. */ 777 return true; 778 } 779 780 /* Allow ObjC* access to CFStrings. */ 781 static tree 782 darwin_objc_construct_string (tree str) 783 { 784 if (!darwin_constant_cfstrings) 785 { 786 /* Even though we are not using CFStrings, place our literal 787 into the cfstring_htab hash table, so that the 788 darwin_constant_cfstring_p() function will see it. */ 789 darwin_enter_string_into_cfstring_table (str); 790 /* Fall back to NSConstantString. */ 791 return NULL_TREE; 792 } 793 794 return darwin_build_constant_cfstring (str); 795 } 796 797 /* The string ref type is created as CFStringRef by <CFBase.h> therefore, we 798 must match for it explicitly, since it's outside the gcc code. */ 799 800 static bool 801 darwin_cfstring_ref_p (const_tree strp) 802 { 803 tree tn; 804 if (!strp || TREE_CODE (strp) != POINTER_TYPE) 805 return false; 806 807 tn = TYPE_NAME (strp); 808 if (tn) 809 tn = DECL_NAME (tn); 810 return (tn 811 && IDENTIFIER_POINTER (tn) 812 && !strncmp (IDENTIFIER_POINTER (tn), "CFStringRef", 8)); 813 } 814 815 /* At present the behavior of this is undefined and it does nothing. */ 816 static void 817 darwin_check_cfstring_format_arg (tree ARG_UNUSED (format_arg), 818 tree ARG_UNUSED (args_list)) 819 { 820 } 821 822 /* The extra format types we recognize. */ 823 EXPORTED_CONST format_kind_info darwin_additional_format_types[] = { 824 { "CFString", NULL, NULL, NULL, NULL, 825 NULL, NULL, 826 FMT_FLAG_ARG_CONVERT|FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL, 0, 0, 0, 0, 0, 0, 827 NULL, NULL 828 } 829 }; 830 831 832 /* Support routines to dump the class references for NeXT ABI v1, aka 833 32-bits ObjC-2.0, as top-level asms. 834 The following two functions should only be called from 835 objc/objc-next-runtime-abi-01.c. */ 836 837 static void 838 darwin_objc_declare_unresolved_class_reference (const char *name) 839 { 840 const char *lazy_reference = ".lazy_reference\t"; 841 const char *hard_reference = ".reference\t"; 842 const char *reference = MACHOPIC_INDIRECT ? lazy_reference : hard_reference; 843 size_t len = strlen (reference) + strlen(name) + 2; 844 char *buf = (char *) alloca (len); 845 846 gcc_checking_assert (!strncmp (name, ".objc_class_name_", 17)); 847 848 snprintf (buf, len, "%s%s", reference, name); 849 symtab->finalize_toplevel_asm (build_string (strlen (buf), buf)); 850 } 851 852 static void 853 darwin_objc_declare_class_definition (const char *name) 854 { 855 const char *xname = targetm.strip_name_encoding (name); 856 size_t len = strlen (xname) + 7 + 5; 857 char *buf = (char *) alloca (len); 858 859 gcc_checking_assert (!strncmp (name, ".objc_class_name_", 17) 860 || !strncmp (name, "*.objc_category_name_", 21)); 861 862 /* Mimic default_globalize_label. */ 863 snprintf (buf, len, ".globl\t%s", xname); 864 symtab->finalize_toplevel_asm (build_string (strlen (buf), buf)); 865 866 snprintf (buf, len, "%s = 0", xname); 867 symtab->finalize_toplevel_asm (build_string (strlen (buf), buf)); 868 } 869 870 #undef TARGET_HANDLE_C_OPTION 871 #define TARGET_HANDLE_C_OPTION handle_c_option 872 873 #undef TARGET_OBJC_CONSTRUCT_STRING_OBJECT 874 #define TARGET_OBJC_CONSTRUCT_STRING_OBJECT darwin_objc_construct_string 875 876 #undef TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE 877 #define TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE \ 878 darwin_objc_declare_unresolved_class_reference 879 880 #undef TARGET_OBJC_DECLARE_CLASS_DEFINITION 881 #define TARGET_OBJC_DECLARE_CLASS_DEFINITION \ 882 darwin_objc_declare_class_definition 883 884 #undef TARGET_STRING_OBJECT_REF_TYPE_P 885 #define TARGET_STRING_OBJECT_REF_TYPE_P darwin_cfstring_ref_p 886 887 #undef TARGET_CHECK_STRING_OBJECT_FORMAT_ARG 888 #define TARGET_CHECK_STRING_OBJECT_FORMAT_ARG darwin_check_cfstring_format_arg 889 890 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER; 891