1 /* Darwin support needed only by C/C++ frontends.
2 Copyright (C) 2001-2016 Free Software Foundation, Inc.
3 Contributed by Apple Computer Inc.
5 This file is part of GCC.
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 3, or (at your option)
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.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "c-family/c-target.h"
26 #include "c-family/c-target-def.h"
30 #include "c-family/c-pragma.h"
31 #include "c-family/c-format.h"
32 #include "cppdefault.h"
34 #include "../../libcpp/internal.h"
38 #define BAD(gmsgid) do { warning (OPT_Wpragmas, gmsgid); return; } while (0)
39 #define BAD2(msgid, arg) do { warning (OPT_Wpragmas, msgid, arg); return; } while (0)
41 static bool using_frameworks
= false;
43 static const char *find_subframework_header (cpp_reader
*pfile
, const char *header
,
46 typedef struct align_stack
49 struct align_stack
* prev
;
52 static struct align_stack
* field_align_stack
= NULL
;
54 /* Maintain a small stack of alignments. This is similar to pragma
55 pack's stack, but simpler. */
58 push_field_alignment (int bit_alignment
)
60 align_stack
*entry
= XNEW (align_stack
);
62 entry
->alignment
= maximum_field_alignment
;
63 entry
->prev
= field_align_stack
;
64 field_align_stack
= entry
;
66 maximum_field_alignment
= bit_alignment
;
70 pop_field_alignment (void)
72 if (field_align_stack
)
74 align_stack
*entry
= field_align_stack
;
76 maximum_field_alignment
= entry
->alignment
;
77 field_align_stack
= entry
->prev
;
81 error ("too many #pragma options align=reset");
84 /* Handlers for Darwin-specific pragmas. */
87 darwin_pragma_ignore (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
92 /* #pragma options align={mac68k|power|reset} */
95 darwin_pragma_options (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
100 if (pragma_lex (&t
) != CPP_NAME
)
101 BAD ("malformed '#pragma options', ignoring");
102 arg
= IDENTIFIER_POINTER (t
);
103 if (strcmp (arg
, "align"))
104 BAD ("malformed '#pragma options', ignoring");
105 if (pragma_lex (&t
) != CPP_EQ
)
106 BAD ("malformed '#pragma options', ignoring");
107 if (pragma_lex (&t
) != CPP_NAME
)
108 BAD ("malformed '#pragma options', ignoring");
110 if (pragma_lex (&x
) != CPP_EOF
)
111 warning (OPT_Wpragmas
, "junk at end of '#pragma options'");
113 arg
= IDENTIFIER_POINTER (t
);
114 if (!strcmp (arg
, "mac68k"))
115 push_field_alignment (16);
116 else if (!strcmp (arg
, "power"))
117 push_field_alignment (0);
118 else if (!strcmp (arg
, "reset"))
119 pop_field_alignment ();
121 BAD ("malformed '#pragma options align={mac68k|power|reset}', ignoring");
124 /* #pragma unused ([var {, var}*]) */
127 darwin_pragma_unused (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
132 if (pragma_lex (&x
) != CPP_OPEN_PAREN
)
133 BAD ("missing '(' after '#pragma unused', ignoring");
137 tok
= pragma_lex (&decl
);
138 if (tok
== CPP_NAME
&& decl
)
140 tree local
= lookup_name (decl
);
141 if (local
&& (TREE_CODE (local
) == PARM_DECL
142 || TREE_CODE (local
) == VAR_DECL
))
144 TREE_USED (local
) = 1;
145 DECL_READ_P (local
) = 1;
147 tok
= pragma_lex (&x
);
148 if (tok
!= CPP_COMMA
)
153 if (tok
!= CPP_CLOSE_PAREN
)
154 BAD ("missing ')' after '#pragma unused', ignoring");
156 if (pragma_lex (&x
) != CPP_EOF
)
157 BAD ("junk at end of '#pragma unused'");
160 /* Parse the ms_struct pragma. */
162 darwin_pragma_ms_struct (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
167 if (pragma_lex (&t
) != CPP_NAME
)
168 BAD ("malformed '#pragma ms_struct', ignoring");
169 arg
= IDENTIFIER_POINTER (t
);
171 if (!strcmp (arg
, "on"))
172 darwin_ms_struct
= true;
173 else if (!strcmp (arg
, "off") || !strcmp (arg
, "reset"))
174 darwin_ms_struct
= false;
176 BAD ("malformed '#pragma ms_struct {on|off|reset}', ignoring");
178 if (pragma_lex (&t
) != CPP_EOF
)
179 BAD ("junk at end of '#pragma ms_struct'");
182 static struct frameworks_in_use
{
186 } *frameworks_in_use
;
187 static int num_frameworks
= 0;
188 static int max_frameworks
= 0;
191 /* Remember which frameworks have been seen, so that we can ensure
192 that all uses of that framework come from the same framework. DIR
193 is the place where the named framework NAME, which is of length
194 LEN, was found. We copy the directory name from NAME, as it will be
198 add_framework (const char *name
, size_t len
, cpp_dir
*dir
)
202 for (i
= 0; i
< num_frameworks
; ++i
)
204 if (len
== frameworks_in_use
[i
].len
205 && strncmp (name
, frameworks_in_use
[i
].name
, len
) == 0)
210 if (i
>= max_frameworks
)
212 max_frameworks
= i
*2;
213 max_frameworks
+= i
== 0;
214 frameworks_in_use
= XRESIZEVEC (struct frameworks_in_use
,
215 frameworks_in_use
, max_frameworks
);
217 dir_name
= XNEWVEC (char, len
+ 1);
218 memcpy (dir_name
, name
, len
);
219 dir_name
[len
] = '\0';
220 frameworks_in_use
[num_frameworks
].name
= dir_name
;
221 frameworks_in_use
[num_frameworks
].len
= len
;
222 frameworks_in_use
[num_frameworks
].dir
= dir
;
226 /* Recall if we have seen the named framework NAME, before, and where
227 we saw it. NAME is LEN bytes long. The return value is the place
228 where it was seen before. */
230 static struct cpp_dir
*
231 find_framework (const char *name
, size_t len
)
234 for (i
= 0; i
< num_frameworks
; ++i
)
236 if (len
== frameworks_in_use
[i
].len
237 && strncmp (name
, frameworks_in_use
[i
].name
, len
) == 0)
239 return frameworks_in_use
[i
].dir
;
245 /* There are two directories in a framework that contain header files,
246 Headers and PrivateHeaders. We search Headers first as it is more
247 common to upgrade a header from PrivateHeaders to Headers and when
248 that is done, the old one might hang around and be out of data,
251 struct framework_header
{const char * dirName
; int dirNameLen
; };
252 static struct framework_header framework_header_dirs
[] = {
254 { "PrivateHeaders", 14 },
258 /* Returns a pointer to a malloced string that contains the real pathname
259 to the file, given the base name and the name. */
262 framework_construct_pathname (const char *fname
, cpp_dir
*dir
)
265 size_t fname_len
, frname_len
;
271 /* Framework names must have a / in them. */
272 buf
= strchr (fname
, '/');
274 fname_len
= buf
- fname
;
278 fast_dir
= find_framework (fname
, fname_len
);
280 /* Framework includes must all come from one framework. */
281 if (fast_dir
&& dir
!= fast_dir
)
284 frname
= XNEWVEC (char, strlen (fname
) + dir
->len
+ 2
285 + strlen(".framework/") + strlen("PrivateHeaders"));
286 strncpy (&frname
[0], dir
->name
, dir
->len
);
287 frname_len
= dir
->len
;
288 if (frname_len
&& frname
[frname_len
-1] != '/')
289 frname
[frname_len
++] = '/';
290 strncpy (&frname
[frname_len
], fname
, fname_len
);
291 frname_len
+= fname_len
;
292 strncpy (&frname
[frname_len
], ".framework/", strlen (".framework/"));
293 frname_len
+= strlen (".framework/");
297 frname
[frname_len
-1] = 0;
298 if (stat (frname
, &st
) == 0)
300 /* As soon as we find the first instance of the framework,
301 we stop and never use any later instance of that
303 add_framework (fname
, fname_len
, dir
);
307 /* If we can't find the parent directory, no point looking
312 frname
[frname_len
-1] = '/';
315 /* Append framework_header_dirs and header file name */
316 for (i
= 0; framework_header_dirs
[i
].dirName
; i
++)
318 strncpy (&frname
[frname_len
],
319 framework_header_dirs
[i
].dirName
,
320 framework_header_dirs
[i
].dirNameLen
);
321 strcpy (&frname
[frname_len
+ framework_header_dirs
[i
].dirNameLen
],
324 if (stat (frname
, &st
) == 0)
332 /* Search for FNAME in sub-frameworks. pname is the context that we
333 wish to search in. Return the path the file was found at,
334 otherwise return 0. */
337 find_subframework_file (const char *fname
, const char *pname
)
340 const char *dot_framework
= ".framework/";
342 int sfrname_len
, i
, fname_len
;
343 struct cpp_dir
*fast_dir
;
344 static struct cpp_dir subframe_dir
;
347 bufptr
= strchr (fname
, '/');
349 /* Subframework files must have / in the name. */
353 fname_len
= bufptr
- fname
;
354 fast_dir
= find_framework (fname
, fname_len
);
356 /* Sub framework header filename includes parent framework name and
357 header name in the "CarbonCore/OSUtils.h" form. If it does not
358 include slash it is not a sub framework include. */
359 bufptr
= strstr (pname
, dot_framework
);
361 /* If the parent header is not of any framework, then this header
362 cannot be part of any subframework. */
366 /* Now translate. For example, +- bufptr
367 fname = CarbonCore/OSUtils.h |
368 pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h
370 sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */
372 sfrname
= XNEWVEC (char, strlen (pname
) + strlen (fname
) + 2 +
373 strlen ("Frameworks/") + strlen (".framework/")
374 + strlen ("PrivateHeaders"));
376 bufptr
+= strlen (dot_framework
);
378 sfrname_len
= bufptr
- pname
;
380 strncpy (&sfrname
[0], pname
, sfrname_len
);
382 strncpy (&sfrname
[sfrname_len
], "Frameworks/", strlen ("Frameworks/"));
383 sfrname_len
+= strlen("Frameworks/");
385 strncpy (&sfrname
[sfrname_len
], fname
, fname_len
);
386 sfrname_len
+= fname_len
;
388 strncpy (&sfrname
[sfrname_len
], ".framework/", strlen (".framework/"));
389 sfrname_len
+= strlen (".framework/");
391 /* Append framework_header_dirs and header file name */
392 for (i
= 0; framework_header_dirs
[i
].dirName
; i
++)
394 strncpy (&sfrname
[sfrname_len
],
395 framework_header_dirs
[i
].dirName
,
396 framework_header_dirs
[i
].dirNameLen
);
397 strcpy (&sfrname
[sfrname_len
+ framework_header_dirs
[i
].dirNameLen
],
400 if (stat (sfrname
, &st
) == 0)
402 if (fast_dir
!= &subframe_dir
)
405 warning (0, "subframework include %s conflicts with framework include",
408 add_framework (fname
, fname_len
, &subframe_dir
);
419 /* Add PATH to the system includes. PATH must be malloc-ed and
420 NUL-terminated. System framework paths are C++ aware. */
423 add_system_framework_path (char *path
)
431 p
->sysp
= 1 + !cxx_aware
;
432 p
->construct
= framework_construct_pathname
;
433 using_frameworks
= 1;
435 add_cpp_dir_path (p
, SYSTEM
);
438 /* Add PATH to the bracket includes. PATH must be malloc-ed and
442 add_framework_path (char *path
)
450 p
->construct
= framework_construct_pathname
;
451 using_frameworks
= 1;
453 add_cpp_dir_path (p
, BRACKET
);
456 static const char *framework_defaults
[] =
458 "/System/Library/Frameworks",
459 "/Library/Frameworks",
462 /* Register the GNU objective-C runtime include path if STDINC. */
465 darwin_register_objc_includes (const char *sysroot
, const char *iprefix
,
470 /* We do not do anything if we do not want the standard includes. */
474 fname
= GCC_INCLUDE_DIR
"-gnu-runtime";
476 /* Register the GNU OBJC runtime include path if we are compiling OBJC
479 if (c_dialect_objc () && !flag_next_runtime
)
482 /* See if our directory starts with the standard prefix.
483 "Translate" them, i.e. replace /usr/local/lib/gcc... with
484 IPREFIX and search them first. */
485 if (iprefix
&& (len
= cpp_GCC_INCLUDE_DIR_len
) != 0 && !sysroot
486 && !strncmp (fname
, cpp_GCC_INCLUDE_DIR
, len
))
488 str
= concat (iprefix
, fname
+ len
, NULL
);
489 /* FIXME: wrap the headers for C++awareness. */
490 add_path (str
, SYSTEM
, /*c++aware=*/false, false);
493 /* Should this directory start with the sysroot? */
495 str
= concat (sysroot
, fname
, NULL
);
497 str
= update_path (fname
, "");
499 add_path (str
, SYSTEM
, /*c++aware=*/false, false);
504 /* Register all the system framework paths if STDINC is true and setup
505 the missing_header callback for subframework searching if any
506 frameworks had been registered. */
509 darwin_register_frameworks (const char *sysroot
,
510 const char *iprefix ATTRIBUTE_UNUSED
, int stdinc
)
516 /* Setup default search path for frameworks. */
517 for (i
=0; i
<sizeof (framework_defaults
)/sizeof(const char *); ++i
)
521 str
= concat (sysroot
, xstrdup (framework_defaults
[i
]), NULL
);
523 str
= xstrdup (framework_defaults
[i
]);
524 /* System Framework headers are cxx aware. */
525 add_system_framework_path (str
);
529 if (using_frameworks
)
530 cpp_get_callbacks (parse_in
)->missing_header
= find_subframework_header
;
533 /* Search for HEADER in context dependent way. The return value is
534 the malloced name of a header to try and open, if any, or NULL
535 otherwise. This is called after normal header lookup processing
536 fails to find a header. We search each file in the include stack,
537 using FUNC, starting from the most deeply nested include and
538 finishing with the main input file. We stop searching when FUNC
542 find_subframework_header (cpp_reader
*pfile
, const char *header
, cpp_dir
**dirp
)
544 const char *fname
= header
;
545 struct cpp_buffer
*b
;
548 for (b
= cpp_get_buffer (pfile
);
549 b
&& cpp_get_file (b
) && cpp_get_path (cpp_get_file (b
));
550 b
= cpp_get_prev (b
))
552 n
= find_subframework_file (fname
, cpp_get_path (cpp_get_file (b
)));
555 /* Logically, the place where we found the subframework is
556 the place where we found the Framework that contains the
557 subframework. This is useful for tracking wether or not
558 we are in a system header. */
559 *dirp
= cpp_get_dir (cpp_get_file (b
));
567 /* Given an OS X version VERSION_STR, return it as a statically-allocated array
568 of three integers. If VERSION_STR is invalid, return NULL.
570 VERSION_STR must consist of one, two, or three tokens, each separated by
571 a single period. Each token must contain only the characters '0' through
572 '9' and is converted to an equivalent non-negative decimal integer. Omitted
573 tokens become zeros. For example:
575 "10" becomes {10,0,0}
576 "10.10" becomes {10,10,0}
577 "10.10.1" becomes {10,10,1}
578 "10.000010.1" becomes {10,10,1}
579 "10.010.001" becomes {10,10,1}
580 "000010.10.00001" becomes {10,10,1}
583 "10.10." is invalid */
585 enum version_components
{ MAJOR
, MINOR
, TINY
};
587 static const unsigned long *
588 parse_version (const char *version_str
)
592 static unsigned long version_array
[3];
594 version_len
= strlen (version_str
);
598 /* Version string must consist of digits and periods only. */
599 if (strspn (version_str
, "0123456789.") != version_len
)
602 if (!ISDIGIT (version_str
[0]) || !ISDIGIT (version_str
[version_len
- 1]))
605 version_array
[MAJOR
] = strtoul (version_str
, &end
, 10);
606 version_str
= end
+ ((*end
== '.') ? 1 : 0);
608 /* Version string must not contain adjacent periods. */
609 if (*version_str
== '.')
612 version_array
[MINOR
] = strtoul (version_str
, &end
, 10);
613 version_str
= end
+ ((*end
== '.') ? 1 : 0);
615 version_array
[TINY
] = strtoul (version_str
, &end
, 10);
617 /* Version string must contain no more than three tokens. */
621 return version_array
;
624 /* Given VERSION -- a three-component OS X version represented as an array of
625 non-negative integers -- return a statically-allocated string suitable for
626 the legacy __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro. If VERSION
627 is invalid and cannot be coerced into a valid form, return NULL.
629 The legacy format is a four-character string -- two chars for the major
630 number and one each for the minor and tiny numbers. Minor and tiny numbers
631 from 10 through 99 are permitted but are clamped to 9 (for example, {10,9,10}
632 produces "1099"). If VERSION contains numbers greater than 99, it is
636 version_as_legacy_macro (const unsigned long *version
)
638 unsigned long major
, minor
, tiny
;
639 static char result
[5];
641 major
= version
[MAJOR
];
642 minor
= version
[MINOR
];
643 tiny
= version
[TINY
];
645 if (major
> 99 || minor
> 99 || tiny
> 99)
648 minor
= ((minor
> 9) ? 9 : minor
);
649 tiny
= ((tiny
> 9) ? 9 : tiny
);
651 if (sprintf (result
, "%lu%lu%lu", major
, minor
, tiny
) != 4)
657 /* Given VERSION -- a three-component OS X version represented as an array of
658 non-negative integers -- return a statically-allocated string suitable for
659 the modern __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro. If VERSION
660 is invalid, return NULL.
662 The modern format is a six-character string -- two chars for each component,
663 with zero-padding if necessary (for example, {10,10,1} produces "101001"). If
664 VERSION contains numbers greater than 99, it is rejected. */
667 version_as_modern_macro (const unsigned long *version
)
669 unsigned long major
, minor
, tiny
;
670 static char result
[7];
672 major
= version
[MAJOR
];
673 minor
= version
[MINOR
];
674 tiny
= version
[TINY
];
676 if (major
> 99 || minor
> 99 || tiny
> 99)
679 if (sprintf (result
, "%02lu%02lu%02lu", major
, minor
, tiny
) != 6)
685 /* Return the value of darwin_macosx_version_min, suitably formatted for the
686 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro. Values representing
687 OS X 10.9 and earlier are encoded using the legacy four-character format,
688 while 10.10 and later use a modern six-character format. (For example,
689 "10.9" produces "1090", and "10.10.1" produces "101001".) If
690 darwin_macosx_version_min is invalid and cannot be coerced into a valid
691 form, print a warning and return "1000". */
694 macosx_version_as_macro (void)
696 const unsigned long *version_array
;
697 const char *version_macro
;
699 version_array
= parse_version (darwin_macosx_version_min
);
703 if (version_array
[MAJOR
] != 10)
706 if (version_array
[MINOR
] < 10)
707 version_macro
= version_as_legacy_macro (version_array
);
709 version_macro
= version_as_modern_macro (version_array
);
714 return version_macro
;
717 error ("unknown value %qs of -mmacosx-version-min",
718 darwin_macosx_version_min
);
722 /* Define additional CPP flags for Darwin. */
724 #define builtin_define(TXT) cpp_define (pfile, TXT)
727 darwin_cpp_builtins (cpp_reader
*pfile
)
729 builtin_define ("__MACH__");
730 builtin_define ("__APPLE__");
732 /* __APPLE_CC__ is defined as some old Apple include files expect it
733 to be defined and won't work if it isn't. */
734 builtin_define_with_value ("__APPLE_CC__", "1", false);
736 if (darwin_constant_cfstrings
)
737 builtin_define ("__CONSTANT_CFSTRINGS__");
739 builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
740 macosx_version_as_macro(), false);
742 /* Since we do not (at 4.6) support ObjC gc for the NeXT runtime, the
743 following will cause a syntax error if one tries to compile gc attributed
744 items. However, without this, NeXT system headers cannot be parsed
745 properly (on systems >= darwin 9). */
748 builtin_define ("__strong=__attribute__((objc_gc(strong)))");
749 builtin_define ("__weak=__attribute__((objc_gc(weak)))");
750 builtin_define ("__OBJC_GC__");
754 builtin_define ("__strong=");
755 builtin_define ("__weak=");
758 if (CPP_OPTION (pfile
, objc
) && flag_objc_abi
== 2)
759 builtin_define ("__OBJC2__");
762 /* Handle C family front-end options. */
765 handle_c_option (size_t code
,
767 int value ATTRIBUTE_UNUSED
)
772 /* Unrecognized options that we said we'd handle turn into
773 errors if not listed here. */
777 add_system_framework_path (xstrdup (arg
));
780 case OPT_fapple_kext
:
784 /* We recognized the option. */
788 /* Allow ObjC* access to CFStrings. */
790 darwin_objc_construct_string (tree str
)
792 if (!darwin_constant_cfstrings
)
794 /* Even though we are not using CFStrings, place our literal
795 into the cfstring_htab hash table, so that the
796 darwin_constant_cfstring_p() function will see it. */
797 darwin_enter_string_into_cfstring_table (str
);
798 /* Fall back to NSConstantString. */
802 return darwin_build_constant_cfstring (str
);
805 /* The string ref type is created as CFStringRef by <CFBase.h> therefore, we
806 must match for it explicitly, since it's outside the gcc code. */
809 darwin_cfstring_ref_p (const_tree strp
)
812 if (!strp
|| TREE_CODE (strp
) != POINTER_TYPE
)
815 tn
= TYPE_NAME (strp
);
819 && IDENTIFIER_POINTER (tn
)
820 && !strncmp (IDENTIFIER_POINTER (tn
), "CFStringRef", 8));
823 /* At present the behavior of this is undefined and it does nothing. */
825 darwin_check_cfstring_format_arg (tree
ARG_UNUSED (format_arg
),
826 tree
ARG_UNUSED (args_list
))
830 /* The extra format types we recognize. */
831 EXPORTED_CONST format_kind_info darwin_additional_format_types
[] = {
832 { "CFString", NULL
, NULL
, NULL
, NULL
,
834 FMT_FLAG_ARG_CONVERT
|FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL
, 0, 0, 0, 0, 0, 0,
840 /* Support routines to dump the class references for NeXT ABI v1, aka
841 32-bits ObjC-2.0, as top-level asms.
842 The following two functions should only be called from
843 objc/objc-next-runtime-abi-01.c. */
846 darwin_objc_declare_unresolved_class_reference (const char *name
)
848 const char *lazy_reference
= ".lazy_reference\t";
849 const char *hard_reference
= ".reference\t";
850 const char *reference
= MACHOPIC_INDIRECT
? lazy_reference
: hard_reference
;
851 size_t len
= strlen (reference
) + strlen(name
) + 2;
852 char *buf
= (char *) alloca (len
);
854 gcc_checking_assert (!strncmp (name
, ".objc_class_name_", 17));
856 snprintf (buf
, len
, "%s%s", reference
, name
);
857 symtab
->finalize_toplevel_asm (build_string (strlen (buf
), buf
));
861 darwin_objc_declare_class_definition (const char *name
)
863 const char *xname
= targetm
.strip_name_encoding (name
);
864 size_t len
= strlen (xname
) + 7 + 5;
865 char *buf
= (char *) alloca (len
);
867 gcc_checking_assert (!strncmp (name
, ".objc_class_name_", 17)
868 || !strncmp (name
, "*.objc_category_name_", 21));
870 /* Mimic default_globalize_label. */
871 snprintf (buf
, len
, ".globl\t%s", xname
);
872 symtab
->finalize_toplevel_asm (build_string (strlen (buf
), buf
));
874 snprintf (buf
, len
, "%s = 0", xname
);
875 symtab
->finalize_toplevel_asm (build_string (strlen (buf
), buf
));
878 #undef TARGET_HANDLE_C_OPTION
879 #define TARGET_HANDLE_C_OPTION handle_c_option
881 #undef TARGET_OBJC_CONSTRUCT_STRING_OBJECT
882 #define TARGET_OBJC_CONSTRUCT_STRING_OBJECT darwin_objc_construct_string
884 #undef TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE
885 #define TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE \
886 darwin_objc_declare_unresolved_class_reference
888 #undef TARGET_OBJC_DECLARE_CLASS_DEFINITION
889 #define TARGET_OBJC_DECLARE_CLASS_DEFINITION \
890 darwin_objc_declare_class_definition
892 #undef TARGET_STRING_OBJECT_REF_TYPE_P
893 #define TARGET_STRING_OBJECT_REF_TYPE_P darwin_cfstring_ref_p
895 #undef TARGET_CHECK_STRING_OBJECT_FORMAT_ARG
896 #define TARGET_CHECK_STRING_OBJECT_FORMAT_ARG darwin_check_cfstring_format_arg
898 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;