gcc/config/darwin-c.c

   1 /* Darwin support needed only by C/C++ frontends.
   2    Copyright (C) 2001, 2003, 2004, 2005, 2007, 2008, 2010, 2011
   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 "incpath.h"
  29 #include "c-family/c-common.h"
  30 #include "c-family/c-pragma.h"
  31 #include "c-family/c-format.h"
  32 #include "diagnostic-core.h"
  33 #include "flags.h"
  34 #include "tm_p.h"
  35 #include "cppdefault.h"
  36 #include "prefix.h"
  37 #include "c-family/c-target.h"
  38 #include "c-family/c-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             {
 148               TREE_USED (local) = 1;
 149               DECL_READ_P (local) = 1;
 150             }
 151           tok = pragma_lex (&x);
 152           if (tok != CPP_COMMA)
 153             break;
 154         }
 155     }
 156
 157   if (tok != CPP_CLOSE_PAREN)
 158     BAD ("missing ')' after '#pragma unused', ignoring");
 159
 160   if (pragma_lex (&x) != CPP_EOF)
 161     BAD ("junk at end of '#pragma unused'");
 162 }
 163
 164 /* Parse the ms_struct pragma.  */
 165 void
 166 darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED)
 167 {
 168   const char *arg;
 169   tree t;
 170
 171   if (pragma_lex (&t) != CPP_NAME)
 172     BAD ("malformed '#pragma ms_struct', ignoring");
 173   arg = IDENTIFIER_POINTER (t);
 174
 175   if (!strcmp (arg, "on"))
 176     darwin_ms_struct = true;
 177   else if (!strcmp (arg, "off") || !strcmp (arg, "reset"))
 178     darwin_ms_struct = false;
 179   else
 180     BAD ("malformed '#pragma ms_struct {on|off|reset}', ignoring");
 181
 182   if (pragma_lex (&t) != CPP_EOF)
 183     BAD ("junk at end of '#pragma ms_struct'");
 184 }
 185
 186 static struct frameworks_in_use {
 187   size_t len;
 188   const char *name;
 189   cpp_dir* dir;
 190 } *frameworks_in_use;
 191 static int num_frameworks = 0;
 192 static int max_frameworks = 0;
 193
 194
 195 /* Remember which frameworks have been seen, so that we can ensure
 196    that all uses of that framework come from the same framework.  DIR
 197    is the place where the named framework NAME, which is of length
 198    LEN, was found.  We copy the directory name from NAME, as it will be
 199    freed by others.  */
 200
 201 static void
 202 add_framework (const char *name, size_t len, cpp_dir *dir)
 203 {
 204   char *dir_name;
 205   int i;
 206   for (i = 0; i < num_frameworks; ++i)
 207     {
 208       if (len == frameworks_in_use[i].len
 209           && strncmp (name, frameworks_in_use[i].name, len) == 0)
 210         {
 211           return;
 212         }
 213     }
 214   if (i >= max_frameworks)
 215     {
 216       max_frameworks = i*2;
 217       max_frameworks += i == 0;
 218       frameworks_in_use = XRESIZEVEC (struct frameworks_in_use,
 219                                       frameworks_in_use, max_frameworks);
 220     }
 221   dir_name = XNEWVEC (char, len + 1);
 222   memcpy (dir_name, name, len);
 223   dir_name[len] = '\0';
 224   frameworks_in_use[num_frameworks].name = dir_name;
 225   frameworks_in_use[num_frameworks].len = len;
 226   frameworks_in_use[num_frameworks].dir = dir;
 227   ++num_frameworks;
 228 }
 229
 230 /* Recall if we have seen the named framework NAME, before, and where
 231    we saw it.  NAME is LEN bytes long.  The return value is the place
 232    where it was seen before.  */
 233
 234 static struct cpp_dir*
 235 find_framework (const char *name, size_t len)
 236 {
 237   int i;
 238   for (i = 0; i < num_frameworks; ++i)
 239     {
 240       if (len == frameworks_in_use[i].len
 241           && strncmp (name, frameworks_in_use[i].name, len) == 0)
 242         {
 243           return frameworks_in_use[i].dir;
 244         }
 245     }
 246   return 0;
 247 }
 248
 249 /* There are two directories in a framework that contain header files,
 250    Headers and PrivateHeaders.  We search Headers first as it is more
 251    common to upgrade a header from PrivateHeaders to Headers and when
 252    that is done, the old one might hang around and be out of data,
 253    causing grief.  */
 254
 255 struct framework_header {const char * dirName; int dirNameLen; };
 256 static struct framework_header framework_header_dirs[] = {
 257   { "Headers", 7 },
 258   { "PrivateHeaders", 14 },
 259   { NULL, 0 }
 260 };
 261
 262 /* Returns a pointer to a malloced string that contains the real pathname
 263    to the file, given the base name and the name.  */
 264
 265 static char *
 266 framework_construct_pathname (const char *fname, cpp_dir *dir)
 267 {
 268   char *buf;
 269   size_t fname_len, frname_len;
 270   cpp_dir *fast_dir;
 271   char *frname;
 272   struct stat st;
 273   int i;
 274
 275   /* Framework names must have a / in them.  */
 276   buf = strchr (fname, '/');
 277   if (buf)
 278     fname_len = buf - fname;
 279   else
 280     return 0;
 281
 282   fast_dir = find_framework (fname, fname_len);
 283
 284   /* Framework includes must all come from one framework.  */
 285   if (fast_dir && dir != fast_dir)
 286     return 0;
 287
 288   frname = XNEWVEC (char, strlen (fname) + dir->len + 2
 289                     + strlen(".framework/") + strlen("PrivateHeaders"));
 290   strncpy (&frname[0], dir->name, dir->len);
 291   frname_len = dir->len;
 292   if (frname_len && frname[frname_len-1] != '/')
 293     frname[frname_len++] = '/';
 294   strncpy (&frname[frname_len], fname, fname_len);
 295   frname_len += fname_len;
 296   strncpy (&frname[frname_len], ".framework/", strlen (".framework/"));
 297   frname_len += strlen (".framework/");
 298
 299   if (fast_dir == 0)
 300     {
 301       frname[frname_len-1] = 0;
 302       if (stat (frname, &st) == 0)
 303         {
 304           /* As soon as we find the first instance of the framework,
 305              we stop and never use any later instance of that
 306              framework.  */
 307           add_framework (fname, fname_len, dir);
 308         }
 309       else
 310         {
 311           /* If we can't find the parent directory, no point looking
 312              further.  */
 313           free (frname);
 314           return 0;
 315         }
 316       frname[frname_len-1] = '/';
 317     }
 318
 319   /* Append framework_header_dirs and header file name */
 320   for (i = 0; framework_header_dirs[i].dirName; i++)
 321     {
 322       strncpy (&frname[frname_len],
 323                framework_header_dirs[i].dirName,
 324                framework_header_dirs[i].dirNameLen);
 325       strcpy (&frname[frname_len + framework_header_dirs[i].dirNameLen],
 326               &fname[fname_len]);
 327
 328       if (stat (frname, &st) == 0)
 329         return frname;
 330     }
 331
 332   free (frname);
 333   return 0;
 334 }
 335
 336 /* Search for FNAME in sub-frameworks.  pname is the context that we
 337    wish to search in.  Return the path the file was found at,
 338    otherwise return 0.  */
 339
 340 static const char*
 341 find_subframework_file (const char *fname, const char *pname)
 342 {
 343   char *sfrname;
 344   const char *dot_framework = ".framework/";
 345   char *bufptr;
 346   int sfrname_len, i, fname_len;
 347   struct cpp_dir *fast_dir;
 348   static struct cpp_dir subframe_dir;
 349   struct stat st;
 350
 351   bufptr = strchr (fname, '/');
 352
 353   /* Subframework files must have / in the name.  */
 354   if (bufptr == 0)
 355     return 0;
 356
 357   fname_len = bufptr - fname;
 358   fast_dir = find_framework (fname, fname_len);
 359
 360   /* Sub framework header filename includes parent framework name and
 361      header name in the "CarbonCore/OSUtils.h" form. If it does not
 362      include slash it is not a sub framework include.  */
 363   bufptr = strstr (pname, dot_framework);
 364
 365   /* If the parent header is not of any framework, then this header
 366      cannot be part of any subframework.  */
 367   if (!bufptr)
 368     return 0;
 369
 370   /* Now translate. For example,                  +- bufptr
 371      fname = CarbonCore/OSUtils.h                 |
 372      pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h
 373      into
 374      sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */
 375
 376   sfrname = XNEWVEC (char, strlen (pname) + strlen (fname) + 2 +
 377                               strlen ("Frameworks/") + strlen (".framework/")
 378                               + strlen ("PrivateHeaders"));
 379
 380   bufptr += strlen (dot_framework);
 381
 382   sfrname_len = bufptr - pname;
 383
 384   strncpy (&sfrname[0], pname, sfrname_len);
 385
 386   strncpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/"));
 387   sfrname_len += strlen("Frameworks/");
 388
 389   strncpy (&sfrname[sfrname_len], fname, fname_len);
 390   sfrname_len += fname_len;
 391
 392   strncpy (&sfrname[sfrname_len], ".framework/", strlen (".framework/"));
 393   sfrname_len += strlen (".framework/");
 394
 395   /* Append framework_header_dirs and header file name */
 396   for (i = 0; framework_header_dirs[i].dirName; i++)
 397     {
 398       strncpy (&sfrname[sfrname_len],
 399                framework_header_dirs[i].dirName,
 400                framework_header_dirs[i].dirNameLen);
 401       strcpy (&sfrname[sfrname_len + framework_header_dirs[i].dirNameLen],
 402               &fname[fname_len]);
 403
 404       if (stat (sfrname, &st) == 0)
 405         {
 406           if (fast_dir != &subframe_dir)
 407             {
 408               if (fast_dir)
 409                 warning (0, "subframework include %s conflicts with framework include",
 410                          fname);
 411               else
 412                 add_framework (fname, fname_len, &subframe_dir);
 413             }
 414
 415           return sfrname;
 416         }
 417     }
 418   free (sfrname);
 419
 420   return 0;
 421 }
 422
 423 /* Add PATH to the system includes. PATH must be malloc-ed and
 424    NUL-terminated.  System framework paths are C++ aware.  */
 425
 426 static void
 427 add_system_framework_path (char *path)
 428 {
 429   int cxx_aware = 1;
 430   cpp_dir *p;
 431
 432   p = XNEW (cpp_dir);
 433   p->next = NULL;
 434   p->name = path;
 435   p->sysp = 1 + !cxx_aware;
 436   p->construct = framework_construct_pathname;
 437   using_frameworks = 1;
 438
 439   add_cpp_dir_path (p, SYSTEM);
 440 }
 441
 442 /* Add PATH to the bracket includes. PATH must be malloc-ed and
 443    NUL-terminated.  */
 444
 445 void
 446 add_framework_path (char *path)
 447 {
 448   cpp_dir *p;
 449
 450   p = XNEW (cpp_dir);
 451   p->next = NULL;
 452   p->name = path;
 453   p->sysp = 0;
 454   p->construct = framework_construct_pathname;
 455   using_frameworks = 1;
 456
 457   add_cpp_dir_path (p, BRACKET);
 458 }
 459
 460 static const char *framework_defaults [] =
 461   {
 462     "/System/Library/Frameworks",
 463     "/Library/Frameworks",
 464   };
 465
 466 /* Register the GNU objective-C runtime include path if STDINC.  */
 467
 468 void
 469 darwin_register_objc_includes (const char *sysroot, const char *iprefix,
 470                                int stdinc)
 471 {
 472   const char *fname;
 473   size_t len;
 474   /* We do not do anything if we do not want the standard includes. */
 475   if (!stdinc)
 476     return;
 477
 478   fname = GCC_INCLUDE_DIR "-gnu-runtime";
 479
 480   /* Register the GNU OBJC runtime include path if we are compiling  OBJC
 481     with GNU-runtime.  */
 482
 483   if (c_dialect_objc () && !flag_next_runtime)
 484     {
 485       char *str;
 486       /* See if our directory starts with the standard prefix.
 487          "Translate" them, i.e. replace /usr/local/lib/gcc... with
 488          IPREFIX and search them first.  */
 489       if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 && !sysroot
 490           && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len))
 491         {
 492           str = concat (iprefix, fname + len, NULL);
 493           /* FIXME: wrap the headers for C++awareness.  */
 494           add_path (str, SYSTEM, /*c++aware=*/false, false);
 495         }
 496
 497       /* Should this directory start with the sysroot?  */
 498       if (sysroot)
 499         str = concat (sysroot, fname, NULL);
 500       else
 501         str = update_path (fname, "");
 502
 503       add_path (str, SYSTEM, /*c++aware=*/false, false);
 504     }
 505 }
 506
 507
 508 /* Register all the system framework paths if STDINC is true and setup
 509    the missing_header callback for subframework searching if any
 510    frameworks had been registered.  */
 511
 512 void
 513 darwin_register_frameworks (const char *sysroot,
 514                             const char *iprefix ATTRIBUTE_UNUSED, int stdinc)
 515 {
 516   if (stdinc)
 517     {
 518       size_t i;
 519
 520       /* Setup default search path for frameworks.  */
 521       for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i)
 522         {
 523           char *str;
 524           if (sysroot)
 525             str = concat (sysroot, xstrdup (framework_defaults [i]), NULL);
 526           else
 527             str = xstrdup (framework_defaults[i]);
 528           /* System Framework headers are cxx aware.  */
 529           add_system_framework_path (str);
 530         }
 531     }
 532
 533   if (using_frameworks)
 534     cpp_get_callbacks (parse_in)->missing_header = find_subframework_header;
 535 }
 536
 537 /* Search for HEADER in context dependent way.  The return value is
 538    the malloced name of a header to try and open, if any, or NULL
 539    otherwise.  This is called after normal header lookup processing
 540    fails to find a header.  We search each file in the include stack,
 541    using FUNC, starting from the most deeply nested include and
 542    finishing with the main input file.  We stop searching when FUNC
 543    returns nonzero.  */
 544
 545 static const char*
 546 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp)
 547 {
 548   const char *fname = header;
 549   struct cpp_buffer *b;
 550   const char *n;
 551
 552   for (b = cpp_get_buffer (pfile);
 553        b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b));
 554        b = cpp_get_prev (b))
 555     {
 556       n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b)));
 557       if (n)
 558         {
 559           /* Logically, the place where we found the subframework is
 560              the place where we found the Framework that contains the
 561              subframework.  This is useful for tracking wether or not
 562              we are in a system header.  */
 563           *dirp = cpp_get_dir (cpp_get_file (b));
 564           return n;
 565         }
 566     }
 567
 568   return 0;
 569 }
 570
 571 /* Return the value of darwin_macosx_version_min suitable for the
 572    __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro,
 573    so '10.4.2' becomes 1040.  The lowest digit is always zero.
 574    Print a warning if the version number can't be understood.  */
 575 static const char *
 576 version_as_macro (void)
 577 {
 578   static char result[] = "1000";
 579
 580   if (strncmp (darwin_macosx_version_min, "10.", 3) != 0)
 581     goto fail;
 582   if (! ISDIGIT (darwin_macosx_version_min[3]))
 583     goto fail;
 584   result[2] = darwin_macosx_version_min[3];
 585   if (darwin_macosx_version_min[4] != '\0'
 586       && darwin_macosx_version_min[4] != '.')
 587     goto fail;
 588
 589   return result;
 590
 591  fail:
 592   error ("unknown value %qs of -mmacosx-version-min",
 593          darwin_macosx_version_min);
 594   return "1000";
 595 }
 596
 597 /* Define additional CPP flags for Darwin.   */
 598
 599 #define builtin_define(TXT) cpp_define (pfile, TXT)
 600
 601 void
 602 darwin_cpp_builtins (cpp_reader *pfile)
 603 {
 604   builtin_define ("__MACH__");
 605   builtin_define ("__APPLE__");
 606
 607   /* __APPLE_CC__ is defined as some old Apple include files expect it
 608      to be defined and won't work if it isn't.  */
 609   builtin_define_with_value ("__APPLE_CC__", "1", false);
 610
 611   if (darwin_constant_cfstrings)
 612     builtin_define ("__CONSTANT_CFSTRINGS__");
 613
 614   builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
 615                              version_as_macro(), false);
 616
 617   /* Since we do not (at 4.6) support ObjC gc for the NeXT runtime, the
 618      following will cause a syntax error if one tries to compile gc attributed
 619      items.  However, without this, NeXT system headers cannot be parsed
 620      properly (on systems >= darwin 9).  */
 621   if (flag_objc_gc)
 622     {
 623       builtin_define ("__strong=__attribute__((objc_gc(strong)))");
 624       builtin_define ("__weak=__attribute__((objc_gc(weak)))");
 625       builtin_define ("__OBJC_GC__");
 626     }
 627   else
 628     {
 629       builtin_define ("__strong=");
 630       builtin_define ("__weak=");
 631     }
 632
 633   if (flag_objc_abi == 2)
 634     builtin_define ("__OBJC2__");
 635 }
 636
 637 /* Handle C family front-end options.  */
 638
 639 static bool
 640 handle_c_option (size_t code,
 641                  const char *arg,
 642                  int value ATTRIBUTE_UNUSED)
 643 {
 644   switch (code)
 645     {
 646     default:
 647       /* Unrecognized options that we said we'd handle turn into
 648          errors if not listed here.  */
 649       return false;
 650
 651     case OPT_iframework:
 652       add_system_framework_path (xstrdup (arg));
 653       break;
 654
 655     case OPT_fapple_kext:
 656       ;
 657     }
 658
 659   /* We recognized the option.  */
 660   return true;
 661 }
 662
 663 /* Allow ObjC* access to CFStrings.  */
 664 static tree
 665 darwin_objc_construct_string (tree str)
 666 {
 667   if (!darwin_constant_cfstrings)
 668     {
 669     /* Even though we are not using CFStrings, place our literal
 670        into the cfstring_htab hash table, so that the
 671        darwin_constant_cfstring_p() function will see it.  */
 672       darwin_enter_string_into_cfstring_table (str);
 673       /* Fall back to NSConstantString.  */
 674       return NULL_TREE;
 675     }
 676
 677   return darwin_build_constant_cfstring (str);
 678 }
 679
 680 /* The string ref type is created as CFStringRef by <CFBase.h> therefore, we
 681    must match for it explicitly, since it's outside the gcc code.  */
 682
 683 static bool
 684 darwin_cfstring_ref_p (const_tree strp)
 685 {
 686   tree tn;
 687   if (!strp || TREE_CODE (strp) != POINTER_TYPE)
 688     return false;
 689
 690   tn = TYPE_NAME (strp);
 691   if (tn)
 692     tn = DECL_NAME (tn);
 693   return (tn
 694           && IDENTIFIER_POINTER (tn)
 695           && !strncmp (IDENTIFIER_POINTER (tn), "CFStringRef", 8));
 696 }
 697
 698 /* At present the behavior of this is undefined and it does nothing.  */
 699 static void
 700 darwin_check_cfstring_format_arg (tree ARG_UNUSED (format_arg),
 701                                   tree ARG_UNUSED (args_list))
 702 {
 703 }
 704
 705 /* The extra format types we recognize.  */
 706 EXPORTED_CONST format_kind_info darwin_additional_format_types[] = {
 707   { "CFString",   NULL,  NULL, NULL, NULL,
 708     NULL, NULL,
 709     FMT_FLAG_ARG_CONVERT|FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL, 0, 0, 0, 0, 0, 0,
 710     NULL, NULL
 711   }
 712 };
 713
 714 #undef TARGET_HANDLE_C_OPTION
 715 #define TARGET_HANDLE_C_OPTION handle_c_option
 716
 717 #undef TARGET_OBJC_CONSTRUCT_STRING_OBJECT
 718 #define TARGET_OBJC_CONSTRUCT_STRING_OBJECT darwin_objc_construct_string
 719
 720 #undef TARGET_STRING_OBJECT_REF_TYPE_P
 721 #define TARGET_STRING_OBJECT_REF_TYPE_P darwin_cfstring_ref_p
 722
 723 #undef TARGET_CHECK_STRING_OBJECT_FORMAT_ARG
 724 #define TARGET_CHECK_STRING_OBJECT_FORMAT_ARG darwin_check_cfstring_format_arg
 725
 726 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;