Mercurial > hg > CbC > CbC_gcc

comparison gcc/config/darwin-c.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children b7f97abdc517
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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;