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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [darwin-c.c] - Blame information for rev 282

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn
/* Darwin support needed only by C/C++ frontends.
2
   Copyright (C) 2001, 2003, 2004, 2005, 2007, 2008
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 "c-pragma.h"
29
#include "c-tree.h"
30
#include "incpath.h"
31
#include "c-common.h"
32
#include "toplev.h"
33
#include "flags.h"
34
#include "tm_p.h"
35
#include "cppdefault.h"
36
#include "prefix.h"
37
#include "target.h"
38
#include "target-def.h"
39
 
40
/* Pragmas.  */
41
 
42
#define BAD(gmsgid) do { warning (OPT_Wpragmas, gmsgid); return; } while (0)
43
#define BAD2(msgid, arg) do { warning (OPT_Wpragmas, msgid, arg); return; } while (0)
44
 
45
static bool using_frameworks = false;
46
 
47
static const char *find_subframework_header (cpp_reader *pfile, const char *header,
48
                                             cpp_dir **dirp);
49
 
50
typedef struct align_stack
51
{
52
  int alignment;
53
  struct align_stack * prev;
54
} align_stack;
55
 
56
static struct align_stack * field_align_stack = NULL;
57
 
58
/* Maintain a small stack of alignments.  This is similar to pragma
59
   pack's stack, but simpler.  */
60
 
61
static void
62
push_field_alignment (int bit_alignment)
63
{
64
  align_stack *entry = XNEW (align_stack);
65
 
66
  entry->alignment = maximum_field_alignment;
67
  entry->prev = field_align_stack;
68
  field_align_stack = entry;
69
 
70
  maximum_field_alignment = bit_alignment;
71
}
72
 
73
static void
74
pop_field_alignment (void)
75
{
76
  if (field_align_stack)
77
    {
78
      align_stack *entry = field_align_stack;
79
 
80
      maximum_field_alignment = entry->alignment;
81
      field_align_stack = entry->prev;
82
      free (entry);
83
    }
84
  else
85
    error ("too many #pragma options align=reset");
86
}
87
 
88
/* Handlers for Darwin-specific pragmas.  */
89
 
90
void
91
darwin_pragma_ignore (cpp_reader *pfile ATTRIBUTE_UNUSED)
92
{
93
  /* Do nothing.  */
94
}
95
 
96
/* #pragma options align={mac68k|power|reset} */
97
 
98
void
99
darwin_pragma_options (cpp_reader *pfile ATTRIBUTE_UNUSED)
100
{
101
  const char *arg;
102
  tree t, x;
103
 
104
  if (pragma_lex (&t) != CPP_NAME)
105
    BAD ("malformed '#pragma options', ignoring");
106
  arg = IDENTIFIER_POINTER (t);
107
  if (strcmp (arg, "align"))
108
    BAD ("malformed '#pragma options', ignoring");
109
  if (pragma_lex (&t) != CPP_EQ)
110
    BAD ("malformed '#pragma options', ignoring");
111
  if (pragma_lex (&t) != CPP_NAME)
112
    BAD ("malformed '#pragma options', ignoring");
113
 
114
  if (pragma_lex (&x) != CPP_EOF)
115
    warning (OPT_Wpragmas, "junk at end of '#pragma options'");
116
 
117
  arg = IDENTIFIER_POINTER (t);
118
  if (!strcmp (arg, "mac68k"))
119
    push_field_alignment (16);
120
  else if (!strcmp (arg, "power"))
121
    push_field_alignment (0);
122
  else if (!strcmp (arg, "reset"))
123
    pop_field_alignment ();
124
  else
125
    BAD ("malformed '#pragma options align={mac68k|power|reset}', ignoring");
126
}
127
 
128
/* #pragma unused ([var {, var}*]) */
129
 
130
void
131
darwin_pragma_unused (cpp_reader *pfile ATTRIBUTE_UNUSED)
132
{
133
  tree decl, x;
134
  int tok;
135
 
136
  if (pragma_lex (&x) != CPP_OPEN_PAREN)
137
    BAD ("missing '(' after '#pragma unused', ignoring");
138
 
139
  while (1)
140
    {
141
      tok = pragma_lex (&decl);
142
      if (tok == CPP_NAME && decl)
143
        {
144
          tree local = lookup_name (decl);
145
          if (local && (TREE_CODE (local) == PARM_DECL
146
                        || TREE_CODE (local) == VAR_DECL))
147
            TREE_USED (local) = 1;
148
          tok = pragma_lex (&x);
149
          if (tok != CPP_COMMA)
150
            break;
151
        }
152
    }
153
 
154
  if (tok != CPP_CLOSE_PAREN)
155
    BAD ("missing ')' after '#pragma unused', ignoring");
156
 
157
  if (pragma_lex (&x) != CPP_EOF)
158
    BAD ("junk at end of '#pragma unused'");
159
}
160
 
