/* Subroutines shared by all languages that are variants of C.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002 Free Software Foundation, Inc.
+ 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "intl.h"
#include "tree.h"
-#include "real.h"
#include "flags.h"
#include "toplev.h"
#include "output.h"
#include "c-pragma.h"
#include "rtl.h"
#include "ggc.h"
+#include "varray.h"
#include "expr.h"
#include "c-common.h"
#include "diagnostic.h"
#include "cpplib.h"
#include "target.h"
#include "langhooks.h"
-#include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
#include "tree-inline.h"
+#include "c-tree.h"
cpp_reader *parse_in; /* Declared in c-pragma.h. */
: "long long unsigned int"))
#endif
-#ifndef REGISTER_PREFIX
-#define REGISTER_PREFIX ""
-#endif
-
/* The variant of the C language being processed. */
enum c_language_kind c_language;
tree c99_function_name_decl_node;
Stack of nested function name VAR_DECLs.
-
+
tree saved_function_name_decls;
*/
tree c_global_trees[CTI_MAX];
+/* TRUE if a code represents a statement. The front end init
+ langhook should take care of initialization of this array. */
+
+bool statement_code_p[MAX_TREE_CODES];
+
+/* Nonzero if we can read a PCH file now. */
+
+int allow_pch = 1;
+\f
/* Switches common to the C front ends. */
/* Nonzero if prepreprocessing only. */
+
int flag_preprocess_only;
+/* Nonzero means don't output line number information. */
+
+char flag_no_line_commands;
+
+/* Nonzero causes -E output not to be done, but directives such as
+ #define that have side effects are still obeyed. */
+
+char flag_no_output;
+
+/* Nonzero means dump macros in some fashion. */
+
+char flag_dump_macros;
+
+/* Nonzero means pass #include lines through to the output. */
+
+char flag_dump_includes;
+
+/* The file name to which we should write a precompiled header, or
+ NULL if no header will be written in this compile. */
+
+const char *pch_file;
+
/* Nonzero if an ISO standard was selected. It rejects macros in the
user's namespace. */
int flag_iso;
int flag_const_strings;
-/* Nonzero means `$' can be in an identifier. */
-
-#ifndef DOLLARS_IN_IDENTIFIERS
-#define DOLLARS_IN_IDENTIFIERS 1
-#endif
-int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
-
/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
int flag_signed_bitfields = 1;
int warn_missing_braces;
/* Warn about comparison of signed and unsigned values.
- If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
+ If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
+ (in which case -Wextra gets to decide). */
-int warn_sign_compare;
+int warn_sign_compare = -1;
/* Nonzero means warn about usage of long long when `-pedantic'. */
int warn_conversion;
-/* Warn about #pragma directives that are not recognised. */
+/* Warn about #pragma directives that are not recognized. */
-int warn_unknown_pragmas; /* Tri state variable. */
+int warn_unknown_pragmas; /* Tri state variable. */
/* Warn about format/argument anomalies in calls to formatted I/O functions
(*printf, *scanf, strftime, strfmon, etc.). */
int warn_implicit_int;
/* Warn about NULL being passed to argument slots marked as requiring
- non-NULL. */
-
+ non-NULL. */
+
int warn_nonnull;
int warn_undeclared_selector;
-/* Warn if methods required by a protocol are not implemented in the
+/* Warn if methods required by a protocol are not implemented in the
class adopting it. When turned off, methods inherited to that
class are also considered implemented. */
int flag_enforce_eh_specs = 1;
+/* The version of the C++ ABI in use. The following values are
+ allowed:
+
+ 0: The version of the ABI believed most conformant with the
+ C++ ABI specification. This ABI may change as bugs are
+ discovered and fixed. Therefore, 0 will not necessarily
+ indicate the same ABI in different versions of G++.
+
+ 1: The version of the ABI first used in G++ 3.2.
+
+ Additional positive integers will be assigned as new versions of
+ the ABI become the default version of the ABI. */
+
+int flag_abi_version = 1;
+
/* Nonzero means warn about things that will change when compiling
with an ABI-compliant compiler. */
int warn_abi = 0;
+/* Nonzero means warn about invalid uses of offsetof. */
+
+int warn_invalid_offsetof = 1;
+
/* Nonzero means warn about implicit declarations. */
int warn_implicit = 1;
/* Nonzero means warn when all ctors or dtors are private, and the class
has no friends. */
-int warn_ctor_dtor_privacy = 1;
+int warn_ctor_dtor_privacy = 0;
-/* Non-zero means warn in function declared in derived class has the
+/* Nonzero means warn in function declared in derived class has the
same name as a virtual in the base class, but fails to match the
type signature of any virtual function in the base class. */
int warn_overloaded_virtual;
-/* Non-zero means warn when declaring a class that has a non virtual
+/* Nonzero means warn when declaring a class that has a non virtual
destructor, when it really ought to have a virtual one. */
int warn_nonvdtor;
-/* Non-zero means warn when the compiler will reorder code. */
+/* Nonzero means warn when the compiler will reorder code. */
int warn_reorder;
-/* Non-zero means warn when synthesis behavior differs from Cfront's. */
+/* Nonzero means warn when synthesis behavior differs from Cfront's. */
int warn_synth;
-/* Non-zero means warn when we convert a pointer to member function
+/* Nonzero means warn when we convert a pointer to member function
into a pointer to (void or function). */
int warn_pmf2ptr = 1;
type names and storage classes. It is indexed by a RID_... value. */
tree *ridpointers;
-tree (*make_fname_decl) PARAMS ((tree, int));
-
-/* If non-NULL, the address of a language-specific function that
- returns 1 for language-specific statement codes. */
-int (*lang_statement_code_p) PARAMS ((enum tree_code));
+tree (*make_fname_decl) (tree, int);
/* If non-NULL, the address of a language-specific function that takes
any action required right before expand_function_end is called. */
-void (*lang_expand_function_end) PARAMS ((void));
+void (*lang_expand_function_end) (void);
/* Nonzero means the expression being parsed will never be evaluated.
This is a count, since unevaluated expressions can nest. */
{NULL, 0, 0},
};
-static int constant_fits_type_p PARAMS ((tree, tree));
+static int constant_fits_type_p (tree, tree);
/* Keep a stack of if statements. We record the number of compound
statements seen up to the if keyword, as well as the line number
typedef struct
{
int compstmt_count;
- int line;
- const char *file;
+ location_t locus;
int needs_warning;
tree if_stmt;
} if_elt;
/* Stack pointer. */
static int if_stack_pointer = 0;
-static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
- int, bool *));
-static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
- tree, int,
- bool *));
-static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
- bool *));
-static tree vector_size_helper PARAMS ((tree, tree));
-
-static void check_function_nonnull PARAMS ((tree, tree));
-static void check_nonnull_arg PARAMS ((void *, tree,
- unsigned HOST_WIDE_INT));
-static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
-static bool get_nonnull_operand PARAMS ((tree,
- unsigned HOST_WIDE_INT *));
-void builtin_define_std PARAMS ((const char *));
-static void builtin_define_with_value PARAMS ((const char *, const char *,
- int));
-static void builtin_define_with_int_value PARAMS ((const char *,
- HOST_WIDE_INT));
-static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
- int, const char *,
- const char *));
-static void builtin_define_type_max PARAMS ((const char *, tree, int));
-static void cpp_define_data_format PARAMS ((cpp_reader *));
-static void builtin_define_type_precision PARAMS ((const char *, tree));
-static void builtin_define_float_constants PARAMS ((const char *,
- const char *, tree));
+static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
+static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
+static tree handle_common_attribute (tree *, tree, tree, int, bool *);
+static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
+static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
+static tree handle_always_inline_attribute (tree *, tree, tree, int,
+ bool *);
+static tree handle_used_attribute (tree *, tree, tree, int, bool *);
+static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
+static tree handle_const_attribute (tree *, tree, tree, int, bool *);
+static tree handle_transparent_union_attribute (tree *, tree, tree,
+ int, bool *);
+static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
+static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
+static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
+static tree handle_section_attribute (tree *, tree, tree, int, bool *);
+static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
+static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
+static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
+static tree handle_visibility_attribute (tree *, tree, tree, int,
+ bool *);
+static tree handle_tls_model_attribute (tree *, tree, tree, int,
+ bool *);
+static tree handle_no_instrument_function_attribute (tree *, tree,
+ tree, int, bool *);
+static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
+static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
+ bool *);
+static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
+static tree handle_deprecated_attribute (tree *, tree, tree, int,
+ bool *);
+static tree handle_vector_size_attribute (tree *, tree, tree, int,
+ bool *);
+static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
+static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
+static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
+static tree vector_size_helper (tree, tree);
+
+static void check_function_nonnull (tree, tree);
+static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
+static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
+static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
/* Table of machine-independent attributes common to all C-like languages. */
const struct attribute_spec c_common_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
{ "packed", 0, 0, false, false, false,
- handle_packed_attribute },
+ handle_packed_attribute },
{ "nocommon", 0, 0, true, false, false,
handle_nocommon_attribute },
{ "common", 0, 0, true, false, false,
handle_vector_size_attribute },
{ "visibility", 1, 1, true, false, false,
handle_visibility_attribute },
+ { "tls_model", 1, 1, true, false, false,
+ handle_tls_model_attribute },
{ "nonnull", 0, -1, false, true, true,
handle_nonnull_attribute },
{ "nothrow", 0, 0, true, false, false,
handle_nothrow_attribute },
{ "may_alias", 0, 0, false, true, false, NULL },
+ { "cleanup", 1, 1, true, false, false,
+ handle_cleanup_attribute },
{ NULL, 0, 0, false, false, false, NULL }
};
/* Give the specifications for the format attributes, used by C and all
- descendents. */
+ descendants. */
const struct attribute_spec c_common_format_attribute_table[] =
{
condition to keep line number information accurate. */
void
-c_expand_start_cond (cond, compstmt_count, if_stmt)
- tree cond;
- int compstmt_count;
- tree if_stmt;
+c_expand_start_cond (tree cond, int compstmt_count, tree if_stmt)
{
/* Make sure there is enough space on the stack. */
if (if_stack_space == 0)
/* Record this if statement. */
if_stack[if_stack_pointer].compstmt_count = compstmt_count;
- if_stack[if_stack_pointer].file = input_filename;
- if_stack[if_stack_pointer].line = lineno;
+ if_stack[if_stack_pointer].locus = input_location;
if_stack[if_stack_pointer].needs_warning = 0;
if_stack[if_stack_pointer].if_stmt = if_stmt;
if_stack_pointer++;
/* Called after the then-clause for an if-statement is processed. */
void
-c_finish_then ()
+c_finish_then (void)
{
tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
if statement had an ambiguous else clause. */
void
-c_expand_end_cond ()
+c_expand_end_cond (void)
{
if_stack_pointer--;
if (if_stack[if_stack_pointer].needs_warning)
- warning_with_file_and_line (if_stack[if_stack_pointer].file,
- if_stack[if_stack_pointer].line,
- "suggest explicit braces to avoid ambiguous `else'");
+ warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
+ &if_stack[if_stack_pointer].locus);
last_expr_type = NULL_TREE;
}
of an if-then-else. */
void
-c_expand_start_else ()
+c_expand_start_else (void)
{
/* An ambiguous else warning must be generated for the enclosing if
statement, unless we see an else branch for that one, too. */
/* Called after the else-clause for an if-statement is processed. */
void
-c_finish_else ()
+c_finish_else (void)
{
tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
beyond what is strictly necessary for correctness. */
tree
-c_begin_if_stmt ()
+c_begin_if_stmt (void)
{
tree r;
r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
beyond what is strictly necessary for correctness. */
tree
-c_begin_while_stmt ()
+c_begin_while_stmt (void)
{
tree r;
r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
}
void
-c_finish_while_stmt_cond (cond, while_stmt)
- tree while_stmt;
- tree cond;
+c_finish_while_stmt_cond (tree cond, tree while_stmt)
{
WHILE_COND (while_stmt) = cond;
}
/* Push current bindings for the function name VAR_DECLS. */
void
-start_fname_decls ()
+start_fname_decls (void)
{
unsigned ix;
tree saved = NULL_TREE;
-
+
for (ix = 0; fname_vars[ix].decl; ix++)
{
tree decl = *fname_vars[ix].decl;
involved. Pop the previous bindings. */
void
-finish_fname_decls ()
+finish_fname_decls (void)
{
unsigned ix;
tree body = NULL_TREE;
for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
body = chainon (TREE_VALUE (stack), body);
-
+
if (body)
{
- /* They were called into existence, so add to statement tree. */
- body = chainon (body,
- TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
- body = build_stmt (COMPOUND_STMT, body);
-
- COMPOUND_STMT_NO_SCOPE (body) = 1;
- TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
+ /* They were called into existence, so add to statement tree. Add
+ the DECL_STMTs inside the outermost scope. */
+ tree *p = &DECL_SAVED_TREE (current_function_decl);
+ /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
+ while (TREE_CODE (*p) != COMPOUND_STMT)
+ p = &TREE_CHAIN (*p);
+ p = &COMPOUND_BODY (*p);
+ if (TREE_CODE (*p) == SCOPE_STMT)
+ p = &TREE_CHAIN (*p);
+
+ body = chainon (body, *p);
+ *p = body;
}
-
+
for (ix = 0; fname_vars[ix].decl; ix++)
*fname_vars[ix].decl = NULL_TREE;
-
+
if (stack)
{
/* We had saved values, restore them. */
{
tree decl = TREE_PURPOSE (saved);
unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
-
+
*fname_vars[ix].decl = decl;
}
stack = TREE_CHAIN (stack);
saved_function_name_decls = stack;
}
-/* Return the text name of the current function, suitable prettified
+/* Return the text name of the current function, suitably prettified
by PRETTY_P. */
const char *
-fname_as_string (pretty_p)
- int pretty_p;
+fname_as_string (int pretty_p)
{
const char *name = NULL;
-
+
if (pretty_p)
name = (current_function_decl
? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
required by the supplied RID value. */
const char *
-fname_string (rid)
- unsigned rid;
+fname_string (unsigned int rid)
{
unsigned ix;
-
+
for (ix = 0; fname_vars[ix].decl; ix++)
if (fname_vars[ix].rid == rid)
break;
this language independent code. */
tree
-fname_decl (rid, id)
- unsigned rid;
- tree id;
+fname_decl (unsigned int rid, tree id)
{
unsigned ix;
tree decl = NULL_TREE;
beginning of the function and this line number will be wrong.
To avoid this problem set the lineno to 0 here; that prevents
it from appearing in the RTL. */
- int saved_lineno = lineno;
- lineno = 0;
-
+ int saved_lineno = input_line;
+ input_line = 0;
+
decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
if (last_tree != saved_last_tree)
{
saved_function_name_decls);
}
*fname_vars[ix].decl = decl;
- lineno = saved_lineno;
+ input_line = saved_lineno;
}
if (!ix && !current_function_decl)
pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
-
+
return decl;
}
/* Given a STRING_CST, give it a suitable array-of-chars data type. */
tree
-fix_string_type (value)
- tree value;
+fix_string_type (tree value)
{
const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
STRING_CST. */
tree
-combine_strings (strings)
- varray_type strings;
+combine_strings (varray_type strings)
{
const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
const int nstrings = VARRAY_ACTIVE_SIZE (strings);
{
length += (TREE_STRING_LENGTH (t) - 1);
if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
- warning ("concatenation of string literals with __FUNCTION__ is deprecated");
+ warning ("concatenation of string literals with __FUNCTION__ is deprecated");
}
}
return value;
}
\f
-static int is_valid_printf_arglist PARAMS ((tree));
-static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
-static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
- enum expand_modifier, int, int));
-static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
- enum expand_modifier, int, int));
+static int is_valid_printf_arglist (tree);
+static rtx c_expand_builtin (tree, rtx, enum machine_mode,
+ enum expand_modifier);
+static rtx c_expand_builtin_printf (tree, rtx, enum machine_mode,
+ enum expand_modifier, int, int);
+static rtx c_expand_builtin_fprintf (tree, rtx, enum machine_mode,
+ enum expand_modifier, int, int);
\f
/* Print a warning if a constant expression had overflow in folding.
Invoke this function on every expression that the language
constant expression to overflow. */
void
-constant_expression_warning (value)
- tree value;
+constant_expression_warning (tree value)
{
if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
|| TREE_CODE (value) == VECTOR_CST
however, do not invoke this function on operands of explicit casts. */
void
-overflow_warning (value)
- tree value;
+overflow_warning (tree value)
{
if ((TREE_CODE (value) == INTEGER_CST
|| (TREE_CODE (value) == COMPLEX_CST
converted to an unsigned type. */
void
-unsigned_conversion_warning (result, operand)
- tree result, operand;
+unsigned_conversion_warning (tree result, tree operand)
{
tree type = TREE_TYPE (result);
for type TYPE (an INTEGER_TYPE). */
static int
-constant_fits_type_p (c, type)
- tree c, type;
+constant_fits_type_p (tree c, tree type)
{
if (TREE_CODE (c) == INTEGER_CST)
return int_fits_type_p (c, type);
c = convert (type, c);
return !TREE_OVERFLOW (c);
-}
+}
/* Convert EXPR to TYPE, warning about conversion problems with constants.
Invoke this function on every expression that is converted implicitly,
i.e. because of language rules and not because of an explicit cast. */
tree
-convert_and_check (type, expr)
- tree type, expr;
+convert_and_check (tree type, tree expr)
{
tree t = convert (type, expr);
if (TREE_CODE (t) == INTEGER_CST)
cache the results. */
static struct tlist_cache *save_expr_cache;
-static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
-static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
-static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
-static int warning_candidate_p PARAMS ((tree));
-static void warn_for_collisions PARAMS ((struct tlist *));
-static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
-static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
-static void verify_sequence_points PARAMS ((tree));
+static void add_tlist (struct tlist **, struct tlist *, tree, int);
+static void merge_tlist (struct tlist **, struct tlist *, int);
+static void verify_tree (tree, struct tlist **, struct tlist **, tree);
+static int warning_candidate_p (tree);
+static void warn_for_collisions (struct tlist *);
+static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
+static struct tlist *new_tlist (struct tlist *, tree, tree);
+static void verify_sequence_points (tree);
/* Create a new struct tlist and fill in its fields. */
static struct tlist *
-new_tlist (next, t, writer)
- struct tlist *next;
- tree t;
- tree writer;
+new_tlist (struct tlist *next, tree t, tree writer)
{
struct tlist *l;
l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
is nonnull, we ignore any node we find which has a writer equal to it. */
static void
-add_tlist (to, add, exclude_writer, copy)
- struct tlist **to;
- struct tlist *add;
- tree exclude_writer;
- int copy;
+add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
{
while (add)
{
write. */
static void
-merge_tlist (to, add, copy)
- struct tlist **to;
- struct tlist *add;
- int copy;
+merge_tlist (struct tlist **to, struct tlist *add, int copy)
{
struct tlist **end = to;
is nonzero. */
static void
-warn_for_collisions_1 (written, writer, list, only_writes)
- tree written, writer;
- struct tlist *list;
- int only_writes;
+warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
+ int only_writes)
{
struct tlist *tmp;
can cause conflicts due to missing sequence points. */
static void
-warn_for_collisions (list)
- struct tlist *list;
+warn_for_collisions (struct tlist *list)
{
struct tlist *tmp;
-
+
for (tmp = list; tmp; tmp = tmp->next)
{
if (tmp->writer)
/* Return nonzero if X is a tree that can be verified by the sequence point
warnings. */
static int
-warning_candidate_p (x)
- tree x;
+warning_candidate_p (tree x)
{
return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
}
way, so that no more than one access to B is recorded. */
static void
-verify_tree (x, pbefore_sp, pno_sp, writer)
- tree x;
- struct tlist **pbefore_sp, **pno_sp;
- tree writer;
+verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
+ tree writer)
{
struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
enum tree_code code;
}
}
-/* Try to warn for undefined behaviour in EXPR due to missing sequence
+/* Try to warn for undefined behavior in EXPR due to missing sequence
points. */
static void
-verify_sequence_points (expr)
- tree expr;
+verify_sequence_points (tree expr)
{
struct tlist *before_sp = 0, *after_sp = 0;
}
tree
-c_expand_expr_stmt (expr)
- tree expr;
+c_expand_expr_stmt (tree expr)
{
/* Do default conversion if safe and possibly important,
in case within ({...}). */
&& TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
error ("expression statement has incomplete type");
- last_expr_type = TREE_TYPE (expr);
+ last_expr_type = TREE_TYPE (expr);
return add_stmt (build_stmt (EXPR_STMT, expr));
}
\f
/* Validate the expression after `case' and apply default promotions. */
tree
-check_case_value (value)
- tree value;
+check_case_value (tree value)
{
if (value == NULL_TREE)
return value;
that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
tree
-c_common_type_for_size (bits, unsignedp)
- unsigned bits;
- int unsignedp;
+c_common_type_for_size (unsigned int bits, int unsignedp)
{
if (bits == TYPE_PRECISION (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
then UNSIGNEDP selects between signed and unsigned types. */
tree
-c_common_type_for_mode (mode, unsignedp)
- enum machine_mode mode;
- int unsignedp;
+c_common_type_for_mode (enum machine_mode mode, int unsignedp)
{
if (mode == TYPE_MODE (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
case V2SImode:
return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
+ case V2HImode:
+ return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
case V4HImode:
return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
case V8QImode:
return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
+ case V1DImode:
+ return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
case V16SFmode:
return V16SF_type_node;
case V4SFmode:
/* Return an unsigned type the same as TYPE in other respects. */
tree
-c_common_unsigned_type (type)
- tree type;
+c_common_unsigned_type (tree type)
{
tree type1 = TYPE_MAIN_VARIANT (type);
if (type1 == signed_char_type_node || type1 == char_type_node)
/* Return a signed type the same as TYPE in other respects. */
tree
-c_common_signed_type (type)
- tree type;
+c_common_signed_type (tree type)
{
tree type1 = TYPE_MAIN_VARIANT (type);
if (type1 == unsigned_char_type_node || type1 == char_type_node)
signed according to UNSIGNEDP. */
tree
-c_common_signed_or_unsigned_type (unsignedp, type)
- int unsignedp;
- tree type;
+c_common_signed_or_unsigned_type (int unsignedp, tree type)
{
if (! INTEGRAL_TYPE_P (type)
|| TREE_UNSIGNED (type) == unsignedp)
signed or unsigned type, UNSIGNEDP says which. */
unsigned int
-min_precision (value, unsignedp)
- tree value;
- int unsignedp;
+min_precision (tree value, int unsignedp)
{
int log;
c_common_truthvalue_conversion). */
void
-binary_op_error (code)
- enum tree_code code;
+binary_op_error (enum tree_code code)
{
const char *opname;
that value. */
tree
-shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
- tree *op0_ptr, *op1_ptr;
- tree *restype_ptr;
- enum tree_code *rescode_ptr;
+shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
+ enum tree_code *rescode_ptr)
{
tree type;
tree op0 = *op0_ptr;
of pointer PTROP and integer INTOP. */
tree
-pointer_int_sum (resultcode, ptrop, intop)
- enum tree_code resultcode;
- tree ptrop, intop;
+pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
{
tree size_exp;
if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
|| TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
- intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
+ intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
TREE_UNSIGNED (sizetype)), intop);
/* Replace the integer argument with a suitable product by the object size.
The resulting type should always be `boolean_type_node'. */
tree
-c_common_truthvalue_conversion (expr)
- tree expr;
+c_common_truthvalue_conversion (tree expr)
{
if (TREE_CODE (expr) == ERROR_MARK)
return expr;
case ABS_EXPR:
case FLOAT_EXPR:
case FFS_EXPR:
- /* These don't change whether an object is non-zero or zero. */
+ case POPCOUNT_EXPR:
+ /* These don't change whether an object is nonzero or zero. */
return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
case LROTATE_EXPR:
case RROTATE_EXPR:
- /* These don't change whether an object is zero or non-zero, but
+ /* These don't change whether an object is zero or nonzero, but
we can't ignore them if their second arg has side-effects. */
if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
}
\f
-static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
- int, enum built_in_class, int, int,
- tree));
+static tree builtin_function_2 (const char *, const char *, tree, tree,
+ int, enum built_in_class, int, int,
+ tree);
/* Make a variant type in the proper way for C/C++, propagating qualifiers
down to the element type of an array. */
tree
-c_build_qualified_type (type, type_quals)
- tree type;
- int type_quals;
+c_build_qualified_type (tree type, int type_quals)
{
/* A restrict-qualified pointer type must be a pointer to object or
incomplete type. Note that the use of POINTER_TYPE_P also allows
/* Apply the TYPE_QUALS to the new DECL. */
void
-c_apply_type_quals_to_decl (type_quals, decl)
- int type_quals;
- tree decl;
+c_apply_type_quals_to_decl (int type_quals, tree decl)
{
if ((type_quals & TYPE_QUAL_CONST)
- || (TREE_TYPE (decl)
+ || (TREE_TYPE (decl)
&& TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
TREE_READONLY (decl) = 1;
if (type_quals & TYPE_QUAL_VOLATILE)
or a type. Return -1 if we don't do anything special. */
HOST_WIDE_INT
-c_common_get_alias_set (t)
- tree t;
+c_common_get_alias_set (tree t)
{
tree u;
-
+
/* Permit type-punning when accessing a union, provided the access
is directly through the union. For example, this code does not
permit taking the address of a union member and then storing
if (! TYPE_P (t))
return -1;
- /* The C standard guarantess that any object may be accessed via an
+ /* The C standard guarantees that any object may be accessed via an
lvalue that has character type. */
if (t == char_type_node
|| t == signed_char_type_node
flag controls whether we should diagnose possibly ill-formed
constructs or not. */
tree
-c_sizeof_or_alignof_type (type, op, complain)
- tree type;
- enum tree_code op;
- int complain;
+c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
{
const char *op_name;
tree value = NULL;
enum tree_code type_code = TREE_CODE (type);
-
+
my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
-
+
if (type_code == FUNCTION_TYPE)
{
if (op == SIZEOF_EXPR)
}
else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
{
- if (type_code == VOID_TYPE
+ if (type_code == VOID_TYPE
&& complain && (pedantic || warn_pointer_arith))
pedwarn ("invalid application of `%s' to a void type", op_name);
value = size_one_node;
TYPE_IS_SIZETYPE means that certain things (like overflow) will
never happen. However, this node should really have type
`size_t', which is just a typedef for an ordinary integer type. */
- value = fold (build1 (NOP_EXPR, c_size_type_node, value));
+ value = fold (build1 (NOP_EXPR, size_type_node, value));
my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
-
+
return value;
}
"aligned" __attribute__ specification). */
tree
-c_alignof_expr (expr)
- tree expr;
+c_alignof_expr (tree expr)
{
tree t;
if (TREE_CODE (expr) == VAR_DECL)
t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
-
+
else if (TREE_CODE (expr) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
{
else if (TREE_CODE (expr) == COMPONENT_REF
&& TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
-
+
else if (TREE_CODE (expr) == INDIRECT_REF)
{
tree t = TREE_OPERAND (expr, 0);
tree best = t;
int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
-
+
while (TREE_CODE (t) == NOP_EXPR
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
{
else
return c_alignof (TREE_TYPE (expr));
- return fold (build1 (NOP_EXPR, c_size_type_node, t));
+ return fold (build1 (NOP_EXPR, size_type_node, t));
}
\f
/* Handle C and C++ default attributes. */
static bool c_attrs_initialized = false;
-static void c_init_attributes PARAMS ((void));
+static void c_init_attributes (void);
/* Build tree nodes and builtin functions common to both C and C++ language
frontends. */
void
-c_common_nodes_and_builtins ()
+c_common_nodes_and_builtins (void)
{
- enum builtin_type
+ enum builtin_type
{
#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
+#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
#include "builtin-types.def"
#undef DEF_PRIMITIVE_TYPE
#undef DEF_FUNCTION_TYPE_VAR_0
#undef DEF_FUNCTION_TYPE_VAR_1
#undef DEF_FUNCTION_TYPE_VAR_2
+#undef DEF_FUNCTION_TYPE_VAR_3
#undef DEF_POINTER_TYPE
BT_LAST
};
/* `unsigned long' is the standard type for sizeof.
Note that stddef.h uses `unsigned long',
and this must agree, even if long and int are the same size. */
- c_size_type_node =
+ size_type_node =
TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
- signed_size_type_node = c_common_signed_type (c_size_type_node);
- set_sizetype (c_size_type_node);
+ signed_size_type_node = c_common_signed_type (size_type_node);
+ set_sizetype (size_type_node);
build_common_tree_nodes_2 (flag_short_double);
= build_pointer_type (build_qualified_type
(char_type_node, TYPE_QUAL_CONST));
- (*targetm.init_builtins) ();
-
/* This is special for C++ so functions can be overloaded. */
wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
va_list_arg_type_node = va_list_type_node;
va_list_ref_type_node = build_reference_type (va_list_type_node);
}
-
+
#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
builtin_types[(int) ENUM] = VALUE;
#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
void_list_node));
#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
builtin_types[(int) ENUM] \
- = build_function_type \
+ = build_function_type \
(builtin_types[(int) RETURN], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG1], \
builtin_types[(int) ARG1], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG2], \
- tree_cons \
+ tree_cons \
(NULL_TREE, \
- builtin_types[(int) ARG3], \
+ builtin_types[(int) ARG3], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG4], \
void_list_node)))));
= build_function_type (builtin_types[(int) RETURN], NULL_TREE);
#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
builtin_types[(int) ENUM] \
- = build_function_type (builtin_types[(int) RETURN], \
+ = build_function_type (builtin_types[(int) RETURN], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG1], \
NULL_TREE));
#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
builtin_types[(int) ENUM] \
- = build_function_type \
+ = build_function_type \
(builtin_types[(int) RETURN], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG1], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG2], \
NULL_TREE)));
+
+#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
+ builtin_types[(int) ENUM] \
+ = build_function_type \
+ (builtin_types[(int) RETURN], \
+ tree_cons (NULL_TREE, \
+ builtin_types[(int) ARG1], \
+ tree_cons (NULL_TREE, \
+ builtin_types[(int) ARG2], \
+ tree_cons (NULL_TREE, \
+ builtin_types[(int) ARG3], \
+ NULL_TREE))));
+
#define DEF_POINTER_TYPE(ENUM, TYPE) \
builtin_types[(int) ENUM] \
= build_pointer_type (builtin_types[(int) TYPE]);
#undef DEF_FUNCTION_TYPE_4
#undef DEF_FUNCTION_TYPE_VAR_0
#undef DEF_FUNCTION_TYPE_VAR_1
+#undef DEF_FUNCTION_TYPE_VAR_2
+#undef DEF_FUNCTION_TYPE_VAR_3
#undef DEF_POINTER_TYPE
if (!c_attrs_initialized)
c_init_attributes ();
#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
- BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
+ BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
if (NAME) \
{ \
tree decl; \
built_in_attributes[(int) ATTRS]); \
\
built_in_decls[(int) ENUM] = decl; \
- }
+ if (IMPLICIT) \
+ implicit_built_in_decls[(int) ENUM] = decl; \
+ }
#include "builtins.def"
#undef DEF_BUILTIN
+ (*targetm.init_builtins) ();
+
main_identifier_node = get_identifier ("main");
}
tree
-build_va_arg (expr, type)
- tree expr, type;
+build_va_arg (tree expr, tree type)
{
return build1 (VA_ARG_EXPR, type, expr);
}
} disabled_builtin;
static disabled_builtin *disabled_builtins = NULL;
-static bool builtin_function_disabled_p PARAMS ((const char *));
+static bool builtin_function_disabled_p (const char *);
/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
begins with "__builtin_", give an error. */
void
-disable_builtin_function (name)
- const char *name;
+disable_builtin_function (const char *name)
{
if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
error ("cannot disable built-in function `%s'", name);
otherwise. */
static bool
-builtin_function_disabled_p (name)
- const char *name;
+builtin_function_disabled_p (const char *name)
{
disabled_builtin *p;
for (p = disabled_builtins; p != NULL; p = p->next)
or if NONANSI_P and flag_no_nonansi_builtin. */
static tree
-builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
- class, library_name_p, nonansi_p, attrs)
- const char *builtin_name;
- const char *name;
- tree builtin_type;
- tree type;
- int function_code;
- enum built_in_class class;
- int library_name_p;
- int nonansi_p;
- tree attrs;
+builtin_function_2 (const char *builtin_name, const char *name,
+ tree builtin_type, tree type, int function_code,
+ enum built_in_class class, int library_name_p,
+ int nonansi_p, tree attrs)
{
tree bdecl = NULL_TREE;
tree decl = NULL_TREE;
+
if (builtin_name != 0)
- {
- bdecl = builtin_function (builtin_name, builtin_type, function_code,
- class, library_name_p ? name : NULL,
- attrs);
- }
+ bdecl = builtin_function (builtin_name, builtin_type, function_code,
+ class, library_name_p ? name : NULL, attrs);
+
if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
&& !(nonansi_p && flag_no_nonansi_builtin))
- {
- decl = builtin_function (name, type, function_code, class, NULL,
- attrs);
- if (nonansi_p)
- DECL_BUILT_IN_NONANSI (decl) = 1;
- }
+ decl = builtin_function (name, type, function_code, class, NULL, attrs);
+
return (bdecl != 0 ? bdecl : decl);
}
\f
integral promotions defined in ISO C99 6.3.1.1/2. */
bool
-c_promoting_integer_type_p (t)
- tree t;
+c_promoting_integer_type_p (tree t)
{
switch (TREE_CODE (t))
{
and none of their types is affected by default promotions. */
int
-self_promoting_args_p (parms)
- tree parms;
+self_promoting_args_p (tree parms)
{
tree t;
for (t = parms; t; t = TREE_CHAIN (t))
element type is found. */
tree
-strip_array_types (type)
- tree type;
+strip_array_types (tree type)
{
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
return type;
}
-static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
- enum tree_code));
+static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
/* Expand a call to an unordered comparison function such as
__builtin_isgreater(). FUNCTION is the function's declaration and
rest. */
static tree
-expand_unordered_cmp (function, params, unordered_code, ordered_code)
- tree function, params;
- enum tree_code unordered_code, ordered_code;
+expand_unordered_cmp (tree function, tree params,
+ enum tree_code unordered_code,
+ enum tree_code ordered_code)
{
tree arg0, arg1, type;
enum tree_code code0, code1;
where the similar functionality exists in the other front ends. */
tree
-expand_tree_builtin (function, params, coerced_params)
- tree function, params, coerced_params;
+expand_tree_builtin (tree function, tree params, tree coerced_params)
{
if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
return NULL_TREE;
return NULL_TREE;
}
-/* Returns non-zero if CODE is the code for a statement. */
-
-int
-statement_code_p (code)
- enum tree_code code;
-{
- switch (code)
- {
- case CLEANUP_STMT:
- case EXPR_STMT:
- case COMPOUND_STMT:
- case DECL_STMT:
- case IF_STMT:
- case FOR_STMT:
- case WHILE_STMT:
- case DO_STMT:
- case RETURN_STMT:
- case BREAK_STMT:
- case CONTINUE_STMT:
- case SCOPE_STMT:
- case SWITCH_STMT:
- case GOTO_STMT:
- case LABEL_STMT:
- case ASM_STMT:
- case FILE_STMT:
- case CASE_LABEL:
- return 1;
-
- default:
- if (lang_statement_code_p)
- return (*lang_statement_code_p) (code);
- return 0;
- }
-}
-
/* Walk the statement tree, rooted at *tp. Apply FUNC to all the
sub-trees of *TP in a pre-order traversal. FUNC is called with the
DATA and the address of each sub-tree. If FUNC returns a non-NULL
We don't need a without_duplicates variant of this one because the
statement tree is a tree, not a graph. */
-tree
-walk_stmt_tree (tp, func, data)
- tree *tp;
- walk_tree_fn func;
- void *data;
+tree
+walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
{
enum tree_code code;
int walk_subtrees;
return NULL_TREE;
/* Skip subtrees below non-statement nodes. */
- if (!statement_code_p (TREE_CODE (*tp)))
+ if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
return NULL_TREE;
/* Call the function. */
/* FUNC may have modified the tree, recheck that we're looking at a
statement node. */
code = TREE_CODE (*tp);
- if (!statement_code_p (code))
+ if (!STATEMENT_CODE_P (code))
return NULL_TREE;
/* Visit the subtrees unless FUNC decided that there was nothing
K2, and 0 if K1 and K2 are equal. */
int
-case_compare (k1, k2)
- splay_tree_key k1;
- splay_tree_key k2;
+case_compare (splay_tree_key k1, splay_tree_key k2)
{
/* Consider a NULL key (such as arises with a `default' label) to be
smaller than anything else. */
ERROR_MARK_NODE if no CASE_LABEL is created. */
tree
-c_add_case_label (cases, cond, low_value, high_value)
- splay_tree cases;
- tree cond;
- tree low_value;
- tree high_value;
+c_add_case_label (splay_tree cases, tree cond, tree low_value,
+ tree high_value)
{
tree type;
tree label;
return error_mark_node;
}
- if ((low_value && TREE_TYPE (low_value)
- && POINTER_TYPE_P (TREE_TYPE (low_value)))
+ if ((low_value && TREE_TYPE (low_value)
+ && POINTER_TYPE_P (TREE_TYPE (low_value)))
|| (high_value && TREE_TYPE (high_value)
&& POINTER_TYPE_P (TREE_TYPE (high_value))))
error ("pointers are not permitted as case values");
the HIGH_VALUE to simplify later processing. */
if (tree_int_cst_equal (low_value, high_value))
high_value = NULL_TREE;
- if (low_value && high_value
- && !tree_int_cst_lt (low_value, high_value))
+ if (low_value && high_value
+ && !tree_int_cst_lt (low_value, high_value))
warning ("empty range specified");
/* Look up the LOW_VALUE in the table of case labels we already
range is bigger than the low end of the current range, so we
are only interested if the current range is a real range, and
not an ordinary case label. */
- else if (high_bound
+ else if (high_bound
&& high_value
&& (tree_int_cst_compare ((tree) high_bound->key,
high_value)
if (high_value)
{
error ("duplicate (or overlapping) case value");
- error_with_decl (duplicate,
+ error_with_decl (duplicate,
"this is the first entry overlapping that value");
}
else if (low_value)
/* Add a CASE_LABEL to the statement-tree. */
case_label = add_stmt (build_case_label (low_value, high_value, label));
/* Register this case label in the splay tree. */
- splay_tree_insert (cases,
+ splay_tree_insert (cases,
(splay_tree_key) low_value,
(splay_tree_value) case_label);
return case_label;
}
-/* Finish an expression taking the address of LABEL. Returns an
- expression for the address. */
+/* Finish an expression taking the address of LABEL (an
+ IDENTIFIER_NODE). Returns an expression for the address. */
-tree
-finish_label_address_expr (label)
- tree label;
+tree
+finish_label_address_expr (tree label)
{
tree result;
pedwarn ("ISO C forbids taking the address of a label");
}
+ if (label == error_mark_node)
+ return error_mark_node;
+
label = lookup_label (label);
if (label == NULL_TREE)
result = null_pointer_node;
/* Hook used by expand_expr to expand language-specific tree codes. */
rtx
-c_expand_expr (exp, target, tmode, modifier)
- tree exp;
- rtx target;
- enum machine_mode tmode;
- int modifier; /* Actually enum_modifier. */
+c_expand_expr (tree exp, rtx target, enum machine_mode tmode, int modifier)
+ /* Actually enum_modifier. */
{
switch (TREE_CODE (exp))
{
return result;
}
break;
-
+
case CALL_EXPR:
{
if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
/* Hook used by safe_from_p to handle language-specific tree codes. */
int
-c_safe_from_p (target, exp)
- rtx target;
- tree exp;
+c_safe_from_p (rtx target, tree exp)
{
/* We can see statements here when processing the body of a
statement-expression. For a declaration statement declaring a
variable, look at the variable's initializer. */
- if (TREE_CODE (exp) == DECL_STMT)
+ if (TREE_CODE (exp) == DECL_STMT)
{
tree decl = DECL_STMT_DECL (exp);
}
/* For any statement, we must follow the statement-chain. */
- if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
+ if (STATEMENT_CODE_P (TREE_CODE (exp)) && TREE_CHAIN (exp))
return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
/* Assume everything else is safe. */
/* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
int
-c_common_unsafe_for_reeval (exp)
- tree exp;
+c_common_unsafe_for_reeval (tree exp)
{
/* Statement expressions may not be reevaluated, likewise compound
literals. */
/* Hook used by staticp to handle language-specific tree codes. */
int
-c_staticp (exp)
- tree exp;
+c_staticp (tree exp)
{
if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
&& TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
(!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
static rtx
-c_expand_builtin (exp, target, tmode, modifier)
- tree exp;
- rtx target;
- enum machine_mode tmode;
- enum expand_modifier modifier;
+c_expand_builtin (tree exp, rtx target, enum machine_mode tmode,
+ enum expand_modifier modifier)
{
tree type = TREE_TYPE (exp);
tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
at the format specifier, with the remaining arguments immediately
following it. */
static int
-is_valid_printf_arglist (arglist)
- tree arglist;
+is_valid_printf_arglist (tree arglist)
{
/* Save this value so we can restore it later. */
const int SAVE_pedantic = pedantic;
/* If the arguments passed to printf are suitable for optimizations,
we attempt to transform the call. */
static rtx
-c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
- tree arglist;
- rtx target;
- enum machine_mode tmode;
- enum expand_modifier modifier;
- int ignore;
- int unlocked;
+c_expand_builtin_printf (tree arglist, rtx target, enum machine_mode tmode,
+ enum expand_modifier modifier, int ignore,
+ int unlocked)
{
tree fn_putchar = unlocked ?
- built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
+ implicit_built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTCHAR];
tree fn_puts = unlocked ?
- built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
+ implicit_built_in_decls[BUILT_IN_PUTS_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTS];
tree fn, format_arg, stripped_string;
/* If the return value is used, or the replacement _DECL isn't
if (arglist == 0
|| (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
return 0;
-
+
/* Check the specifier vs. the parameters. */
if (!is_valid_printf_arglist (arglist))
return 0;
-
+
format_arg = TREE_VALUE (arglist);
stripped_string = format_arg;
STRIP_NOPS (stripped_string);
/* If the format specifier isn't a STRING_CST, punt. */
if (TREE_CODE (stripped_string) != STRING_CST)
return 0;
-
+
/* OK! We can attempt optimization. */
/* If the format specifier was "%s\n", call __builtin_puts(arg2). */
/* We can't handle anything else with % args or %% ... yet. */
if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
return 0;
-
+
/* If the resulting constant string has a length of 1, call
putchar. Note, TREE_STRING_LENGTH includes the terminating
NULL in its count. */
function. */
arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
arglist = build_tree_list (NULL_TREE, arglist);
-
+
fn = fn_putchar;
}
/* If the resulting constant was "string\n", call
char *newstr = (char *) alloca (newlen);
memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
newstr[newlen - 1] = 0;
-
+
arglist = fix_string_type (build_string (newlen, newstr));
arglist = build_tree_list (NULL_TREE, arglist);
fn = fn_puts;
need stdout and don't have a way to get it ... yet. */
return 0;
}
-
+
return expand_expr (build_function_call (fn, arglist),
(ignore ? const0_rtx : target),
tmode, modifier);
/* If the arguments passed to fprintf are suitable for optimizations,
we attempt to transform the call. */
static rtx
-c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
- tree arglist;
- rtx target;
- enum machine_mode tmode;
- enum expand_modifier modifier;
- int ignore;
- int unlocked;
+c_expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode tmode,
+ enum expand_modifier modifier, int ignore,
+ int unlocked)
{
tree fn_fputc = unlocked ?
- built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
+ implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTC];
tree fn_fputs = unlocked ?
- built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
+ implicit_built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTS];
tree fn, format_arg, stripped_string;
/* If the return value is used, or the replacement _DECL isn't
|| (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
POINTER_TYPE))
return 0;
-
+
/* Check the specifier vs. the parameters. */
if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
return 0;
-
+
format_arg = TREE_VALUE (TREE_CHAIN (arglist));
stripped_string = format_arg;
STRIP_NOPS (stripped_string);
/* If the format specifier isn't a STRING_CST, punt. */
if (TREE_CODE (stripped_string) != STRING_CST)
return 0;
-
+
/* OK! We can attempt optimization. */
/* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
/* We can't handle anything else with % args or %% ... yet. */
if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
return 0;
-
+
/* When "string" doesn't contain %, replace all cases of
fprintf(stream,string) with fputs(string,stream). The fputs
builtin will take take of special cases like length==1. */
build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
fn = fn_fputs;
}
-
+
return expand_expr (build_function_call (fn, arglist),
(ignore ? const0_rtx : target),
tmode, modifier);
or decrement (as indicated by CODE) of ARG. The front end must check for
invalid cases (e.g., decrement in C++). */
tree
-boolean_increment (code, arg)
- enum tree_code code;
- tree arg;
+boolean_increment (enum tree_code code, tree arg)
{
tree val;
tree true_res = (c_language == clk_cplusplus
return val;
}
\f
-/* Define macros necessary to describe fundamental data type formats. */
-static void
-cpp_define_data_format (pfile)
- cpp_reader *pfile;
-{
- const char *format;
-
- /* Define endianness enumeration values. */
- cpp_define (pfile, "__GCC_LITTLE_ENDIAN__=0");
- cpp_define (pfile, "__GCC_BIG_ENDIAN__=1");
-
- /* Define supported floating-point format enumeration values. */
- cpp_define (pfile, "__UNKNOWN_FORMAT__=0");
- cpp_define (pfile, "__IEEE_FORMAT__=1");
- cpp_define (pfile, "__IBM_FORMAT__=2");
- cpp_define (pfile, "__C4X_FORMAT__=3");
- cpp_define (pfile, "__VAX_FORMAT__=4");
-
- /* Define target endianness:
- - bit order
- - byte order
- - word order in an integer that spans a multi-word
- - word order in a floating-poing that spans a multi-word */
- if (BITS_BIG_ENDIAN)
- cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
- else
- cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
- if (BYTES_BIG_ENDIAN)
- cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_BIG_ENDIAN__");
- else
- cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_LITTLE_ENDIAN__");
- /* Define words order in a multi-word integer. */
- if (WORDS_BIG_ENDIAN)
- cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
- else
- cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
- /* Define words order in a multi-word floating point. */
- if (FLOAT_WORDS_BIG_ENDIAN)
- cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
- else
- cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
-
- switch (TARGET_FLOAT_FORMAT)
- {
- case UNKNOWN_FLOAT_FORMAT:
- format = "__UNKNOWN_FORMAT__";
- break;
-
- case IEEE_FLOAT_FORMAT:
- format = "__IEEE_FORMAT__";
- break;
-
- case VAX_FLOAT_FORMAT:
- format = "__VAX_FORMAT__";
- cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=1");
-#ifdef TARGET_G_FLOAT
- if (TARGET_G_FLOAT)
- {
- cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
- cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=1");
- }
- else
- {
- cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=1");
- cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
- }
-#endif
- cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=1");
- break;
-
- case IBM_FLOAT_FORMAT:
- format = "__IBM_FORMAT__";
- break;
-
- case C4X_FLOAT_FORMAT:
- format = "__C4X_FORMAT__";
- break;
-
- default:
- abort();
- }
- if (TARGET_FLOAT_FORMAT != VAX_FLOAT_FORMAT)
- {
- cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=0");
- cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
- cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
- cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=0");
- }
- builtin_define_with_value ("__GCC_FLOAT_FORMAT__", format, 0);
-}
-
-/* Define NAME with value TYPE precision. */
-static void
-builtin_define_type_precision (name, type)
- const char *name;
- tree type;
-{
- builtin_define_with_int_value (name, TYPE_PRECISION (type));
-}
-
-/* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
-static void
-builtin_define_float_constants (name_prefix, fp_suffix, type)
- const char *name_prefix;
- const char *fp_suffix;
- tree type;
-{
- /* Used to convert radix-based values to base 10 values in several cases.
-
- In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
- least 6 significant digits for correct results. Using the fraction
- formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
- intermediate; perhaps someone can find a better approximation, in the
- mean time, I suspect using doubles won't harm the bootstrap here. */
-
- const double log10_2 = .30102999566398119521;
- const double log10_16 = 1.20411998265592478085;
- const double log10_b
- = TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT ? log10_16 : log10_2;
-
- const int log2_b = TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT ? 4 : 1;
-
- char name[64], buf[128];
- int mant_dig, max_exp, min_exp;
- int dig, min_10_exp, max_10_exp;
- int decimal_dig;
-
- /* ??? This information should be shared with real.c. */
-
-#ifndef INTEL_EXTENDED_IEEE_FORMAT
-#define INTEL_EXTENDED_IEEE_FORMAT 0
-#endif
-#ifndef TARGET_G_FLOAT
-#define TARGET_G_FLOAT 0
-#endif
-
- switch (TARGET_FLOAT_FORMAT)
- {
- case IEEE_FLOAT_FORMAT:
- switch (TYPE_PRECISION (type))
- {
- case 32:
- /* ??? Handle MIPS r5900, which doesn't implement Inf or NaN,
- but rather reuses the largest exponent as a normal number. */
- mant_dig = 24;
- min_exp = -125;
- max_exp = 128;
- break;
- case 64:
- mant_dig = 53;
- min_exp = -1021;
- max_exp = 1024;
- break;
- case 128:
- if (!INTEL_EXTENDED_IEEE_FORMAT)
- {
- mant_dig = 113;
- min_exp = -16381;
- max_exp = 16384;
- break;
- }
- /* FALLTHRU */
- case 96:
- mant_dig = 64;
- max_exp = 16384;
- if (INTEL_EXTENDED_IEEE_FORMAT)
- min_exp = -16381;
- else
- /* ??? Otherwise assume m68k. */
- min_exp = -16382;
- break;
- default:
- abort ();
- }
- break;
-
- case VAX_FLOAT_FORMAT:
- switch (TYPE_PRECISION (type))
- {
- case 32: /* F_FLOAT */
- mant_dig = 24;
- min_exp = -127;
- max_exp = 127;
- break;
- case 64: /* G_FLOAT or D_FLOAT */
- if (TARGET_G_FLOAT)
- {
- mant_dig = 53;
- min_exp = -1023;
- max_exp = 1023;
- }
- else
- {
- mant_dig = 56;
- min_exp = -127;
- max_exp = 127;
- }
- break;
- case 128: /* H_FLOAT */
- mant_dig = 113;
- min_exp = -16383;
- max_exp = 16383;
- break;
- default:
- abort ();
- }
- break;
-
- case IBM_FLOAT_FORMAT:
- switch (TYPE_PRECISION (type))
- {
- case 32:
- mant_dig = 6;
- min_exp = -64;
- max_exp = 63;
- break;
- case 64:
- mant_dig = 14;
- min_exp = -64;
- max_exp = 63;
- break;
- default:
- abort ();
- }
- break;
-
- case C4X_FLOAT_FORMAT:
- switch (TYPE_PRECISION (type))
- {
- case 32:
- mant_dig = 24;
- min_exp = -126;
- max_exp = 128;
- break;
- case 64:
- mant_dig = 32;
- min_exp = -126;
- max_exp = 128;
- break;
- default:
- abort ();
- }
- break;
-
- default:
- abort ();
- }
-
- /* The number of radix digits, p, in the floating-point significand. */
- sprintf (name, "__%s_MANT_DIG__", name_prefix);
- builtin_define_with_int_value (name, mant_dig);
-
- /* The number of decimal digits, q, such that any floating-point number
- with q decimal digits can be rounded into a floating-point number with
- p radix b digits and back again without change to the q decimal digits,
-
- p log10 b if b is a power of 10
- floor((p - 1) log10 b) otherwise
- */
- dig = (mant_dig - 1) * log10_b;
- sprintf (name, "__%s_DIG__", name_prefix);
- builtin_define_with_int_value (name, dig);
-
- /* The minimum negative int x such that b**(x-1) is a normalised float. */
- sprintf (name, "__%s_MIN_EXP__", name_prefix);
- sprintf (buf, "(%d)", min_exp);
- builtin_define_with_value (name, buf, 0);
-
- /* The minimum negative int x such that 10**x is a normalized float,
-
- ceil (log10 (b ** (min_exp - 1)))
- = ceil (log10 (b) * (min_exp - 1))
-
- Recall that min_exp is negative, so the integer truncation calculates
- the ceiling, not the floor, in this case. */
- min_10_exp = (min_exp - 1) * log10_b;
- sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
- sprintf (buf, "(%d)", min_10_exp);
- builtin_define_with_value (name, buf, 0);
-
- /* The maximum int x such that b**(x-1) is a representable float. */
- sprintf (name, "__%s_MAX_EXP__", name_prefix);
- builtin_define_with_int_value (name, max_exp);
-
- /* The maximum int x such that 10**x is in the range of representable
- finite floating-point numbers,
-
- floor (log10((1 - b**-p) * b**max_exp))
- = floor (log10(1 - b**-p) + log10(b**max_exp))
- = floor (log10(1 - b**-p) + log10(b)*max_exp)
-
- The safest thing to do here is to just compute this number. But since
- we don't link cc1 with libm, we cannot. We could implement log10 here
- a series expansion, but that seems too much effort because:
-
- Note that the first term, for all extant p, is a number exceedingly close
- to zero, but slightly negative. Note that the second term is an integer
- scaling an irrational number, and that because of the floor we are only
- interested in its integral portion.
-
- In order for the first term to have any effect on the integral portion
- of the second term, the second term has to be exceedingly close to an
- integer itself (e.g. 123.000000000001 or something). Getting a result
- that close to an integer requires that the irrational multiplicand have
- a long series of zeros in its expansion, which doesn't occur in the
- first 20 digits or so of log10(b).
-
- Hand-waving aside, crunching all of the sets of constants above by hand
- does not yield a case for which the first term is significant, which
- in the end is all that matters. */
- max_10_exp = max_exp * log10_b;
- sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
- builtin_define_with_int_value (name, max_10_exp);
-
- /* The number of decimal digits, n, such that any floating-point number
- can be rounded to n decimal digits and back again without change to
- the value.
-
- p * log10(b) if b is a power of 10
- ceil(1 + p * log10(b)) otherwise
-
- The only macro we care about is this number for the widest supported
- floating type, but we want this value for rendering constants below. */
- {
- double d_decimal_dig = 1 + mant_dig * log10_b;
- decimal_dig = d_decimal_dig;
- if (decimal_dig < d_decimal_dig)
- decimal_dig++;
- }
- if (type == long_double_type_node)
- builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
-
- /* Since, for the supported formats, B is always a power of 2, we
- construct the following numbers directly as a hexadecimal
- constants. */
-
- /* The maximum representable finite floating-point number,
- (1 - b**-p) * b**max_exp */
- {
- int i, n;
- char *p;
-
- strcpy (buf, "0x0.");
- n = mant_dig * log2_b;
- for (i = 0, p = buf + 4; i + 3 < n; i += 4)
- *p++ = 'f';
- if (i < n)
- *p++ = "08ce"[n - i];
- sprintf (p, "p%d", max_exp * log2_b);
- }
- sprintf (name, "__%s_MAX__", name_prefix);
- builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
-
- /* The minimum normalized positive floating-point number,
- b**(min_exp-1). */
- sprintf (name, "__%s_MIN__", name_prefix);
- sprintf (buf, "0x1p%d", (min_exp - 1) * log2_b);
- builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
-
- /* The difference between 1 and the least value greater than 1 that is
- representable in the given floating point type, b**(1-p). */
- sprintf (name, "__%s_EPSILON__", name_prefix);
- sprintf (buf, "0x1p%d", (1 - mant_dig) * log2_b);
- builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
-}
-
-/* Hook that registers front end and target-specific built-ins. */
+/* Built-in macros for stddef.h, that require macros defined in this
+ file. */
void
-cb_register_builtins (pfile)
- cpp_reader *pfile;
+c_stddef_cpp_builtins(void)
{
- /* -undef turns off target-specific built-ins. */
- if (flag_undef)
- return;
-
- if (c_language == clk_cplusplus)
- {
- if (SUPPORTS_ONE_ONLY)
- cpp_define (pfile, "__GXX_WEAK__=1");
- else
- cpp_define (pfile, "__GXX_WEAK__=0");
- if (flag_exceptions)
- cpp_define (pfile, "__EXCEPTIONS");
- if (warn_deprecated)
- cpp_define (pfile, "__DEPRECATED");
- }
-
- /* represents the C++ ABI version, always defined so it can be used while
- preprocessing C and assembler. */
- cpp_define (pfile, "__GXX_ABI_VERSION=102");
-
- /* libgcc needs to know this. */
- if (USING_SJLJ_EXCEPTIONS)
- cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
-
- /* stddef.h needs to know these. */
builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
-
- /* limits.h needs to know these. */
- builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
- builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
- builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
- builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
- builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
-
- builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
- builtin_define_type_precision ("__WCHAR_BIT__", wchar_type_node);
- builtin_define_type_precision ("__SHRT_BIT__", short_integer_type_node);
- builtin_define_type_precision ("__INT_BIT__", integer_type_node);
- builtin_define_type_precision ("__LONG_BIT__", long_integer_type_node);
- builtin_define_type_precision ("__LONG_LONG_BIT__",
- long_long_integer_type_node);
- builtin_define_type_precision ("__FLOAT_BIT__", float_type_node);
- builtin_define_type_precision ("__DOUBLE_BIT__", double_type_node);
- builtin_define_type_precision ("__LONG_DOUBLE_BIT__", long_double_type_node);
-
- /* float.h needs to know these. */
-
- /* The radix of the exponent representation. */
- builtin_define_with_int_value ("__FLT_RADIX__",
- (TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT
- ? 16 : 2));
-
- builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
- TARGET_FLT_EVAL_METHOD);
-
- builtin_define_float_constants ("FLT", "F", float_type_node);
- builtin_define_float_constants ("DBL", "", double_type_node);
- builtin_define_float_constants ("LDBL", "L", long_double_type_node);
-
- /* For use in assembly language. */
- builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
- builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
-
- /* Misc. */
- builtin_define_with_value ("__VERSION__", version_string, 1);
-
- /* Other target-independent built-ins determined by command-line
- options. */
- if (optimize_size)
- cpp_define (pfile, "__OPTIMIZE_SIZE__");
- if (optimize)
- cpp_define (pfile, "__OPTIMIZE__");
-
- if (flag_hosted)
- cpp_define (pfile, "__STDC_HOSTED__=1");
- else
- cpp_define (pfile, "__STDC_HOSTED__=0");
-
- if (fast_math_flags_set_p ())
- cpp_define (pfile, "__FAST_MATH__");
- if (flag_no_inline)
- cpp_define (pfile, "__NO_INLINE__");
- if (flag_signaling_nans)
- cpp_define (pfile, "__SUPPORT_SNAN__");
- if (flag_finite_math_only)
- cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
- else
- cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
-
- if (flag_iso)
- cpp_define (pfile, "__STRICT_ANSI__");
-
- if (!flag_signed_char)
- cpp_define (pfile, "__CHAR_UNSIGNED__");
-
- if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
- cpp_define (pfile, "__WCHAR_UNSIGNED__");
-
- cpp_define_data_format (pfile);
-
- /* Make the choice of ObjC runtime visible to source code. */
- if (flag_objc && flag_next_runtime)
- cpp_define (pfile, "__NEXT_RUNTIME__");
-
- /* A straightforward target hook doesn't work, because of problems
- linking that hook's body when part of non-C front ends. */
-# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
-# define builtin_define(TXT) cpp_define (pfile, TXT)
-# define builtin_assert(TXT) cpp_assert (pfile, TXT)
- TARGET_CPU_CPP_BUILTINS ();
- TARGET_OS_CPP_BUILTINS ();
-}
-
-/* Pass an object-like macro. If it doesn't lie in the user's
- namespace, defines it unconditionally. Otherwise define a version
- with two leading underscores, and another version with two leading
- and trailing underscores, and define the original only if an ISO
- standard was not nominated.
-
- e.g. passing "unix" defines "__unix", "__unix__" and possibly
- "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
- "_mips". */
-void
-builtin_define_std (macro)
- const char *macro;
-{
- size_t len = strlen (macro);
- char *buff = alloca (len + 5);
- char *p = buff + 2;
- char *q = p + len;
-
- /* prepend __ (or maybe just _) if in user's namespace. */
- memcpy (p, macro, len + 1);
- if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
- {
- if (*p != '_')
- *--p = '_';
- if (p[1] != '_')
- *--p = '_';
- }
- cpp_define (parse_in, p);
-
- /* If it was in user's namespace... */
- if (p != buff + 2)
- {
- /* Define the macro with leading and following __. */
- if (q[-1] != '_')
- *q++ = '_';
- if (q[-2] != '_')
- *q++ = '_';
- *q = '\0';
- cpp_define (parse_in, p);
-
- /* Finally, define the original macro if permitted. */
- if (!flag_iso)
- cpp_define (parse_in, macro);
- }
-}
-
-/* Pass an object-like macro and a value to define it to. The third
- parameter says whether or not to turn the value into a string
- constant. */
-static void
-builtin_define_with_value (macro, expansion, is_str)
- const char *macro;
- const char *expansion;
- int is_str;
-{
- char *buf;
- size_t mlen = strlen (macro);
- size_t elen = strlen (expansion);
- size_t extra = 2; /* space for an = and a NUL */
-
- if (is_str)
- extra += 2; /* space for two quote marks */
-
- buf = alloca (mlen + elen + extra);
- if (is_str)
- sprintf (buf, "%s=\"%s\"", macro, expansion);
- else
- sprintf (buf, "%s=%s", macro, expansion);
-
- cpp_define (parse_in, buf);
}
-/* Pass an object-like macro and an integer value to define it to. */
static void
-builtin_define_with_int_value (macro, value)
- const char *macro;
- HOST_WIDE_INT value;
-{
- char *buf;
- size_t mlen = strlen (macro);
- size_t vlen = 18;
- size_t extra = 2; /* space for = and NUL. */
-
- buf = alloca (mlen + vlen + extra);
- memcpy (buf, macro, mlen);
- buf[mlen] = '=';
- sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
-
- cpp_define (parse_in, buf);
-}
-
-/* Pass an object-like macro a hexadecimal floating-point value. */
-static void
-builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
- const char *macro;
- tree type;
- int digits;
- const char *hex_str;
- const char *fp_suffix;
-{
- REAL_VALUE_TYPE real;
- char dec_str[64], buf[256];
-
- /* Hex values are really cool and convenient, except that they're
- not supported in strict ISO C90 mode. First, the "p-" sequence
- is not valid as part of a preprocessor number. Second, we get a
- pedwarn from the preprocessor, which has no context, so we can't
- suppress the warning with __extension__.
-
- So instead what we do is construct the number in hex (because
- it's easy to get the exact correct value), parse it as a real,
- then print it back out as decimal. */
-
- real = REAL_VALUE_HTOF (hex_str, TYPE_MODE (type));
- REAL_VALUE_TO_DECIMAL (real, dec_str, digits);
-
- sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
- cpp_define (parse_in, buf);
-}
-
-/* Define MAX for TYPE based on the precision of the type, which is assumed
- to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
-
-static void
-builtin_define_type_max (macro, type, is_long)
- const char *macro;
- tree type;
- int is_long;
-{
- const char *value;
- char *buf;
- size_t mlen, vlen, extra;
-
- /* Pre-rendering the values mean we don't have to futz with printing a
- multi-word decimal value. There are also a very limited number of
- precisions that we support, so it's really a waste of time. */
- switch (TYPE_PRECISION (type))
- {
- case 8:
- value = "127";
- break;
- case 16:
- value = "32767";
- break;
- case 32:
- value = "2147483647";
- break;
- case 64:
- value = "9223372036854775807";
- break;
- case 128:
- value = "170141183460469231731687303715884105727";
- break;
- default:
- abort ();
- }
-
- mlen = strlen (macro);
- vlen = strlen (value);
- extra = 2 + is_long;
- buf = alloca (mlen + vlen + extra);
-
- sprintf (buf, "%s=%s%s", macro, value,
- (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
-
- cpp_define (parse_in, buf);
-}
-
-static void
-c_init_attributes ()
+c_init_attributes (void)
{
/* Fill in the built_in_attributes array. */
#define DEF_ATTR_NULL_TREE(ENUM) \
/* Depending on the name of DECL, apply default attributes to it. */
void
-c_common_insert_default_attributes (decl)
- tree decl;
+c_common_insert_default_attributes (tree decl)
{
tree name = DECL_NAME (decl);
#undef DEF_FN_ATTR
}
-/* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
- additionally give the location of the previous declaration DECL. */
+/* Output a -Wshadow warning MSGCODE about NAME, and give the location
+ of the previous declaration DECL. */
void
-shadow_warning (msgid, name, decl)
- const char *msgid;
- tree name, decl;
+shadow_warning (enum sw_kind msgcode, const char *name, tree decl)
{
- warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
- warning_with_file_and_line (DECL_SOURCE_FILE (decl),
- DECL_SOURCE_LINE (decl),
- "shadowed declaration is here");
+ static const char *const msgs[] = {
+ /* SW_PARAM */ N_("declaration of \"%s\" shadows a parameter"),
+ /* SW_LOCAL */ N_("declaration of \"%s\" shadows a previous local"),
+ /* SW_GLOBAL */ N_("declaration of \"%s\" shadows a global declaration")
+ };
+
+ warning (msgs[msgcode], name);
+ warning ("%Hshadowed declaration is here", &DECL_SOURCE_LOCATION (decl));
}
/* Attribute handlers common to C front ends. */
struct attribute_spec.handler. */
static tree
-handle_packed_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags;
- bool *no_add_attrs;
+handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags, _Bool *no_add_attrs)
{
tree *type = NULL;
if (DECL_P (*node))
struct attribute_spec.handler. */
static tree
-handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_nocommon_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == VAR_DECL)
DECL_COMMON (*node) = 0;
struct attribute_spec.handler. */
static tree
-handle_common_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == VAR_DECL)
DECL_COMMON (*node) = 1;
struct attribute_spec.handler. */
static tree
-handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
tree type = TREE_TYPE (*node);
struct attribute_spec.handler. */
static tree
-handle_noinline_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_noinline_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_UNINLINABLE (*node) = 1;
struct attribute_spec.handler. */
static tree
-handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_always_inline_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
{
struct attribute_spec.handler. */
static tree
-handle_used_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
- if (TREE_CODE (*node) == FUNCTION_DECL)
- TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
- = TREE_USED (*node) = 1;
+ tree node = *pnode;
+
+ if (TREE_CODE (node) == FUNCTION_DECL
+ || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
+ TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (node))
+ = TREE_USED (node) = 1;
else
{
warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
struct attribute_spec.handler. */
static tree
-handle_unused_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags;
- bool *no_add_attrs;
+handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (DECL_P (*node))
{
struct attribute_spec.handler. */
static tree
-handle_const_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
tree type = TREE_TYPE (*node);
struct attribute_spec.handler. */
static tree
-handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags;
- bool *no_add_attrs;
+handle_transparent_union_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED, int flags,
+ _Bool *no_add_attrs)
{
tree decl = NULL_TREE;
tree *type = NULL;
struct attribute_spec.handler. */
static tree
-handle_constructor_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_constructor_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
tree decl = *node;
tree type = TREE_TYPE (decl);
struct attribute_spec.handler. */
static tree
-handle_destructor_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_destructor_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
tree decl = *node;
tree type = TREE_TYPE (decl);
struct attribute_spec.handler. */
static tree
-handle_mode_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
tree type = *node;
int len = strlen (p);
enum machine_mode mode = VOIDmode;
tree typefm;
+ tree ptr_type;
if (len > 4 && p[0] == '_' && p[1] == '_'
&& p[len - 1] == '_' && p[len - 2] == '_')
else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
(mode, TREE_UNSIGNED (type))))
error ("no data type for mode `%s'", p);
+ else if ((TREE_CODE (type) == POINTER_TYPE
+ || TREE_CODE (type) == REFERENCE_TYPE)
+ && !(*targetm.valid_pointer_mode) (mode))
+ error ("invalid pointer mode `%s'", p);
else
{
/* If this is a vector, make sure we either have hardware
support, or we can emulate it. */
- if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
- || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
- && !vector_mode_valid_p (mode))
+ if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
{
error ("unable to emulate '%s'", GET_MODE_NAME (mode));
return NULL_TREE;
}
+ if (TREE_CODE (type) == POINTER_TYPE)
+ {
+ ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
+ mode);
+ *node = ptr_type;
+ }
+ else if (TREE_CODE (type) == REFERENCE_TYPE)
+ {
+ ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
+ mode);
+ *node = ptr_type;
+ }
+ else
*node = typefm;
/* No need to layout the type here. The caller should do this. */
}
struct attribute_spec.handler. */
static tree
-handle_section_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name ATTRIBUTE_UNUSED;
- tree args;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
tree decl = *node;
struct attribute_spec.handler. */
static tree
-handle_aligned_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name ATTRIBUTE_UNUSED;
- tree args;
- int flags;
- bool *no_add_attrs;
+handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
+ int flags, _Bool *no_add_attrs)
{
tree decl = NULL_TREE;
tree *type = NULL;
struct attribute_spec.handler. */
static tree
-handle_weak_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name ATTRIBUTE_UNUSED;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs ATTRIBUTE_UNUSED;
+handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs ATTRIBUTE_UNUSED)
{
declare_weak (*node);
struct attribute_spec.handler. */
static tree
-handle_alias_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_alias_attribute (tree *node, tree name, tree args,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
tree decl = *node;
struct attribute_spec.handler. */
static tree
-handle_visibility_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_visibility_attribute (tree *node, tree name, tree args,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
tree decl = *node;
}
if (strcmp (TREE_STRING_POINTER (id), "hidden")
&& strcmp (TREE_STRING_POINTER (id), "protected")
- && strcmp (TREE_STRING_POINTER (id), "internal"))
+ && strcmp (TREE_STRING_POINTER (id), "internal")
+ && strcmp (TREE_STRING_POINTER (id), "default"))
{
- error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
+ error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+ }
+
+ return NULL_TREE;
+}
+
+/* Handle an "tls_model" attribute; arguments as in
+ struct attribute_spec.handler. */
+
+static tree
+handle_tls_model_attribute (tree *node, tree name, tree args,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
+{
+ tree decl = *node;
+
+ if (! DECL_THREAD_LOCAL (decl))
+ {
+ warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ *no_add_attrs = true;
+ }
+ else
+ {
+ tree id;
+
+ id = TREE_VALUE (args);
+ if (TREE_CODE (id) != STRING_CST)
+ {
+ error ("tls_model arg not a string");
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+ if (strcmp (TREE_STRING_POINTER (id), "local-exec")
+ && strcmp (TREE_STRING_POINTER (id), "initial-exec")
+ && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
+ && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
+ {
+ error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
*no_add_attrs = true;
return NULL_TREE;
}
struct attribute_spec.handler. */
static tree
-handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_no_instrument_function_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
tree decl = *node;
struct attribute_spec.handler. */
static tree
-handle_malloc_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_IS_MALLOC (*node) = 1;
struct attribute_spec.handler. */
static tree
-handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_no_limit_stack_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
tree decl = *node;
struct attribute_spec.handler. */
static tree
-handle_pure_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_IS_PURE (*node) = 1;
/* Handle a "deprecated" attribute; arguments as in
struct attribute_spec.handler. */
-
+
static tree
-handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags;
- bool *no_add_attrs;
+handle_deprecated_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED, int flags,
+ _Bool *no_add_attrs)
{
tree type = NULL_TREE;
int warn = 0;
const char *what = NULL;
-
+
if (DECL_P (*node))
{
tree decl = *node;
type = TREE_TYPE (decl);
-
+
if (TREE_CODE (decl) == TYPE_DECL
|| TREE_CODE (decl) == PARM_DECL
|| TREE_CODE (decl) == VAR_DECL
}
else
warn = 1;
-
+
if (warn)
{
*no_add_attrs = true;
warning ("`%s' attribute ignored for `%s'",
IDENTIFIER_POINTER (name), what);
else
- warning ("`%s' attribute ignored",
+ warning ("`%s' attribute ignored",
IDENTIFIER_POINTER (name));
}
The normal mechanism to prevent duplicates is to use type_hash_canon, but
since we want to distinguish types that are essentially identical (except
for their debug representation), we use a local list here. */
-static tree vector_type_node_list = 0;
+static GTY(()) tree vector_type_node_list = 0;
/* Handle a "vector_size" attribute; arguments as in
struct attribute_spec.handler. */
static tree
-handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_vector_size_attribute (tree *node, tree name, tree args,
+ int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
unsigned HOST_WIDE_INT vecsize, nunits;
enum machine_mode mode, orig_mode, new_mode;
new type which we will point to. */
static tree
-vector_size_helper (type, bottom)
- tree type, bottom;
+vector_size_helper (tree type, tree bottom)
{
tree inner, outer;
}
else
return bottom;
-
+
TREE_READONLY (outer) = TREE_READONLY (type);
TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
/* Handle the "nonnull" attribute. */
static tree
-handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name ATTRIBUTE_UNUSED;
- tree args;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
+ tree args, int flags ATTRIBUTE_UNUSED,
+ _Bool *no_add_attrs)
{
tree type = *node;
unsigned HOST_WIDE_INT attr_arg_num;
/* If no arguments are specified, all pointer arguments should be
- non-null. Veryify a full prototype is given so that the arguments
+ non-null. Verify a full prototype is given so that the arguments
will have the correct types when we actually check them later. */
if (! args)
{
that are marked as requiring a non-null pointer argument. */
static void
-check_function_nonnull (attrs, params)
- tree attrs;
- tree params;
+check_function_nonnull (tree attrs, tree params)
{
tree a, args, param;
int param_num;
param_num++, param = TREE_CHAIN (param))
{
if (! param)
- break;
+ break;
if (! args || nonnull_check_p (args, param_num))
- check_function_arguments_recurse (check_nonnull_arg, NULL,
- TREE_VALUE (param),
- param_num);
+ check_function_arguments_recurse (check_nonnull_arg, NULL,
+ TREE_VALUE (param),
+ param_num);
}
}
}
checked. */
static bool
-nonnull_check_p (args, param_num)
- tree args;
- unsigned HOST_WIDE_INT param_num;
+nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
{
unsigned HOST_WIDE_INT arg_num;
via check_function_arguments_recurse. */
static void
-check_nonnull_arg (ctx, param, param_num)
- void *ctx ATTRIBUTE_UNUSED;
- tree param;
- unsigned HOST_WIDE_INT param_num;
+check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
+ unsigned HOST_WIDE_INT param_num)
{
/* Just skip checking the argument if it's not a pointer. This can
happen if the "nonnull" attribute was given without an operand
from the attribute argument list. */
static bool
-get_nonnull_operand (arg_num_expr, valp)
- tree arg_num_expr;
- unsigned HOST_WIDE_INT *valp;
+get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
{
/* Strip any conversions from the arg number and verify they
are constants. */
struct attribute_spec.handler. */
static tree
-handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_NOTHROW (*node) = 1;
return NULL_TREE;
}
+
+/* Handle a "cleanup" attribute; arguments as in
+ struct attribute_spec.handler. */
+
+static tree
+handle_cleanup_attribute (tree *node, tree name, tree args,
+ int flags ATTRIBUTE_UNUSED, _Bool *no_add_attrs)
+{
+ tree decl = *node;
+ tree cleanup_id, cleanup_decl;
+
+ /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
+ for global destructors in C++. This requires infrastructure that
+ we don't have generically at the moment. It's also not a feature
+ we'd be missing too much, since we do have attribute constructor. */
+ if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
+ {
+ warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+
+ /* Verify that the argument is a function in scope. */
+ /* ??? We could support pointers to functions here as well, if
+ that was considered desirable. */
+ cleanup_id = TREE_VALUE (args);
+ if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
+ {
+ error ("cleanup arg not an identifier");
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+ cleanup_decl = lookup_name (cleanup_id);
+ if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
+ {
+ error ("cleanup arg not a function");
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+
+ /* That the function has proper type is checked with the
+ eventual call to build_function_call. */
+
+ return NULL_TREE;
+}
\f
/* Check for valid arguments being passed to a function. */
void
-check_function_arguments (attrs, params)
- tree attrs;
- tree params;
+check_function_arguments (tree attrs, tree params)
{
/* Check for null being passed in a pointer argument that must be
non-null. We also need to do this if format checking is enabled. */
be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
once the argument is resolved. CTX is context for the callback. */
void
-check_function_arguments_recurse (callback, ctx, param, param_num)
- void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
- void *ctx;
- tree param;
- unsigned HOST_WIDE_INT param_num;
+check_function_arguments_recurse (void (*callback)
+ (void *, tree, unsigned HOST_WIDE_INT),
+ void *ctx, tree param,
+ unsigned HOST_WIDE_INT param_num)
{
if (TREE_CODE (param) == NOP_EXPR)
{
OSDN Git Service
