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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [config/] [darwin-c.c] - Blame information for rev 38

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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