161
/* Parse the ms_struct pragma.  */
162
void
163
darwin_pragma_ms_struct (cpp_reader *pfile ATTRIBUTE_UNUSED)
164
{
165
  const char *arg;
166
  tree t;
167
 
168
  if (pragma_lex (&t) != CPP_NAME)
169
    BAD ("malformed '#pragma ms_struct', ignoring");
170
  arg = IDENTIFIER_POINTER (t);
171
 
172
  if (!strcmp (arg, "on"))
173
    darwin_ms_struct = true;
174
  else if (!strcmp (arg, "off") || !strcmp (arg, "reset"))
175
    darwin_ms_struct = false;
176
  else
177
    BAD ("malformed '#pragma ms_struct {on|off|reset}', ignoring");
178
 
179
  if (pragma_lex (&t) != CPP_EOF)
180
    BAD ("junk at end of '#pragma ms_struct'");
181
}
182
 
183
static struct frameworks_in_use {
184
  size_t len;
185
  const char *name;
186
  cpp_dir* dir;
187
} *frameworks_in_use;
188
static int num_frameworks = 0;
189
static int max_frameworks = 0;
190
 
191
 
192
/* Remember which frameworks have been seen, so that we can ensure
193
   that all uses of that framework come from the same framework.  DIR
194
   is the place where the named framework NAME, which is of length
195
   LEN, was found.  We copy the directory name from NAME, as it will be
196
   freed by others.  */
197
 
198
static void
199
add_framework (const char *name, size_t len, cpp_dir *dir)
200
{
201
  char *dir_name;
202
  int i;
203
  for (i = 0; i < num_frameworks; ++i)
204
    {
205
      if (len == frameworks_in_use[i].len
206
          && strncmp (name, frameworks_in_use[i].name, len) == 0)
207
        {
208
          return;
209
        }
210
    }
211
  if (i >= max_frameworks)
212
    {
213
      max_frameworks = i*2;
214
      max_frameworks += i == 0;
215
      frameworks_in_use = XRESIZEVEC (struct frameworks_in_use,
216
                                      frameworks_in_use, max_frameworks);
217
    }
218
  dir_name = XNEWVEC (char, len + 1);
219
  memcpy (dir_name, name, len);
220
  dir_name[len] = '\0';
221
  frameworks_in_use[num_frameworks].name = dir_name;
222
  frameworks_in_use[num_frameworks].len = len;
223
  frameworks_in_use[num_frameworks].dir = dir;
224
  ++num_frameworks;
225
}
226
 
227
/* Recall if we have seen the named framework NAME, before, and where
228
   we saw it.  NAME is LEN bytes long.  The return value is the place
229
   where it was seen before.  */
230
 
231
static struct cpp_dir*
232
find_framework (const char *name, size_t len)
233
{
234
  int i;
235
  for (i = 0; i < num_frameworks; ++i)
236
    {
237
      if (len == frameworks_in_use[i].len
238
          && strncmp (name, frameworks_in_use[i].name, len) == 0)
239
        {
240
          return frameworks_in_use[i].dir;
241
        }
242
    }
243
  return 0;
244
}
245
 
246
/* There are two directories in a framework that contain header files,
247
   Headers and PrivateHeaders.  We search Headers first as it is more
248
   common to upgrade a header from PrivateHeaders to Headers and when
249
   that is done, the old one might hang around and be out of data,
250
   causing grief.  */
251
 
252
struct framework_header {const char * dirName; int dirNameLen; };
253
static struct framework_header framework_header_dirs[] = {
254
  { "Headers", 7 },
255
  { "PrivateHeaders", 14 },
256
  { NULL, 0 }
257
};
258
 
259
/* Returns a pointer to a malloced string that contains the real pathname
260
   to the file, given the base name and the name.  */
261
 
