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 #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 {
 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 = xrealloc (frameworks_in_use,
 216                                     max_frameworks*sizeof(*frameworks_in_use));
 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 1042.
 571    Print a warning if the version number is not known.  */
 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     {
 584       if (darwin_macosx_version_min[4] != '.')
 585         goto fail;
 586       if (! ISDIGIT (darwin_macosx_version_min[5]))
 587         goto fail;
 588       if (darwin_macosx_version_min[6] != '\0')
 589         goto fail;
 590       result[3] = darwin_macosx_version_min[5];
 591     }
 592   else
 593     result[3] = '0';
 594
 595   return result;
 596
 597  fail:
 598   error ("Unknown value %qs of -mmacosx-version-min",
 599          darwin_macosx_version_min);
 600   return "1000";
 601 }
 602
 603 /* Define additional CPP flags for Darwin.   */
 604
 605 #define builtin_define(TXT) cpp_define (pfile, TXT)
 606
 607 void
 608 darwin_cpp_builtins (cpp_reader *pfile)
 609 {
 610   builtin_define ("__MACH__");
 611   builtin_define ("__APPLE__");
 612
 613   /* __APPLE_CC__ is defined as some old Apple include files expect it
 614      to be defined and won't work if it isn't.  */
 615   builtin_define_with_value ("__APPLE_CC__", "1", false);
 616
 617   builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
 618                              version_as_macro(), false);
 619 }
 620
 621 /* Handle C family front-end options.  */
 622
 623 static bool
 624 handle_c_option (size_t code,
 625                  const char *arg,
 626                  int value ATTRIBUTE_UNUSED)
 627 {
 628   switch (code)
 629     {
 630     default:
 631       /* Unrecognized options that we said we'd handle turn into
 632          errors if not listed here.  */
 633       return false;
 634
 635     case OPT_iframework:
 636       add_system_framework_path (xstrdup (arg));
 637       break;
 638     }
 639
 640   /* We recognized the option.  */
 641   return true;
 642 }
 643
 644 #undef TARGET_HANDLE_C_OPTION
 645 #define TARGET_HANDLE_C_OPTION handle_c_option
 646
 647 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;