Mercurial > hg > CbC > CbC_gcc
annotate gcc/config/darwin-c.c @ 63:b7f97abdc517 gcc-4.6-20100522
update gcc from gcc-4.5.0 to gcc-4.6
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 24 May 2010 12:47:05 +0900 |
| parents | a06113de4d67 |
| children | f6334be47118 |
| rev | line source |
|---|---|
| 0 | 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)) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
147 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
148 TREE_USED (local) = 1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
149 DECL_READ_P (local) = 1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
150 } |
| 0 | 151 tok = pragma_lex (&x); |
| 152 if (tok != CPP_COMMA) | |
| 153 break; | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 if (tok != CPP_CLOSE_PAREN) | |
| 158 BAD ("missing ')' after '#pragma unused', ignoring"); | |
| 159 | |
| 160 if (pragma_lex (&x) != CPP_EOF) | |
| 161 BAD ("junk at end of '#pragma unused'"); | |
| 162 } | |
| 163 | |
| 164 /* Parse the ms_struct pragma. */ | |
| 165 void | |
| 166 darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED) | |
| 167 { | |
| 168 const char *arg; | |
| 169 tree t; | |
| 170 | |
| 171 if (pragma_lex (&t) != CPP_NAME) | |
| 172 BAD ("malformed '#pragma ms_struct', ignoring"); | |
| 173 arg = IDENTIFIER_POINTER (t); | |
| 174 | |
| 175 if (!strcmp (arg, "on")) | |
| 176 darwin_ms_struct = true; | |
| 177 else if (!strcmp (arg, "off") || !strcmp (arg, "reset")) | |
| 178 darwin_ms_struct = false; | |
| 179 else | |
| 180 BAD ("malformed '#pragma ms_struct {on|off|reset}', ignoring"); | |
| 181 | |
| 182 if (pragma_lex (&t) != CPP_EOF) | |
| 183 BAD ("junk at end of '#pragma ms_struct'"); | |
| 184 } | |
| 185 | |
| 186 static struct frameworks_in_use { | |
| 187 size_t len; | |
| 188 const char *name; | |
| 189 cpp_dir* dir; | |
| 190 } *frameworks_in_use; | |
| 191 static int num_frameworks = 0; | |
| 192 static int max_frameworks = 0; | |
| 193 | |
| 194 | |
| 195 /* Remember which frameworks have been seen, so that we can ensure | |
| 196 that all uses of that framework come from the same framework. DIR | |
| 197 is the place where the named framework NAME, which is of length | |
| 198 LEN, was found. We copy the directory name from NAME, as it will be | |
| 199 freed by others. */ | |
| 200 | |
| 201 static void | |
| 202 add_framework (const char *name, size_t len, cpp_dir *dir) | |
| 203 { | |
| 204 char *dir_name; | |
| 205 int i; | |
| 206 for (i = 0; i < num_frameworks; ++i) | |
| 207 { | |
| 208 if (len == frameworks_in_use[i].len | |
| 209 && strncmp (name, frameworks_in_use[i].name, len) == 0) | |
| 210 { | |
| 211 return; | |
| 212 } | |
| 213 } | |
| 214 if (i >= max_frameworks) | |
| 215 { | |
| 216 max_frameworks = i*2; | |
| 217 max_frameworks += i == 0; | |
| 218 frameworks_in_use = XRESIZEVEC (struct frameworks_in_use, | |
| 219 frameworks_in_use, max_frameworks); | |
| 220 } | |
| 221 dir_name = XNEWVEC (char, len + 1); | |
| 222 memcpy (dir_name, name, len); | |
| 223 dir_name[len] = '\0'; | |
| 224 frameworks_in_use[num_frameworks].name = dir_name; | |
| 225 frameworks_in_use[num_frameworks].len = len; | |
| 226 frameworks_in_use[num_frameworks].dir = dir; | |
| 227 ++num_frameworks; | |
| 228 } | |
| 229 | |
| 230 /* Recall if we have seen the named framework NAME, before, and where | |
| 231 we saw it. NAME is LEN bytes long. The return value is the place | |
| 232 where it was seen before. */ | |
| 233 | |
| 234 static struct cpp_dir* | |
| 235 find_framework (const char *name, size_t len) | |
| 236 { | |
| 237 int i; | |
| 238 for (i = 0; i < num_frameworks; ++i) | |
| 239 { | |
| 240 if (len == frameworks_in_use[i].len | |
| 241 && strncmp (name, frameworks_in_use[i].name, len) == 0) | |
| 242 { | |
| 243 return frameworks_in_use[i].dir; | |
| 244 } | |
| 245 } | |
| 246 return 0; | |
| 247 } | |
| 248 | |
| 249 /* There are two directories in a framework that contain header files, | |
| 250 Headers and PrivateHeaders. We search Headers first as it is more | |
| 251 common to upgrade a header from PrivateHeaders to Headers and when | |
| 252 that is done, the old one might hang around and be out of data, | |
| 253 causing grief. */ | |
| 254 | |
| 255 struct framework_header {const char * dirName; int dirNameLen; }; | |
| 256 static struct framework_header framework_header_dirs[] = { | |
| 257 { "Headers", 7 }, | |
| 258 { "PrivateHeaders", 14 }, | |
| 259 { NULL, 0 } | |
| 260 }; | |
| 261 | |
| 262 /* Returns a pointer to a malloced string that contains the real pathname | |
| 263 to the file, given the base name and the name. */ | |
| 264 | |
| 265 static char * | |
| 266 framework_construct_pathname (const char *fname, cpp_dir *dir) | |
| 267 { | |
| 268 char *buf; | |
| 269 size_t fname_len, frname_len; | |
| 270 cpp_dir *fast_dir; | |
| 271 char *frname; | |
| 272 struct stat st; | |
| 273 int i; | |
| 274 | |
| 275 /* Framework names must have a / in them. */ | |
| 276 buf = strchr (fname, '/'); | |
| 277 if (buf) | |
| 278 fname_len = buf - fname; | |
| 279 else | |
| 280 return 0; | |
| 281 | |
| 282 fast_dir = find_framework (fname, fname_len); | |
| 283 | |
| 284 /* Framework includes must all come from one framework. */ | |
| 285 if (fast_dir && dir != fast_dir) | |
| 286 return 0; | |
| 287 | |
| 288 frname = XNEWVEC (char, strlen (fname) + dir->len + 2 | |
| 289 + strlen(".framework/") + strlen("PrivateHeaders")); | |
| 290 strncpy (&frname[0], dir->name, dir->len); | |
| 291 frname_len = dir->len; | |
| 292 if (frname_len && frname[frname_len-1] != '/') | |
| 293 frname[frname_len++] = '/'; | |
| 294 strncpy (&frname[frname_len], fname, fname_len); | |
| 295 frname_len += fname_len; | |
| 296 strncpy (&frname[frname_len], ".framework/", strlen (".framework/")); | |
| 297 frname_len += strlen (".framework/"); | |
| 298 | |
| 299 if (fast_dir == 0) | |
| 300 { | |
| 301 frname[frname_len-1] = 0; | |
| 302 if (stat (frname, &st) == 0) | |
| 303 { | |
| 304 /* As soon as we find the first instance of the framework, | |
| 305 we stop and never use any later instance of that | |
| 306 framework. */ | |
| 307 add_framework (fname, fname_len, dir); | |
| 308 } | |
| 309 else | |
| 310 { | |
| 311 /* If we can't find the parent directory, no point looking | |
| 312 further. */ | |
| 313 free (frname); | |
| 314 return 0; | |
| 315 } | |
| 316 frname[frname_len-1] = '/'; | |
| 317 } | |
| 318 | |
| 319 /* Append framework_header_dirs and header file name */ | |
| 320 for (i = 0; framework_header_dirs[i].dirName; i++) | |
| 321 { | |
| 322 strncpy (&frname[frname_len], | |
| 323 framework_header_dirs[i].dirName, | |
| 324 framework_header_dirs[i].dirNameLen); | |
| 325 strcpy (&frname[frname_len + framework_header_dirs[i].dirNameLen], | |
| 326 &fname[fname_len]); | |
| 327 | |
| 328 if (stat (frname, &st) == 0) | |
| 329 return frname; | |
| 330 } | |
| 331 | |
| 332 free (frname); | |
| 333 return 0; | |
| 334 } | |
| 335 | |
| 336 /* Search for FNAME in sub-frameworks. pname is the context that we | |
| 337 wish to search in. Return the path the file was found at, | |
| 338 otherwise return 0. */ | |
| 339 | |
| 340 static const char* | |
| 341 find_subframework_file (const char *fname, const char *pname) | |
| 342 { | |
| 343 char *sfrname; | |
| 344 const char *dot_framework = ".framework/"; | |
| 345 char *bufptr; | |
| 346 int sfrname_len, i, fname_len; | |
| 347 struct cpp_dir *fast_dir; | |
| 348 static struct cpp_dir subframe_dir; | |
| 349 struct stat st; | |
| 350 | |
| 351 bufptr = strchr (fname, '/'); | |
| 352 | |
| 353 /* Subframework files must have / in the name. */ | |
| 354 if (bufptr == 0) | |
| 355 return 0; | |
| 356 | |
| 357 fname_len = bufptr - fname; | |
| 358 fast_dir = find_framework (fname, fname_len); | |
| 359 | |
| 360 /* Sub framework header filename includes parent framework name and | |
| 361 header name in the "CarbonCore/OSUtils.h" form. If it does not | |
| 362 include slash it is not a sub framework include. */ | |
| 363 bufptr = strstr (pname, dot_framework); | |
| 364 | |
| 365 /* If the parent header is not of any framework, then this header | |
| 366 cannot be part of any subframework. */ | |
| 367 if (!bufptr) | |
| 368 return 0; | |
| 369 | |
| 370 /* Now translate. For example, +- bufptr | |
| 371 fname = CarbonCore/OSUtils.h | | |
| 372 pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h | |
| 373 into | |
| 374 sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */ | |
| 375 | |
| 376 sfrname = XNEWVEC (char, strlen (pname) + strlen (fname) + 2 + | |
| 377 strlen ("Frameworks/") + strlen (".framework/") | |
| 378 + strlen ("PrivateHeaders")); | |
| 379 | |
| 380 bufptr += strlen (dot_framework); | |
| 381 | |
| 382 sfrname_len = bufptr - pname; | |
| 383 | |
| 384 strncpy (&sfrname[0], pname, sfrname_len); | |
| 385 | |
| 386 strncpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/")); | |
| 387 sfrname_len += strlen("Frameworks/"); | |
| 388 | |
| 389 strncpy (&sfrname[sfrname_len], fname, fname_len); | |
| 390 sfrname_len += fname_len; | |
| 391 | |
| 392 strncpy (&sfrname[sfrname_len], ".framework/", strlen (".framework/")); | |
| 393 sfrname_len += strlen (".framework/"); | |
| 394 | |
| 395 /* Append framework_header_dirs and header file name */ | |
| 396 for (i = 0; framework_header_dirs[i].dirName; i++) | |
| 397 { | |
| 398 strncpy (&sfrname[sfrname_len], | |
| 399 framework_header_dirs[i].dirName, | |
| 400 framework_header_dirs[i].dirNameLen); | |
| 401 strcpy (&sfrname[sfrname_len + framework_header_dirs[i].dirNameLen], | |
| 402 &fname[fname_len]); | |
| 403 | |
| 404 if (stat (sfrname, &st) == 0) | |
| 405 { | |
| 406 if (fast_dir != &subframe_dir) | |
| 407 { | |
| 408 if (fast_dir) | |
| 409 warning (0, "subframework include %s conflicts with framework include", | |
| 410 fname); | |
| 411 else | |
| 412 add_framework (fname, fname_len, &subframe_dir); | |
| 413 } | |
| 414 | |
| 415 return sfrname; | |
| 416 } | |
| 417 } | |
| 418 free (sfrname); | |
| 419 | |
| 420 return 0; | |
| 421 } | |
| 422 | |
| 423 /* Add PATH to the system includes. PATH must be malloc-ed and | |
| 424 NUL-terminated. System framework paths are C++ aware. */ | |
| 425 | |
| 426 static void | |
| 427 add_system_framework_path (char *path) | |
| 428 { | |
| 429 int cxx_aware = 1; | |
| 430 cpp_dir *p; | |
| 431 | |
| 432 p = XNEW (cpp_dir); | |
| 433 p->next = NULL; | |
| 434 p->name = path; | |
| 435 p->sysp = 1 + !cxx_aware; | |
| 436 p->construct = framework_construct_pathname; | |
| 437 using_frameworks = 1; | |
| 438 | |
| 439 add_cpp_dir_path (p, SYSTEM); | |
| 440 } | |
| 441 | |
| 442 /* Add PATH to the bracket includes. PATH must be malloc-ed and | |
| 443 NUL-terminated. */ | |
| 444 | |
| 445 void | |
| 446 add_framework_path (char *path) | |
| 447 { | |
| 448 cpp_dir *p; | |
| 449 | |
| 450 p = XNEW (cpp_dir); | |
| 451 p->next = NULL; | |
| 452 p->name = path; | |
| 453 p->sysp = 0; | |
| 454 p->construct = framework_construct_pathname; | |
| 455 using_frameworks = 1; | |
| 456 | |
| 457 add_cpp_dir_path (p, BRACKET); | |
| 458 } | |
| 459 | |
| 460 static const char *framework_defaults [] = | |
| 461 { | |
| 462 "/System/Library/Frameworks", | |
| 463 "/Library/Frameworks", | |
| 464 }; | |
| 465 | |
| 466 /* Register the GNU objective-C runtime include path if STDINC. */ | |
| 467 | |
| 468 void | |
| 469 darwin_register_objc_includes (const char *sysroot, const char *iprefix, | |
| 470 int stdinc) | |
| 471 { | |
| 472 const char *fname; | |
| 473 size_t len; | |
| 474 /* We do not do anything if we do not want the standard includes. */ | |
| 475 if (!stdinc) | |
| 476 return; | |
| 477 | |
| 478 fname = GCC_INCLUDE_DIR "-gnu-runtime"; | |
| 479 | |
| 480 /* Register the GNU OBJC runtime include path if we are compiling OBJC | |
| 481 with GNU-runtime. */ | |
| 482 | |
| 483 if (c_dialect_objc () && !flag_next_runtime) | |
| 484 { | |
| 485 char *str; | |
| 486 /* See if our directory starts with the standard prefix. | |
| 487 "Translate" them, i.e. replace /usr/local/lib/gcc... with | |
| 488 IPREFIX and search them first. */ | |
| 489 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 && !sysroot | |
| 490 && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len)) | |
| 491 { | |
| 492 str = concat (iprefix, fname + len, NULL); | |
| 493 /* FIXME: wrap the headers for C++awareness. */ | |
| 494 add_path (str, SYSTEM, /*c++aware=*/false, false); | |
| 495 } | |
| 496 | |
| 497 /* Should this directory start with the sysroot? */ | |
| 498 if (sysroot) | |
| 499 str = concat (sysroot, fname, NULL); | |
| 500 else | |
| 501 str = update_path (fname, ""); | |
| 502 | |
| 503 add_path (str, SYSTEM, /*c++aware=*/false, false); | |
| 504 } | |
| 505 } | |
| 506 | |
| 507 | |
| 508 /* Register all the system framework paths if STDINC is true and setup | |
| 509 the missing_header callback for subframework searching if any | |
| 510 frameworks had been registered. */ | |
| 511 | |
| 512 void | |
| 513 darwin_register_frameworks (const char *sysroot, | |
| 514 const char *iprefix ATTRIBUTE_UNUSED, int stdinc) | |
| 515 { | |
| 516 if (stdinc) | |
| 517 { | |
| 518 size_t i; | |
| 519 | |
| 520 /* Setup default search path for frameworks. */ | |
| 521 for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i) | |
| 522 { | |
| 523 char *str; | |
| 524 if (sysroot) | |
| 525 str = concat (sysroot, xstrdup (framework_defaults [i]), NULL); | |
| 526 else | |
| 527 str = xstrdup (framework_defaults[i]); | |
| 528 /* System Framework headers are cxx aware. */ | |
| 529 add_system_framework_path (str); | |
| 530 } | |
| 531 } | |
| 532 | |
| 533 if (using_frameworks) | |
| 534 cpp_get_callbacks (parse_in)->missing_header = find_subframework_header; | |
| 535 } | |
| 536 | |
| 537 /* Search for HEADER in context dependent way. The return value is | |
| 538 the malloced name of a header to try and open, if any, or NULL | |
| 539 otherwise. This is called after normal header lookup processing | |
| 540 fails to find a header. We search each file in the include stack, | |
| 541 using FUNC, starting from the most deeply nested include and | |
| 542 finishing with the main input file. We stop searching when FUNC | |
| 543 returns nonzero. */ | |
| 544 | |
| 545 static const char* | |
| 546 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp) | |
| 547 { | |
| 548 const char *fname = header; | |
| 549 struct cpp_buffer *b; | |
| 550 const char *n; | |
| 551 | |
| 552 for (b = cpp_get_buffer (pfile); | |
| 553 b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b)); | |
| 554 b = cpp_get_prev (b)) | |
| 555 { | |
| 556 n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b))); | |
| 557 if (n) | |
| 558 { | |
| 559 /* Logically, the place where we found the subframework is | |
| 560 the place where we found the Framework that contains the | |
| 561 subframework. This is useful for tracking wether or not | |
| 562 we are in a system header. */ | |
| 563 *dirp = cpp_get_dir (cpp_get_file (b)); | |
| 564 return n; | |
| 565 } | |
| 566 } | |
| 567 | |
| 568 return 0; | |
| 569 } | |
| 570 | |
| 571 /* Return the value of darwin_macosx_version_min suitable for the | |
| 572 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro, | |
| 573 so '10.4.2' becomes 1040. The lowest digit is always zero. | |
| 574 Print a warning if the version number can't be understood. */ | |
| 575 static const char * | |
| 576 version_as_macro (void) | |
| 577 { | |
| 578 static char result[] = "1000"; | |
| 579 | |
| 580 if (strncmp (darwin_macosx_version_min, "10.", 3) != 0) | |
| 581 goto fail; | |
| 582 if (! ISDIGIT (darwin_macosx_version_min[3])) | |
| 583 goto fail; | |
| 584 result[2] = darwin_macosx_version_min[3]; | |
| 585 if (darwin_macosx_version_min[4] != '\0' | |
| 586 && darwin_macosx_version_min[4] != '.') | |
| 587 goto fail; | |
| 588 | |
| 589 return result; | |
| 590 | |
| 591 fail: | |
| 592 error ("Unknown value %qs of -mmacosx-version-min", | |
| 593 darwin_macosx_version_min); | |
| 594 return "1000"; | |
| 595 } | |
| 596 | |
| 597 /* Define additional CPP flags for Darwin. */ | |
| 598 | |
| 599 #define builtin_define(TXT) cpp_define (pfile, TXT) | |
| 600 | |
| 601 void | |
| 602 darwin_cpp_builtins (cpp_reader *pfile) | |
| 603 { | |
| 604 builtin_define ("__MACH__"); | |
| 605 builtin_define ("__APPLE__"); | |
| 606 | |
| 607 /* __APPLE_CC__ is defined as some old Apple include files expect it | |
| 608 to be defined and won't work if it isn't. */ | |
| 609 builtin_define_with_value ("__APPLE_CC__", "1", false); | |
| 610 | |
| 611 builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", | |
| 612 version_as_macro(), false); | |
| 613 } | |
| 614 | |
| 615 /* Handle C family front-end options. */ | |
| 616 | |
| 617 static bool | |
| 618 handle_c_option (size_t code, | |
| 619 const char *arg, | |
| 620 int value ATTRIBUTE_UNUSED) | |
| 621 { | |
| 622 switch (code) | |
| 623 { | |
| 624 default: | |
| 625 /* Unrecognized options that we said we'd handle turn into | |
| 626 errors if not listed here. */ | |
| 627 return false; | |
| 628 | |
| 629 case OPT_iframework: | |
| 630 add_system_framework_path (xstrdup (arg)); | |
| 631 break; | |
| 632 | |
| 633 case OPT_fapple_kext: | |
| 634 ; | |
| 635 } | |
| 636 | |
| 637 /* We recognized the option. */ | |
| 638 return true; | |
| 639 } | |
| 640 | |
| 641 #undef TARGET_HANDLE_C_OPTION | |
| 642 #define TARGET_HANDLE_C_OPTION handle_c_option | |
| 643 | |
| 644 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER; |