1 /* Darwin support needed only by C/C++ frontends. 2 Copyright (C) 2001, 2003, 2004, 2005, 2007, 2008 3 Free Software Foundation, Inc. 4 Contributed by Apple Computer Inc. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GCC is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "cpplib.h" 27 #include "tree.h" 28 #include "c-pragma.h" 29 #include "c-tree.h" 30 #include "incpath.h" 31 #include "c-common.h" 32 #include "toplev.h" 33 #include "flags.h" 34 #include "tm_p.h" 35 #include "cppdefault.h" 36 #include "prefix.h" 37 #include "target.h" 38 #include "target-def.h" 39 40 /* Pragmas. */ 41 42 #define BAD(gmsgid) do { warning (OPT_Wpragmas, gmsgid); return; } while (0) 43 #define BAD2(msgid, arg) do { warning (OPT_Wpragmas, msgid, arg); return; } while (0) 44 45 static bool using_frameworks = false; 46 47 static const char *find_subframework_header (cpp_reader *pfile, const char *header, 48 cpp_dir **dirp); 49 50 typedef struct align_stack 51 { 52 int alignment; 53 struct align_stack * prev; 54 } align_stack; 55 56 static struct align_stack * field_align_stack = NULL; 57 58 /* Maintain a small stack of alignments. This is similar to pragma 59 pack's stack, but simpler. */ 60 61 static void 62 push_field_alignment (int bit_alignment) 63 { 64 align_stack *entry = XNEW (align_stack); 65 66 entry->alignment = maximum_field_alignment; 67 entry->prev = field_align_stack; 68 field_align_stack = entry; 69 70 maximum_field_alignment = bit_alignment; 71 } 72 73 static void 74 pop_field_alignment (void) 75 { 76 if (field_align_stack) 77 { 78 align_stack *entry = field_align_stack; 79 80 maximum_field_alignment = entry->alignment; 81 field_align_stack = entry->prev; 82 free (entry); 83 } 84 else 85 error ("too many #pragma options align=reset"); 86 } 87 88 /* Handlers for Darwin-specific pragmas. */ 89 90 void 91 darwin_pragma_ignore (cpp_reader *pfile ATTRIBUTE_UNUSED) 92 { 93 /* Do nothing. */ 94 } 95 96 /* #pragma options align={mac68k|power|reset} */ 97 98 void 99 darwin_pragma_options (cpp_reader *pfile ATTRIBUTE_UNUSED) 100 { 101 const char *arg; 102 tree t, x; 103 104 if (pragma_lex (&t) != CPP_NAME) 105 BAD ("malformed '#pragma options', ignoring"); 106 arg = IDENTIFIER_POINTER (t); 107 if (strcmp (arg, "align")) 108 BAD ("malformed '#pragma options', ignoring"); 109 if (pragma_lex (&t) != CPP_EQ) 110 BAD ("malformed '#pragma options', ignoring"); 111 if (pragma_lex (&t) != CPP_NAME) 112 BAD ("malformed '#pragma options', ignoring"); 113 114 if (pragma_lex (&x) != CPP_EOF) 115 warning (OPT_Wpragmas, "junk at end of '#pragma options'"); 116 117 arg = IDENTIFIER_POINTER (t); 118 if (!strcmp (arg, "mac68k")) 119 push_field_alignment (16); 120 else if (!strcmp (arg, "power")) 121 push_field_alignment (0); 122 else if (!strcmp (arg, "reset")) 123 pop_field_alignment (); 124 else 125 BAD ("malformed '#pragma options align={mac68k|power|reset}', ignoring"); 126 } 127 128 /* #pragma unused ([var {, var}*]) */ 129 130 void 131 darwin_pragma_unused (cpp_reader *pfile ATTRIBUTE_UNUSED) 132 { 133 tree decl, x; 134 int tok; 135 136 if (pragma_lex (&x) != CPP_OPEN_PAREN) 137 BAD ("missing '(' after '#pragma unused', ignoring"); 138 139 while (1) 140 { 141 tok = pragma_lex (&decl); 142 if (tok == CPP_NAME && decl) 143 { 144 tree local = lookup_name (decl); 145 if (local && (TREE_CODE (local) == PARM_DECL 146 || TREE_CODE (local) == VAR_DECL)) 147 TREE_USED (local) = 1; 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 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 strncpy (&frname[0], dir->name, dir->len); 288 frname_len = dir->len; 289 if (frname_len && frname[frname_len-1] != '/') 290 frname[frname_len++] = '/'; 291 strncpy (&frname[frname_len], fname, fname_len); 292 frname_len += fname_len; 293 strncpy (&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 strncpy (&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 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 strncpy (&sfrname[0], pname, sfrname_len); 382 383 strncpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/")); 384 sfrname_len += strlen("Frameworks/"); 385 386 strncpy (&sfrname[sfrname_len], fname, fname_len); 387 sfrname_len += fname_len; 388 389 strncpy (&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 strncpy (&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, 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, 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, const char *iprefix, 467 int stdinc) 468 { 469 const char *fname; 470 size_t len; 471 /* We do not do anything if we do not want the standard includes. */ 472 if (!stdinc) 473 return; 474 475 fname = GCC_INCLUDE_DIR "-gnu-runtime"; 476 477 /* Register the GNU OBJC runtime include path if we are compiling OBJC 478 with GNU-runtime. */ 479 480 if (c_dialect_objc () && !flag_next_runtime) 481 { 482 char *str; 483 /* See if our directory starts with the standard prefix. 484 "Translate" them, i.e. replace /usr/local/lib/gcc... with 485 IPREFIX and search them first. */ 486 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 && !sysroot 487 && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len)) 488 { 489 str = concat (iprefix, fname + len, NULL); 490 /* FIXME: wrap the headers for C++awareness. */ 491 add_path (str, SYSTEM, /*c++aware=*/false, false); 492 } 493 494 /* Should this directory start with the sysroot? */ 495 if (sysroot) 496 str = concat (sysroot, fname, NULL); 497 else 498 str = update_path (fname, ""); 499 500 add_path (str, SYSTEM, /*c++aware=*/false, false); 501 } 502 } 503 504 505 /* Register all the system framework paths if STDINC is true and setup 506 the missing_header callback for subframework searching if any 507 frameworks had been registered. */ 508 509 void 510 darwin_register_frameworks (const char *sysroot, 511 const char *iprefix ATTRIBUTE_UNUSED, int stdinc) 512 { 513 if (stdinc) 514 { 515 size_t i; 516 517 /* Setup default search path for frameworks. */ 518 for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i) 519 { 520 char *str; 521 if (sysroot) 522 str = concat (sysroot, xstrdup (framework_defaults [i]), NULL); 523 else 524 str = xstrdup (framework_defaults[i]); 525 /* System Framework headers are cxx aware. */ 526 add_system_framework_path (str); 527 } 528 } 529 530 if (using_frameworks) 531 cpp_get_callbacks (parse_in)->missing_header = find_subframework_header; 532 } 533 534 /* Search for HEADER in context dependent way. The return value is 535 the malloced name of a header to try and open, if any, or NULL 536 otherwise. This is called after normal header lookup processing 537 fails to find a header. We search each file in the include stack, 538 using FUNC, starting from the most deeply nested include and 539 finishing with the main input file. We stop searching when FUNC 540 returns nonzero. */ 541 542 static const char* 543 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp) 544 { 545 const char *fname = header; 546 struct cpp_buffer *b; 547 const char *n; 548 549 for (b = cpp_get_buffer (pfile); 550 b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b)); 551 b = cpp_get_prev (b)) 552 { 553 n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b))); 554 if (n) 555 { 556 /* Logically, the place where we found the subframework is 557 the place where we found the Framework that contains the 558 subframework. This is useful for tracking wether or not 559 we are in a system header. */ 560 *dirp = cpp_get_dir (cpp_get_file (b)); 561 return n; 562 } 563 } 564 565 return 0; 566 } 567 568 /* Return the value of darwin_macosx_version_min suitable for the 569 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro, 570 so '10.4.2' becomes 1040. The lowest digit is always zero. 571 Print a warning if the version number can't be understood. */ 572 static const char * 573 version_as_macro (void) 574 { 575 static char result[] = "1000"; 576 577 if (strncmp (darwin_macosx_version_min, "10.", 3) != 0) 578 goto fail; 579 if (! ISDIGIT (darwin_macosx_version_min[3])) 580 goto fail; 581 result[2] = darwin_macosx_version_min[3]; 582 if (darwin_macosx_version_min[4] != '\0' 583 && darwin_macosx_version_min[4] != '.') 584 goto fail; 585 586 return result; 587 588 fail: 589 error ("Unknown value %qs of -mmacosx-version-min", 590 darwin_macosx_version_min); 591 return "1000"; 592 } 593 594 /* Define additional CPP flags for Darwin. */ 595 596 #define builtin_define(TXT) cpp_define (pfile, TXT) 597 598 void 599 darwin_cpp_builtins (cpp_reader *pfile) 600 { 601 builtin_define ("__MACH__"); 602 builtin_define ("__APPLE__"); 603 604 /* __APPLE_CC__ is defined as some old Apple include files expect it 605 to be defined and won't work if it isn't. */ 606 builtin_define_with_value ("__APPLE_CC__", "1", false); 607 608 builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", 609 version_as_macro(), false); 610 } 611 612 /* Handle C family front-end options. */ 613 614 static bool 615 handle_c_option (size_t code, 616 const char *arg, 617 int value ATTRIBUTE_UNUSED) 618 { 619 switch (code) 620 { 621 default: 622 /* Unrecognized options that we said we'd handle turn into 623 errors if not listed here. */ 624 return false; 625 626 case OPT_iframework: 627 add_system_framework_path (xstrdup (arg)); 628 break; 629 630 case OPT_fapple_kext: 631 ; 632 } 633 634 /* We recognized the option. */ 635 return true; 636 } 637 638 #undef TARGET_HANDLE_C_OPTION 639 #define TARGET_HANDLE_C_OPTION handle_c_option 640 641 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER; 642