#include "target.h"
#include "diagnostic.h"
#include "opts.h"
+#include "plugin.h"
#define GCC_BAD(gmsgid) \
do { warning (OPT_Wpragmas, gmsgid); return; } while (0)
#define GCC_BAD2(gmsgid, arg) \
do { warning (OPT_Wpragmas, gmsgid, arg); return; } while (0)
-typedef struct align_stack GTY(())
-{
+typedef struct GTY(()) align_stack {
int alignment;
tree id;
struct align_stack * prev;
}
if (entry == NULL)
warning (OPT_Wpragmas, "\
-#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s)"
- , IDENTIFIER_POINTER (id), IDENTIFIER_POINTER (id));
+#pragma pack(pop, %E) encountered without matching #pragma pack(push, %E)"
+ , id, id);
}
entry = alignment_stack->prev;
else if (!strcmp (op, "pop"))
action = pop;
else
- GCC_BAD2 ("unknown action %qs for %<#pragma pack%> - ignored", op);
+ GCC_BAD2 ("unknown action %qE for %<#pragma pack%> - ignored", x);
while ((token = pragma_lex (&x)) == CPP_COMMA)
{
}
#endif /* HANDLE_PRAGMA_PACK */
-struct def_pragma_macro_value GTY(())
-{
- struct def_pragma_macro_value *prev;
- cpp_macro *value;
-};
-
-struct def_pragma_macro GTY(())
-{
- hashval_t hash;
- const char *name;
- struct def_pragma_macro_value value;
-};
-
-static GTY((param_is (struct def_pragma_macro))) htab_t pushed_macro_table;
-
-#ifdef HANDLE_PRAGMA_PUSH_POP_MACRO
-/* Hash table control functions for pushed_macro_table. */
-static hashval_t
-dpm_hash (const void *p)
-{
- return ((const struct def_pragma_macro *)p)->hash;
-}
-
-static int
-dpm_eq (const void *pa, const void *pb)
-{
- const struct def_pragma_macro *const a = (const struct def_pragma_macro *) pa,
- *const b = (const struct def_pragma_macro *) pb;
- return a->hash == b->hash && strcmp (a->name, b->name) == 0;
-}
-
-/* #pragma push_macro("MACRO_NAME")
- #pragma pop_macro("MACRO_NAME") */
-
-static void
-handle_pragma_push_macro (cpp_reader *reader)
-{
- tree x, id = 0;
- enum cpp_ttype token;
- struct def_pragma_macro dummy, *c;
- const char *macroname;
- void **slot;
-
- if (pragma_lex (&x) != CPP_OPEN_PAREN)
- GCC_BAD ("missing %<(%> after %<#pragma push_macro%> - ignored");
-
- token = pragma_lex (&id);
-
- /* Silently ignore */
- if (token == CPP_CLOSE_PAREN)
- return;
- if (token != CPP_STRING)
- GCC_BAD ("invalid constant in %<#pragma push_macro%> - ignored");
-
- if (pragma_lex (&x) != CPP_CLOSE_PAREN)
- GCC_BAD ("missing %<)%> after %<#pragma push_macro%> - ignored");
-
- if (pragma_lex (&x) != CPP_EOF)
- warning (OPT_Wpragmas, "junk at end of %<#pragma push_macro%>");
-
- /* Check for empty string, and silently ignore. */
- if (TREE_STRING_LENGTH (id) < 1)
- return;
- macroname = TREE_STRING_POINTER (id);
-
- if (pushed_macro_table == NULL)
- pushed_macro_table = htab_create_ggc (15, dpm_hash, dpm_eq, 0);
-
- dummy.hash = htab_hash_string (macroname);
- dummy.name = macroname;
- slot = htab_find_slot_with_hash (pushed_macro_table, &dummy,
- dummy.hash, INSERT);
- c = (struct def_pragma_macro *) *slot;
- if (c == NULL)
- {
- *slot = c = GGC_NEW (struct def_pragma_macro);
- c->hash = dummy.hash;
- c->name = ggc_alloc_string (macroname, TREE_STRING_LENGTH (id) - 1);
- c->value.prev = NULL;
- }
- else
- {
- struct def_pragma_macro_value *v;
- v = GGC_NEW (struct def_pragma_macro_value);
- *v = c->value;
- c->value.prev = v;
- }
-
- c->value.value = cpp_push_definition (reader, macroname);
-}
-
-static void
-handle_pragma_pop_macro (cpp_reader *reader)
-{
- tree x, id = 0;
- enum cpp_ttype token;
- struct def_pragma_macro dummy, *c;
- const char *macroname;
- void **slot = NULL;
-
- if (pragma_lex (&x) != CPP_OPEN_PAREN)
- GCC_BAD ("missing %<(%> after %<#pragma pop_macro%> - ignored");
-
- token = pragma_lex (&id);
-
- /* Silently ignore */
- if (token == CPP_CLOSE_PAREN)
- return;
- if (token != CPP_STRING)
- GCC_BAD ("invalid constant in %<#pragma pop_macro%> - ignored");
-
- if (pragma_lex (&x) != CPP_CLOSE_PAREN)
- GCC_BAD ("missing %<)%> after %<#pragma pop_macro%> - ignored");
-
- if (pragma_lex (&x) != CPP_EOF)
- warning (OPT_Wpragmas, "junk at end of %<#pragma pop_macro%>");
-
- /* Check for empty string, and silently ignore. */
- if (TREE_STRING_LENGTH (id) < 1)
- return;
- macroname = TREE_STRING_POINTER (id);
-
- dummy.hash = htab_hash_string (macroname);
- dummy.name = macroname;
- if (pushed_macro_table)
- slot = htab_find_slot_with_hash (pushed_macro_table, &dummy,
- dummy.hash, NO_INSERT);
- if (slot == NULL)
- return;
- c = (struct def_pragma_macro *) *slot;
-
- cpp_pop_definition (reader, c->name, c->value.value);
-
- if (c->value.prev)
- c->value = *c->value.prev;
- else
- htab_clear_slot (pushed_macro_table, slot);
-}
-#endif /* HANDLE_PRAGMA_PUSH_POP_MACRO */
-
static GTY(()) tree pending_weaks;
#ifdef HANDLE_PRAGMA_WEAK
if (TREE_VALUE (t) == NULL)
continue;
- decl = build_decl (FUNCTION_DECL, alias_id, default_function_type);
+ decl = build_decl (UNKNOWN_LOCATION,
+ FUNCTION_DECL, alias_id, default_function_type);
DECL_ARTIFICIAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
if (t != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma redefine_extname%>");
- if (!flag_mudflap && !targetm.handle_pragma_redefine_extname)
- {
- if (warn_unknown_pragmas > in_system_header)
- warning (OPT_Wunknown_pragmas,
- "#pragma redefine_extname not supported on this target");
- return;
- }
-
decl = identifier_global_value (oldname);
if (decl
&& (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
#ifdef HANDLE_PRAGMA_VISIBILITY
static void handle_pragma_visibility (cpp_reader *);
-typedef enum symbol_visibility visibility;
-DEF_VEC_I (visibility);
-DEF_VEC_ALLOC_I (visibility, heap);
-static VEC (visibility, heap) *visstack;
+static VEC (int, heap) *visstack;
/* Push the visibility indicated by STR onto the top of the #pragma
- visibility stack. */
+ visibility stack. KIND is 0 for #pragma GCC visibility, 1 for
+ C++ namespace with visibility attribute and 2 for C++ builtin
+ ABI namespace. push_visibility/pop_visibility calls must have
+ matching KIND, it is not allowed to push visibility using one
+ KIND and pop using a different one. */
void
-push_visibility (const char *str)
+push_visibility (const char *str, int kind)
{
- VEC_safe_push (visibility, heap, visstack,
- default_visibility);
+ VEC_safe_push (int, heap, visstack,
+ ((int) default_visibility) | (kind << 8));
if (!strcmp (str, "default"))
default_visibility = VISIBILITY_DEFAULT;
else if (!strcmp (str, "internal"))
visibility_options.inpragma = 1;
}
-/* Pop a level of the #pragma visibility stack. */
+/* Pop a level of the #pragma visibility stack. Return true if
+ successful. */
-void
-pop_visibility (void)
+bool
+pop_visibility (int kind)
{
- default_visibility = VEC_pop (visibility, visstack);
+ if (!VEC_length (int, visstack))
+ return false;
+ if ((VEC_last (int, visstack) >> 8) != kind)
+ return false;
+ default_visibility
+ = (enum symbol_visibility) (VEC_pop (int, visstack) & 0xff);
visibility_options.inpragma
- = VEC_length (visibility, visstack) != 0;
+ = VEC_length (int, visstack) != 0;
+ return true;
}
/* Sets the default visibility for symbols to something other than that
{
if (pop == action)
{
- if (!VEC_length (visibility, visstack))
+ if (! pop_visibility (0))
GCC_BAD ("no matching push for %<#pragma GCC visibility pop%>");
- else
- pop_visibility ();
}
else
{
if (token != CPP_NAME)
GCC_BAD ("malformed #pragma GCC visibility push");
else
- push_visibility (IDENTIFIER_POINTER (x));
+ push_visibility (IDENTIFIER_POINTER (x), 0);
if (pragma_lex (&x) != CPP_CLOSE_PAREN)
GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
}
GCC_BAD ("unknown option after %<#pragma GCC diagnostic%> kind");
}
-/* Stack of the #pragma GCC options created with #pragma GCC option push. */
-static GTY(()) VEC(tree,gc) *option_stack;
-
-/* Parse #pragma GCC option (xxx) to set target specific options. */
+/* Parse #pragma GCC target (xxx) to set target specific options. */
static void
-handle_pragma_option(cpp_reader *ARG_UNUSED(dummy))
+handle_pragma_target(cpp_reader *ARG_UNUSED(dummy))
{
enum cpp_ttype token;
- const char *name;
tree x;
bool close_paren_needed_p = false;
return;
}
- if (!targetm.target_option.pragma_parse)
- {
- error ("#pragma GCC option is not supported for this system");
- return;
- }
-
token = pragma_lex (&x);
if (token == CPP_OPEN_PAREN)
{
token = pragma_lex (&x);
}
- if (token == CPP_NAME)
- {
- bool call_pragma_parse_p = false;
- bool ok_p;
-
- name = IDENTIFIER_POINTER (x);
- if (strcmp (name, "reset") == 0)
- {
- current_option_pragma = NULL_TREE;
- call_pragma_parse_p = true;
- }
-
- else if (strcmp (name, "push") == 0)
- VEC_safe_push (tree, gc, option_stack,
- copy_list (current_option_pragma));
-
- else if (strcmp (name, "pop") == 0)
- {
- int len = VEC_length (tree, option_stack);
- if (len == 0)
- {
- GCC_BAD ("%<#pragma GCC option pop%> without a %<#pragma GCC "
- "option push%>");
- return;
- }
- else
- {
- VEC_truncate (tree, option_stack, len-1);
- current_option_pragma = ((len > 1)
- ? VEC_last (tree, option_stack)
- : NULL_TREE);
-
- call_pragma_parse_p = true;
- }
- }
-
- else
- {
- GCC_BAD ("%<#pragma GCC option%> is not a string or "
- "push/pop/reset");
- return;
- }
-
- token = pragma_lex (&x);
- if (close_paren_needed_p)
- {
- if (token == CPP_CLOSE_PAREN)
- token = pragma_lex (&x);
- else
- GCC_BAD ("%<#pragma GCC option ([push|pop|reset])%> does not "
- "have a final %<)%>.");
- }
-
- if (token != CPP_EOF)
- {
- GCC_BAD ("%<#pragma GCC option [push|pop|reset]%> is badly "
- "formed");
- return;
- }
-
- /* See if we need to call the pragma_parse hook. This must occur at the
- end after processing all of the tokens, or we may get spurious errors
- when we define or undef macros. */
- ok_p = targetm.target_option.pragma_parse (current_option_pragma);
- gcc_assert (ok_p);
- }
-
- else if (token != CPP_STRING)
+ if (token != CPP_STRING)
{
- GCC_BAD ("%<#pragma GCC option%> is not a string or push/pop/reset");
+ GCC_BAD ("%<#pragma GCC option%> is not a string");
return;
}
if (token == CPP_CLOSE_PAREN)
token = pragma_lex (&x);
else
- GCC_BAD ("%<#pragma GCC option (string [,string]...)%> does "
+ GCC_BAD ("%<#pragma GCC target (string [,string]...)%> does "
"not have a final %<)%>.");
}
if (token != CPP_EOF)
{
- error ("#pragma GCC option string... is badly formed");
+ error ("#pragma GCC target string... is badly formed");
return;
}
/* put arguments in the order the user typed them. */
args = nreverse (args);
- if (targetm.target_option.pragma_parse (args))
- current_option_pragma = args;
+ if (targetm.target_option.pragma_parse (args, NULL_TREE))
+ current_target_pragma = args;
}
}
-/* Stack of the #pragma GCC optimize options created with #pragma GCC optimize
- push. */
-static GTY(()) VEC(tree,gc) *optimize_stack;
-
/* Handle #pragma GCC optimize to set optimization options. */
static void
-handle_pragma_optimize(cpp_reader *ARG_UNUSED(dummy))
+handle_pragma_optimize (cpp_reader *ARG_UNUSED(dummy))
{
enum cpp_ttype token;
- const char *name;
tree x;
bool close_paren_needed_p = false;
tree optimization_previous_node = optimization_current_node;
token = pragma_lex (&x);
}
- if (token == CPP_NAME)
+ if (token != CPP_STRING && token != CPP_NUMBER)
{
- bool call_opt_p = false;
-
- name = IDENTIFIER_POINTER (x);
- if (strcmp (name, "reset") == 0)
- {
- struct cl_optimization *def
- = TREE_OPTIMIZATION (optimization_default_node);
- current_optimize_pragma = NULL_TREE;
- optimization_current_node = optimization_default_node;
- cl_optimization_restore (def);
- call_opt_p = true;
- }
-
- else if (strcmp (name, "push") == 0)
- VEC_safe_push (tree, gc, optimize_stack, current_optimize_pragma);
-
- else if (strcmp (name, "pop") == 0)
- {
- int len = VEC_length (tree, optimize_stack);
- if (len == 0)
- {
- GCC_BAD ("%<#pragma GCC optimize pop%> without a %<#pragma "
- "GCC optimize push%>");
- return;
- }
- else
- {
- VEC_truncate (tree, optimize_stack, len-1);
- current_optimize_pragma
- = ((len > 1)
- ? VEC_last (tree, optimize_stack)
- : NULL_TREE);
-
- call_opt_p = true;
- if (current_optimize_pragma)
- {
- bool ok_p
- = parse_optimize_options (current_optimize_pragma, false);
- gcc_assert (ok_p); /* should be parsed previously. */
- optimization_current_node = build_optimization_node ();
- }
- else
- {
- struct cl_optimization *opt
- = TREE_OPTIMIZATION (optimization_default_node);
- optimization_current_node = optimization_default_node;
- cl_optimization_restore (opt);
- }
- }
- }
-
- else
- {
- GCC_BAD ("%<#pragma GCC optimize%> is not a string or "
- "push/pop/reset");
- return;
- }
-
- token = pragma_lex (&x);
- if (close_paren_needed_p)
- {
- if (token == CPP_CLOSE_PAREN)
- token = pragma_lex (&x);
- else
- GCC_BAD ("%<#pragma GCC optimize ([push|pop|reset])%> does not "
- "have a final %<)%>.");
- }
-
- if (token != CPP_EOF)
- {
- GCC_BAD ("%<#pragma GCC optimize [push|pop|reset]%> is badly "
- "formed");
- return;
- }
-
- if (call_opt_p &&
- (optimization_previous_node != optimization_current_node))
- c_cpp_builtins_optimize_pragma (parse_in,
- optimization_previous_node,
- optimization_current_node);
-
- }
-
- else if (token != CPP_STRING && token != CPP_NUMBER)
- {
- GCC_BAD ("%<#pragma GCC optimize%> is not a string, number, or "
- "push/pop/reset");
+ GCC_BAD ("%<#pragma GCC optimize%> is not a string or number");
return;
}
args = nreverse (args);
parse_optimize_options (args, false);
+ current_optimize_pragma = chainon (current_optimize_pragma, args);
optimization_current_node = build_optimization_node ();
c_cpp_builtins_optimize_pragma (parse_in,
optimization_previous_node,
}
}
+/* Stack of the #pragma GCC options created with #pragma GCC push_option. Save
+ both the binary representation of the options and the TREE_LIST of
+ strings that will be added to the function's attribute list. */
+typedef struct GTY(()) opt_stack {
+ struct opt_stack *prev;
+ tree target_binary;
+ tree target_strings;
+ tree optimize_binary;
+ tree optimize_strings;
+} opt_stack;
+
+static GTY(()) struct opt_stack * options_stack;
+
+/* Handle #pragma GCC push_options to save the current target and optimization
+ options. */
+
+static void
+handle_pragma_push_options (cpp_reader *ARG_UNUSED(dummy))
+{
+ enum cpp_ttype token;
+ tree x = 0;
+ opt_stack *p;
+
+ token = pragma_lex (&x);
+ if (token != CPP_EOF)
+ {
+ warning (OPT_Wpragmas, "junk at end of %<#pragma push_options%>");
+ return;
+ }
+
+ p = GGC_NEW (opt_stack);
+ p->prev = options_stack;
+ options_stack = p;
+
+ /* Save optimization and target flags in binary format. */
+ p->optimize_binary = build_optimization_node ();
+ p->target_binary = build_target_option_node ();
+
+ /* Save optimization and target flags in string list format. */
+ p->optimize_strings = copy_list (current_optimize_pragma);
+ p->target_strings = copy_list (current_target_pragma);
+}
+
+/* Handle #pragma GCC pop_options to restore the current target and
+ optimization options from a previous push_options. */
+
+static void
+handle_pragma_pop_options (cpp_reader *ARG_UNUSED(dummy))
+{
+ enum cpp_ttype token;
+ tree x = 0;
+ opt_stack *p;
+
+ token = pragma_lex (&x);
+ if (token != CPP_EOF)
+ {
+ warning (OPT_Wpragmas, "junk at end of %<#pragma pop_options%>");
+ return;
+ }
+
+ if (! options_stack)
+ {
+ warning (OPT_Wpragmas,
+ "%<#pragma GCC pop_options%> without a corresponding "
+ "%<#pragma GCC push_options%>");
+ return;
+ }
+
+ p = options_stack;
+ options_stack = p->prev;
+
+ if (p->target_binary != target_option_current_node)
+ {
+ (void) targetm.target_option.pragma_parse (NULL_TREE, p->target_binary);
+ target_option_current_node = p->target_binary;
+ }
+
+ if (p->optimize_binary != optimization_current_node)
+ {
+ tree old_optimize = optimization_current_node;
+ cl_optimization_restore (TREE_OPTIMIZATION (p->optimize_binary));
+ c_cpp_builtins_optimize_pragma (parse_in, old_optimize,
+ p->optimize_binary);
+ optimization_current_node = p->optimize_binary;
+ }
+
+ current_target_pragma = p->target_strings;
+ current_optimize_pragma = p->optimize_strings;
+}
+
+/* Handle #pragma GCC reset_options to restore the current target and
+ optimization options to the original options used on the command line. */
+
+static void
+handle_pragma_reset_options (cpp_reader *ARG_UNUSED(dummy))
+{
+ enum cpp_ttype token;
+ tree x = 0;
+ tree new_optimize = optimization_default_node;
+ tree new_target = target_option_default_node;
+
+ token = pragma_lex (&x);
+ if (token != CPP_EOF)
+ {
+ warning (OPT_Wpragmas, "junk at end of %<#pragma reset_options%>");
+ return;
+ }
+
+ if (new_target != target_option_current_node)
+ {
+ (void) targetm.target_option.pragma_parse (NULL_TREE, new_target);
+ target_option_current_node = new_target;
+ }
+
+ if (new_optimize != optimization_current_node)
+ {
+ tree old_optimize = optimization_current_node;
+ cl_optimization_restore (TREE_OPTIMIZATION (new_optimize));
+ c_cpp_builtins_optimize_pragma (parse_in, old_optimize, new_optimize);
+ optimization_current_node = new_optimize;
+ }
+
+ current_target_pragma = NULL_TREE;
+ current_optimize_pragma = NULL_TREE;
+}
+
/* Print a plain user-specified message. */
static void
inform (input_location, "#pragma message: %s", TREE_STRING_POINTER (message));
}
+/* Mark whether the current location is valid for a STDC pragma. */
+
+static bool valid_location_for_stdc_pragma;
+
+void
+mark_valid_location_for_stdc_pragma (bool flag)
+{
+ valid_location_for_stdc_pragma = flag;
+}
+
+/* Return true if the current location is valid for a STDC pragma. */
+
+bool
+valid_location_for_stdc_pragma_p (void)
+{
+ return valid_location_for_stdc_pragma;
+}
+
+enum pragma_switch_t { PRAGMA_ON, PRAGMA_OFF, PRAGMA_DEFAULT, PRAGMA_BAD };
+
+/* A STDC pragma must appear outside of external declarations or
+ preceding all explicit declarations and statements inside a compound
+ statement; its behavior is undefined if used in any other context.
+ It takes a switch of ON, OFF, or DEFAULT. */
+
+static enum pragma_switch_t
+handle_stdc_pragma (const char *pname)
+{
+ const char *arg;
+ tree t;
+ enum pragma_switch_t ret;
+
+ if (!valid_location_for_stdc_pragma_p ())
+ {
+ warning (OPT_Wpragmas, "invalid location for %<pragma %s%>, ignored",
+ pname);
+ return PRAGMA_BAD;
+ }
+
+ if (pragma_lex (&t) != CPP_NAME)
+ {
+ warning (OPT_Wpragmas, "malformed %<#pragma %s%>, ignored", pname);
+ return PRAGMA_BAD;
+ }
+
+ arg = IDENTIFIER_POINTER (t);
+
+ if (!strcmp (arg, "ON"))
+ ret = PRAGMA_ON;
+ else if (!strcmp (arg, "OFF"))
+ ret = PRAGMA_OFF;
+ else if (!strcmp (arg, "DEFAULT"))
+ ret = PRAGMA_DEFAULT;
+ else
+ {
+ warning (OPT_Wpragmas, "malformed %<#pragma %s%>, ignored", pname);
+ return PRAGMA_BAD;
+ }
+
+ if (pragma_lex (&t) != CPP_EOF)
+ {
+ warning (OPT_Wpragmas, "junk at end of %<#pragma %s%>", pname);
+ return PRAGMA_BAD;
+ }
+
+ return ret;
+}
+
+/* #pragma STDC FLOAT_CONST_DECIMAL64 ON
+ #pragma STDC FLOAT_CONST_DECIMAL64 OFF
+ #pragma STDC FLOAT_CONST_DECIMAL64 DEFAULT */
+
+static void
+handle_pragma_float_const_decimal64 (cpp_reader *ARG_UNUSED (dummy))
+{
+ if (c_dialect_cxx ())
+ {
+ if (warn_unknown_pragmas > in_system_header)
+ warning (OPT_Wunknown_pragmas,
+ "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported"
+ " for C++");
+ return;
+ }
+
+ if (!targetm.decimal_float_supported_p ())
+ {
+ if (warn_unknown_pragmas > in_system_header)
+ warning (OPT_Wunknown_pragmas,
+ "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported"
+ " on this target");
+ return;
+ }
+
+ pedwarn (input_location, OPT_pedantic,
+ "ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>");
+
+ switch (handle_stdc_pragma ("STDC FLOAT_CONST_DECIMAL64"))
+ {
+ case PRAGMA_ON:
+ set_float_const_decimal64 ();
+ break;
+ case PRAGMA_OFF:
+ case PRAGMA_DEFAULT:
+ clear_float_const_decimal64 ();
+ break;
+ case PRAGMA_BAD:
+ break;
+ }
+}
+
/* A vector of registered pragma callbacks. */
DEF_VEC_O (pragma_handler);
c_register_pragma (0, "pack", handle_pragma_pack);
#endif
#endif
-#ifdef HANDLE_PRAGMA_PUSH_POP_MACRO
- c_register_pragma (0 ,"push_macro", handle_pragma_push_macro);
- c_register_pragma (0 ,"pop_macro", handle_pragma_pop_macro);
-#endif
#ifdef HANDLE_PRAGMA_WEAK
c_register_pragma (0, "weak", handle_pragma_weak);
#endif
#endif
c_register_pragma ("GCC", "diagnostic", handle_pragma_diagnostic);
- c_register_pragma ("GCC", "option", handle_pragma_option);
+ c_register_pragma ("GCC", "target", handle_pragma_target);
c_register_pragma ("GCC", "optimize", handle_pragma_optimize);
+ c_register_pragma ("GCC", "push_options", handle_pragma_push_options);
+ c_register_pragma ("GCC", "pop_options", handle_pragma_pop_options);
+ c_register_pragma ("GCC", "reset_options", handle_pragma_reset_options);
+
+ c_register_pragma ("STDC", "FLOAT_CONST_DECIMAL64",
+ handle_pragma_float_const_decimal64);
c_register_pragma_with_expansion (0, "redefine_extname", handle_pragma_redefine_extname);
c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix);
#ifdef REGISTER_TARGET_PRAGMAS
REGISTER_TARGET_PRAGMAS ();
#endif
+
+ /* Allow plugins to register their own pragmas. */
+ invoke_plugin_callbacks (PLUGIN_PRAGMAS, NULL);
}
#include "gt-c-pragma.h"