OSDN Git Service

gcc:
[pf3gnuchains/gcc-fork.git] / gcc / c-pragma.c
1 /* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
2    Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3    Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "function.h"
29 #include "cpplib.h"
30 #include "c-pragma.h"
31 #include "flags.h"
32 #include "toplev.h"
33 #include "ggc.h"
34 #include "c-common.h"
35 #include "output.h"
36 #include "tm_p.h"
37 #include "target.h"
38
39 #define GCC_BAD(msgid) do { warning (msgid); return; } while (0)
40 #define GCC_BAD2(msgid, arg) do { warning (msgid, arg); return; } while (0)
41
42 typedef struct align_stack GTY(())
43 {
44   int                  alignment;
45   tree                 id;
46   struct align_stack * prev;
47 } align_stack;
48
49 static GTY(()) struct align_stack * alignment_stack;
50
51 #ifdef HANDLE_PRAGMA_PACK
52 static void handle_pragma_pack (cpp_reader *);
53
54 #ifdef HANDLE_PRAGMA_PACK_PUSH_POP
55 /* If we have a "global" #pragma pack(<n>) in effect when the first
56    #pragma pack(push,<n>) is encountered, this stores the value of 
57    maximum_field_alignment in effect.  When the final pop_alignment() 
58    happens, we restore the value to this, not to a value of 0 for
59    maximum_field_alignment.  Value is in bits.  */
60 static int default_alignment;
61 #define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = *(alignment_stack == NULL \
62         ? &default_alignment \
63         : &alignment_stack->alignment) = (ALIGN))
64
65 static void push_alignment (int, tree);
66 static void pop_alignment (tree);
67
68 /* Push an alignment value onto the stack.  */
69 static void
70 push_alignment (int alignment, tree id)
71 {
72   align_stack * entry;
73
74   entry = ggc_alloc (sizeof (* entry));
75
76   entry->alignment  = alignment;
77   entry->id         = id;
78   entry->prev       = alignment_stack;
79        
80   /* The current value of maximum_field_alignment is not necessarily 
81      0 since there may be a #pragma pack(<n>) in effect; remember it 
82      so that we can restore it after the final #pragma pop().  */
83   if (alignment_stack == NULL)
84     default_alignment = maximum_field_alignment;
85  
86   alignment_stack = entry;
87
88   maximum_field_alignment = alignment;
89 }
90
91 /* Undo a push of an alignment onto the stack.  */
92 static void
93 pop_alignment (tree id)
94 {
95   align_stack * entry;
96       
97   if (alignment_stack == NULL)
98     GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)");
99
100   /* If we got an identifier, strip away everything above the target
101      entry so that the next step will restore the state just below it.  */
102   if (id)
103     {
104       for (entry = alignment_stack; entry; entry = entry->prev)
105         if (entry->id == id)
106           {
107             alignment_stack = entry;
108             break;
109           }
110       if (entry == NULL)
111         warning ("\
112 #pragma pack(pop, %s) encountered without matching #pragma pack(push, %s)"
113                  , IDENTIFIER_POINTER (id), IDENTIFIER_POINTER (id));
114     }
115
116   entry = alignment_stack->prev;
117
118   maximum_field_alignment = entry ? entry->alignment : default_alignment;
119
120   alignment_stack = entry;
121 }
122 #else  /* not HANDLE_PRAGMA_PACK_PUSH_POP */
123 #define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN))
124 #define push_alignment(ID, N) \
125     GCC_BAD ("#pragma pack(push[, id], <n>) is not supported on this target")
126 #define pop_alignment(ID) \
127     GCC_BAD ("#pragma pack(pop[, id], <n>) is not supported on this target")
128 #endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
129
130 /* #pragma pack ()
131    #pragma pack (N)
132    
133    #pragma pack (push)
134    #pragma pack (push, N)
135    #pragma pack (push, ID)
136    #pragma pack (push, ID, N)
137    #pragma pack (pop)
138    #pragma pack (pop, ID) */
139 static void
140 handle_pragma_pack (cpp_reader * ARG_UNUSED (dummy))
141 {
142   tree x, id = 0;
143   int align = -1;
144   enum cpp_ttype token;
145   enum { set, push, pop } action;
146
147   if (c_lex (&x) != CPP_OPEN_PAREN)
148     GCC_BAD ("missing %<(%> after %<#pragma pack%> - ignored");
149
150   token = c_lex (&x);
151   if (token == CPP_CLOSE_PAREN)
152     {
153       action = set;
154       align = initial_max_fld_align;
155     }
156   else if (token == CPP_NUMBER)
157     {
158       align = TREE_INT_CST_LOW (x);
159       action = set;
160       if (c_lex (&x) != CPP_CLOSE_PAREN)
161         GCC_BAD ("malformed %<#pragma pack%> - ignored");
162     }
163   else if (token == CPP_NAME)
164     {
165 #define GCC_BAD_ACTION do { if (action != pop) \
166           GCC_BAD ("malformed %<#pragma pack(push[, id][, <n>])%> - ignored"); \
167         else \
168           GCC_BAD ("malformed %<#pragma pack(pop[, id])%> - ignored"); \
169         } while (0)
170
171       const char *op = IDENTIFIER_POINTER (x);
172       if (!strcmp (op, "push"))
173         action = push;
174       else if (!strcmp (op, "pop"))
175         action = pop;
176       else
177         GCC_BAD2 ("unknown action %qs for %<#pragma pack%> - ignored", op);
178
179       while ((token = c_lex (&x)) == CPP_COMMA)
180         {
181           token = c_lex (&x);
182           if (token == CPP_NAME && id == 0)
183             {
184               id = x;
185             }
186           else if (token == CPP_NUMBER && action == push && align == -1)
187             {
188               align = TREE_INT_CST_LOW (x);
189               if (align == -1)
190                 action = set;
191             }
192           else
193             GCC_BAD_ACTION;
194         }
195
196       if (token != CPP_CLOSE_PAREN)
197         GCC_BAD_ACTION;
198 #undef GCC_BAD_ACTION
199     }
200   else
201     GCC_BAD ("malformed %<#pragma pack%> - ignored");
202
203   if (c_lex (&x) != CPP_EOF)
204     warning ("junk at end of %<#pragma pack%>");
205
206   if (flag_pack_struct)
207     GCC_BAD ("#pragma pack has no effect with -fpack-struct - ignored");
208
209   if (action != pop)
210     switch (align)
211       {
212       case 0:
213       case 1:
214       case 2:
215       case 4:
216       case 8:
217       case 16:
218         align *= BITS_PER_UNIT;
219         break;
220       case -1:
221         if (action == push)
222           {
223             align = maximum_field_alignment;
224             break;
225           }
226       default:
227         GCC_BAD2 ("alignment must be a small power of two, not %d", align);
228       }
229
230   switch (action)
231     {
232     case set:   SET_GLOBAL_ALIGNMENT (align);  break;
233     case push:  push_alignment (align, id);    break;
234     case pop:   pop_alignment (id);            break;
235     }
236 }
237 #endif  /* HANDLE_PRAGMA_PACK */
238
239 static GTY(()) tree pending_weaks;
240
241 #ifdef HANDLE_PRAGMA_WEAK
242 static void apply_pragma_weak (tree, tree);
243 static void handle_pragma_weak (cpp_reader *);
244
245 static void
246 apply_pragma_weak (tree decl, tree value)
247 {
248   if (value)
249     {
250       value = build_string (IDENTIFIER_LENGTH (value),
251                             IDENTIFIER_POINTER (value));
252       decl_attributes (&decl, build_tree_list (get_identifier ("alias"),
253                                                build_tree_list (NULL, value)),
254                        0);
255     }
256
257   if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl)
258       && !DECL_WEAK (decl) /* Don't complain about a redundant #pragma.  */
259       && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
260     warning ("%Japplying #pragma weak %qD after first use results "
261              "in unspecified behavior", decl, decl);
262
263   declare_weak (decl);
264 }
265
266 void
267 maybe_apply_pragma_weak (tree decl)
268 {
269   tree *p, t, id;
270
271   /* Avoid asking for DECL_ASSEMBLER_NAME when it's not needed.  */
272
273   /* No weak symbols pending, take the short-cut.  */
274   if (!pending_weaks)
275     return;
276   /* If it's not visible outside this file, it doesn't matter whether
277      it's weak.  */
278   if (!DECL_EXTERNAL (decl) && !TREE_PUBLIC (decl))
279     return;
280   /* If it's not a function or a variable, it can't be weak.
281      FIXME: what kinds of things are visible outside this file but
282      aren't functions or variables?   Should this be an assert instead?  */
283   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
284     return;
285
286   id = DECL_ASSEMBLER_NAME (decl);
287
288   for (p = &pending_weaks; (t = *p) ; p = &TREE_CHAIN (t))
289     if (id == TREE_PURPOSE (t))
290       {
291         apply_pragma_weak (decl, TREE_VALUE (t));
292         *p = TREE_CHAIN (t);
293         break;
294       }
295 }
296
297 /* #pragma weak name [= value] */
298 static void
299 handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy))
300 {
301   tree name, value, x, decl;
302   enum cpp_ttype t;
303
304   value = 0;
305
306   if (c_lex (&name) != CPP_NAME)
307     GCC_BAD ("malformed #pragma weak, ignored");
308   t = c_lex (&x);
309   if (t == CPP_EQ)
310     {
311       if (c_lex (&value) != CPP_NAME)
312         GCC_BAD ("malformed #pragma weak, ignored");
313       t = c_lex (&x);
314     }
315   if (t != CPP_EOF)
316     warning ("junk at end of #pragma weak");
317
318   decl = identifier_global_value (name);
319   if (decl && DECL_P (decl))
320     {
321       apply_pragma_weak (decl, value);
322       if (value)
323         assemble_alias (decl, value);
324     }
325   else
326     pending_weaks = tree_cons (name, value, pending_weaks);
327 }
328 #else
329 void
330 maybe_apply_pragma_weak (tree ARG_UNUSED (decl))
331 {
332 }
333 #endif /* HANDLE_PRAGMA_WEAK */
334
335 /* GCC supports two #pragma directives for renaming the external
336    symbol associated with a declaration (DECL_ASSEMBLER_NAME), for
337    compatibility with the Solaris and Tru64 system headers.  GCC also
338    has its own notation for this, __asm__("name") annotations.
339
340    Corner cases of these features and their interaction:
341
342    1) Both pragmas silently apply only to declarations with external
343       linkage (that is, TREE_PUBLIC || DECL_EXTERNAL).  Asm labels
344       do not have this restriction.
345
346    2) In C++, both #pragmas silently apply only to extern "C" declarations.
347       Asm labels do not have this restriction.
348
349    3) If any of the three ways of changing DECL_ASSEMBLER_NAME is
350       applied to a decl whose DECL_ASSEMBLER_NAME is already set, and the
351       new name is different, a warning issues and the name does not change.
352
353    4) The "source name" for #pragma redefine_extname is the DECL_NAME,
354       *not* the DECL_ASSEMBLER_NAME.
355
356    5) If #pragma extern_prefix is in effect and a declaration occurs
357       with an __asm__ name, the #pragma extern_prefix is silently
358       ignored for that declaration.
359
360    6) If #pragma extern_prefix and #pragma redefine_extname apply to
361       the same declaration, whichever triggered first wins, and a warning
362       is issued.  (We would like to have #pragma redefine_extname always
363       win, but it can appear either before or after the declaration, and
364       if it appears afterward, we have no way of knowing whether a modified
365       DECL_ASSEMBLER_NAME is due to #pragma extern_prefix.)  */
366
367 static GTY(()) tree pending_redefine_extname;
368
369 static void handle_pragma_redefine_extname (cpp_reader *);
370
371 /* #pragma redefine_extname oldname newname */
372 static void
373 handle_pragma_redefine_extname (cpp_reader * ARG_UNUSED (dummy))
374 {
375   tree oldname, newname, decl, x;
376   enum cpp_ttype t;
377
378   if (c_lex (&oldname) != CPP_NAME)
379     GCC_BAD ("malformed #pragma redefine_extname, ignored");
380   if (c_lex (&newname) != CPP_NAME)
381     GCC_BAD ("malformed #pragma redefine_extname, ignored");
382   t = c_lex (&x);
383   if (t != CPP_EOF)
384     warning ("junk at end of #pragma redefine_extname");
385
386   if (!flag_mudflap && !targetm.handle_pragma_redefine_extname)
387     {
388       if (warn_unknown_pragmas > in_system_header)
389         warning ("#pragma redefine_extname not supported on this target");
390       return;
391     }
392
393   decl = identifier_global_value (oldname);
394   if (decl
395       && (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
396       && (TREE_CODE (decl) == FUNCTION_DECL
397           || TREE_CODE (decl) == VAR_DECL)
398       && has_c_linkage (decl))
399     {
400       if (DECL_ASSEMBLER_NAME_SET_P (decl))
401         {
402           const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
403           name = targetm.strip_name_encoding (name);
404
405           if (strcmp (name, IDENTIFIER_POINTER (newname)))
406             warning ("#pragma redefine_extname ignored due to conflict with "
407                      "previous rename");
408         }
409       else
410         change_decl_assembler_name (decl, newname);
411     }
412   else
413     /* We have to add this to the rename list even if there's already
414        a global value that doesn't meet the above criteria, because in
415        C++ "struct foo {...};" puts "foo" in the current namespace but
416        does *not* conflict with a subsequent declaration of a function
417        or variable foo.  See g++.dg/other/pragma-re-2.C.  */
418     add_to_renaming_pragma_list (oldname, newname);
419 }
420
421 /* This is called from here and from ia64.c.  */
422 void
423 add_to_renaming_pragma_list (tree oldname, tree newname)
424 {
425   tree previous = purpose_member (oldname, pending_redefine_extname);
426   if (previous)
427     {
428       if (TREE_VALUE (previous) != newname)
429         warning ("#pragma redefine_extname ignored due to conflict with "
430                  "previous #pragma redefine_extname");
431       return;
432     }
433   
434   pending_redefine_extname
435     = tree_cons (oldname, newname, pending_redefine_extname);
436 }
437
438 static GTY(()) tree pragma_extern_prefix;
439
440 /* #pragma extern_prefix "prefix" */
441 static void
442 handle_pragma_extern_prefix (cpp_reader * ARG_UNUSED (dummy))
443 {
444   tree prefix, x;
445   enum cpp_ttype t;
446
447   if (c_lex (&prefix) != CPP_STRING)
448     GCC_BAD ("malformed #pragma extern_prefix, ignored");
449   t = c_lex (&x);
450   if (t != CPP_EOF)
451     warning ("junk at end of #pragma extern_prefix");
452
453   if (targetm.handle_pragma_extern_prefix)
454     /* Note that the length includes the null terminator.  */
455     pragma_extern_prefix = (TREE_STRING_LENGTH (prefix) > 1 ? prefix : NULL);
456   else if (warn_unknown_pragmas > in_system_header)
457     warning ("#pragma extern_prefix not supported on this target");
458 }
459
460 /* Hook from the front ends to apply the results of one of the preceding
461    pragmas that rename variables.  */
462
463 tree
464 maybe_apply_renaming_pragma (tree decl, tree asmname)
465 {
466   tree *p, t;
467
468   /* The renaming pragmas are only applied to declarations with
469      external linkage.  */
470   if ((TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
471       || (!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
472       || !has_c_linkage (decl))
473     return asmname;
474
475   /* If the DECL_ASSEMBLER_NAME is already set, it does not change,
476      but we may warn about a rename that conflicts.  */
477   if (DECL_ASSEMBLER_NAME_SET_P (decl))
478     {
479       const char *oldname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
480       oldname = targetm.strip_name_encoding (oldname);
481
482       if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname))
483           warning ("asm declaration ignored due to "
484                    "conflict with previous rename");
485
486       /* Take any pending redefine_extname off the list.  */
487       for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t))
488         if (DECL_NAME (decl) == TREE_PURPOSE (t))
489           {
490             /* Only warn if there is a conflict.  */
491             if (strcmp (IDENTIFIER_POINTER (TREE_VALUE (t)), oldname))
492               warning ("#pragma redefine_extname ignored due to "
493                        "conflict with previous rename");
494
495             *p = TREE_CHAIN (t);
496             break;
497           }
498       return 0;
499     }
500
501   /* Find out if we have a pending #pragma redefine_extname.  */
502   for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t))
503     if (DECL_NAME (decl) == TREE_PURPOSE (t))
504       {
505         tree newname = TREE_VALUE (t);
506         *p = TREE_CHAIN (t);
507
508         /* If we already have an asmname, #pragma redefine_extname is
509            ignored (with a warning if it conflicts).  */
510         if (asmname)
511           {
512             if (strcmp (TREE_STRING_POINTER (asmname),
513                         IDENTIFIER_POINTER (newname)) != 0)
514               warning ("#pragma redefine_extname ignored due to "
515                        "conflict with __asm__ declaration");
516             return asmname;
517           }
518
519         /* Otherwise we use what we've got; #pragma extern_prefix is
520            silently ignored.  */
521         return build_string (IDENTIFIER_LENGTH (newname),
522                              IDENTIFIER_POINTER (newname));
523       }
524
525   /* If we've got an asmname, #pragma extern_prefix is silently ignored.  */
526   if (asmname)
527     return asmname;
528
529   /* If #pragma extern_prefix is in effect, apply it.  */
530   if (pragma_extern_prefix)
531     {
532       const char *prefix = TREE_STRING_POINTER (pragma_extern_prefix);
533       size_t plen = TREE_STRING_LENGTH (pragma_extern_prefix) - 1;
534
535       const char *id = IDENTIFIER_POINTER (DECL_NAME (decl));
536       size_t ilen = IDENTIFIER_LENGTH (DECL_NAME (decl));
537         
538       char *newname = (char *) alloca (plen + ilen + 1);
539
540       memcpy (newname,        prefix, plen);
541       memcpy (newname + plen, id, ilen + 1);
542
543       return build_string (plen + ilen, newname);
544     }
545
546   /* Nada.  */
547   return 0;
548 }
549
550
551 #ifdef HANDLE_PRAGMA_VISIBILITY
552 static void handle_pragma_visibility (cpp_reader *);
553
554 /* Sets the default visibility for symbols to something other than that
555    specified on the command line.  */
556 static void
557 handle_pragma_visibility (cpp_reader *dummy ATTRIBUTE_UNUSED)
558 { /* Form is #pragma GCC visibility push(hidden)|pop */
559   static int visstack [16], visidx;
560   tree x;
561   enum cpp_ttype token;
562   enum { bad, push, pop } action = bad;
563  
564   token = c_lex (&x);
565   if (token == CPP_NAME)
566     {
567       const char *op = IDENTIFIER_POINTER (x);
568       if (!strcmp (op, "push"))
569         action = push;
570       else if (!strcmp (op, "pop"))
571         action = pop;
572     }
573   if (bad == action)
574     GCC_BAD ("#pragma GCC visibility must be followed by push or pop");
575   else
576     {
577       if (pop == action)
578         {
579           if (!visidx)
580             {
581               GCC_BAD ("No matching push for %<#pragma GCC visibility pop%>");
582             }
583           else
584             {
585               default_visibility = visstack[--visidx];
586               visibility_options.inpragma = (visidx>0);
587             }
588         }
589       else
590         {
591           if (c_lex (&x) != CPP_OPEN_PAREN)
592             GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
593           token = c_lex (&x);
594           if (token != CPP_NAME)
595             {
596               GCC_BAD ("malformed #pragma GCC visibility push");
597             }
598           else if (visidx >= 16)
599             {
600               GCC_BAD ("No more than sixteen #pragma GCC visibility pushes allowed at once");
601             }
602           else
603             {
604               const char *str = IDENTIFIER_POINTER (x);
605               visstack[visidx++] = default_visibility;
606               if (!strcmp (str, "default"))
607                 default_visibility = VISIBILITY_DEFAULT;
608               else if (!strcmp (str, "internal"))
609                 default_visibility = VISIBILITY_INTERNAL;
610               else if (!strcmp (str, "hidden"))
611                 default_visibility = VISIBILITY_HIDDEN;  
612               else if (!strcmp (str, "protected"))
613                 default_visibility = VISIBILITY_PROTECTED;
614               else
615                 {
616                   GCC_BAD ("#pragma GCC visibility push() must specify default, internal, hidden or protected");
617                 }
618               visibility_options.inpragma = 1;
619             }
620           if (c_lex (&x) != CPP_CLOSE_PAREN)
621             GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
622         }
623     }
624   if (c_lex (&x) != CPP_EOF)
625     warning ("junk at end of %<#pragma GCC visibility%>");
626 }
627
628 #endif
629
630 /* Front-end wrappers for pragma registration to avoid dragging
631    cpplib.h in almost everywhere.  */
632 void
633 c_register_pragma (const char *space, const char *name,
634                    void (*handler) (struct cpp_reader *))
635 {
636   cpp_register_pragma (parse_in, space, name, handler, 0);
637 }
638
639 void
640 c_register_pragma_with_expansion (const char *space, const char *name,
641                                   void (*handler) (struct cpp_reader *))
642 {
643   cpp_register_pragma (parse_in, space, name, handler, 1);
644 }
645
646 /* Set up front-end pragmas.  */
647 void
648 init_pragma (void)
649 {
650 #ifdef HANDLE_PRAGMA_PACK
651 #ifdef HANDLE_PRAGMA_PACK_WITH_EXPANSION
652   c_register_pragma_with_expansion (0, "pack", handle_pragma_pack);
653 #else
654   c_register_pragma (0, "pack", handle_pragma_pack);
655 #endif
656 #endif
657 #ifdef HANDLE_PRAGMA_WEAK
658   c_register_pragma (0, "weak", handle_pragma_weak);
659 #endif
660 #ifdef HANDLE_PRAGMA_VISIBILITY
661   c_register_pragma ("GCC", "visibility", handle_pragma_visibility);
662 #endif
663
664   c_register_pragma (0, "redefine_extname", handle_pragma_redefine_extname);
665   c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix);
666
667   c_register_pragma ("GCC", "pch_preprocess", c_common_pch_pragma);
668
669 #ifdef REGISTER_TARGET_PRAGMAS
670   REGISTER_TARGET_PRAGMAS ();
671 #endif
672 }
673
674 #include "gt-c-pragma.h"