262
static char *
263
framework_construct_pathname (const char *fname, cpp_dir *dir)
264
{
265
  char *buf;
266
  size_t fname_len, frname_len;
267
  cpp_dir *fast_dir;
268
  char *frname;
269
  struct stat st;
270
  int i;
271
 
272
  /* Framework names must have a / in them.  */
273
  buf = strchr (fname, '/');
274
  if (buf)
275
    fname_len = buf - fname;
276
  else
277
    return 0;
278
 
279
  fast_dir = find_framework (fname, fname_len);
280
 
281
  /* Framework includes must all come from one framework.  */
282
  if (fast_dir && dir != fast_dir)
283
    return 0;
284
 
285
  frname = XNEWVEC (char, strlen (fname) + dir->len + 2
286
                    + strlen(".framework/") + strlen("PrivateHeaders"));
287
  strncpy (&frname[0], dir->name, dir->len);
288
  frname_len = dir->len;
289
  if (frname_len && frname[frname_len-1] != '/')
290
    frname[frname_len++] = '/';
291
  strncpy (&frname[frname_len], fname, fname_len);
292
  frname_len += fname_len;
293
  strncpy (&frname[frname_len], ".framework/", strlen (".framework/"));
294
  frname_len += strlen (".framework/");
295
 
296
  if (fast_dir == 0)
297
    {
298
      frname[frname_len-1] = 0;
299
      if (stat (frname, &st) == 0)
300
        {
301
          /* As soon as we find the first instance of the framework,
302
             we stop and never use any later instance of that
303
             framework.  */
304
          add_framework (fname, fname_len, dir);
305
        }
306
      else
307
        {
308
          /* If we can't find the parent directory, no point looking
309
             further.  */
310
          free (frname);
311
          return 0;
312
        }
313
      frname[frname_len-1] = '/';
314
    }
315
 
316
  /* Append framework_header_dirs and header file name */
317
  for (i = 0; framework_header_dirs[i].dirName; i++)
318
    {
319
      strncpy (&frname[frname_len],
320
               framework_header_dirs[i].dirName,
321
               framework_header_dirs[i].dirNameLen);
322
      strcpy (&frname[frname_len + framework_header_dirs[i].dirNameLen],
323
              &fname[fname_len]);
324
 
325
      if (stat (frname, &st) == 0)
326
        return frname;
327
    }
328
 
329
  free (frname);
330
  return 0;
331
}
332
 
333
/* Search for FNAME in sub-frameworks.  pname is the context that we
334
   wish to search in.  Return the path the file was found at,
335
   otherwise return 0.  */
336
 
337
static const char*
338
find_subframework_file (const char *fname, const char *pname)
339
{
340
  char *sfrname;
341
  const char *dot_framework = ".framework/";
342
  char *bufptr;
343
  int sfrname_len, i, fname_len;
344
  struct cpp_dir *fast_dir;
345
  static struct cpp_dir subframe_dir;
346
  struct stat st;
347
 
348
  bufptr = strchr (fname, '/');
349
 
350
  /* Subframework files must have / in the name.  */
351
  if (bufptr == 0)
352
    return 0;
353
 
354
  fname_len = bufptr - fname;
355
  fast_dir = find_framework (fname, fname_len);
356
 
357
  /* Sub framework header filename includes parent framework name and
358
     header name in the "CarbonCore/OSUtils.h" form. If it does not
359
     include slash it is not a sub framework include.  */
360
  bufptr = strstr (pname, dot_framework);
361
 
362
  /* If the parent header is not of any framework, then this header
363
     cannot be part of any subframework.  */
364
  if (!bufptr)
365
    return 0;
366
 
367
  /* Now translate. For example,                  +- bufptr
368
     fname = CarbonCore/OSUtils.h                 |
369
     pname = /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h
370
     into
371
     sfrname = /System/Library/Frameworks/Foundation.framework/Frameworks/CarbonCore.framework/Headers/OSUtils.h */
372
 
373
  sfrname = XNEWVEC (char, strlen (pname) + strlen (fname) + 2 +
374
                              strlen ("Frameworks/") + strlen (".framework/")
375
                              + strlen ("PrivateHeaders"));
376
 
377
  bufptr += strlen (dot_framework);
378
 
379
  sfrname_len = bufptr - pname;
380
 
381
  strncpy (&sfrname[0], pname, sfrname_len);
382
 
383
  strncpy (&sfrname[sfrname_len], "Frameworks/", strlen ("Frameworks/"));
384
  sfrname_len += strlen("Frameworks/");
385
 
386
  strncpy (&sfrname[sfrname_len], fname, fname_len);
387
  sfrname_len += fname_len;
388
 
389
  strncpy (&sfrname[sfrname_len], ".framework/", strlen (".framework/"));
390
  sfrname_len += strlen (".framework/");
391
 
392
  /* Append framework_header_dirs and header file name */
393
  for (i = 0; framework_header_dirs[i].dirName; i++)
394
    {
395
      strncpy (&sfrname[sfrname_len],
396
               framework_header_dirs[i].dirName,
397
               framework_header_dirs[i].dirNameLen);
398
      strcpy (&sfrname[sfrname_len + framework_header_dirs[i].dirNameLen],
399
              &fname[fname_len]);
400
 
401
      if (stat (sfrname, &st) == 0)
402
        {
403
          if (fast_dir != &subframe_dir)
404
            {
405
              if (fast_dir)
406
                warning (0, "subframework include %s conflicts with framework include",
407
                         fname);
408
              else
409
                add_framework (fname, fname_len, &subframe_dir);
410
            }
411
 
412
          return sfrname;
413
        }
414
    }
415
  free (sfrname);
416
 
417
  return 0;
418
}
419
 
