gcc/config/darwin-c.c

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