gcc/
[official-gcc.git] / gcc / config / darwin-c.c
blob23ec18041955a28a8852664a1d87a7476750bdc0
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)
10 any later version.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "target.h"
25 #include "c-family/c-target.h"
26 #include "c-family/c-target-def.h"
27 #include "tm_p.h"
28 #include "cgraph.h"
29 #include "incpath.h"
30 #include "c-family/c-pragma.h"
31 #include "c-family/c-format.h"
32 #include "cppdefault.h"
33 #include "prefix.h"
34 #include "../../libcpp/internal.h"
36 /* Pragmas. */
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,
44 cpp_dir **dirp);
46 typedef struct align_stack
48 int alignment;
49 struct align_stack * prev;
50 } align_stack;
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. */
57 static void
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;
69 static void
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;
78 free (entry);
80 else
81 error ("too many #pragma options align=reset");
84 /* Handlers for Darwin-specific pragmas. */
86 void
87 darwin_pragma_ignore (cpp_reader *pfile ATTRIBUTE_UNUSED)
89 /* Do nothing. */
92 /* #pragma options align={mac68k|power|reset} */
94 void
95 darwin_pragma_options (cpp_reader *pfile ATTRIBUTE_UNUSED)
97 const char *arg;
98 tree t, x;
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 ();
120 else
121 BAD ("malformed '#pragma options align={mac68k|power|reset}', ignoring");
124 /* #pragma unused ([var {, var}*]) */
126 void
127 darwin_pragma_unused (cpp_reader *pfile ATTRIBUTE_UNUSED)
129 tree decl, x;
130 int tok;
132 if (pragma_lex (&x) != CPP_OPEN_PAREN)
133 BAD ("missing '(' after '#pragma unused', ignoring");
135 while (1)
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)
149 break;
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. */
161 void
162 darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED)
164 const char *arg;
165 tree t;
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;
175 else
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 {
183 size_t len;
184 const char *name;
185 cpp_dir* dir;
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
195 freed by others. */
197 static void
198 add_framework (const char *name, size_t len, cpp_dir *dir)
200 char *dir_name;
201 int i;
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)
207 return;
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;
223 ++num_frameworks;
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)
233 int i;
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;
242 return 0;
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,
249 causing grief. */
251 struct framework_header {const char * dirName; int dirNameLen; };
252 static struct framework_header framework_header_dirs[] = {
253 { "Headers", 7 },
254 { "PrivateHeaders", 14 },
255 { NULL, 0 }
258 /* Returns a pointer to a malloced string that contains the real pathname
259 to the file, given the base name and the name. */
261 static char *
262 framework_construct_pathname (const char *fname, cpp_dir *dir)
264 const char *buf;
265 size_t fname_len, frname_len;
266 cpp_dir *fast_dir;
267 char *frname;
268 struct stat st;
269 int i;
271 /* Framework names must have a / in them. */
272 buf = strchr (fname, '/');
273 if (buf)
274 fname_len = buf - fname;
275 else
276 return 0;
278 fast_dir = find_framework (fname, fname_len);
280 /* Framework includes must all come from one framework. */
281 if (fast_dir && dir != fast_dir)
282 return 0;
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/");
295 if (fast_dir == 0)
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
302 framework. */
303 add_framework (fname, fname_len, dir);
305 else
307 /* If we can't find the parent directory, no point looking
308 further. */
309 free (frname);
310 return 0;
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],
322 &fname[fname_len]);
324 if (stat (frname, &st) == 0)
325 return frname;
328 free (frname);
329 return 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. */
336 static const char*
337 find_subframework_file (const char *fname, const char *pname)
339 char *sfrname;
340 const char *dot_framework = ".framework/";
341 const char *bufptr;
342 int sfrname_len, i, fname_len;
343 struct cpp_dir *fast_dir;
344 static struct cpp_dir subframe_dir;
345 struct stat st;
347 bufptr = strchr (fname, '/');
349 /* Subframework files must have / in the name. */
350 if (bufptr == 0)
351 return 0;
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. */
363 if (!bufptr)
364 return 0;
366 /* Now translate. For example, +- bufptr
367 fname = CarbonCore/OSUtils.h |
368 pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h
369 into
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],
398 &fname[fname_len]);
400 if (stat (sfrname, &st) == 0)
402 if (fast_dir != &subframe_dir)
404 if (fast_dir)
405 warning (0, "subframework include %s conflicts with framework include",
406 fname);
407 else
408 add_framework (fname, fname_len, &subframe_dir);
411 return sfrname;
414 free (sfrname);
416 return 0;
419 /* Add PATH to the system includes. PATH must be malloc-ed and
420 NUL-terminated. System framework paths are C++ aware. */
422 static void
423 add_system_framework_path (char *path)
425 int cxx_aware = 1;
426 cpp_dir *p;
428 p = XNEW (cpp_dir);
429 p->next = NULL;
430 p->name = 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
439 NUL-terminated. */
441 void
442 add_framework_path (char *path)
444 cpp_dir *p;
446 p = XNEW (cpp_dir);
447 p->next = NULL;
448 p->name = path;
449 p->sysp = 0;
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. */
464 void
465 darwin_register_objc_includes (const char *sysroot, const char *iprefix,
466 int stdinc)
468 const char *fname;
469 size_t len;
470 /* We do not do anything if we do not want the standard includes. */
471 if (!stdinc)
472 return;
474 fname = GCC_INCLUDE_DIR "-gnu-runtime";
476 /* Register the GNU OBJC runtime include path if we are compiling OBJC
477 with GNU-runtime. */
479 if (c_dialect_objc () && !flag_next_runtime)
481 char *str;
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? */
494 if (sysroot)
495 str = concat (sysroot, fname, NULL);
496 else
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. */
508 void
509 darwin_register_frameworks (const char *sysroot,
510 const char *iprefix ATTRIBUTE_UNUSED, int stdinc)
512 if (stdinc)
514 size_t i;
516 /* Setup default search path for frameworks. */
517 for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i)
519 char *str;
520 if (sysroot)
521 str = concat (sysroot, xstrdup (framework_defaults [i]), NULL);
522 else
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
539 returns nonzero. */
541 static const char*
542 find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp)
544 const char *fname = header;
545 struct cpp_buffer *b;
546 const char *n;
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)));
553 if (n)
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));
560 return n;
564 return 0;
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}
581 ".9.1" is invalid
582 "10..9" is invalid
583 "10.10." is invalid */
585 enum version_components { MAJOR, MINOR, TINY };
587 static const unsigned long *
588 parse_version (const char *version_str)
590 size_t version_len;
591 char *end;
592 static unsigned long version_array[3];
594 version_len = strlen (version_str);
595 if (version_len < 1)
596 return NULL;
598 /* Version string must consist of digits and periods only. */
599 if (strspn (version_str, "0123456789.") != version_len)
600 return NULL;
602 if (!ISDIGIT (version_str[0]) || !ISDIGIT (version_str[version_len - 1]))
603 return NULL;
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 == '.')
610 return NULL;
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. */
618 if (*end != '\0')
619 return NULL;
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
633 rejected. */
635 static const char *
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)
646 return NULL;
648 minor = ((minor > 9) ? 9 : minor);
649 tiny = ((tiny > 9) ? 9 : tiny);
651 if (sprintf (result, "%lu%lu%lu", major, minor, tiny) != 4)
652 return NULL;
654 return result;
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. */
666 static const char *
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)
677 return NULL;
679 if (sprintf (result, "%02lu%02lu%02lu", major, minor, tiny) != 6)
680 return NULL;
682 return result;
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". */
693 static const char *
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);
700 if (!version_array)
701 goto fail;
703 if (version_array[MAJOR] != 10)
704 goto fail;
706 if (version_array[MINOR] < 10)
707 version_macro = version_as_legacy_macro (version_array);
708 else
709 version_macro = version_as_modern_macro (version_array);
711 if (!version_macro)
712 goto fail;
714 return version_macro;
716 fail:
717 error ("unknown value %qs of -mmacosx-version-min",
718 darwin_macosx_version_min);
719 return "1000";
722 /* Define additional CPP flags for Darwin. */
724 #define builtin_define(TXT) cpp_define (pfile, TXT)
726 void
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). */
746 if (flag_objc_gc)
748 builtin_define ("__strong=__attribute__((objc_gc(strong)))");
749 builtin_define ("__weak=__attribute__((objc_gc(weak)))");
750 builtin_define ("__OBJC_GC__");
752 else
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. */
764 static bool
765 handle_c_option (size_t code,
766 const char *arg,
767 int value ATTRIBUTE_UNUSED)
769 switch (code)
771 default:
772 /* Unrecognized options that we said we'd handle turn into
773 errors if not listed here. */
774 return false;
776 case OPT_iframework:
777 add_system_framework_path (xstrdup (arg));
778 break;
780 case OPT_fapple_kext:
784 /* We recognized the option. */
785 return true;
788 /* Allow ObjC* access to CFStrings. */
789 static tree
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. */
799 return NULL_TREE;
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. */
808 static bool
809 darwin_cfstring_ref_p (const_tree strp)
811 tree tn;
812 if (!strp || TREE_CODE (strp) != POINTER_TYPE)
813 return false;
815 tn = TYPE_NAME (strp);
816 if (tn)
817 tn = DECL_NAME (tn);
818 return (tn
819 && IDENTIFIER_POINTER (tn)
820 && !strncmp (IDENTIFIER_POINTER (tn), "CFStringRef", 8));
823 /* At present the behavior of this is undefined and it does nothing. */
824 static void
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,
833 NULL, NULL,
834 FMT_FLAG_ARG_CONVERT|FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL, 0, 0, 0, 0, 0, 0,
835 NULL, NULL
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. */
845 static void
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));
860 static void
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;