420
/* Add PATH to the system includes. PATH must be malloc-ed and
421
   NUL-terminated.  System framework paths are C++ aware.  */
422
 
423
static void
424
add_system_framework_path (char *path)
425
{
426
  int cxx_aware = 1;
427
  cpp_dir *p;
428
 
429
  p = XNEW (cpp_dir);
430
  p->next = NULL;
431
  p->name = path;
432
  p->sysp = 1 + !cxx_aware;
433
  p->construct = framework_construct_pathname;
434
  using_frameworks = 1;
435
 
436
  add_cpp_dir_path (p, SYSTEM);
437
}
438
 
439
/* Add PATH to the bracket includes. PATH must be malloc-ed and
440
   NUL-terminated.  */
441
 
442
void
443
add_framework_path (char *path)
444
{
445
  cpp_dir *p;
446
 
447
  p = XNEW (cpp_dir);
448
  p->next = NULL;
449
  p->name = path;
450
  p->sysp = 0;
451
  p->construct = framework_construct_pathname;
452
  using_frameworks = 1;
453
 
454
  add_cpp_dir_path (p, BRACKET);
455
}
456
 
457
static const char *framework_defaults [] =
458
  {
459
    "/System/Library/Frameworks",
460
    "/Library/Frameworks",
461
  };
462
 
463
/* Register the GNU objective-C runtime include path if STDINC.  */
464
 
465
void
466
darwin_register_objc_includes (const char *sysroot, const char *iprefix,
467
                               int stdinc)
468
{
469
  const char *fname;
470
  size_t len;
471
  /* We do not do anything if we do not want the standard includes. */
472
  if (!stdinc)
473
    return;
474
 
475
  fname = GCC_INCLUDE_DIR "-gnu-runtime";
476
 
477
  /* Register the GNU OBJC runtime include path if we are compiling  OBJC
478
    with GNU-runtime.  */
479
 
480
  if (c_dialect_objc () && !flag_next_runtime)
481
    {
482
      char *str;
483
      /* See if our directory starts with the standard prefix.
484
         "Translate" them, i.e. replace /usr/local/lib/gcc... with
485
         IPREFIX and search them first.  */
486
      if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 && !sysroot
487
          && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len))
488
        {
489
          str = concat (iprefix, fname + len, NULL);
490
          /* FIXME: wrap the headers for C++awareness.  */
491
          add_path (str, SYSTEM, /*c++aware=*/false, false);
492
        }
493
 
494
      /* Should this directory start with the sysroot?  */
495
      if (sysroot)
496
        str = concat (sysroot, fname, NULL);
497
      else
498
        str = update_path (fname, "");
499
 
500
      add_path (str, SYSTEM, /*c++aware=*/false, false);
501
    }
502
}
503
 
504
 
505
/* Register all the system framework paths if STDINC is true and setup
506
   the missing_header callback for subframework searching if any
507
   frameworks had been registered.  */
508
 
509
void
510
darwin_register_frameworks (const char *sysroot,
511
                            const char *iprefix ATTRIBUTE_UNUSED, int stdinc)
