OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [darwin-c.c] - Blame information for rev 709

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn
/* 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;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.