OSDN Git Service

52180d7a9a1f754f09b65c35f8cb295ec2b8674c
[pf3gnuchains/gcc-fork.git] / gcc / config / darwin-c.c
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
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
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
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
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     BAD ("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
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
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
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*
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 *
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*
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
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
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
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
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*
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 *
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
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 }