512
{
513
  if (stdinc)
514
    {
515
      size_t i;
516
 
517
      /* Setup default search path for frameworks.  */
518
      for (i=0; i<sizeof (framework_defaults)/sizeof(const char *); ++i)
519
        {
520
          char *str;
521
          if (sysroot)
522
            str = concat (sysroot, xstrdup (framework_defaults [i]), NULL);
523
          else
524
            str = xstrdup (framework_defaults[i]);
525
          /* System Framework headers are cxx aware.  */
526
          add_system_framework_path (str);
527
        }
528
    }
529
 
530
  if (using_frameworks)
531
    cpp_get_callbacks (parse_in)->missing_header = find_subframework_header;
532
}
533
 
534
/* Search for HEADER in context dependent way.  The return value is
535
   the malloced name of a header to try and open, if any, or NULL
536
   otherwise.  This is called after normal header lookup processing
537
   fails to find a header.  We search each file in the include stack,
538
   using FUNC, starting from the most deeply nested include and
539
   finishing with the main input file.  We stop searching when FUNC
540
   returns nonzero.  */
541
 
542
static const char*
543
find_subframework_header (cpp_reader *pfile, const char *header, cpp_dir **dirp)
544
{
545
  const char *fname = header;
546
  struct cpp_buffer *b;
547
  const char *n;
548
 
549
  for (b = cpp_get_buffer (pfile);
550
       b && cpp_get_file (b) && cpp_get_path (cpp_get_file (b));
551
       b = cpp_get_prev (b))
552
    {
553
      n = find_subframework_file (fname, cpp_get_path (cpp_get_file (b)));
554
      if (n)
555
        {
556
          /* Logically, the place where we found the subframework is
557
             the place where we found the Framework that contains the
558
             subframework.  This is useful for tracking wether or not
559
             we are in a system header.  */
560
          *dirp = cpp_get_dir (cpp_get_file (b));
561
          return n;
562
        }
563
    }
564
 
565
  return 0;
566
}
567
 
568
/* Return the value of darwin_macosx_version_min suitable for the
569
   __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro,
570
   so '10.4.2' becomes 1040.  The lowest digit is always zero.
571
   Print a warning if the version number can't be understood.  */
572
static const char *
573
version_as_macro (void)
574
{
575
  static char result[] = "1000";
576
 
577
  if (strncmp (darwin_macosx_version_min, "10.", 3) != 0)
578
    goto fail;
579
  if (! ISDIGIT (darwin_macosx_version_min[3]))
580
    goto fail;
581
  result[2] = darwin_macosx_version_min[3];
582
  if (darwin_macosx_version_min[4] != '\0'
583
      && darwin_macosx_version_min[4] != '.')
584
    goto fail;
585
 
586
  return result;
587
 
588
 fail:
589
  error ("Unknown value %qs of -mmacosx-version-min",
590
         darwin_macosx_version_min);
591
  return "1000";
592
}
593
 
594
/* Define additional CPP flags for Darwin.   */
595
 
596
#define builtin_define(TXT) cpp_define (pfile, TXT)
597
 
598
void
599
darwin_cpp_builtins (cpp_reader *pfile)
600
{
601
  builtin_define ("__MACH__");
602
  builtin_define ("__APPLE__");
603
 
604
  /* __APPLE_CC__ is defined as some old Apple include files expect it
605
     to be defined and won't work if it isn't.  */
606
  builtin_define_with_value ("__APPLE_CC__", "1", false);
607
 
608
  builtin_define_with_value ("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
609
                             version_as_macro(), false);
610
}
611
 
612
/* Handle C family front-end options.  */
613
 
614
static bool
615
handle_c_option (size_t code,
616
                 const char *arg,
617
                 int value ATTRIBUTE_UNUSED)
618
{
619
  switch (code)
620
    {
621
    default:
622
      /* Unrecognized options that we said we'd handle turn into
623
         errors if not listed here.  */
624
      return false;
625
 
626
    case OPT_iframework:
627
      add_system_framework_path (xstrdup (arg));
628
      break;
629
 
630
    case OPT_fapple_kext:
631
      ;
632
    }
633
 
634
  /* We recognized the option.  */
635
  return true;
636
}
637
 
638
#undef TARGET_HANDLE_C_OPTION
639
#define TARGET_HANDLE_C_OPTION handle_c_option
640
 
641
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.