1 /* Darwin support needed only by C/C++ frontends.
2 Copyright (C) 2001, 2003, 2004, 2005 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 2, 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 COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
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 "c-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
38 /* Pragmas. */
39
40 #define BAD(gmsgid) do { warning (OPT_Wpragmas, gmsgid); return; } while (0)
41 #define BAD2(msgid, arg) do { warning (OPT_Wpragmas, msgid, arg); return; } while (0)
42
43 static bool using_frameworks = false;
44
45 /* Maintain a small stack of alignments. This is similar to pragma
46 pack's stack, but simpler. */
47
48 static void push_field_alignment (int);
49 static void pop_field_alignment (void);
50 static const char *find_subframework_file (const char *, const char *);
51 static void add_system_framework_path (char *);
52 static const char *find_subframework_header (cpp_reader *pfile, const char *header,
53 cpp_dir **dirp);
54
55 typedef struct align_stack
56 {
57 int alignment;
58 struct align_stack * prev;
59 } align_stack;
60
61 static struct align_stack * field_align_stack = NULL;
62
63 static void
push_field_alignment(int bit_alignment)64 push_field_alignment (int bit_alignment)
65 {
66 align_stack *entry = XNEW (align_stack);
67
68 entry->alignment = maximum_field_alignment;
69 entry->prev = field_align_stack;
70 field_align_stack = entry;
71
72 maximum_field_alignment = bit_alignment;
73 }
74
75 static void
pop_field_alignment(void)76 pop_field_alignment (void)
77 {
78 if (field_align_stack)
79 {
80 align_stack *entry = field_align_stack;
81
82 maximum_field_alignment = entry->alignment;
83 field_align_stack = entry->prev;
84 free (entry);
85 }
86 else
87 error ("too many #pragma options align=reset");
88 }
89
90 /* Handlers for Darwin-specific pragmas. */
91
92 void
darwin_pragma_ignore(cpp_reader * pfile ATTRIBUTE_UNUSED)93 darwin_pragma_ignore (cpp_reader *pfile ATTRIBUTE_UNUSED)
94 {
95 /* Do nothing. */
96 }
97
98 /* #pragma options align={mac68k|power|reset} */
99
100 void
darwin_pragma_options(cpp_reader * pfile ATTRIBUTE_UNUSED)101 darwin_pragma_options (cpp_reader *pfile ATTRIBUTE_UNUSED)
102 {
103 const char *arg;
104 tree t, x;
105
106 if (pragma_lex (&t) != CPP_NAME)
107 BAD ("malformed '#pragma options', ignoring");
108 arg = IDENTIFIER_POINTER (t);
109 if (strcmp (arg, "align"))
110 BAD ("malformed '#pragma options', ignoring");
111 if (pragma_lex (&t) != CPP_EQ)
112 BAD ("malformed '#pragma options', ignoring");
113 if (pragma_lex (&t) != CPP_NAME)
114 BAD ("malformed '#pragma options', ignoring");
115
116 if (pragma_lex (&x) != CPP_EOF)
117 warning (OPT_Wpragmas, "junk at end of '#pragma options'");
118
119 arg = IDENTIFIER_POINTER (t);
120 if (!strcmp (arg, "mac68k"))
121 push_field_alignment (16);
122 else if (!strcmp (arg, "power"))
123 push_field_alignment (0);
124 else if (!strcmp (arg, "reset"))
125 pop_field_alignment ();
126 else
127 BAD ("malformed '#pragma options align={mac68k|power|reset}', ignoring");
128 }
129
130 /* #pragma unused ([var {, var}*]) */
131
132 void
darwin_pragma_unused(cpp_reader * pfile ATTRIBUTE_UNUSED)133 darwin_pragma_unused (cpp_reader *pfile ATTRIBUTE_UNUSED)
134 {
135 tree decl, x;
136 int tok;
137
138 if (pragma_lex (&x) != CPP_OPEN_PAREN)
139 BAD ("missing '(' after '#pragma unused', ignoring");
140
141 while (1)
142 {
143 tok = pragma_lex (&decl);
144 if (tok == CPP_NAME && decl)
145 {
146 tree local = lookup_name (decl);
147 if (local && (TREE_CODE (local) == PARM_DECL
148 || TREE_CODE (local) == VAR_DECL))
149 TREE_USED (local) = 1;
150 tok = pragma_lex (&x);
151 if (tok != CPP_COMMA)
152 break;
153 }
154 }
155
156 if (tok != CPP_CLOSE_PAREN)
157 BAD ("missing ')' after '#pragma unused', ignoring");
158
159 if (pragma_lex (&x) != CPP_EOF)
160 BAD ("junk at end of '#pragma unused'");
161 }
162
163 /* Parse the ms_struct pragma. */
164 void
darwin_pragma_ms_struct(cpp_reader * pfile ATTRIBUTE_UNUSED)165 darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED)
166 {
167 const char *arg;
168 tree t;
169
170 if (pragma_lex (&t) != CPP_NAME)
171 BAD ("malformed '#pragma ms_struct', ignoring");
172 arg = IDENTIFIER_POINTER (t);
173
174 if (!strcmp (arg, "on"))
175 darwin_ms_struct = true;
176 else if (!strcmp (arg, "off") || !strcmp (arg, "reset"))
177 darwin_ms_struct = false;
178 else
179 BAD ("malformed '#pragma ms_struct {on|off|reset}', ignoring");
180
181 if (pragma_lex (&t) != CPP_EOF)
182 BAD ("junk at end of '#pragma ms_struct'");
183 }
184
185 static struct {
186 size_t len;
187 const char *name;
188 cpp_dir* dir;
189 } *frameworks_in_use;
190 static int num_frameworks = 0;
191 static int max_frameworks = 0;
192
193
194 /* Remember which frameworks have been seen, so that we can ensure
195 that all uses of that framework come from the same framework. DIR
196 is the place where the named framework NAME, which is of length
197 LEN, was found. We copy the directory name from NAME, as it will be
198 freed by others. */
199
200 static void
add_framework(const char * name,size_t len,cpp_dir * dir)201 add_framework (const char *name, size_t len, cpp_dir *dir)
202 {
203 char *dir_name;
204 int i;
205 for (i = 0; i < num_frameworks; ++i)
206 {
207 if (len == frameworks_in_use[i].len
208 && strncmp (name, frameworks_in_use[i].name, len) == 0)
209 {
210 return;
211 }
212 }
213 if (i >= max_frameworks)
214 {
215 max_frameworks = i*2;
216 max_frameworks += i == 0;
217 frameworks_in_use = xrealloc (frameworks_in_use,
218 max_frameworks*sizeof(*frameworks_in_use));
219 }
220 dir_name = XNEWVEC (char, len + 1);
221 memcpy (dir_name, name, len);
222 dir_name[len] = '\0';
223 frameworks_in_use[num_frameworks].name = dir_name;
224 frameworks_in_use[num_frameworks].len = len;
225 frameworks_in_use[num_frameworks].dir = dir;
226 ++num_frameworks;
227 }
228
229 /* Recall if we have seen the named framework NAME, before, and where
230 we saw it. NAME is LEN bytes long. The return value is the place
231 where it was seen before. */
232
233 static struct cpp_dir*
find_framework(const char * name,size_t len)234 find_framework (const char *name, size_t len)
235 {
236 int i;
237 for (i = 0; i < num_frameworks; ++i)
238 {
239 if (len == frameworks_in_use[i].len
240 && strncmp (name, frameworks_in_use[i].name, len) == 0)
241 {
242 return frameworks_in_use[i].dir;
243 }
244 }
245 return 0;
246 }
247
248 /* There are two directories in a framework that contain header files,
249 Headers and PrivateHeaders. We search Headers first as it is more
250 common to upgrade a header from PrivateHeaders to Headers and when
251 that is done, the old one might hang around and be out of data,
252 causing grief. */
253
254 struct framework_header {const char * dirName; int dirNameLen; };
255 static struct framework_header framework_header_dirs[] = {
256 { "Headers", 7 },
257 { "PrivateHeaders", 14 },
258 { NULL, 0 }
259 };
260
261 /* Returns a pointer to a malloced string that contains the real pathname
262 to the file, given the base name and the name. */
263
264 static char *
framework_construct_pathname(const char * fname,cpp_dir * dir)265 framework_construct_pathname (const char *fname, cpp_dir *dir)
266 {
267 char *buf;
268 size_t fname_len, frname_len;
269 cpp_dir *fast_dir;
270 char *frname;
271 struct stat st;
272 int i;
273
274 /* Framework names must have a / in them. */
275 buf = strchr (fname, '/');
276 if (buf)
277 fname_len = buf - fname;
278 else
279 return 0;
280
281 fast_dir = find_framework (fname, fname_len);
282
283 /* Framework includes must all come from one framework. */
284 if (fast_dir && dir != fast_dir)
285 return 0;
286
287 frname = XNEWVEC (char, strlen (fname) + dir->len + 2
288 + strlen(".framework/") + strlen("PrivateHeaders"));
289 strncpy (&frname[0], dir->name, dir->len);
290 frname_len = dir->len;
291 if (frname_len && frname[frname_len-1] != '/')
292 frname[frname_len++] = '/';
293 strncpy (&frname[frname_len], fname, fname_len);
294 frname_len += fname_len;
295 strncpy (&frname[frname_len], ".framework/", strlen (".framework/"));
296 frname_len += strlen (".framework/");
297
298 if (fast_dir == 0)
299 {
300 frname[frname_len-1] = 0;
301 if (stat (frname, &st) == 0)
302 {
303 /* As soon as we find the first instance of the framework,
304 we stop and never use any later instance of that
305 framework. */
306 add_framework (fname, fname_len, dir);
307 }
308 else
309 {
310 /* If we can't find the parent directory, no point looking
311 further. */
312 free (frname);
313 return 0;
314 }
315 frname[frname_len-1] = '/';
316 }
317
318 /* Append framework_header_dirs and header file name */
319 for (i = 0; framework_header_dirs[i].dirName; i++)
320 {
321 strncpy (&frname[frname_len],
322 framework_header_dirs[i].dirName,
323 framework_header_dirs[i].dirNameLen);
324 strcpy (&frname[frname_len + framework_header_dirs[i].dirNameLen],
325 &fname[fname_len]);
326
327 if (stat (frname, &st) == 0)
328 return frname;
329 }
330
331 free (frname);
332 return 0;
333 }
334
335 /* Search for FNAME in sub-frameworks. pname is the context that we
336 wish to search in. Return the path the file was found at,
337 otherwise return 0. */
338
339 static const char*
find_subframework_file(const char * fname,const char * pname)340 find_subframework_file (const char *fname, const char *pname)
341 {
342 char *sfrname;
343 const char *dot_framework = ".framework/";
344 char *bufptr;
345 int sfrname_len, i, fname_len;
346 struct cpp_dir *fast_dir;
347 static struct cpp_dir subframe_dir;
348 struct stat st;
349
350 bufptr = strchr (fname, '/');
351
352 /* Subframework files must have / in the name. */
353 if (bufptr == 0)
354 return 0;
355
356 fname_len = bufptr - fname;
357 fast_dir = find_framework (fname, fname_len);
358
359 /* Sub framework header filename includes parent framework name and
360 header name in the "CarbonCore/OSUtils.h" form. If it does not
361 include slash it is not a sub framework include. */
362 bufptr = strstr (pname, dot_framework);
363
364 /* If the parent header is not of any framework, then this header
365 cannot be part of any subframework. */
366 if (!bufptr)
367 return 0;
368
369 /* Now translate. For example, +- bufptr
370 fname = CarbonCore/OSUtils.h |
371 pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h
372 into
373 sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */
374
375 sfrname = XNEWVEC (char, strlen (pname) + strlen (fname) + 2 +
376 strlen ("Frameworks/") + strlen (".framework/")
377 + strlen ("PrivateHeaders"));
378
379 bufptr += strlen (dot_framework);
380
381 sfrname_len = bufptr - pname;
382
383 strncpy (&sfrname[0], pname, sfrname_len);
384
385 strncpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/"));
386 sfrname_len += strlen("Frameworks/");
387
388 strncpy (&sfrname[sfrname_len], fname, fname_len);
389 sfrname_len += fname_len;
390
391 strncpy (&sfrname[sfrname_len], ".framework/", strlen (".framework/"));
392 sfrname_len += strlen (".framework/");
393
394 /* Append framework_header_dirs and header file name */
395 for (i = 0; framework_header_dirs[i].dirName; i++)
396 {
397 strncpy (&sfrname[sfrname_len],
398 framework_header_dirs[i].dirName,
399 framework_header_dirs[i].dirNameLen);
400 strcpy (&sfrname[sfrname_len + framework_header_dirs[i].dirNameLen],
401 &fname[fname_len]);
402
403 if (stat (sfrname, &st) == 0)
404 {
405 if (fast_dir != &subframe_dir)
406 {
407 if (fast_dir)
408 warning (0, "subframework include %s conflicts with framework include",
409 fname);
410 else
411 add_framework (fname, fname_len, &subframe_dir);
412 }
413
414 return sfrname;
415 }
416 }
417 free (sfrname);
418
419 return 0;
420 }
421
422 /* Add PATH to the system includes. PATH must be malloc-ed and
423 NUL-terminated. System framework paths are C++ aware. */
424
425 static void
add_system_framework_path(char * path)426 add_system_framework_path (char *path)
427 {
428 int cxx_aware = 1;
429 cpp_dir *p;
430
431 p = XNEW (cpp_dir);
432 p->next = NULL;
433 p->name = path;
434 p->sysp = 1 + !cxx_aware;
435 p->construct = framework_construct_pathname;
436 using_frameworks = 1;
437
438 add_cpp_dir_path (p, SYSTEM);
439 }
440
441 /* Add PATH to the bracket includes. PATH must be malloc-ed and
442 NUL-terminated. */
443
444 void
add_framework_path(char * path)445 add_framework_path (char *path)
446 {
447 cpp_dir *p;
448
449 p = XNEW (cpp_dir);
450 p->next = NULL;
451 p->name = path;
452 p->sysp = 0;
453 p->construct = framework_construct_pathname;
454 using_frameworks = 1;
455
456 add_cpp_dir_path (p, BRACKET);
457 }
458
459 static const char *framework_defaults [] =
460 {
461 "/System/Library/Frameworks",
462 "/Library/Frameworks",
463 };
464
465 /* Register the GNU objective-C runtime include path if STDINC. */
466
467 void
darwin_register_objc_includes(const char * sysroot,const char * iprefix,int stdinc)468 darwin_register_objc_includes (const char *sysroot, const char *iprefix,
469 int stdinc)
470 {
471 const char *fname;
472 size_t len;
473 /* We do not do anything if we do not want the standard includes. */
474 if (!stdinc)
475 return;
476
477 fname = GCC_INCLUDE_DIR "-gnu-runtime";
478
479 /* Register the GNU OBJC runtime include path if we are compiling OBJC
480 with GNU-runtime. */
481
482 if (c_dialect_objc () && !flag_next_runtime)
483 {
484 char *str;
485 /* See if our directory starts with the standard prefix.
486 "Translate" them, i.e. replace /usr/local/lib/gcc... with
487 IPREFIX and search them first. */
488 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 && !sysroot
489 && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len))
490 {
491 str = concat (iprefix, fname + len, NULL);
492 /* FIXME: wrap the headers for C++awareness. */
493 add_path (str, SYSTEM, /*c++aware=*/false, false);
494 }
495
496 /* Should this directory start with the sysroot? */
497 if (sysroot)
498 str = concat (sysroot, fname, NULL);
499 else
500 str = update_path (fname, "");
501
502 add_path (str, SYSTEM, /*c++aware=*/false, false);
503 }
504 }
505
506
507 /* Register all the system framework paths if STDINC is true and setup
508 the missing_header callback for subframework searching if any
509 frameworks had been registered. */
510
511 void
darwin_register_frameworks(const char * sysroot,const char * iprefix ATTRIBUTE_UNUSED,int stdinc)512 darwin_register_frameworks (const char *sysroot,
513 const char *iprefix ATTRIBUTE_UNUSED, int stdinc)
514 {
515 if (stdinc)
516 {
517 size_t i;
518
519 /* Setup default search path for frameworks. */
520 for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i)
521 {
522 char *str;
523 if (sysroot)
524 str = concat (sysroot, xstrdup (framework_defaults [i]), NULL);
525 else
526 str = xstrdup (framework_defaults[i]);
527 /* System Framework headers are cxx aware. */
528 add_system_framework_path (str);
529 }
530 }
531
532 if (using_frameworks)
533 cpp_get_callbacks (parse_in)->missing_header = find_subframework_header;
534 }
535
536 /* Search for HEADER in context dependent way. The return value is
537 the malloced name of a header to try and open, if any, or NULL
538 otherwise. This is called after normal header lookup processing
539 fails to find a header. We search each file in the include stack,
540 using FUNC, starting from the most deeply nested include and
541 finishing with the main input file. We stop searching when FUNC
542 returns nonzero. */
543
544 static const char*
find_subframework_header(cpp_reader * pfile,const char * header,cpp_dir ** dirp)545 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp)
546 {
547 const char *fname = header;
548 struct cpp_buffer *b;
549 const char *n;
550
551 for (b = cpp_get_buffer (pfile);
552 b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b));
553 b = cpp_get_prev (b))
554 {
555 n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b)));
556 if (n)
557 {
558 /* Logically, the place where we found the subframework is
559 the place where we found the Framework that contains the
560 subframework. This is useful for tracking wether or not
561 we are in a system header. */
562 *dirp = cpp_get_dir (cpp_get_file (b));
563 return n;
564 }
565 }
566
567 return 0;
568 }
569
570 /* Return the value of darwin_macosx_version_min suitable for the
571 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro,
572 so '10.4.2' becomes 1042.
573 Print a warning if the version number is not known. */
574 static const char *
version_as_macro(void)575 version_as_macro (void)
576 {
577 static char result[] = "1000";
578
579 if (strncmp (darwin_macosx_version_min, "10.", 3) != 0)
580 goto fail;
581 if (! ISDIGIT (darwin_macosx_version_min[3]))
582 goto fail;
583 result[2] = darwin_macosx_version_min[3];
584 if (darwin_macosx_version_min[4] != '\0')
585 {
586 if (darwin_macosx_version_min[4] != '.')
587 goto fail;
588 if (! ISDIGIT (darwin_macosx_version_min[5]))
589 goto fail;
590 if (darwin_macosx_version_min[6] != '\0')
591 goto fail;
592 result[3] = darwin_macosx_version_min[5];
593 }
594 else
595 result[3] = '0';
596
597 return result;
598
599 fail:
600 error ("Unknown value %qs of -mmacosx-version-min",
601 darwin_macosx_version_min);
602 return "1000";
603 }
604
605 /* Define additional CPP flags for Darwin. */
606
607 #define builtin_define(TXT) cpp_define (pfile, TXT)
608
609 void
darwin_cpp_builtins(cpp_reader * pfile)610 darwin_cpp_builtins (cpp_reader *pfile)
611 {
612 builtin_define ("__MACH__");
613 builtin_define ("__APPLE__");
614
615 /* __APPLE_CC__ is defined as some old Apple include files expect it
616 to be defined and won't work if it isn't. */
617 builtin_define_with_value ("__APPLE_CC__", "1", false);
618
619 if (darwin_macosx_version_min)
620 builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
621 version_as_macro(), false);
622 }
623