2008-07-01 Jerry DeLisle <jvdelisle@gcc.gnu.org>
[official-gcc.git] / gcc / config / darwin-c.c
blob9f3b444d6bc6766ecfea776bcd3716129f528edd
1 /* Darwin support needed only by C/C++ frontends.
2 Copyright (C) 2001, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
3 Contributed by Apple Computer Inc.
5 This file is part of GCC.
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.
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.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "cpplib.h"
26 #include "tree.h"
27 #include "c-pragma.h"
28 #include "c-tree.h"
29 #include "incpath.h"
30 #include "c-common.h"
31 #include "toplev.h"
32 #include "flags.h"
33 #include "tm_p.h"
34 #include "cppdefault.h"
35 #include "prefix.h"
36 #include "target.h"
37 #include "target-def.h"
39 /* Pragmas. */
41 #define BAD(gmsgid) do { warning (OPT_Wpragmas, gmsgid); return; } while (0)
42 #define BAD2(msgid, arg) do { warning (OPT_Wpragmas, msgid, arg); return; } while (0)
44 static bool using_frameworks = false;
46 static const char *find_subframework_header (cpp_reader *pfile, const char *header,
47 cpp_dir **dirp);
49 typedef struct align_stack
51 int alignment;
52 struct align_stack * prev;
53 } align_stack;
55 static struct align_stack * field_align_stack = NULL;
57 /* Maintain a small stack of alignments. This is similar to pragma
58 pack's stack, but simpler. */
60 static void
61 push_field_alignment (int bit_alignment)
63 align_stack *entry = XNEW (align_stack);
65 entry->alignment = maximum_field_alignment;
66 entry->prev = field_align_stack;
67 field_align_stack = entry;
69 maximum_field_alignment = bit_alignment;
72 static void
73 pop_field_alignment (void)
75 if (field_align_stack)
77 align_stack *entry = field_align_stack;
79 maximum_field_alignment = entry->alignment;
80 field_align_stack = entry->prev;
81 free (entry);
83 else
84 error ("too many #pragma options align=reset");
87 /* Handlers for Darwin-specific pragmas. */
89 void
90 darwin_pragma_ignore (cpp_reader *pfile ATTRIBUTE_UNUSED)
92 /* Do nothing. */
95 /* #pragma options align={mac68k|power|reset} */
97 void
98 darwin_pragma_options (cpp_reader *pfile ATTRIBUTE_UNUSED)
100 const char *arg;
101 tree t, x;
103 if (pragma_lex (&t) != CPP_NAME)
104 BAD ("malformed '#pragma options', ignoring");
105 arg = IDENTIFIER_POINTER (t);
106 if (strcmp (arg, "align"))
107 BAD ("malformed '#pragma options', ignoring");
108 if (pragma_lex (&t) != CPP_EQ)
109 BAD ("malformed '#pragma options', ignoring");
110 if (pragma_lex (&t) != CPP_NAME)
111 BAD ("malformed '#pragma options', ignoring");
113 if (pragma_lex (&x) != CPP_EOF)
114 warning (OPT_Wpragmas, "junk at end of '#pragma options'");
116 arg = IDENTIFIER_POINTER (t);
117 if (!strcmp (arg, "mac68k"))
118 push_field_alignment (16);
119 else if (!strcmp (arg, "power"))
120 push_field_alignment (0);
121 else if (!strcmp (arg, "reset"))
122 pop_field_alignment ();
123 else
124 BAD ("malformed '#pragma options align={mac68k|power|reset}', ignoring");
127 /* #pragma unused ([var {, var}*]) */
129 void
130 darwin_pragma_unused (cpp_reader *pfile ATTRIBUTE_UNUSED)
132 tree decl, x;
133 int tok;
135 if (pragma_lex (&x) != CPP_OPEN_PAREN)
136 BAD ("missing '(' after '#pragma unused', ignoring");
138 while (1)
140 tok = pragma_lex (&decl);
141 if (tok == CPP_NAME && decl)
143 tree local = lookup_name (decl);
144 if (local && (TREE_CODE (local) == PARM_DECL
145 || TREE_CODE (local) == VAR_DECL))
146 TREE_USED (local) = 1;
147 tok = pragma_lex (&x);
148 if (tok != CPP_COMMA)
149 break;
153 if (tok != CPP_CLOSE_PAREN)
154 BAD ("missing ')' after '#pragma unused', ignoring");
156 if (pragma_lex (&x) != CPP_EOF)
157 BAD ("junk at end of '#pragma unused'");
160 /* Parse the ms_struct pragma. */
161 void
162 darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED)
164 const char *arg;
165 tree t;
167 if (pragma_lex (&t) != CPP_NAME)
168 BAD ("malformed '#pragma ms_struct', ignoring");
169 arg = IDENTIFIER_POINTER (t);
171 if (!strcmp (arg, "on"))
172 darwin_ms_struct = true;
173 else if (!strcmp (arg, "off") || !strcmp (arg, "reset"))
174 darwin_ms_struct = false;
175 else
176 BAD ("malformed '#pragma ms_struct {on|off|reset}', ignoring");
178 if (pragma_lex (&t) != CPP_EOF)
179 BAD ("junk at end of '#pragma ms_struct'");
182 static struct frameworks_in_use {
183 size_t len;
184 const char *name;
185 cpp_dir* dir;
186 } *frameworks_in_use;
187 static int num_frameworks = 0;
188 static int max_frameworks = 0;
191 /* Remember which frameworks have been seen, so that we can ensure
192 that all uses of that framework come from the same framework. DIR
193 is the place where the named framework NAME, which is of length
194 LEN, was found. We copy the directory name from NAME, as it will be
195 freed by others. */
197 static void
198 add_framework (const char *name, size_t len, cpp_dir *dir)
200 char *dir_name;
201 int i;
202 for (i = 0; i < num_frameworks; ++i)
204 if (len == frameworks_in_use[i].len
205 && strncmp (name, frameworks_in_use[i].name, len) == 0)
207 return;
210 if (i >= max_frameworks)
212 max_frameworks = i*2;
213 max_frameworks += i == 0;
214 frameworks_in_use = XRESIZEVEC (struct frameworks_in_use,
215 frameworks_in_use, max_frameworks);
217 dir_name = XNEWVEC (char, len + 1);
218 memcpy (dir_name, name, len);
219 dir_name[len] = '\0';
220 frameworks_in_use[num_frameworks].name = dir_name;
221 frameworks_in_use[num_frameworks].len = len;
222 frameworks_in_use[num_frameworks].dir = dir;
223 ++num_frameworks;
226 /* Recall if we have seen the named framework NAME, before, and where
227 we saw it. NAME is LEN bytes long. The return value is the place
228 where it was seen before. */
230 static struct cpp_dir*
231 find_framework (const char *name, size_t len)
233 int i;
234 for (i = 0; i < num_frameworks; ++i)
236 if (len == frameworks_in_use[i].len
237 && strncmp (name, frameworks_in_use[i].name, len) == 0)
239 return frameworks_in_use[i].dir;
242 return 0;
245 /* There are two directories in a framework that contain header files,
246 Headers and PrivateHeaders. We search Headers first as it is more
247 common to upgrade a header from PrivateHeaders to Headers and when
248 that is done, the old one might hang around and be out of data,
249 causing grief. */
251 struct framework_header {const char * dirName; int dirNameLen; };
252 static struct framework_header framework_header_dirs[] = {
253 { "Headers", 7 },
254 { "PrivateHeaders", 14 },
255 { NULL, 0 }
258 /* Returns a pointer to a malloced string that contains the real pathname
259 to the file, given the base name and the name. */
261 static char *
262 framework_construct_pathname (const char *fname, cpp_dir *dir)
264 char *buf;
265 size_t fname_len, frname_len;
266 cpp_dir *fast_dir;
267 char *frname;
268 struct stat st;
269 int i;
271 /* Framework names must have a / in them. */
272 buf = strchr (fname, '/');
273 if (buf)
274 fname_len = buf - fname;
275 else
276 return 0;
278 fast_dir = find_framework (fname, fname_len);
280 /* Framework includes must all come from one framework. */
281 if (fast_dir && dir != fast_dir)
282 return 0;
284 frname = XNEWVEC (char, strlen (fname) + dir->len + 2
285 + strlen(".framework/") + strlen("PrivateHeaders"));
286 strncpy (&frname[0], dir->name, dir->len);
287 frname_len = dir->len;
288 if (frname_len && frname[frname_len-1] != '/')
289 frname[frname_len++] = '/';
290 strncpy (&frname[frname_len], fname, fname_len);
291 frname_len += fname_len;
292 strncpy (&frname[frname_len], ".framework/", strlen (".framework/"));
293 frname_len += strlen (".framework/");
295 if (fast_dir == 0)
297 frname[frname_len-1] = 0;
298 if (stat (frname, &st) == 0)
300 /* As soon as we find the first instance of the framework,
301 we stop and never use any later instance of that
302 framework. */
303 add_framework (fname, fname_len, dir);
305 else
307 /* If we can't find the parent directory, no point looking
308 further. */
309 free (frname);
310 return 0;
312 frname[frname_len-1] = '/';
315 /* Append framework_header_dirs and header file name */
316 for (i = 0; framework_header_dirs[i].dirName; i++)
318 strncpy (&frname[frname_len],
319 framework_header_dirs[i].dirName,
320 framework_header_dirs[i].dirNameLen);
321 strcpy (&frname[frname_len + framework_header_dirs[i].dirNameLen],
322 &fname[fname_len]);
324 if (stat (frname, &st) == 0)
325 return frname;
328 free (frname);
329 return 0;
332 /* Search for FNAME in sub-frameworks. pname is the context that we
333 wish to search in. Return the path the file was found at,
334 otherwise return 0. */
336 static const char*
337 find_subframework_file (const char *fname, const char *pname)
339 char *sfrname;
340 const char *dot_framework = ".framework/";
341 char *bufptr;
342 int sfrname_len, i, fname_len;
343 struct cpp_dir *fast_dir;
344 static struct cpp_dir subframe_dir;
345 struct stat st;
347 bufptr = strchr (fname, '/');
349 /* Subframework files must have / in the name. */
350 if (bufptr == 0)
351 return 0;
353 fname_len = bufptr - fname;
354 fast_dir = find_framework (fname, fname_len);
356 /* Sub framework header filename includes parent framework name and
357 header name in the "CarbonCore/OSUtils.h" form. If it does not
358 include slash it is not a sub framework include. */
359 bufptr = strstr (pname, dot_framework);
361 /* If the parent header is not of any framework, then this header
362 cannot be part of any subframework. */
363 if (!bufptr)
364 return 0;
366 /* Now translate. For example, +- bufptr
367 fname = CarbonCore/OSUtils.h |
368 pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h
369 into
370 sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */
372 sfrname = XNEWVEC (char, strlen (pname) + strlen (fname) + 2 +
373 strlen ("Frameworks/") + strlen (".framework/")
374 + strlen ("PrivateHeaders"));
376 bufptr += strlen (dot_framework);
378 sfrname_len = bufptr - pname;
380 strncpy (&sfrname[0], pname, sfrname_len);
382 strncpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/"));
383 sfrname_len += strlen("Frameworks/");
385 strncpy (&sfrname[sfrname_len], fname, fname_len);
386 sfrname_len += fname_len;
388 strncpy (&sfrname[sfrname_len], ".framework/", strlen (".framework/"));
389 sfrname_len += strlen (".framework/");
391 /* Append framework_header_dirs and header file name */
392 for (i = 0; framework_header_dirs[i].dirName; i++)
394 strncpy (&sfrname[sfrname_len],
395 framework_header_dirs[i].dirName,
396 framework_header_dirs[i].dirNameLen);
397 strcpy (&sfrname[sfrname_len + framework_header_dirs[i].dirNameLen],
398 &fname[fname_len]);
400 if (stat (sfrname, &st) == 0)
402 if (fast_dir != &subframe_dir)
404 if (fast_dir)
405 warning (0, "subframework include %s conflicts with framework include",
406 fname);
407 else
408 add_framework (fname, fname_len, &subframe_dir);
411 return sfrname;
414 free (sfrname);
416 return 0;
419 /* Add PATH to the system includes. PATH must be malloc-ed and
420 NUL-terminated. System framework paths are C++ aware. */
422 static void
423 add_system_framework_path (char *path)
425 int cxx_aware = 1;
426 cpp_dir *p;
428 p = XNEW (cpp_dir);
429 p->next = NULL;
430 p->name = path;
431 p->sysp = 1 + !cxx_aware;
432 p->construct = framework_construct_pathname;
433 using_frameworks = 1;
435 add_cpp_dir_path (p, SYSTEM);
438 /* Add PATH to the bracket includes. PATH must be malloc-ed and
439 NUL-terminated. */
441 void
442 add_framework_path (char *path)
444 cpp_dir *p;
446 p = XNEW (cpp_dir);
447 p->next = NULL;
448 p->name = path;
449 p->sysp = 0;
450 p->construct = framework_construct_pathname;
451 using_frameworks = 1;
453 add_cpp_dir_path (p, BRACKET);
456 static const char *framework_defaults [] =
458 "/System/Library/Frameworks",
459 "/Library/Frameworks",
462 /* Register the GNU objective-C runtime include path if STDINC. */
464 void
465 darwin_register_objc_includes (const char *sysroot, const char *iprefix,
466 int stdinc)
468 const char *fname;
469 size_t len;
470 /* We do not do anything if we do not want the standard includes. */
471 if (!stdinc)
472 return;
474 fname = GCC_INCLUDE_DIR "-gnu-runtime";
476 /* Register the GNU OBJC runtime include path if we are compiling OBJC
477 with GNU-runtime. */
479 if (c_dialect_objc () && !flag_next_runtime)
481 char *str;
482 /* See if our directory starts with the standard prefix.
483 "Translate" them, i.e. replace /usr/local/lib/gcc... with
484 IPREFIX and search them first. */
485 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 && !sysroot
486 && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len))
488 str = concat (iprefix, fname + len, NULL);
489 /* FIXME: wrap the headers for C++awareness. */
490 add_path (str, SYSTEM, /*c++aware=*/false, false);
493 /* Should this directory start with the sysroot? */
494 if (sysroot)
495 str = concat (sysroot, fname, NULL);
496 else
497 str = update_path (fname, "");
499 add_path (str, SYSTEM, /*c++aware=*/false, false);
504 /* Register all the system framework paths if STDINC is true and setup
505 the missing_header callback for subframework searching if any
506 frameworks had been registered. */
508 void
509 darwin_register_frameworks (const char *sysroot,
510 const char *iprefix ATTRIBUTE_UNUSED, int stdinc)
512 if (stdinc)
514 size_t i;
516 /* Setup default search path for frameworks. */
517 for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i)
519 char *str;
520 if (sysroot)
521 str = concat (sysroot, xstrdup (framework_defaults [i]), NULL);
522 else
523 str = xstrdup (framework_defaults[i]);
524 /* System Framework headers are cxx aware. */
525 add_system_framework_path (str);
529 if (using_frameworks)
530 cpp_get_callbacks (parse_in)->missing_header = find_subframework_header;
533 /* Search for HEADER in context dependent way. The return value is
534 the malloced name of a header to try and open, if any, or NULL
535 otherwise. This is called after normal header lookup processing
536 fails to find a header. We search each file in the include stack,
537 using FUNC, starting from the most deeply nested include and
538 finishing with the main input file. We stop searching when FUNC
539 returns nonzero. */
541 static const char*
542 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp)
544 const char *fname = header;
545 struct cpp_buffer *b;
546 const char *n;
548 for (b = cpp_get_buffer (pfile);
549 b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b));
550 b = cpp_get_prev (b))
552 n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b)));
553 if (n)
555 /* Logically, the place where we found the subframework is
556 the place where we found the Framework that contains the
557 subframework. This is useful for tracking wether or not
558 we are in a system header. */
559 *dirp = cpp_get_dir (cpp_get_file (b));
560 return n;
564 return 0;
567 /* Return the value of darwin_macosx_version_min suitable for the
568 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro,
569 so '10.4.2' becomes 1040. The lowest digit is always zero.
570 Print a warning if the version number can't be understood. */
571 static const char *
572 version_as_macro (void)
574 static char result[] = "1000";
576 if (strncmp (darwin_macosx_version_min, "10.", 3) != 0)
577 goto fail;
578 if (! ISDIGIT (darwin_macosx_version_min[3]))
579 goto fail;
580 result[2] = darwin_macosx_version_min[3];
581 if (darwin_macosx_version_min[4] != '\0'
582 && darwin_macosx_version_min[4] != '.')
583 goto fail;
585 return result;
587 fail:
588 error ("Unknown value %qs of -mmacosx-version-min",
589 darwin_macosx_version_min);
590 return "1000";
593 /* Define additional CPP flags for Darwin. */
595 #define builtin_define(TXT) cpp_define (pfile, TXT)
597 void
598 darwin_cpp_builtins (cpp_reader *pfile)
600 builtin_define ("__MACH__");
601 builtin_define ("__APPLE__");
603 /* __APPLE_CC__ is defined as some old Apple include files expect it
604 to be defined and won't work if it isn't. */
605 builtin_define_with_value ("__APPLE_CC__", "1", false);
607 builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
608 version_as_macro(), false);
611 /* Handle C family front-end options. */
613 static bool
614 handle_c_option (size_t code,
615 const char *arg,
616 int value ATTRIBUTE_UNUSED)
618 switch (code)
620 default:
621 /* Unrecognized options that we said we'd handle turn into
622 errors if not listed here. */
623 return false;
625 case OPT_iframework:
626 add_system_framework_path (xstrdup (arg));
627 break;
629 case OPT_fapple_kext:
633 /* We recognized the option. */
634 return true;
637 #undef TARGET_HANDLE_C_OPTION
638 #define TARGET_HANDLE_C_OPTION handle_c_option
640 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;