#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "intl.h"
#include "tree.h"
#include "flags.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 "tm_p.h"
#include "obstack.h"
#include "cpplib.h"
#include "target.h"
#include "langhooks.h"
#include "tree-inline.h"
#include "c-tree.h"
#include "toplev.h"
#include "tree-iterator.h"
#include "hashtab.h"
#include "tree-mudflap.h"
#include "opts.h"
#include "real.h"
#include "options.h"
cpp_reader *parse_in;
#ifndef SIZE_TYPE
#define SIZE_TYPE "long unsigned int"
#endif
#ifndef PID_TYPE
#define PID_TYPE "int"
#endif
#ifndef WCHAR_TYPE
#define WCHAR_TYPE "int"
#endif
#define MODIFIED_WCHAR_TYPE \
(flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
#ifndef PTRDIFF_TYPE
#define PTRDIFF_TYPE "long int"
#endif
#ifndef WINT_TYPE
#define WINT_TYPE "unsigned int"
#endif
#ifndef INTMAX_TYPE
#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
? "int" \
: ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
? "long int" \
: "long long int"))
#endif
#ifndef UINTMAX_TYPE
#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
? "unsigned int" \
: ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
? "long unsigned int" \
: "long long unsigned int"))
#endif
tree c_global_trees[CTI_MAX];
bool statement_code_p[MAX_TREE_CODES];
int flag_preprocess_only;
char flag_no_line_commands;
char flag_no_output;
char flag_dump_macros;
char flag_dump_includes;
bool flag_pch_preprocess;
const char *pch_file;
int flag_iso;
int flag_undef;
int flag_no_builtin;
int flag_no_nonansi_builtin;
int flag_short_double;
int flag_short_wchar;
int flag_lvalue_cast_assign = 1;
int flag_ms_extensions;
int flag_no_asm;
int flag_iasm_blocks;
int flag_const_strings;
int flag_signed_bitfields = 1;
int warn_write_strings;
int warn_unknown_pragmas;
int warn_format;
int warn_strict_null_sentinel;
int flag_nil_receivers = 1;
int flag_objc_exceptions = 0;
int flag_objc_sjlj_exceptions = -1;
int flag_zero_link = 0;
int flag_replace_objc_classes = 0;
int flag_cond_mismatch;
int flag_isoc94;
int flag_isoc99;
int flag_hosted = 1;
int warn_main;
int disable_typechecking_for_spec_flag;
int flag_gen_declaration;
#ifdef NEXT_OBJC_RUNTIME
int flag_next_runtime = 1;
#else
int flag_next_runtime = 0;
#endif
int flag_objc_call_cxx_cdtors = 0;
int print_struct_values;
const char *constant_string_class_name;
int flag_no_gnu_keywords;
int flag_implement_inlines = 1;
int flag_implicit_templates = 1;
int flag_implicit_inline_templates = 1;
int flag_use_repository;
int flag_optional_diags = 1;
int flag_elide_constructors = 1;
int flag_default_inline = 1;
int flag_rtti = 1;
int flag_conserve_space;
int flag_access_control = 1;
int flag_check_new;
int flag_new_for_scope = 1;
int flag_weak = 1;
int flag_working_directory = -1;
int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
int flag_use_cxa_get_exception_ptr = 2;
int flag_permissive;
int flag_enforce_eh_specs = 1;
int flag_preprocessed = 0;
int flag_clone_structors = 0;
int flag_threadsafe_statics = 1;
int warn_implicit = 1;
int max_tinst_depth = 500;
tree *ridpointers;
tree (*make_fname_decl) (tree, int);
int skip_evaluation;
struct fname_var_t
{
tree *const decl;
const unsigned rid;
const int pretty;
};
const struct fname_var_t fname_vars[] =
{
{&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
{&function_name_decl_node, RID_FUNCTION_NAME, 0},
{&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
{NULL, 0, 0},
};
static int constant_fits_type_p (tree, tree);
static tree check_case_value (tree);
static bool check_case_bounds (tree, tree, tree *, tree *);
enum iasm_states iasm_state = iasm_none;
bool iasm_in_decl;
bool inside_iasm_block;
bool iasm_at_bol;
int iasm_in_operands;
const cpp_token *iasm_split_next;
static char *iasm_buffer;
static GTY(()) varray_type iasm_labels;
static GTY(()) varray_type iasm_labels_uniq;
static tree iasm_identifier (tree expr);
extern bool iasm_memory_clobber (const char *);
static tree iasm_get_label (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_nodebug_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_unavailable_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 handle_warn_unused_result_attribute (tree *, tree, tree, int,
bool *);
static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
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 *);
static int resort_field_decl_cmp (const void *, const void *);
const struct attribute_spec c_common_attribute_table[] =
{
{ "packed", 0, 0, false, false, false,
handle_packed_attribute },
{ "nocommon", 0, 0, true, false, false,
handle_nocommon_attribute },
{ "common", 0, 0, true, false, false,
handle_common_attribute },
{ "noreturn", 0, 0, true, false, false,
handle_noreturn_attribute },
{ "volatile", 0, 0, true, false, false,
handle_noreturn_attribute },
{ "noinline", 0, 0, true, false, false,
handle_noinline_attribute },
{ "always_inline", 0, 0, true, false, false,
handle_always_inline_attribute },
{ "nodebug", 0, 0, true, false, false,
handle_nodebug_attribute },
{ "used", 0, 0, true, false, false,
handle_used_attribute },
{ "unused", 0, 0, false, false, false,
handle_unused_attribute },
{ "const", 0, 0, true, false, false,
handle_const_attribute },
{ "transparent_union", 0, 0, false, false, false,
handle_transparent_union_attribute },
{ "constructor", 0, 0, true, false, false,
handle_constructor_attribute },
{ "destructor", 0, 0, true, false, false,
handle_destructor_attribute },
{ "mode", 1, 1, false, true, false,
handle_mode_attribute },
{ "section", 1, 1, true, false, false,
handle_section_attribute },
{ "aligned", 0, 1, false, false, false,
handle_aligned_attribute },
{ "weak", 0, 0, true, false, false,
handle_weak_attribute },
{ "alias", 1, 1, true, false, false,
handle_alias_attribute },
{ "no_instrument_function", 0, 0, true, false, false,
handle_no_instrument_function_attribute },
{ "malloc", 0, 0, true, false, false,
handle_malloc_attribute },
{ "no_stack_limit", 0, 0, true, false, false,
handle_no_limit_stack_attribute },
{ "pure", 0, 0, true, false, false,
handle_pure_attribute },
{ "deprecated", 0, 0, false, false, false,
handle_deprecated_attribute },
{ "unavailable", 0, 0, false, false, false,
handle_unavailable_attribute },
{ "vector_size", 1, 1, false, true, false,
handle_vector_size_attribute },
{ "visibility", 1, 1, false, 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 },
{ "warn_unused_result", 0, 0, false, true, true,
handle_warn_unused_result_attribute },
{ "sentinel", 0, 1, false, true, true,
handle_sentinel_attribute },
{ NULL, 0, 0, false, false, false, NULL }
};
const struct attribute_spec c_common_format_attribute_table[] =
{
{ "format", 3, 3, false, true, true,
handle_format_attribute },
{ "format_arg", 1, 1, false, true, true,
handle_format_arg_attribute },
{ NULL, 0, 0, false, false, false, NULL }
};
void
start_fname_decls (void)
{
unsigned ix;
tree saved = NULL_TREE;
for (ix = 0; fname_vars[ix].decl; ix++)
{
tree decl = *fname_vars[ix].decl;
if (decl)
{
saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
*fname_vars[ix].decl = NULL_TREE;
}
}
if (saved || saved_function_name_decls)
saved_function_name_decls = tree_cons (saved, NULL_TREE,
saved_function_name_decls);
}
void
finish_fname_decls (void)
{
unsigned ix;
tree stmts = NULL_TREE;
tree stack = saved_function_name_decls;
for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
append_to_statement_list (TREE_VALUE (stack), &stmts);
if (stmts)
{
tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
if (TREE_CODE (*bodyp) == BIND_EXPR)
bodyp = &BIND_EXPR_BODY (*bodyp);
append_to_statement_list (*bodyp, &stmts);
*bodyp = stmts;
}
for (ix = 0; fname_vars[ix].decl; ix++)
*fname_vars[ix].decl = NULL_TREE;
if (stack)
{
tree saved;
for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
{
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;
}
const char *
fname_as_string (int pretty_p)
{
const char *name = "top level";
char *namep;
int vrb = 2;
if (!pretty_p)
{
name = "";
vrb = 0;
}
if (current_function_decl)
name = lang_hooks.decl_printable_name (current_function_decl, vrb);
if (c_lex_string_translate)
{
int len = strlen (name) + 3;
cpp_string cstr = { 0, 0 }, strname;
namep = XNEWVEC (char, len);
snprintf (namep, len, "\"%s\"", name);
strname.text = (unsigned char *) namep;
strname.len = len - 1;
if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false, false))
{
XDELETEVEC (namep);
return (char *) cstr.text;
}
}
else
namep = xstrdup (name);
return namep;
}
int
c_expand_decl (tree decl)
{
if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
{
if (!anon_aggr_type_p (TREE_TYPE (decl)))
emit_local_var (decl);
else
expand_anon_union_decl (decl, NULL_TREE,
DECL_ANON_UNION_ELEMS (decl));
}
else
return 0;
return 1;
}
tree
fname_decl (unsigned int rid, tree id)
{
unsigned ix;
tree decl = NULL_TREE;
for (ix = 0; fname_vars[ix].decl; ix++)
if (fname_vars[ix].rid == rid)
break;
decl = *fname_vars[ix].decl;
if (!decl)
{
tree stmts;
location_t saved_location = input_location;
#ifdef USE_MAPPED_LOCATION
input_location = UNKNOWN_LOCATION;
#else
input_line = 0;
#endif
stmts = push_stmt_list ();
decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
stmts = pop_stmt_list (stmts);
if (!IS_EMPTY_STMT (stmts))
saved_function_name_decls
= tree_cons (decl, stmts, saved_function_name_decls);
*fname_vars[ix].decl = decl;
input_location = saved_location;
}
if (!ix && !current_function_decl)
pedwarn ("%qD is not defined outside of function scope", decl);
return decl;
}
tree
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;
const int pascal_flag = TREE_TYPE (value) == pascal_string_type_node;
const int nchars_max = flag_isoc99 ? 4095 : 509;
int length = TREE_STRING_LENGTH (value);
int nchars;
tree e_type, i_type, a_type;
nchars = wide_flag ? length / wchar_bytes : length;
if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
pedwarn ("string length %qd is greater than the length %qd ISO C%d compilers are required to support",
nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
e_type = wide_flag ? wchar_type_node : (pascal_flag ? unsigned_char_type_node : char_type_node);
i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
a_type = build_array_type (e_type, i_type);
if (flag_const_strings && ! flag_writable_strings)
a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
TREE_TYPE (value) = a_type;
TREE_CONSTANT (value) = !flag_writable_strings;
TREE_INVARIANT (value) = !flag_writable_strings;
TREE_READONLY (value) = !flag_writable_strings;
TREE_STATIC (value) = 1;
return value;
}
void
constant_expression_warning (tree value)
{
if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
|| TREE_CODE (value) == VECTOR_CST
|| TREE_CODE (value) == COMPLEX_CST)
&& TREE_CONSTANT_OVERFLOW (value) && pedantic)
pedwarn ("overflow in constant expression");
}
void
overflow_warning (tree value)
{
if ((TREE_CODE (value) == INTEGER_CST
|| (TREE_CODE (value) == COMPLEX_CST
&& TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
&& TREE_OVERFLOW (value))
{
TREE_OVERFLOW (value) = 0;
if (skip_evaluation == 0)
warning ("integer overflow in expression");
}
else if ((TREE_CODE (value) == REAL_CST
|| (TREE_CODE (value) == COMPLEX_CST
&& TREE_CODE (TREE_REALPART (value)) == REAL_CST))
&& TREE_OVERFLOW (value))
{
TREE_OVERFLOW (value) = 0;
if (skip_evaluation == 0)
warning ("floating point overflow in expression");
}
else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
{
TREE_OVERFLOW (value) = 0;
if (skip_evaluation == 0)
warning ("vector overflow in expression");
}
}
void
unsigned_conversion_warning (tree result, tree operand)
{
tree type = TREE_TYPE (result);
if (TREE_CODE (operand) == INTEGER_CST
&& TREE_CODE (type) == INTEGER_TYPE
&& TYPE_UNSIGNED (type)
&& skip_evaluation == 0
&& !int_fits_type_p (operand, type))
{
if (!int_fits_type_p (operand, c_common_signed_type (type)))
warning ("large integer implicitly truncated to unsigned type");
else if (warn_conversion)
warning ("negative integer implicitly converted to unsigned type");
}
}
static int
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);
}
int
vector_types_convertible_p (tree t1, tree t2)
{
return targetm.vector_opaque_p (t1)
|| targetm.vector_opaque_p (t2)
|| (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
&& (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE
|| TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
&& INTEGRAL_TYPE_P (TREE_TYPE (t1))
== INTEGRAL_TYPE_P (TREE_TYPE (t2)));
}
tree
convert_and_check (tree type, tree expr)
{
tree t = convert (type, expr);
if (warn_shorten_64_to_32
&& TYPE_PRECISION (TREE_TYPE (expr)) == 64
&& TYPE_PRECISION (type) == 32)
{
warning ("implicit conversion shortens 64-bit value into a 32-bit value");
}
if (TREE_CODE (t) == INTEGER_CST)
{
if (TREE_OVERFLOW (t))
{
TREE_OVERFLOW (t) = 0;
TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
&& TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
&& TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
if ((pedantic
|| TYPE_UNSIGNED (type)
|| !constant_fits_type_p (expr,
c_common_unsigned_type (type)))
&& skip_evaluation == 0)
warning ("overflow in implicit constant conversion");
}
else
unsigned_conversion_warning (t, expr);
}
return t;
}
struct tlist
{
struct tlist *next;
tree expr, writer;
};
struct tlist_cache
{
struct tlist_cache *next;
struct tlist *cache_before_sp;
struct tlist *cache_after_sp;
tree expr;
};
static struct obstack tlist_obstack;
static char *tlist_firstobj = 0;
static struct tlist *warned_ids;
static struct tlist_cache *save_expr_cache;
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 struct tlist *
new_tlist (struct tlist *next, tree t, tree writer)
{
struct tlist *l;
l = XOBNEW (&tlist_obstack, struct tlist);
l->next = next;
l->expr = t;
l->writer = writer;
return l;
}
static void
add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
{
while (add)
{
struct tlist *next = add->next;
if (!copy)
add->next = *to;
if (!exclude_writer || add->writer != exclude_writer)
*to = copy ? new_tlist (*to, add->expr, add->writer) : add;
add = next;
}
}
static void
merge_tlist (struct tlist **to, struct tlist *add, int copy)
{
struct tlist **end = to;
while (*end)
end = &(*end)->next;
while (add)
{
int found = 0;
struct tlist *tmp2;
struct tlist *next = add->next;
for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
if (tmp2->expr == add->expr)
{
found = 1;
if (!tmp2->writer)
tmp2->writer = add->writer;
}
if (!found)
{
*end = copy ? add : new_tlist (NULL, add->expr, add->writer);
end = &(*end)->next;
*end = 0;
}
add = next;
}
}
static void
warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
int only_writes)
{
struct tlist *tmp;
for (tmp = warned_ids; tmp; tmp = tmp->next)
if (tmp->expr == written)
return;
while (list)
{
if (list->expr == written
&& list->writer != writer
&& (!only_writes || list->writer)
&& DECL_NAME (list->expr))
{
warned_ids = new_tlist (warned_ids, written, NULL_TREE);
warning ("operation on %qs may be undefined",
IDENTIFIER_POINTER (DECL_NAME (list->expr)));
}
list = list->next;
}
}
static void
warn_for_collisions (struct tlist *list)
{
struct tlist *tmp;
for (tmp = list; tmp; tmp = tmp->next)
{
if (tmp->writer)
warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
}
}
static int
warning_candidate_p (tree x)
{
return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
}
static void
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;
enum tree_code_class cl;
if (x == NULL)
return;
restart:
code = TREE_CODE (x);
cl = TREE_CODE_CLASS (code);
if (warning_candidate_p (x))
{
*pno_sp = new_tlist (*pno_sp, x, writer);
return;
}
switch (code)
{
case CONSTRUCTOR:
return;
case COMPOUND_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
tmp_before = tmp_nosp = tmp_list3 = 0;
verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
warn_for_collisions (tmp_nosp);
merge_tlist (pbefore_sp, tmp_before, 0);
merge_tlist (pbefore_sp, tmp_nosp, 0);
verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
merge_tlist (pbefore_sp, tmp_list3, 0);
return;
case COND_EXPR:
tmp_before = tmp_list2 = 0;
verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
warn_for_collisions (tmp_list2);
merge_tlist (pbefore_sp, tmp_before, 0);
merge_tlist (pbefore_sp, tmp_list2, 1);
tmp_list3 = tmp_nosp = 0;
verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
warn_for_collisions (tmp_nosp);
merge_tlist (pbefore_sp, tmp_list3, 0);
tmp_list3 = tmp_list2 = 0;
verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
warn_for_collisions (tmp_list2);
merge_tlist (pbefore_sp, tmp_list3, 0);
merge_tlist (&tmp_nosp, tmp_list2, 0);
add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
return;
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
return;
case MODIFY_EXPR:
tmp_before = tmp_nosp = tmp_list3 = 0;
verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
add_tlist (&tmp_before, tmp_list3, x, 1);
warn_for_collisions (tmp_before);
add_tlist (pno_sp, tmp_list3, x, 0);
warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
merge_tlist (pbefore_sp, tmp_before, 0);
if (warning_candidate_p (TREE_OPERAND (x, 0)))
merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
return;
case CALL_EXPR:
tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
if (TREE_OPERAND (x, 1))
verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
merge_tlist (&tmp_list3, tmp_list2, 0);
add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
warn_for_collisions (tmp_before);
add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
return;
case TREE_LIST:
while (x)
{
tmp_before = tmp_nosp = 0;
verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
merge_tlist (&tmp_nosp, tmp_before, 0);
add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
x = TREE_CHAIN (x);
}
return;
case SAVE_EXPR:
{
struct tlist_cache *t;
for (t = save_expr_cache; t; t = t->next)
if (t->expr == x)
break;
if (!t)
{
t = XOBNEW (&tlist_obstack, struct tlist_cache);
t->next = save_expr_cache;
t->expr = x;
save_expr_cache = t;
tmp_before = tmp_nosp = 0;
verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
warn_for_collisions (tmp_nosp);
tmp_list3 = 0;
while (tmp_nosp)
{
struct tlist *t = tmp_nosp;
tmp_nosp = t->next;
merge_tlist (&tmp_list3, t, 0);
}
t->cache_before_sp = tmp_before;
t->cache_after_sp = tmp_list3;
}
merge_tlist (pbefore_sp, t->cache_before_sp, 1);
add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
return;
}
default:
if (cl == tcc_unary)
{
x = TREE_OPERAND (x, 0);
writer = 0;
goto restart;
}
else if (IS_EXPR_CODE_CLASS (cl))
{
int lp;
int max = TREE_CODE_LENGTH (TREE_CODE (x));
for (lp = 0; lp < max; lp++)
{
tmp_before = tmp_nosp = 0;
verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
merge_tlist (&tmp_nosp, tmp_before, 0);
add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
}
}
return;
}
}
void
verify_sequence_points (tree expr)
{
struct tlist *before_sp = 0, *after_sp = 0;
warned_ids = 0;
save_expr_cache = 0;
if (tlist_firstobj == 0)
{
gcc_obstack_init (&tlist_obstack);
tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
}
verify_tree (expr, &before_sp, &after_sp, 0);
warn_for_collisions (after_sp);
obstack_free (&tlist_obstack, tlist_firstobj);
}
static tree
check_case_value (tree value)
{
if (value == NULL_TREE)
return value;
STRIP_TYPE_NOPS (value);
if (c_dialect_cxx ())
{
value = decl_constant_value (value);
STRIP_TYPE_NOPS (value);
value = fold (value);
}
if (TREE_CODE (value) != INTEGER_CST
&& value != error_mark_node)
{
error ("case label does not reduce to an integer constant");
value = error_mark_node;
}
else
value = default_conversion (value);
constant_expression_warning (value);
return value;
}
static bool
check_case_bounds (tree type, tree orig_type,
tree *case_low_p, tree *case_high_p)
{
tree min_value, max_value;
tree case_low = *case_low_p;
tree case_high = case_high_p ? *case_high_p : case_low;
if (orig_type == error_mark_node)
return true;
min_value = TYPE_MIN_VALUE (orig_type);
max_value = TYPE_MAX_VALUE (orig_type);
if (tree_int_cst_compare (case_low, min_value) < 0
&& tree_int_cst_compare (case_high, min_value) < 0)
{
warning ("case label value is less than minimum value for type");
return false;
}
if (tree_int_cst_compare (case_low, max_value) > 0
&& tree_int_cst_compare (case_high, max_value) > 0)
{
warning ("case label value exceeds maximum value for type");
return false;
}
if (tree_int_cst_compare (case_high, min_value) >= 0
&& tree_int_cst_compare (case_low, min_value) < 0)
{
warning ("lower value in case label range"
" less than minimum value for type");
case_low = min_value;
}
if (tree_int_cst_compare (case_low, max_value) <= 0
&& tree_int_cst_compare (case_high, max_value) > 0)
{
warning ("upper value in case label range"
" exceeds maximum value for type");
case_high = max_value;
}
if (*case_low_p != case_low)
*case_low_p = convert (type, case_low);
if (case_high_p && *case_high_p != case_high)
*case_high_p = convert (type, case_high);
return true;
}
tree
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;
if (bits == TYPE_PRECISION (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
if (bits == TYPE_PRECISION (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
if (bits == TYPE_PRECISION (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
if (bits == TYPE_PRECISION (long_long_integer_type_node))
return (unsignedp ? long_long_unsigned_type_node
: long_long_integer_type_node);
if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
return (unsignedp ? widest_unsigned_literal_type_node
: widest_integer_literal_type_node);
if (bits <= TYPE_PRECISION (intQI_type_node))
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
if (bits <= TYPE_PRECISION (intHI_type_node))
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
if (bits <= TYPE_PRECISION (intSI_type_node))
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
if (bits <= TYPE_PRECISION (intDI_type_node))
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
return 0;
}
static GTY(()) tree registered_builtin_types;
tree
c_common_type_for_mode (enum machine_mode mode, int unsignedp)
{
tree t;
if (mode == TYPE_MODE (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
if (mode == TYPE_MODE (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
if (mode == TYPE_MODE (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
if (mode == TYPE_MODE (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
if (mode == TYPE_MODE (long_long_integer_type_node))
return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
if (mode == TYPE_MODE (widest_integer_literal_type_node))
return unsignedp ? widest_unsigned_literal_type_node
: widest_integer_literal_type_node;
if (mode == QImode)
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
if (mode == HImode)
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
if (mode == SImode)
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
if (mode == DImode)
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
#if HOST_BITS_PER_WIDE_INT >= 64
if (mode == TYPE_MODE (intTI_type_node))
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
#endif
if (mode == TYPE_MODE (float_type_node))
return float_type_node;
if (mode == TYPE_MODE (double_type_node))
return double_type_node;
if (mode == TYPE_MODE (long_double_type_node))
return long_double_type_node;
if (mode == TYPE_MODE (void_type_node))
return void_type_node;
if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
return (unsignedp
? make_unsigned_type (GET_MODE_PRECISION (mode))
: make_signed_type (GET_MODE_PRECISION (mode)));
if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
return (unsignedp
? make_unsigned_type (GET_MODE_PRECISION (mode))
: make_signed_type (GET_MODE_PRECISION (mode)));
if (COMPLEX_MODE_P (mode))
{
enum machine_mode inner_mode;
tree inner_type;
if (mode == TYPE_MODE (complex_float_type_node))
return complex_float_type_node;
if (mode == TYPE_MODE (complex_double_type_node))
return complex_double_type_node;
if (mode == TYPE_MODE (complex_long_double_type_node))
return complex_long_double_type_node;
if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
return complex_integer_type_node;
inner_mode = GET_MODE_INNER (mode);
inner_type = c_common_type_for_mode (inner_mode, unsignedp);
if (inner_type != NULL_TREE)
return build_complex_type (inner_type);
}
else if (VECTOR_MODE_P (mode))
{
enum machine_mode inner_mode = GET_MODE_INNER (mode);
tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
if (inner_type != NULL_TREE)
return build_vector_type_for_mode (inner_type, mode);
}
for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
if (TYPE_MODE (TREE_VALUE (t)) == mode)
return TREE_VALUE (t);
return 0;
}
tree
c_common_unsigned_type (tree type)
{
tree type1 = TYPE_MAIN_VARIANT (type);
if (type1 == signed_char_type_node || type1 == char_type_node)
return unsigned_char_type_node;
if (type1 == integer_type_node)
return unsigned_type_node;
if (type1 == short_integer_type_node)
return short_unsigned_type_node;
if (type1 == long_integer_type_node)
return long_unsigned_type_node;
if (type1 == long_long_integer_type_node)
return long_long_unsigned_type_node;
if (type1 == widest_integer_literal_type_node)
return widest_unsigned_literal_type_node;
#if HOST_BITS_PER_WIDE_INT >= 64
if (type1 == intTI_type_node)
return unsigned_intTI_type_node;
#endif
if (type1 == intDI_type_node)
return unsigned_intDI_type_node;
if (type1 == intSI_type_node)
return unsigned_intSI_type_node;
if (type1 == intHI_type_node)
return unsigned_intHI_type_node;
if (type1 == intQI_type_node)
return unsigned_intQI_type_node;
return c_common_signed_or_unsigned_type (1, type);
}
tree
c_common_signed_type (tree type)
{
tree type1 = TYPE_MAIN_VARIANT (type);
if (type1 == unsigned_char_type_node || type1 == char_type_node)
return signed_char_type_node;
if (type1 == unsigned_type_node)
return integer_type_node;
if (type1 == short_unsigned_type_node)
return short_integer_type_node;
if (type1 == long_unsigned_type_node)
return long_integer_type_node;
if (type1 == long_long_unsigned_type_node)
return long_long_integer_type_node;
if (type1 == widest_unsigned_literal_type_node)
return widest_integer_literal_type_node;
#if HOST_BITS_PER_WIDE_INT >= 64
if (type1 == unsigned_intTI_type_node)
return intTI_type_node;
#endif
if (type1 == unsigned_intDI_type_node)
return intDI_type_node;
if (type1 == unsigned_intSI_type_node)
return intSI_type_node;
if (type1 == unsigned_intHI_type_node)
return intHI_type_node;
if (type1 == unsigned_intQI_type_node)
return intQI_type_node;
return c_common_signed_or_unsigned_type (0, type);
}
tree
c_common_signed_or_unsigned_type (int unsignedp, tree type)
{
if (!INTEGRAL_TYPE_P (type)
|| TYPE_UNSIGNED (type) == unsignedp)
return type;
#define TYPE_OK(node) \
(TYPE_MODE (type) == TYPE_MODE (node) \
&& (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
if (TYPE_OK (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
if (TYPE_OK (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
if (TYPE_OK (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
if (TYPE_OK (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
if (TYPE_OK (long_long_integer_type_node))
return (unsignedp ? long_long_unsigned_type_node
: long_long_integer_type_node);
if (TYPE_OK (widest_integer_literal_type_node))
return (unsignedp ? widest_unsigned_literal_type_node
: widest_integer_literal_type_node);
#if HOST_BITS_PER_WIDE_INT >= 64
if (TYPE_OK (intTI_type_node))
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
#endif
if (TYPE_OK (intDI_type_node))
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
if (TYPE_OK (intSI_type_node))
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
if (TYPE_OK (intHI_type_node))
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
if (TYPE_OK (intQI_type_node))
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
#undef TYPE_OK
if (c_dialect_cxx ())
return type;
else
return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
}
void
c_register_builtin_type (tree type, const char* name)
{
tree decl;
decl = build_decl (TYPE_DECL, get_identifier (name), type);
DECL_ARTIFICIAL (decl) = 1;
if (!TYPE_NAME (type))
TYPE_NAME (type) = decl;
pushdecl (decl);
registered_builtin_types = tree_cons (0, type, registered_builtin_types);
}
unsigned int
min_precision (tree value, int unsignedp)
{
int log;
if (tree_int_cst_sgn (value) < 0)
value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
if (integer_zerop (value))
log = 0;
else
log = tree_floor_log2 (value);
return log + 1 + !unsignedp;
}
void
binary_op_error (enum tree_code code)
{
const char *opname;
switch (code)
{
case NOP_EXPR:
error ("invalid truth-value expression");
return;
case PLUS_EXPR:
opname = "+"; break;
case MINUS_EXPR:
opname = "-"; break;
case MULT_EXPR:
opname = "*"; break;
case MAX_EXPR:
opname = "max"; break;
case MIN_EXPR:
opname = "min"; break;
case EQ_EXPR:
opname = "=="; break;
case NE_EXPR:
opname = "!="; break;
case LE_EXPR:
opname = "<="; break;
case GE_EXPR:
opname = ">="; break;
case LT_EXPR:
opname = "<"; break;
case GT_EXPR:
opname = ">"; break;
case LSHIFT_EXPR:
opname = "<<"; break;
case RSHIFT_EXPR:
opname = ">>"; break;
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR:
opname = "%"; break;
case TRUNC_DIV_EXPR:
case FLOOR_DIV_EXPR:
opname = "/"; break;
case BIT_AND_EXPR:
opname = "&"; break;
case BIT_IOR_EXPR:
opname = "|"; break;
case TRUTH_ANDIF_EXPR:
opname = "&&"; break;
case TRUTH_ORIF_EXPR:
opname = "||"; break;
case BIT_XOR_EXPR:
opname = "^"; break;
default:
gcc_unreachable ();
}
error ("invalid operands to binary %s", opname);
}
tree
shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
enum tree_code *rescode_ptr)
{
tree type;
tree op0 = *op0_ptr;
tree op1 = *op1_ptr;
int unsignedp0, unsignedp1;
int real1, real2;
tree primop0, primop1;
enum tree_code code = *rescode_ptr;
primop0 = get_narrower (op0, &unsignedp0);
primop1 = get_narrower (op1, &unsignedp1);
if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
if (TREE_CONSTANT (primop0)
&& !integer_zerop (primop1) && !real_zerop (primop1))
{
tree tem = primop0;
int temi = unsignedp0;
primop0 = primop1;
primop1 = tem;
tem = op0;
op0 = op1;
op1 = tem;
*op0_ptr = op0;
*op1_ptr = op1;
unsignedp0 = unsignedp1;
unsignedp1 = temi;
temi = real1;
real1 = real2;
real2 = temi;
switch (code)
{
case LT_EXPR:
code = GT_EXPR;
break;
case GT_EXPR:
code = LT_EXPR;
break;
case LE_EXPR:
code = GE_EXPR;
break;
case GE_EXPR:
code = LE_EXPR;
break;
default:
break;
}
*rescode_ptr = code;
}
if (!real1 && !real2
&& TREE_CODE (primop1) == INTEGER_CST
&& TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
{
int min_gt, max_gt, min_lt, max_lt;
tree maxval, minval;
int unsignedp = TYPE_UNSIGNED (*restype_ptr);
tree val;
type = c_common_signed_or_unsigned_type (unsignedp0,
TREE_TYPE (primop0));
maxval = TYPE_MAX_VALUE (type);
minval = TYPE_MIN_VALUE (type);
if (unsignedp && !unsignedp0)
*restype_ptr = c_common_signed_type (*restype_ptr);
if (TREE_TYPE (primop1) != *restype_ptr)
{
tree tmp = build_int_cst_wide (*restype_ptr,
TREE_INT_CST_LOW (primop1),
TREE_INT_CST_HIGH (primop1));
primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
TREE_CONSTANT_OVERFLOW (primop1));
}
if (type != *restype_ptr)
{
minval = convert (*restype_ptr, minval);
maxval = convert (*restype_ptr, maxval);
}
if (unsignedp && unsignedp0)
{
min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
}
else
{
min_gt = INT_CST_LT (primop1, minval);
max_gt = INT_CST_LT (primop1, maxval);
min_lt = INT_CST_LT (minval, primop1);
max_lt = INT_CST_LT (maxval, primop1);
}
val = 0;
if (code == NE_EXPR)
{
if (max_lt || min_gt)
val = truthvalue_true_node;
}
else if (code == EQ_EXPR)
{
if (max_lt || min_gt)
val = truthvalue_false_node;
}
else if (code == LT_EXPR)
{
if (max_lt)
val = truthvalue_true_node;
if (!min_lt)
val = truthvalue_false_node;
}
else if (code == GT_EXPR)
{
if (min_gt)
val = truthvalue_true_node;
if (!max_gt)
val = truthvalue_false_node;
}
else if (code == LE_EXPR)
{
if (!max_gt)
val = truthvalue_true_node;
if (min_gt)
val = truthvalue_false_node;
}
else if (code == GE_EXPR)
{
if (!min_lt)
val = truthvalue_true_node;
if (max_lt)
val = truthvalue_false_node;
}
if (unsignedp && !unsignedp0)
{
if (val != 0)
switch (code)
{
case LT_EXPR:
case GE_EXPR:
primop1 = TYPE_MIN_VALUE (type);
val = 0;
break;
case LE_EXPR:
case GT_EXPR:
primop1 = TYPE_MAX_VALUE (type);
val = 0;
break;
default:
break;
}
type = c_common_unsigned_type (type);
}
if (TREE_CODE (primop0) != INTEGER_CST)
{
if (val == truthvalue_false_node)
warning ("comparison is always false due to limited range of data type");
if (val == truthvalue_true_node)
warning ("comparison is always true due to limited range of data type");
}
if (val != 0)
{
if (TREE_SIDE_EFFECTS (primop0))
return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
return val;
}
}
else if (real1 && real2
&& (TYPE_PRECISION (TREE_TYPE (primop0))
== TYPE_PRECISION (TREE_TYPE (primop1))))
type = TREE_TYPE (primop0);
else if (unsignedp0 == unsignedp1 && real1 == real2
&& TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
&& TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
{
type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
type = c_common_signed_or_unsigned_type (unsignedp0
|| TYPE_UNSIGNED (*restype_ptr),
type);
primop0
= convert (c_common_signed_or_unsigned_type (unsignedp0,
TREE_TYPE (primop0)),
primop0);
primop1
= convert (c_common_signed_or_unsigned_type (unsignedp1,
TREE_TYPE (primop1)),
primop1);
}
else
{
type = *restype_ptr;
primop0 = op0;
primop1 = op1;
if (!real1 && !real2 && integer_zerop (primop1)
&& TYPE_UNSIGNED (*restype_ptr))
{
tree value = 0;
switch (code)
{
case GE_EXPR:
if (extra_warnings && !in_system_header
&& !(TREE_CODE (primop0) == INTEGER_CST
&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
primop0))))
warning ("comparison of unsigned expression >= 0 is always true");
value = truthvalue_true_node;
break;
case LT_EXPR:
if (extra_warnings && !in_system_header
&& !(TREE_CODE (primop0) == INTEGER_CST
&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
primop0))))
warning ("comparison of unsigned expression < 0 is always false");
value = truthvalue_false_node;
break;
default:
break;
}
if (value != 0)
{
if (TREE_SIDE_EFFECTS (primop0))
return build2 (COMPOUND_EXPR, TREE_TYPE (value),
primop0, value);
return value;
}
}
}
*op0_ptr = convert (type, primop0);
*op1_ptr = convert (type, primop1);
*restype_ptr = truthvalue_type_node;
return 0;
}
tree
pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
{
tree size_exp;
tree result_type = TREE_TYPE (ptrop);
if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("pointer of type %<void *%> used in arithmetic");
size_exp = integer_one_node;
}
else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("pointer to a function used in arithmetic");
size_exp = integer_one_node;
}
else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
{
if (pedantic || warn_pointer_arith)
pedwarn ("pointer to member function used in arithmetic");
size_exp = integer_one_node;
}
else
size_exp = size_in_bytes (TREE_TYPE (result_type));
if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
&& !TREE_CONSTANT (intop)
&& TREE_CONSTANT (TREE_OPERAND (intop, 1))
&& TREE_CONSTANT (size_exp)
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
&& (!TYPE_UNSIGNED (TREE_TYPE (intop))
|| (TYPE_PRECISION (TREE_TYPE (intop))
== TYPE_PRECISION (TREE_TYPE (ptrop)))))
{
enum tree_code subcode = resultcode;
tree int_type = TREE_TYPE (intop);
if (TREE_CODE (intop) == MINUS_EXPR)
subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
ptrop = build_binary_op (subcode, ptrop,
convert (int_type, TREE_OPERAND (intop, 1)), 1);
intop = convert (int_type, TREE_OPERAND (intop, 0));
}
if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
|| TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
TYPE_UNSIGNED (sizetype)), intop);
{
tree array;
if (inside_iasm_block && flag_ms_asms)
{
ptrop = iasm_addr (ptrop);
result_type = TREE_TYPE (ptrop);
}
array = ptrop;
STRIP_NOPS (array);
if (inside_iasm_block
&& flag_ms_asms
&& resultcode == PLUS_EXPR
&& TREE_CODE (array) == ADDR_EXPR
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (array, 0))) == ARRAY_TYPE
&& !(TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE
|| TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == METHOD_TYPE))
{
tree type;
tree r;
tree new_i;
size_exp = convert (TREE_TYPE (intop), size_exp);
new_i = fold (build_binary_op (CEIL_DIV_EXPR, intop, size_exp, 1));
if (build_binary_op (MULT_EXPR, new_i, size_exp, 1) == intop)
{
array = TREE_OPERAND (array, 0);
type = TREE_TYPE (TREE_TYPE (array));
if (TREE_CODE (type) != ARRAY_TYPE)
type = TYPE_MAIN_VARIANT (type);
r = build4 (ARRAY_REF, type, array, new_i, NULL_TREE, NULL_TREE);
TREE_READONLY (r)
|= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
| TREE_READONLY (array));
TREE_SIDE_EFFECTS (r)
|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
| TREE_SIDE_EFFECTS (array));
TREE_THIS_VOLATILE (r)
|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
| TREE_THIS_VOLATILE (array));
r = fold (r);
r = build1 (ADDR_EXPR, result_type, r);
r = fold (r);
return r;
}
}
}
if (inside_iasm_block && flag_ms_asms)
size_exp = integer_one_node;
intop = convert (result_type,
build_binary_op (MULT_EXPR, intop,
convert (TREE_TYPE (intop), size_exp), 1));
return fold (build2 (resultcode, result_type, ptrop, intop));
}
tree
c_common_truthvalue_conversion (tree expr)
{
switch (TREE_CODE (expr))
{
case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
case ORDERED_EXPR: case UNORDERED_EXPR:
if (TREE_TYPE (expr) == truthvalue_type_node)
return expr;
return build2 (TREE_CODE (expr), truthvalue_type_node,
TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_XOR_EXPR:
if (TREE_TYPE (expr) == truthvalue_type_node)
return expr;
return build2 (TREE_CODE (expr), truthvalue_type_node,
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)));
case TRUTH_NOT_EXPR:
if (TREE_TYPE (expr) == truthvalue_type_node)
return expr;
return build1 (TREE_CODE (expr), truthvalue_type_node,
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
case ERROR_MARK:
return expr;
case INTEGER_CST:
return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
? truthvalue_true_node
: truthvalue_false_node;
case REAL_CST:
return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
? truthvalue_true_node
: truthvalue_false_node;
case FUNCTION_DECL:
expr = build_unary_op (ADDR_EXPR, expr, 0);
case ADDR_EXPR:
{
if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
&& !DECL_WEAK (TREE_OPERAND (expr, 0)))
{
warning ("the address of %qD, will always evaluate as %<true%>",
TREE_OPERAND (expr, 0));
return truthvalue_true_node;
}
if (DECL_P (TREE_OPERAND (expr, 0))
&& DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
break;
if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
return build2 (COMPOUND_EXPR, truthvalue_type_node,
TREE_OPERAND (expr, 0), truthvalue_true_node);
else
return truthvalue_true_node;
}
case COMPLEX_EXPR:
return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
0);
case NEGATE_EXPR:
case ABS_EXPR:
case FLOAT_EXPR:
return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
case LROTATE_EXPR:
case RROTATE_EXPR:
if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
return build2 (COMPOUND_EXPR, truthvalue_type_node,
TREE_OPERAND (expr, 1),
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
else
return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
case COND_EXPR:
return fold (build3 (COND_EXPR, truthvalue_type_node,
TREE_OPERAND (expr, 0),
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
case CONVERT_EXPR:
if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
|| TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
break;
case NOP_EXPR:
if (TYPE_PRECISION (TREE_TYPE (expr))
>= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
break;
case MINUS_EXPR:
if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
break;
case BIT_XOR_EXPR:
if (TREE_TYPE (TREE_OPERAND (expr, 0))
== TREE_TYPE (TREE_OPERAND (expr, 1)))
return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
TREE_OPERAND (expr, 1), 1);
return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
fold (build1 (NOP_EXPR,
TREE_TYPE (TREE_OPERAND (expr, 0)),
TREE_OPERAND (expr, 1))), 1);
case BIT_AND_EXPR:
if (integer_onep (TREE_OPERAND (expr, 1))
&& TREE_TYPE (expr) != truthvalue_type_node)
return build1 (NOP_EXPR, truthvalue_type_node, expr);
break;
case MODIFY_EXPR:
if (warn_parentheses && !TREE_NO_WARNING (expr))
warning ("suggest parentheses around assignment used as truth value");
break;
default:
break;
}
if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
{
tree t = save_expr (expr);
return (build_binary_op
((TREE_SIDE_EFFECTS (expr)
? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
0));
}
return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
}
static tree builtin_function_2 (const char *builtin_name, const char *name,
tree builtin_type, tree type,
enum built_in_function function_code,
enum built_in_class cl, int library_name_p,
bool nonansi_p,
tree attrs);
tree
c_build_qualified_type (tree type, int type_quals)
{
if (type == error_mark_node)
return type;
if (TREE_CODE (type) == ARRAY_TYPE)
{
tree t;
tree element_type = c_build_qualified_type (TREE_TYPE (type),
type_quals);
for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
{
if (TYPE_QUALS (strip_array_types (t)) == type_quals
&& TYPE_NAME (t) == TYPE_NAME (type)
&& TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
&& attribute_list_equal (TYPE_ATTRIBUTES (t),
TYPE_ATTRIBUTES (type)))
break;
}
if (!t)
{
t = build_variant_type_copy (type);
TREE_TYPE (t) = element_type;
}
return t;
}
if ((type_quals & TYPE_QUAL_RESTRICT)
&& (!POINTER_TYPE_P (type)
|| !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
{
error ("invalid use of %<restrict%>");
type_quals &= ~TYPE_QUAL_RESTRICT;
}
return build_qualified_type (type, type_quals);
}
void
c_apply_type_quals_to_decl (int type_quals, tree decl)
{
tree type = TREE_TYPE (decl);
if (type == error_mark_node)
return;
if (((type_quals & TYPE_QUAL_CONST)
|| (type && TREE_CODE (type) == REFERENCE_TYPE))
&& !(type && TYPE_NEEDS_CONSTRUCTING (type)))
TREE_READONLY (decl) = 1;
if (type_quals & TYPE_QUAL_VOLATILE)
{
TREE_SIDE_EFFECTS (decl) = 1;
TREE_THIS_VOLATILE (decl) = 1;
}
if (type_quals & TYPE_QUAL_RESTRICT)
{
while (type && TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
if (!type
|| !POINTER_TYPE_P (type)
|| !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
error ("invalid use of %<restrict%>");
else if (flag_strict_aliasing && type == TREE_TYPE (decl))
DECL_POINTER_ALIAS_SET (decl) = -2;
}
}
static hashval_t
c_type_hash (const void *p)
{
int i = 0;
int shift, size;
tree t = (tree) p;
tree t2;
switch (TREE_CODE (t))
{
case POINTER_TYPE:
return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
case ENUMERAL_TYPE:
shift = 3;
t2 = TYPE_VALUES (t);
break;
case RECORD_TYPE:
shift = 0;
t2 = TYPE_FIELDS (t);
break;
case QUAL_UNION_TYPE:
shift = 1;
t2 = TYPE_FIELDS (t);
break;
case UNION_TYPE:
shift = 2;
t2 = TYPE_FIELDS (t);
break;
default:
gcc_unreachable ();
}
for (; t2; t2 = TREE_CHAIN (t2))
i++;
size = TREE_INT_CST_LOW (TYPE_SIZE (t));
return ((size << 24) | (i << shift));
}
static GTY((param_is (union tree_node))) htab_t type_hash_table;
HOST_WIDE_INT
c_common_get_alias_set (tree t)
{
tree u;
PTR *slot;
for (u = t;
TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
u = TREE_OPERAND (u, 0))
if (TREE_CODE (u) == COMPONENT_REF
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
return 0;
if (!TYPE_P (t))
return -1;
if (t == char_type_node
|| t == signed_char_type_node
|| t == unsigned_char_type_node)
return 0;
if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
return 0;
if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
{
tree t1 = c_common_signed_type (t);
if (t1 != t)
return get_alias_set (t1);
}
else if (POINTER_TYPE_P (t))
{
tree t1;
t1 = build_type_no_quals (t);
if (t1 != t)
return get_alias_set (t1);
}
if (c_language != clk_c || flag_isoc99)
return -1;
if (num_in_fnames == 1)
return -1;
if (TREE_CODE (t) == POINTER_TYPE)
{
tree t2;
for (t2 = TREE_TYPE (t);
TREE_CODE (t2) == POINTER_TYPE;
t2 = TREE_TYPE (t2))
;
if (TREE_CODE (t2) != RECORD_TYPE
&& TREE_CODE (t2) != ENUMERAL_TYPE
&& TREE_CODE (t2) != QUAL_UNION_TYPE
&& TREE_CODE (t2) != UNION_TYPE)
return -1;
if (TYPE_SIZE (t2) == 0)
return -1;
}
if (TREE_CODE (t) != RECORD_TYPE
&& TREE_CODE (t) != ENUMERAL_TYPE
&& TREE_CODE (t) != QUAL_UNION_TYPE
&& TREE_CODE (t) != UNION_TYPE
&& TREE_CODE (t) != POINTER_TYPE)
return -1;
if (TYPE_SIZE (t) == 0)
return -1;
if (!type_hash_table)
type_hash_table = htab_create_ggc (1021, c_type_hash,
(htab_eq) lang_hooks.types_compatible_p,
NULL);
slot = htab_find_slot (type_hash_table, t, INSERT);
if (*slot != NULL)
{
TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
return TYPE_ALIAS_SET ((tree)*slot);
}
else
*slot = t;
return -1;
}
tree
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);
gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
if (type_code == FUNCTION_TYPE)
{
if (op == SIZEOF_EXPR)
{
if (complain && (pedantic || warn_pointer_arith))
pedwarn ("invalid application of %<sizeof%> to a function type");
value = size_one_node;
}
else
value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
}
else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
{
if (type_code == VOID_TYPE
&& complain && (pedantic || warn_pointer_arith))
pedwarn ("invalid application of %qs to a void type", op_name);
value = size_one_node;
}
else if (!COMPLETE_TYPE_P (type))
{
if (complain)
error ("invalid application of %qs to incomplete type %qT ",
op_name, type);
value = size_zero_node;
}
else
{
if (op == (enum tree_code) SIZEOF_EXPR)
value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
size_int (TYPE_PRECISION (char_type_node)
/ BITS_PER_UNIT));
else
value = size_int (TYPE_ALIGN_UNIT (type));
}
value = fold (build1 (NOP_EXPR, size_type_node, value));
gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
return value;
}
tree
c_alignof_expr (tree expr)
{
tree t;
if (TREE_CODE (expr) == VAR_DECL)
t = size_int (DECL_ALIGN_UNIT (expr));
else if (TREE_CODE (expr) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
{
error ("%<__alignof%> applied to a bit-field");
t = size_one_node;
}
else if (TREE_CODE (expr) == COMPONENT_REF
&& TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
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)
{
int thisalign;
t = TREE_OPERAND (t, 0);
thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
if (thisalign > bestalign)
best = t, bestalign = thisalign;
}
return c_alignof (TREE_TYPE (TREE_TYPE (best)));
}
else
return c_alignof (TREE_TYPE (expr));
return fold (build1 (NOP_EXPR, size_type_node, t));
}
enum built_in_attribute
{
#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
#define DEF_ATTR_INT(ENUM, VALUE) ENUM,
#define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
#include "builtin-attrs.def"
#undef DEF_ATTR_NULL_TREE
#undef DEF_ATTR_INT
#undef DEF_ATTR_IDENT
#undef DEF_ATTR_TREE_LIST
ATTR_LAST
};
static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
static void c_init_attributes (void);
void
c_common_nodes_and_builtins (void)
{
enum builtin_type
{
#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) 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_0
#undef DEF_FUNCTION_TYPE_1
#undef DEF_FUNCTION_TYPE_2
#undef DEF_FUNCTION_TYPE_3
#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
BT_LAST
};
typedef enum builtin_type builtin_type;
tree builtin_types[(int) BT_LAST];
int wchar_type_size;
tree array_domain_type;
tree va_list_ref_type_node;
tree va_list_arg_type_node;
record_builtin_type (RID_INT, NULL, integer_type_node);
record_builtin_type (RID_CHAR, "char", char_type_node);
if (c_dialect_cxx ())
record_builtin_type (RID_SIGNED, NULL, integer_type_node);
record_builtin_type (RID_LONG, "long int", long_integer_type_node);
record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
record_builtin_type (RID_MAX, "long unsigned int",
long_unsigned_type_node);
if (c_dialect_cxx ())
record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
record_builtin_type (RID_MAX, "long long int",
long_long_integer_type_node);
record_builtin_type (RID_MAX, "long long unsigned int",
long_long_unsigned_type_node);
if (c_dialect_cxx ())
record_builtin_type (RID_MAX, "long long unsigned",
long_long_unsigned_type_node);
record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
record_builtin_type (RID_MAX, "short unsigned int",
short_unsigned_type_node);
if (c_dialect_cxx ())
record_builtin_type (RID_MAX, "unsigned short",
short_unsigned_type_node);
record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
intQI_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
intHI_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
intSI_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
intDI_type_node));
#if HOST_BITS_PER_WIDE_INT >= 64
if (targetm.scalar_mode_supported_p (TImode))
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
get_identifier ("__int128_t"),
intTI_type_node));
#endif
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
unsigned_intQI_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
unsigned_intHI_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
unsigned_intSI_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
unsigned_intDI_type_node));
#if HOST_BITS_PER_WIDE_INT >= 64
if (targetm.scalar_mode_supported_p (TImode))
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
get_identifier ("__uint128_t"),
unsigned_intTI_type_node));
#endif
widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
widest_integer_literal_type_node));
widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
widest_unsigned_literal_type_node));
size_type_node =
TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
signed_size_type_node = c_common_signed_type (size_type_node);
set_sizetype (size_type_node);
pid_type_node =
TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
build_common_tree_nodes_2 (flag_short_double);
record_builtin_type (RID_FLOAT, NULL, float_type_node);
record_builtin_type (RID_DOUBLE, NULL, double_type_node);
record_builtin_type (RID_MAX, "long double", long_double_type_node);
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
get_identifier ("complex int"),
complex_integer_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
get_identifier ("complex float"),
complex_float_type_node));
lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
get_identifier ("complex double"),
complex_double_type_node));
lang_hooks.decls.pushdecl
(build_decl (TYPE_DECL, get_identifier ("complex long double"),
complex_long_double_type_node));
if (c_dialect_cxx ())
fileptr_type_node = build_variant_type_copy (ptr_type_node);
record_builtin_type (RID_VOID, NULL, void_type_node);
void_zero_node = make_node (INTEGER_CST);
TREE_TYPE (void_zero_node) = void_type_node;
void_list_node = build_void_list_node ();
array_domain_type = build_index_type (size_int (200));
char_array_type_node
= build_array_type (char_type_node, array_domain_type);
pascal_string_type_node
= build_array_type (unsigned_char_type_node, array_domain_type);
int_array_type_node
= build_array_type (integer_type_node, array_domain_type);
string_type_node = build_pointer_type (char_type_node);
const_string_type_node
= build_pointer_type (build_qualified_type
(char_type_node, TYPE_QUAL_CONST));
wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
wchar_type_size = TYPE_PRECISION (wchar_type_node);
if (c_dialect_cxx ())
{
if (TYPE_UNSIGNED (wchar_type_node))
wchar_type_node = make_unsigned_type (wchar_type_size);
else
wchar_type_node = make_signed_type (wchar_type_size);
record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
}
else
{
signed_wchar_type_node = c_common_signed_type (wchar_type_node);
unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
}
wchar_array_type_node
= build_array_type (wchar_type_node, array_domain_type);
wint_type_node =
TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
intmax_type_node =
TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
uintmax_type_node =
TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
default_function_type = build_function_type (integer_type_node, NULL_TREE);
ptrdiff_type_node
= TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
lang_hooks.decls.pushdecl
(build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
va_list_type_node));
if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
{
va_list_arg_type_node = va_list_ref_type_node =
build_pointer_type (TREE_TYPE (va_list_type_node));
}
else
{
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) \
builtin_types[(int) ENUM] \
= build_function_type (builtin_types[(int) RETURN], \
void_list_node);
#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
builtin_types[(int) ENUM] \
= build_function_type (builtin_types[(int) RETURN], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG1], \
void_list_node));
#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
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], \
void_list_node)));
#define DEF_FUNCTION_TYPE_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], \
void_list_node))));
#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
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], \
tree_cons (NULL_TREE, \
builtin_types[(int) ARG4], \
void_list_node)))));
#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
builtin_types[(int) ENUM] \
= 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], \
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 \
(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]);
#include "builtin-types.def"
#undef DEF_PRIMITIVE_TYPE
#undef DEF_FUNCTION_TYPE_1
#undef DEF_FUNCTION_TYPE_2
#undef DEF_FUNCTION_TYPE_3
#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
c_init_attributes ();
#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
NONANSI_P, ATTRS, IMPLICIT, COND) \
if (NAME && COND) \
{ \
tree decl; \
\
gcc_assert (!strncmp (NAME, "__builtin_", \
strlen ("__builtin_"))); \
\
if (!BOTH_P) \
decl = lang_hooks.builtin_function (NAME, builtin_types[TYPE], \
ENUM, \
CLASS, \
(FALLBACK_P \
? (NAME + strlen ("__builtin_")) \
: NULL), \
built_in_attributes[(int) ATTRS]); \
else \
decl = builtin_function_2 (NAME, \
NAME + strlen ("__builtin_"), \
builtin_types[TYPE], \
builtin_types[LIBTYPE], \
ENUM, \
CLASS, \
FALLBACK_P, \
NONANSI_P, \
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
build_common_builtin_nodes ();
targetm.init_builtins ();
if (flag_mudflap)
mudflap_init ();
main_identifier_node = get_identifier ("main");
null_node = make_node (INTEGER_CST);
TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
}
void
set_builtin_user_assembler_name (tree decl, const char *asmspec)
{
tree builtin;
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
&& asmspec != 0);
builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
set_user_assembler_name (builtin, asmspec);
if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
init_block_move_fn (asmspec);
else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
init_block_clear_fn (asmspec);
}
tree
build_va_arg (tree expr, tree type)
{
return build1 (VA_ARG_EXPR, type, expr);
}
typedef struct disabled_builtin
{
const char *name;
struct disabled_builtin *next;
} disabled_builtin;
static disabled_builtin *disabled_builtins = NULL;
bool builtin_function_disabled_p (const char *);
void
disable_builtin_function (const char *name)
{
if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
error ("cannot disable built-in function %qs", name);
else
{
disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
new_disabled_builtin->name = name;
new_disabled_builtin->next = disabled_builtins;
disabled_builtins = new_disabled_builtin;
}
}
bool
builtin_function_disabled_p (const char *name)
{
disabled_builtin *p;
for (p = disabled_builtins; p != NULL; p = p->next)
{
if (strcmp (name, p->name) == 0)
return true;
}
return false;
}
static tree
builtin_function_2 (const char *builtin_name, const char *name,
tree builtin_type, tree type,
enum built_in_function function_code,
enum built_in_class cl, int library_name_p,
bool nonansi_p, tree attrs)
{
tree bdecl = NULL_TREE;
tree decl = NULL_TREE;
if (builtin_name != 0)
bdecl = lang_hooks.builtin_function (builtin_name, builtin_type,
function_code, cl,
library_name_p ? name : NULL, attrs);
if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
&& !(nonansi_p && flag_no_nonansi_builtin))
decl = lang_hooks.builtin_function (name, type, function_code, cl,
NULL, attrs);
return (bdecl != 0 ? bdecl : decl);
}
bool
c_promoting_integer_type_p (tree t)
{
switch (TREE_CODE (t))
{
case INTEGER_TYPE:
return (TYPE_MAIN_VARIANT (t) == char_type_node
|| TYPE_MAIN_VARIANT (t) == signed_char_type_node
|| TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
|| TYPE_MAIN_VARIANT (t) == short_integer_type_node
|| TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
|| TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
case ENUMERAL_TYPE:
return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
case BOOLEAN_TYPE:
return 1;
default:
return 0;
}
}
int
self_promoting_args_p (tree parms)
{
tree t;
for (t = parms; t; t = TREE_CHAIN (t))
{
tree type = TREE_VALUE (t);
if (TREE_CHAIN (t) == 0 && type != void_type_node)
return 0;
if (type == 0)
return 0;
if (TYPE_MAIN_VARIANT (type) == float_type_node)
return 0;
if (c_promoting_integer_type_p (type))
return 0;
}
return 1;
}
tree
strip_array_types (tree type)
{
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
return type;
}
tree
strip_pointer_operator (tree t)
{
while (POINTER_TYPE_P (t))
t = TREE_TYPE (t);
return t;
}
int
case_compare (splay_tree_key k1, splay_tree_key k2)
{
if (!k1)
return k2 ? -1 : 0;
else if (!k2)
return k1 ? 1 : 0;
return tree_int_cst_compare ((tree) k1, (tree) k2);
}
tree
c_add_case_label (splay_tree cases, tree cond, tree orig_type,
tree low_value, tree high_value)
{
tree type;
tree label;
tree case_label;
splay_tree_node node;
label = create_artificial_label ();
if (!cond || cond == error_mark_node)
goto error_out;
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");
if (high_value && pedantic)
pedwarn ("range expressions in switch statements are non-standard");
type = TREE_TYPE (cond);
if (low_value)
{
low_value = check_case_value (low_value);
low_value = convert_and_check (type, low_value);
}
if (high_value)
{
high_value = check_case_value (high_value);
high_value = convert_and_check (type, high_value);
}
if (low_value == error_mark_node || high_value == error_mark_node)
goto error_out;
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))
warning ("empty range specified");
if (low_value
&& !check_case_bounds (type, orig_type,
&low_value, high_value ? &high_value : NULL))
return NULL_TREE;
node = splay_tree_lookup (cases, (splay_tree_key) low_value);
if (!node && (low_value || high_value))
{
splay_tree_node low_bound;
splay_tree_node high_bound;
low_bound = splay_tree_predecessor (cases,
(splay_tree_key) low_value);
high_bound = splay_tree_successor (cases,
(splay_tree_key) low_value);
if (low_bound
&& CASE_HIGH ((tree) low_bound->value)
&& tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
low_value) >= 0)
node = low_bound;
else if (high_bound
&& high_value
&& (tree_int_cst_compare ((tree) high_bound->key,
high_value)
<= 0))
node = high_bound;
}
if (node)
{
tree duplicate = CASE_LABEL ((tree) node->value);
if (high_value)
{
error ("duplicate (or overlapping) case value");
error ("%Jthis is the first entry overlapping that value", duplicate);
}
else if (low_value)
{
error ("duplicate case value") ;
error ("%Jpreviously used here", duplicate);
}
else
{
error ("multiple default labels in one switch");
error ("%Jthis is the first default label", duplicate);
}
goto error_out;
}
case_label = add_stmt (build_case_label (low_value, high_value, label));
splay_tree_insert (cases,
(splay_tree_key) low_value,
(splay_tree_value) case_label);
return case_label;
error_out:
if (!cases->root)
{
tree t = create_artificial_label ();
add_stmt (build_stmt (LABEL_EXPR, t));
}
return error_mark_node;
}
static void
match_case_to_enum_1 (tree key, tree type, tree label)
{
char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
if (TREE_INT_CST_HIGH (key) == 0)
snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
TREE_INT_CST_LOW (key));
else if (!TYPE_UNSIGNED (type)
&& TREE_INT_CST_HIGH (key) == -1
&& TREE_INT_CST_LOW (key) != 0)
snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
-TREE_INT_CST_LOW (key));
else
snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
if (TYPE_NAME (type) == 0)
warning ("%Jcase value %qs not in enumerated type",
CASE_LABEL (label), buf);
else
warning ("%Jcase value %qs not in enumerated type %qT",
CASE_LABEL (label), buf, type);
}
static int
match_case_to_enum (splay_tree_node node, void *data)
{
tree label = (tree) node->value;
tree type = (tree) data;
if (!CASE_LOW (label))
return 0;
if (!TREE_ADDRESSABLE (label))
match_case_to_enum_1 (CASE_LOW (label), type, label);
else
TREE_ADDRESSABLE (label) = 0;
if (CASE_HIGH (label))
{
tree chain, key = CASE_HIGH (label);
for (chain = TYPE_VALUES (type);
chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
chain = TREE_CHAIN (chain))
continue;
if (!chain)
match_case_to_enum_1 (key, type, label);
}
return 0;
}
void
c_do_switch_warnings (splay_tree cases, tree switch_stmt)
{
splay_tree_node default_node;
location_t switch_location;
tree type;
if (!warn_switch && !warn_switch_enum && !warn_switch_default)
return;
if (EXPR_HAS_LOCATION (switch_stmt))
switch_location = EXPR_LOCATION (switch_stmt);
else
switch_location = input_location;
type = SWITCH_STMT_TYPE (switch_stmt);
default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
if (warn_switch_default && !default_node)
warning ("%Hswitch missing default case", &switch_location);
if (((warn_switch && !default_node) || warn_switch_enum)
&& type && TREE_CODE (type) == ENUMERAL_TYPE
&& TREE_CODE (SWITCH_STMT_COND (switch_stmt)) != INTEGER_CST)
{
tree chain;
for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
{
splay_tree_node node
= splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
if (node)
{
tree label = (tree) node->value;
TREE_ADDRESSABLE (label) = 1;
}
else
{
warning ("%Henumeration value %qE not handled in switch",
&switch_location, TREE_PURPOSE (chain));
}
}
splay_tree_foreach (cases, match_case_to_enum, type);
}
}
tree
finish_label_address_expr (tree label)
{
tree result;
if (pedantic)
pedwarn ("taking the address of a label is non-standard");
if (label == error_mark_node)
return error_mark_node;
label = lookup_label (label);
if (label == NULL_TREE)
result = null_pointer_node;
else
{
TREE_USED (label) = 1;
result = build1 (ADDR_EXPR, ptr_type_node, label);
}
return result;
}
rtx
c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
int modifier ,
rtx *alt_rtl)
{
switch (TREE_CODE (exp))
{
case COMPOUND_LITERAL_EXPR:
{
tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
emit_local_var (decl);
return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
}
default:
gcc_unreachable ();
}
}
tree
c_staticp (tree exp)
{
return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
&& TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
? exp : NULL);
}
tree
boolean_increment (enum tree_code code, tree arg)
{
tree val;
tree true_res = boolean_true_node;
arg = stabilize_reference (arg);
switch (code)
{
case PREINCREMENT_EXPR:
val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
break;
case POSTINCREMENT_EXPR:
val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
arg = save_expr (arg);
val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
break;
case PREDECREMENT_EXPR:
val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
invert_truthvalue (arg));
break;
case POSTDECREMENT_EXPR:
val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
invert_truthvalue (arg));
arg = save_expr (arg);
val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
break;
default:
gcc_unreachable ();
}
TREE_SIDE_EFFECTS (val) = 1;
return val;
}
void
c_stddef_cpp_builtins(void)
{
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);
builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
}
static void
c_init_attributes (void)
{
#define DEF_ATTR_NULL_TREE(ENUM) \
built_in_attributes[(int) ENUM] = NULL_TREE;
#define DEF_ATTR_INT(ENUM, VALUE) \
built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
#define DEF_ATTR_IDENT(ENUM, STRING) \
built_in_attributes[(int) ENUM] = get_identifier (STRING);
#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
built_in_attributes[(int) ENUM] \
= tree_cons (built_in_attributes[(int) PURPOSE], \
built_in_attributes[(int) VALUE], \
built_in_attributes[(int) CHAIN]);
#include "builtin-attrs.def"
#undef DEF_ATTR_NULL_TREE
#undef DEF_ATTR_INT
#undef DEF_ATTR_IDENT
#undef DEF_ATTR_TREE_LIST
}
static tree
handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int flags, bool *no_add_attrs)
{
if (TYPE_P (*node))
{
if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*node = build_variant_type_copy (*node);
TYPE_PACKED (*node) = 1;
if (TYPE_MAIN_VARIANT (*node) == *node)
{
tree probe;
for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
TYPE_PACKED (probe) = 1;
}
}
else if (TREE_CODE (*node) == FIELD_DECL)
DECL_PACKED (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_nocommon_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) == VAR_DECL)
DECL_COMMON (*node) = 0;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) == VAR_DECL)
DECL_COMMON (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree type = TREE_TYPE (*node);
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_THIS_VOLATILE (*node) = 1;
else if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
TREE_TYPE (*node)
= build_pointer_type
(build_type_variant (TREE_TYPE (type),
TYPE_READONLY (TREE_TYPE (type)), 1));
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_noinline_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_UNINLINABLE (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_always_inline_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
{
}
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_nodebug_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_IGNORED_P (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree node = *pnode;
if (TREE_CODE (node) == FUNCTION_DECL
|| (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
{
TREE_USED (node) = 1;
DECL_PRESERVE_P (node) = 1;
}
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int flags, bool *no_add_attrs)
{
if (DECL_P (*node))
{
tree decl = *node;
if (TREE_CODE (decl) == PARM_DECL
|| TREE_CODE (decl) == VAR_DECL
|| TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == LABEL_DECL
|| TREE_CODE (decl) == TYPE_DECL)
TREE_USED (decl) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
else
{
if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*node = build_variant_type_copy (*node);
TREE_USED (*node) = 1;
}
return NULL_TREE;
}
static tree
handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree type = TREE_TYPE (*node);
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_READONLY (*node) = 1;
else if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
TREE_TYPE (*node)
= build_pointer_type
(build_type_variant (TREE_TYPE (type), 1,
TREE_THIS_VOLATILE (TREE_TYPE (type))));
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_transparent_union_attribute (tree *node, tree name,
tree ARG_UNUSED (args), int flags,
bool *no_add_attrs)
{
tree decl = NULL_TREE;
tree *type = NULL;
int is_type = 0;
if (DECL_P (*node))
{
decl = *node;
type = &TREE_TYPE (decl);
is_type = TREE_CODE (*node) == TYPE_DECL;
}
else if (TYPE_P (*node))
type = node, is_type = 1;
if (is_type
&& TREE_CODE (*type) == UNION_TYPE
&& (decl == 0
|| (TYPE_FIELDS (*type) != 0
&& TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
{
if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*type = build_variant_type_copy (*type);
TYPE_TRANSPARENT_UNION (*type) = 1;
}
else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
&& TREE_CODE (*type) == UNION_TYPE
&& TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
DECL_TRANSPARENT_UNION (decl) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_constructor_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
tree decl = *node;
tree type = TREE_TYPE (decl);
if (TREE_CODE (decl) == FUNCTION_DECL
&& TREE_CODE (type) == FUNCTION_TYPE
&& decl_function_context (decl) == 0)
{
DECL_STATIC_CONSTRUCTOR (decl) = 1;
TREE_USED (decl) = 1;
}
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_destructor_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
tree decl = *node;
tree type = TREE_TYPE (decl);
if (TREE_CODE (decl) == FUNCTION_DECL
&& TREE_CODE (type) == FUNCTION_TYPE
&& decl_function_context (decl) == 0)
{
DECL_STATIC_DESTRUCTOR (decl) = 1;
TREE_USED (decl) = 1;
}
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_mode_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree type = *node;
*no_add_attrs = true;
if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
else
{
int j;
const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
int len = strlen (p);
enum machine_mode mode = VOIDmode;
tree typefm;
bool valid_mode;
if (len > 4 && p[0] == '_' && p[1] == '_'
&& p[len - 1] == '_' && p[len - 2] == '_')
{
char *newp = (char *) alloca (len - 1);
strcpy (newp, &p[2]);
newp[len - 4] = '\0';
p = newp;
}
if (!strcmp (p, "byte"))
mode = byte_mode;
else if (!strcmp (p, "word"))
mode = word_mode;
else if (!strcmp (p, "pointer"))
mode = ptr_mode;
else
for (j = 0; j < NUM_MACHINE_MODES; j++)
if (!strcmp (p, GET_MODE_NAME (j)))
{
mode = (enum machine_mode) j;
break;
}
if (mode == VOIDmode)
{
error ("unknown machine mode %qs", p);
return NULL_TREE;
}
valid_mode = false;
switch (GET_MODE_CLASS (mode))
{
case MODE_INT:
case MODE_PARTIAL_INT:
case MODE_FLOAT:
valid_mode = targetm.scalar_mode_supported_p (mode);
break;
case MODE_COMPLEX_INT:
case MODE_COMPLEX_FLOAT:
valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
break;
case MODE_VECTOR_INT:
case MODE_VECTOR_FLOAT:
warning ("specifying vector types with __attribute__ ((mode)) "
"is deprecated");
warning ("use __attribute__ ((vector_size)) instead");
valid_mode = vector_mode_valid_p (mode);
break;
default:
break;
}
if (!valid_mode)
{
error ("unable to emulate %qs", p);
return NULL_TREE;
}
if (POINTER_TYPE_P (type))
{
tree (*fn)(tree, enum machine_mode, bool);
if (!targetm.valid_pointer_mode (mode))
{
error ("invalid pointer mode %qs", p);
return NULL_TREE;
}
if (TREE_CODE (type) == POINTER_TYPE)
fn = build_pointer_type_for_mode;
else
fn = build_reference_type_for_mode;
typefm = fn (TREE_TYPE (type), mode, false);
}
else
typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
if (typefm == NULL_TREE)
{
error ("no data type for mode %qs", p);
return NULL_TREE;
}
else if (TREE_CODE (type) == ENUMERAL_TYPE)
{
if (TREE_CODE (typefm) != INTEGER_TYPE)
{
error ("cannot use mode %qs for enumeral types", p);
return NULL_TREE;
}
if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
type = build_variant_type_copy (type);
TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
TYPE_SIZE (type) = TYPE_SIZE (typefm);
TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
TYPE_MODE (type) = TYPE_MODE (typefm);
if (!TYPE_USER_ALIGN (type))
TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
typefm = type;
}
else if (VECTOR_MODE_P (mode)
? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
: TREE_CODE (type) != TREE_CODE (typefm))
{
error ("mode %qs applied to inappropriate type", p);
return NULL_TREE;
}
*node = typefm;
}
return NULL_TREE;
}
static tree
handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree decl = *node;
if (targetm.have_named_sections)
{
user_defined_section_attribute = true;
if ((TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == VAR_DECL)
&& TREE_CODE (TREE_VALUE (args)) == STRING_CST)
{
if (TREE_CODE (decl) == VAR_DECL
&& current_function_decl != NULL_TREE
&& !TREE_STATIC (decl))
{
error ("%Jsection attribute cannot be specified for "
"local variables", decl);
*no_add_attrs = true;
}
else if (DECL_SECTION_NAME (decl) != NULL_TREE
&& strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
{
error ("%Jsection of %qD conflicts with previous declaration",
*node, *node);
*no_add_attrs = true;
}
else
DECL_SECTION_NAME (decl) = TREE_VALUE (args);
}
else
{
error ("%Jsection attribute not allowed for %qD", *node, *node);
*no_add_attrs = true;
}
}
else
{
error ("%Jsection attributes are not supported for this target", *node);
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
int flags, bool *no_add_attrs)
{
tree decl = NULL_TREE;
tree *type = NULL;
int is_type = 0;
tree align_expr = (args ? TREE_VALUE (args)
: size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
int i;
if (DECL_P (*node))
{
decl = *node;
type = &TREE_TYPE (decl);
is_type = TREE_CODE (*node) == TYPE_DECL;
}
else if (TYPE_P (*node))
type = node, is_type = 1;
while (TREE_CODE (align_expr) == NOP_EXPR
|| TREE_CODE (align_expr) == CONVERT_EXPR
|| TREE_CODE (align_expr) == NON_LVALUE_EXPR)
align_expr = TREE_OPERAND (align_expr, 0);
if (TREE_CODE (align_expr) != INTEGER_CST)
{
error ("requested alignment is not a constant");
*no_add_attrs = true;
}
else if ((i = tree_log2 (align_expr)) == -1)
{
error ("requested alignment is not a power of 2");
*no_add_attrs = true;
}
else if (i > HOST_BITS_PER_INT - 2)
{
error ("requested alignment is too large");
*no_add_attrs = true;
}
else if (is_type)
{
if (decl && TREE_TYPE (decl) != error_mark_node
&& DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
{
tree tt = TREE_TYPE (decl);
*type = build_variant_type_copy (*type);
DECL_ORIGINAL_TYPE (decl) = tt;
TYPE_NAME (*type) = decl;
TREE_USED (*type) = TREE_USED (decl);
TREE_TYPE (decl) = *type;
}
else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*type = build_variant_type_copy (*type);
TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
TYPE_USER_ALIGN (*type) = 1;
}
else if (TREE_CODE (decl) != VAR_DECL
&& TREE_CODE (decl) != FIELD_DECL)
{
error ("%Jalignment may not be specified for %qD", decl, decl);
*no_add_attrs = true;
}
else
{
DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
DECL_USER_ALIGN (decl) = 1;
}
return NULL_TREE;
}
static tree
handle_weak_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
declare_weak (*node);
return NULL_TREE;
}
static tree
handle_alias_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree decl = *node;
if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
|| (TREE_CODE (decl) != FUNCTION_DECL && !DECL_EXTERNAL (decl)))
{
error ("%J%qD defined both normally and as an alias", decl, decl);
*no_add_attrs = true;
}
else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
{
tree id;
id = TREE_VALUE (args);
if (TREE_CODE (id) != STRING_CST)
{
error ("alias argument not a string");
*no_add_attrs = true;
return NULL_TREE;
}
id = get_identifier (TREE_STRING_POINTER (id));
TREE_USED (id) = 1;
if (TREE_CODE (decl) == FUNCTION_DECL)
DECL_INITIAL (decl) = error_mark_node;
else
{
DECL_EXTERNAL (decl) = 0;
TREE_STATIC (decl) = 1;
}
}
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_visibility_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
tree decl = *node;
tree id = TREE_VALUE (args);
*no_add_attrs = true;
if (TYPE_P (*node))
{
if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
{
warning ("%qs attribute ignored on non-class types",
IDENTIFIER_POINTER (name));
return NULL_TREE;
}
}
else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
return NULL_TREE;
}
if (TREE_CODE (id) != STRING_CST)
{
error ("visibility argument not a string");
return NULL_TREE;
}
if (TYPE_P (decl))
{
decl = TYPE_NAME (decl);
if (!decl)
return NULL_TREE;
if (TREE_CODE (decl) == IDENTIFIER_NODE)
{
warning ("%qE attribute ignored on types",
name);
return NULL_TREE;
}
}
if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
else
error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
DECL_VISIBILITY_SPECIFIED (decl) = 1;
if (DECL_P (*node))
*no_add_attrs = false;
return NULL_TREE;
}
bool
c_determine_visibility (tree decl)
{
gcc_assert (TREE_CODE (decl) == VAR_DECL
|| TREE_CODE (decl) == FUNCTION_DECL);
if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
return true;
if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
&& lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
{
DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
DECL_VISIBILITY_SPECIFIED (decl) = 1;
return true;
}
return false;
}
static tree
handle_tls_model_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree decl = *node;
if (!DECL_THREAD_LOCAL (decl))
{
warning ("%qs 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 argument 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 argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
*no_add_attrs = true;
return NULL_TREE;
}
}
return NULL_TREE;
}
static tree
handle_no_instrument_function_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
tree decl = *node;
if (TREE_CODE (decl) != FUNCTION_DECL)
{
error ("%J%qE attribute applies only to functions", decl, name);
*no_add_attrs = true;
}
else if (DECL_INITIAL (decl))
{
error ("%Jcan%'t set %qE attribute after definition", decl, name);
*no_add_attrs = true;
}
else
DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
return NULL_TREE;
}
static tree
handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_IS_MALLOC (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_no_limit_stack_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
tree decl = *node;
if (TREE_CODE (decl) != FUNCTION_DECL)
{
error ("%J%qE attribute applies only to functions", decl, name);
*no_add_attrs = true;
}
else if (DECL_INITIAL (decl))
{
error ("%Jcan%'t set %qE attribute after definition", decl, name);
*no_add_attrs = true;
}
else
DECL_NO_LIMIT_STACK (decl) = 1;
return NULL_TREE;
}
static tree
handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_IS_PURE (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_deprecated_attribute (tree *node, tree name,
tree ARG_UNUSED (args), 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
|| TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == FIELD_DECL)
TREE_DEPRECATED (decl) = 1;
else
warn = 1;
}
else if (TYPE_P (*node))
{
if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*node = build_variant_type_copy (*node);
TREE_DEPRECATED (*node) = 1;
type = *node;
}
else
warn = 1;
if (warn)
{
*no_add_attrs = true;
if (type && TYPE_NAME (type))
{
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
what = IDENTIFIER_POINTER (TYPE_NAME (*node));
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (type)))
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
}
if (what)
warning ("%qs attribute ignored for %qs",
IDENTIFIER_POINTER (name), what);
else
warning ("%qs attribute ignored",
IDENTIFIER_POINTER (name));
}
return NULL_TREE;
}
static tree
handle_unavailable_attribute (tree *node, tree name,
tree args ATTRIBUTE_UNUSED,
int flags ATTRIBUTE_UNUSED,
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
|| TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == FIELD_DECL)
{
TREE_DEPRECATED (decl) = 1;
TREE_UNAVAILABLE (decl) = 1;
}
else
warn = 1;
}
else if (TYPE_P (*node))
{
if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
*node = build_variant_type_copy (*node);
TREE_DEPRECATED (*node) = 1;
TREE_UNAVAILABLE (*node) = 1;
type = *node;
}
else
warn = 1;
if (warn)
{
*no_add_attrs = true;
if (type && TYPE_NAME (type))
{
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
what = IDENTIFIER_POINTER (TYPE_NAME (*node));
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (type)))
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
}
if (what)
warning ("`%s' attribute ignored for `%s'",
IDENTIFIER_POINTER (name), what);
else
warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
}
return NULL_TREE;
}
static tree
handle_vector_size_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags),
bool *no_add_attrs)
{
unsigned HOST_WIDE_INT vecsize, nunits;
enum machine_mode orig_mode;
tree type = *node, new_type, size;
*no_add_attrs = true;
size = TREE_VALUE (args);
if (TREE_CODE (size) == NON_LVALUE_EXPR)
size = TREE_OPERAND (size, 0);
if (!host_integerp (size, 1))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
return NULL_TREE;
}
vecsize = tree_low_cst (size, 1);
while (POINTER_TYPE_P (type)
|| TREE_CODE (type) == FUNCTION_TYPE
|| TREE_CODE (type) == METHOD_TYPE
|| TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
orig_mode = TYPE_MODE (type);
if (TREE_CODE (type) == RECORD_TYPE
|| (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
&& GET_MODE_CLASS (orig_mode) != MODE_INT)
|| !host_integerp (TYPE_SIZE_UNIT (type), 1))
{
error ("invalid vector type for attribute %qs",
IDENTIFIER_POINTER (name));
return NULL_TREE;
}
nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
if (nunits & (nunits - 1))
{
error ("number of components of the vector not a power of two");
return NULL_TREE;
}
new_type = build_vector_type (type, nunits);
*node = reconstruct_complex_type (*node, new_type);
return NULL_TREE;
}
static tree
handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
tree args, int ARG_UNUSED (flags),
bool *no_add_attrs)
{
tree type = *node;
unsigned HOST_WIDE_INT attr_arg_num;
if (!args)
{
if (!TYPE_ARG_TYPES (type))
{
error ("nonnull attribute without arguments on a non-prototype");
*no_add_attrs = true;
}
return NULL_TREE;
}
for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
{
tree argument;
unsigned HOST_WIDE_INT arg_num = 0, ck_num;
if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
{
error ("nonnull argument has invalid operand number (argument %lu)",
(unsigned long) attr_arg_num);
*no_add_attrs = true;
return NULL_TREE;
}
argument = TYPE_ARG_TYPES (type);
if (argument)
{
for (ck_num = 1; ; ck_num++)
{
if (!argument || ck_num == arg_num)
break;
argument = TREE_CHAIN (argument);
}
if (!argument
|| TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
{
error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
(unsigned long) attr_arg_num, (unsigned long) arg_num);
*no_add_attrs = true;
return NULL_TREE;
}
if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
{
error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
(unsigned long) attr_arg_num, (unsigned long) arg_num);
*no_add_attrs = true;
return NULL_TREE;
}
}
}
return NULL_TREE;
}
static void
check_function_nonnull (tree attrs, tree params)
{
tree a, args, param;
int param_num;
for (a = attrs; a; a = TREE_CHAIN (a))
{
if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
{
args = TREE_VALUE (a);
for (param = params, param_num = 1; ;
param_num++, param = TREE_CHAIN (param))
{
if (!param)
break;
if (!args || nonnull_check_p (args, param_num))
check_function_arguments_recurse (check_nonnull_arg, NULL,
TREE_VALUE (param),
param_num);
}
}
}
}
static void
check_function_sentinel (tree attrs, tree params)
{
tree attr = lookup_attribute ("sentinel", attrs);
if (attr)
{
if (!params)
warning ("missing sentinel in function call");
else
{
tree sentinel, end;
unsigned pos = 0;
if (TREE_VALUE (attr))
{
tree p = TREE_VALUE (TREE_VALUE (attr));
STRIP_NOPS (p);
pos = TREE_INT_CST_LOW (p);
}
sentinel = end = params;
while (pos > 0 && TREE_CHAIN (end))
{
pos--;
end = TREE_CHAIN (end);
}
if (pos > 0)
{
warning ("not enough arguments to fit a sentinel");
return;
}
while (TREE_CHAIN (end))
{
end = TREE_CHAIN (end);
sentinel = TREE_CHAIN (sentinel);
}
if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
|| !integer_zerop (TREE_VALUE (sentinel)))
&& (warn_strict_null_sentinel
|| null_node != TREE_VALUE (sentinel)))
warning ("missing sentinel in function call");
}
}
}
static bool
nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
{
unsigned HOST_WIDE_INT arg_num = 0;
for (; args; args = TREE_CHAIN (args))
{
bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
gcc_assert (found);
if (arg_num == param_num)
return true;
}
return false;
}
static void
check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
unsigned HOST_WIDE_INT param_num)
{
if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
return;
if (integer_zerop (param))
warning ("null argument where non-null required (argument %lu)",
(unsigned long) param_num);
}
static bool
get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
{
while (TREE_CODE (arg_num_expr) == NOP_EXPR
|| TREE_CODE (arg_num_expr) == CONVERT_EXPR
|| TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
if (TREE_CODE (arg_num_expr) != INTEGER_CST
|| TREE_INT_CST_HIGH (arg_num_expr) != 0)
return false;
*valp = TREE_INT_CST_LOW (arg_num_expr);
return true;
}
static tree
handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_NOTHROW (*node) = 1;
else
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_cleanup_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree decl = *node;
tree cleanup_id, cleanup_decl;
if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
return NULL_TREE;
}
cleanup_id = TREE_VALUE (args);
if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
{
error ("cleanup argument not an identifier");
*no_add_attrs = true;
return NULL_TREE;
}
cleanup_decl = lookup_name_two (cleanup_id, 0);
if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
{
error ("cleanup argument not a function");
*no_add_attrs = true;
return NULL_TREE;
}
return NULL_TREE;
}
static tree
handle_warn_unused_result_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (VOID_TYPE_P (TREE_TYPE (*node)))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
return NULL_TREE;
}
static tree
handle_sentinel_attribute (tree *node, tree name, tree args,
int ARG_UNUSED (flags), bool *no_add_attrs)
{
tree params = TYPE_ARG_TYPES (*node);
if (!params)
{
warning ("%qs attribute requires prototypes with named arguments",
IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
else
{
while (TREE_CHAIN (params))
params = TREE_CHAIN (params);
if (VOID_TYPE_P (TREE_VALUE (params)))
{
warning ("%qs attribute only applies to variadic functions",
IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
if (args)
{
tree position = TREE_VALUE (args);
STRIP_NOPS (position);
if (TREE_CODE (position) != INTEGER_CST)
{
warning ("requested position is not an integer constant");
*no_add_attrs = true;
}
else
{
if (tree_int_cst_lt (position, integer_zero_node))
{
warning ("requested position is less than zero");
*no_add_attrs = true;
}
}
}
return NULL_TREE;
}
void
check_function_arguments (tree attrs, tree params)
{
if (warn_nonnull)
check_function_nonnull (attrs, params);
if (warn_format)
{
check_function_format (attrs, params);
check_function_sentinel (attrs, params);
}
}
void
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)
{
check_function_arguments_recurse (callback, ctx,
TREE_OPERAND (param, 0), param_num);
return;
}
if (TREE_CODE (param) == CALL_EXPR)
{
tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
tree attrs;
bool found_format_arg = false;
for (attrs = TYPE_ATTRIBUTES (type);
attrs;
attrs = TREE_CHAIN (attrs))
if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
{
tree inner_args;
tree format_num_expr;
int format_num;
int i;
format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
while (TREE_CODE (format_num_expr) == NOP_EXPR
|| TREE_CODE (format_num_expr) == CONVERT_EXPR
|| TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
format_num_expr = TREE_OPERAND (format_num_expr, 0);
gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
&& !TREE_INT_CST_HIGH (format_num_expr));
format_num = TREE_INT_CST_LOW (format_num_expr);
for (inner_args = TREE_OPERAND (param, 1), i = 1;
inner_args != 0;
inner_args = TREE_CHAIN (inner_args), i++)
if (i == format_num)
{
check_function_arguments_recurse (callback, ctx,
TREE_VALUE (inner_args),
param_num);
found_format_arg = true;
break;
}
}
if (found_format_arg)
return;
}
if (TREE_CODE (param) == COND_EXPR)
{
check_function_arguments_recurse (callback, ctx,
TREE_OPERAND (param, 1), param_num);
check_function_arguments_recurse (callback, ctx,
TREE_OPERAND (param, 2), param_num);
return;
}
(*callback) (ctx, param, param_num);
}
int
field_decl_cmp (const void *x_p, const void *y_p)
{
const tree *const x = (const tree *const) x_p;
const tree *const y = (const tree *const) y_p;
if (DECL_NAME (*x) == DECL_NAME (*y))
return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
if (DECL_NAME (*x) == NULL_TREE)
return -1;
if (DECL_NAME (*y) == NULL_TREE)
return 1;
if (DECL_NAME (*x) < DECL_NAME (*y))
return -1;
return 1;
}
static struct {
gt_pointer_operator new_value;
void *cookie;
} resort_data;
static int
resort_field_decl_cmp (const void *x_p, const void *y_p)
{
const tree *const x = (const tree *const) x_p;
const tree *const y = (const tree *const) y_p;
if (DECL_NAME (*x) == DECL_NAME (*y))
return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
if (DECL_NAME (*x) == NULL_TREE)
return -1;
if (DECL_NAME (*y) == NULL_TREE)
return 1;
{
tree d1 = DECL_NAME (*x);
tree d2 = DECL_NAME (*y);
resort_data.new_value (&d1, resort_data.cookie);
resort_data.new_value (&d2, resort_data.cookie);
if (d1 < d2)
return -1;
}
return 1;
}
void
resort_sorted_fields (void *obj,
void * ARG_UNUSED (orig_obj),
gt_pointer_operator new_value,
void *cookie)
{
struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
resort_data.new_value = new_value;
resort_data.cookie = cookie;
qsort (&sf->elts[0], sf->len, sizeof (tree),
resort_field_decl_cmp);
}
static char *
catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
{
const int lhs_size = strlen (lhs);
char *result = XNEWVEC (char, lhs_size + rhs_size);
strncpy (result, lhs, lhs_size);
strncpy (result + lhs_size, rhs_start, rhs_size);
return result;
}
void
c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
{
#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
char *message = NULL;
if (token == CPP_EOF)
message = catenate_messages (gmsgid, " at end of input");
else if (token == CPP_CHAR || token == CPP_WCHAR)
{
unsigned int val = TREE_INT_CST_LOW (value);
const char *const ell = (token == CPP_CHAR) ? "" : "L";
if (val <= UCHAR_MAX && ISGRAPH (val))
message = catenate_messages (gmsgid, " before %s'%c'");
else
message = catenate_messages (gmsgid, " before %s'\\x%x'");
error (message, ell, val);
free (message);
message = NULL;
}
else if (token == CPP_STRING || token == CPP_WSTRING)
message = catenate_messages (gmsgid, " before string constant");
else if (token == CPP_NUMBER)
message = catenate_messages (gmsgid, " before numeric constant");
else if (token == CPP_NAME)
{
message = catenate_messages (gmsgid, " before %qs");
error (message, IDENTIFIER_POINTER (value));
free (message);
message = NULL;
}
else if (token < N_TTYPES)
{
message = catenate_messages (gmsgid, " before %qs token");
error (message, cpp_type2name (token));
free (message);
message = NULL;
}
else
error (gmsgid);
if (message)
{
error (message);
free (message);
}
#undef catenate_messages
}
void
c_warn_unused_result (tree *top_p)
{
tree t = *top_p;
tree_stmt_iterator i;
tree fdecl, ftype;
switch (TREE_CODE (t))
{
case STATEMENT_LIST:
for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
c_warn_unused_result (tsi_stmt_ptr (i));
break;
case COND_EXPR:
c_warn_unused_result (&COND_EXPR_THEN (t));
c_warn_unused_result (&COND_EXPR_ELSE (t));
break;
case BIND_EXPR:
c_warn_unused_result (&BIND_EXPR_BODY (t));
break;
case TRY_FINALLY_EXPR:
case TRY_CATCH_EXPR:
c_warn_unused_result (&TREE_OPERAND (t, 0));
c_warn_unused_result (&TREE_OPERAND (t, 1));
break;
case CATCH_EXPR:
c_warn_unused_result (&CATCH_BODY (t));
break;
case EH_FILTER_EXPR:
c_warn_unused_result (&EH_FILTER_FAILURE (t));
break;
case CALL_EXPR:
if (TREE_USED (t))
break;
fdecl = get_callee_fndecl (t);
if (fdecl)
ftype = TREE_TYPE (fdecl);
else
{
ftype = TREE_TYPE (TREE_OPERAND (t, 0));
ftype = TREE_TYPE (ftype);
}
if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
{
if (fdecl)
warning ("%Hignoring return value of %qD, "
"declared with attribute warn_unused_result",
EXPR_LOCUS (t), fdecl);
else
warning ("%Hignoring return value of function "
"declared with attribute warn_unused_result",
EXPR_LOCUS (t));
}
break;
default:
break;
}
}
HOST_WIDE_INT
c_common_to_target_charset (HOST_WIDE_INT c)
{
cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
uc = cpp_host_to_exec_charset (parse_in, uc);
if (flag_signed_char)
return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
>> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
else
return uc;
}
static tree
fold_offsetof_1 (tree expr)
{
enum tree_code code = PLUS_EXPR;
tree base, off, t;
switch (TREE_CODE (expr))
{
case ERROR_MARK:
return expr;
case INDIRECT_REF:
return size_zero_node;
case COMPONENT_REF:
base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
if (base == error_mark_node)
return base;
t = TREE_OPERAND (expr, 1);
if (DECL_C_BIT_FIELD (t))
{
error ("attempt to take address of bit-field structure "
"member %qs", IDENTIFIER_POINTER (DECL_NAME (t)));
return error_mark_node;
}
off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
/ BITS_PER_UNIT));
break;
case ARRAY_REF:
base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
if (base == error_mark_node)
return base;
t = TREE_OPERAND (expr, 1);
if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
{
code = MINUS_EXPR;
t = fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t));
}
t = convert (sizetype, t);
off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
break;
default:
gcc_unreachable ();
}
return size_binop (code, base, off);
}
tree
fold_offsetof (tree expr)
{
return convert (size_type_node, fold_offsetof_1 (expr));
}
int
lvalue_or_else (tree *ref, enum lvalue_use use)
{
tree r = *ref;
int win = lvalue_p (r);
if (!win && flag_non_lvalue_assign)
{
if ((TREE_CODE (r) == NOP_EXPR || TREE_CODE (r) == CONVERT_EXPR
|| TREE_CODE (r) == NON_LVALUE_EXPR)
&& (use == lv_assign || use == lv_increment || use == lv_decrement
|| use == lv_addressof)
&& lvalue_or_else (&TREE_OPERAND (r, 0), use))
{
tree cast_to = TREE_TYPE (r);
tree cast_from = TREE_TYPE (TREE_OPERAND (r, 0));
if (simple_cst_equal (TYPE_SIZE (cast_to), TYPE_SIZE (cast_from))
&& TYPE_ALIGN (cast_to) == TYPE_ALIGN (cast_from))
{
*ref
= build_indirect_ref
(convert (build_pointer_type (cast_to),
build_unary_op
(ADDR_EXPR, TREE_OPERAND (r, 0), 0)), 0);
goto allow_as_lvalue;
}
}
else if (TREE_CODE (r) == COND_EXPR
&& lvalue_or_else (&TREE_OPERAND (r, 1), use)
&& lvalue_or_else (&TREE_OPERAND (r, 2), use))
{
*ref
= build_indirect_ref
(build_conditional_expr
(TREE_OPERAND (r, 0),
build_unary_op (ADDR_EXPR, TREE_OPERAND (r, 1), 0),
build_unary_op (ADDR_EXPR, TREE_OPERAND (r, 2), 0)),
0);
allow_as_lvalue:
win = 1;
if (warn_non_lvalue_assign)
warning ("%s not really an lvalue; "
"this will be a hard error in the future",
(use == lv_addressof
? "argument to '&'"
: "target of assignment"));
}
}
if (!win)
{
switch (use)
{
case lv_assign:
error ("invalid lvalue in assignment");
break;
case lv_increment:
error ("invalid lvalue in increment");
break;
case lv_decrement:
error ("invalid lvalue in decrement");
break;
case lv_addressof:
error ("invalid lvalue in unary %<&%>");
break;
case lv_asm:
error ("invalid lvalue in asm statement");
break;
default:
gcc_unreachable ();
}
}
return win;
}
int
complete_array_type (tree *ptype, tree initial_value, bool do_default)
{
tree maxindex, type, main_type, elt, unqual_elt;
int failure = 0, quals;
maxindex = size_zero_node;
if (initial_value)
{
if (TREE_CODE (initial_value) == STRING_CST)
{
int eltsize
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
}
else if (TREE_CODE (initial_value) == CONSTRUCTOR)
{
tree elts = CONSTRUCTOR_ELTS (initial_value);
if (elts == NULL)
{
if (pedantic)
failure = 3;
maxindex = integer_minus_one_node;
}
else
{
tree curindex;
if (TREE_PURPOSE (elts))
maxindex = fold_convert (sizetype, TREE_PURPOSE (elts));
curindex = maxindex;
for (elts = TREE_CHAIN (elts); elts; elts = TREE_CHAIN (elts))
{
if (TREE_PURPOSE (elts))
curindex = fold_convert (sizetype, TREE_PURPOSE (elts));
else
curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
if (tree_int_cst_lt (maxindex, curindex))
maxindex = curindex;
}
}
}
else
{
if (initial_value != error_mark_node)
failure = 1;
}
}
else
{
failure = 2;
if (!do_default)
return failure;
}
type = *ptype;
elt = TREE_TYPE (type);
quals = TYPE_QUALS (strip_array_types (elt));
if (quals == 0)
unqual_elt = elt;
else
unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
TREE_TYPE (main_type) = unqual_elt;
TYPE_DOMAIN (main_type) = build_index_type (maxindex);
layout_type (main_type);
if (quals == 0)
type = main_type;
else
type = c_build_qualified_type (main_type, quals);
*ptype = type;
return failure;
}
tree
vector_constructor_from_expr (tree expr, tree vector_type)
{
tree list = NULL_TREE, elttype = TREE_TYPE (vector_type);
int index;
bool final;
int all_constant = TREE_CONSTANT (expr);
if (TREE_CODE (TREE_TYPE (expr)) == VECTOR_TYPE)
return convert (vector_type, expr);
final = false;
for (index = 0; !final; ++index)
{
tree elem;
if (TREE_CODE (expr) == COMPOUND_EXPR)
{
elem = TREE_OPERAND (expr, 1);
expr = TREE_OPERAND (expr, 0);
}
else
{
final = true;
elem = expr;
}
while (TREE_CODE (elem) == COMPOUND_EXPR && TREE_CONSTANT (elem))
elem = TREE_OPERAND (elem, 1);
while (TREE_CODE (elem) == CONVERT_EXPR)
elem = TREE_OPERAND (elem, 0);
list = chainon (list,
build_tree_list (NULL_TREE,
convert (elttype, fold (elem))));
}
list = nreverse (list);
list = build_constructor (vector_type, list);
if (c_dialect_cxx ())
TREE_LANG_FLAG_4 (list) = 1;
TREE_CONSTANT (list) = all_constant;
return list;
}
tree
iasm_addr (tree e)
{
tree type = TREE_TYPE (e);
if (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
if ((TREE_CODE (e) == VAR_DECL
|| TREE_CODE (e) == PARM_DECL)
&& ! C_DECL_REGISTER (e))
{
type = build_pointer_type (type);
e = build1 (ADDR_EXPR, type, e);
}
return e;
}
static enum machine_mode
iasm_get_mode (tree type)
{
const char *s = IDENTIFIER_POINTER (type);
if (strcasecmp (s, "byte") == 0)
return QImode;
if (strcasecmp (s, "word") == 0)
return HImode;
if (strcasecmp (s, "dword") == 0)
return SImode;
if (strcasecmp (s, "qword") == 0)
return DImode;
if (strcasecmp (s, "oword") == 0)
return TImode;
if (strcasecmp (s, "real4") == 0)
return SFmode;
if (strcasecmp (s, "real8") == 0)
return DFmode;
#if defined (TARGET_386)
if (strcasecmp (s, "real10") == 0)
return XFmode;
if (strcasecmp (s, "tbyte") == 0)
return XFmode;
#endif
return VOIDmode;
}
tree
iasm_ptr_conv (tree type, tree exp)
{
tree rhstype, ntype = NULL_TREE;
enum machine_mode to_mode;
if (TREE_TYPE (exp) == void_type_node
&& TREE_CODE (exp) == BRACKET_EXPR)
{
TREE_TYPE (exp) = type;
return exp;
}
if (TREE_CODE (type) == IDENTIFIER_NODE
&& (TREE_CODE (exp) == IDENTIFIER_NODE
|| TREE_CODE (TREE_TYPE (exp)) == IDENTIFIER_NODE))
{
if (TREE_CODE (exp) == BRACKET_EXPR)
{
TREE_OPERAND (exp, 0) = build1 (NOP_EXPR, type, TREE_OPERAND (exp, 0));
return exp;
}
return build1 (NOP_EXPR, type, exp);
}
rhstype = TREE_TYPE (exp);
to_mode = iasm_get_mode (type);
if (to_mode != VOIDmode)
{
if (to_mode == TYPE_MODE (rhstype))
return exp;
ntype = c_common_type_for_mode (to_mode, 0);
}
if (ntype == NULL_TREE)
{
error ("unknown C type for %<ptr%> type");
return exp;
}
exp = build1 (INDIRECT_REF, ntype,
fold_convert (build_pointer_type (ntype),
build_unary_op (ADDR_EXPR, exp, 1)));
return exp;
}
tree
iasm_build_bracket (tree v1, tree v2)
{
tree type = void_type_node;
if (TREE_CODE (v1) == NOP_EXPR
&& TREE_CODE (TREE_TYPE (v1)) == IDENTIFIER_NODE)
{
type = TREE_TYPE (v1);
v1 = TREE_OPERAND (v1, 0);
}
return build2 (BRACKET_EXPR, type, v1, v2);
}
static tree
iasm_default_function_conversion (tree exp)
{
tree type = TREE_TYPE (exp);
enum tree_code code = TREE_CODE (type);
while (TREE_CODE (exp) == NON_LVALUE_EXPR
|| (TREE_CODE (exp) == NOP_EXPR
&& TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
exp = TREE_OPERAND (exp, 0);
if (code == FUNCTION_TYPE)
return build_unary_op (ADDR_EXPR, exp, 0);
return exp;
}
bool
iasm_is_pseudo (const char *opcode)
{
return strcmp (opcode, ".long") == 0
|| strcmp (opcode, ".word") == 0
|| strcmp (opcode, ".byte") == 0
|| strcmp (opcode, ".short") == 0
|| strcmp (opcode, ".quad") == 0
|| strcmp (opcode, ".machine") == 0;
}
struct iasm_op_constraint
{
const char *opcode;
unsigned argnum;
const char *constraint;
};
#ifndef TARGET_IASM_OP_CONSTRAINT
#define TARGET_IASM_OP_CONSTRAINT {}
#endif
static int
iasm_op_comp (const void *a, const void *b)
{
const struct iasm_op_constraint *x = a;
const struct iasm_op_constraint *y = b;
int c = strcasecmp (x->opcode, y->opcode);
if (c)
return c;
if (x->argnum < y->argnum)
return -1;
if (x->argnum > y->argnum)
return 1;
return 0;
}
#if defined(TARGET_386)
#define U(X) ""
#define S(X)
#define m8 "m" S("1")
#define m16 "m" S("2")
#define m32 "m" S("4")
#define m64 "m" S("8")
#define m16m32 m16 m32
#define m16m32m64 m16 m32 m64
#define r8 "r" S("1")
#define r16 "r" S("2")
#define r32 "r" S("4")
#define r64 U("r" S("8"))
#define a8 "a" S("1")
#define a16 "a" S("2")
#define a32 "a" S("4")
#define r16r32 r16 r32
#define r16r32r64 r16 r32 r64
#define r8r16r32 r8 r16 r32
#define rm8 r8 m8
#define rm16 r16 m16
#define rm32 r32 m32
#define rm64 r64 m64
#define rm8rm16 rm8 rm16
#define rm8rm16rm32 rm8 rm16 rm32
#define rm8rm16rm32rm64 rm8 rm16 rm32 rm64
#define m8m16m32 m8 m16 m32
#define r32r64 r32 r64
#define ri8 r8 "i"
#define ri16 r16 "i"
#define ri32 r32 "i"
#define rel8 "s" S("1")
#define m32fp "m" S("3")
#define m64fp "m" S("6")
#define m80fp "m" S("7")
#define m32fpm64fp m32fp m64fp
#define m32fpm64fpm80fp m32fp m64fp m80fp
#endif
#ifndef TARGET_IASM_REORDER_ARG
#define TARGET_IASM_REORDER_ARG(OPCODE, NEWARGNUM, NUM_ARGS, ARGNUM)
#endif
#ifndef IASM_SYNTH_CONSTRAINTS
#define IASM_SYNTH_CONSTRAINTS(R, ARGNUM, NUM_ARGS, DB)
#endif
static const char*
iasm_constraint_for (const char *opcode, unsigned argnum, unsigned ARG_UNUSED (num_args))
{
const struct iasm_op_constraint db[] = {
TARGET_IASM_OP_CONSTRAINT
};
struct iasm_op_constraint key;
struct iasm_op_constraint *r;
#ifdef ENABLE_CHECKING
static int once;
if (once == 0)
{
size_t i;
once = 1;
for (i=0; i < sizeof (db) / sizeof(db[0]) - 1; ++i)
gcc_assert (iasm_op_comp (&db[i+1], &db[i]) >= 0);
}
#endif
key.opcode = opcode;
key.argnum = argnum;
TARGET_IASM_REORDER_ARG(opcode, key.argnum, num_args, argnum);
r = bsearch (&key, db, sizeof (db) / sizeof (db[0]), sizeof (db[0]), iasm_op_comp);
IASM_SYNTH_CONSTRAINTS(r, argnum, num_args, db);
if (r)
return r->constraint;
return NULL;
}
#if defined(TARGET_386)
#undef m8
#undef m16
#undef m32
#undef m64
#undef m16m32
#undef m16m32m64
#undef r8
#undef r16
#undef r32
#undef r64
#undef a8
#undef a16
#undef a32
#undef r16r32
#undef r16r32r64
#undef r8r16r32
#undef rm8
#undef rm16
#undef rm32
#undef rm64
#undef rm8rm16
#undef rm8rm16rm32
#undef rm8rm16rm32rm64
#undef m8m16m32
#undef r32r64
#undef ri8
#undef ri16
#undef ri32
#undef rel8
#undef m32fp
#undef m64fp
#undef m80fp
#undef m32fpm64fp
#undef m32fpm64fpm80fp
#undef U
#undef S
#endif
static void
iasm_process_arg (const char *opcodename, int op_num,
tree *outputsp, tree *inputsp, tree *uses, unsigned num_args,
iasm_md_extra_info *e)
{
const char *s;
bool was_output = true;
tree str, one;
tree var = e->dat[op_num].var;
unsigned argnum = e->dat[op_num].argnum;
bool must_be_reg = e->dat[op_num].must_be_reg;
if (e->dat[op_num].constraint)
s = e->dat[op_num].constraint;
else if (must_be_reg)
{
#if defined(TARGET_TOC)
s = "+b";
#elif defined(TARGET_386)
s = "+r";
#endif
}
else
s = iasm_constraint_for (opcodename, argnum, num_args);
if (TREE_CODE (var) == FUNCTION_DECL)
{
#if defined(TARGET_TOC)
str = build_string (1, "s");
#elif defined (TARGET_386)
str = build_string (strlen (s), s);
#endif
was_output = false;
}
else
{
if (s)
{
str = build_string (strlen (s), s);
was_output = ((s[0] == '=') | (s[0] == '+'));
}
else if (TREE_CODE (TREE_TYPE (var)) == REAL_TYPE)
str = build_string (2, "+f");
else
if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
str = build_string (2, "+v");
else
{
#if defined(TARGET_TOC)
str = build_string (2, "+b");
#elif defined(TARGET_386)
str = build_string (2, "+r");
#endif
}
}
one = build_tree_list (build_tree_list (NULL_TREE, str), var);
if (was_output)
{
*outputsp = chainon (*outputsp, one);
e->dat[op_num].was_output = true;
}
else
*inputsp = chainon (*inputsp, one);
if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
{
const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (var));
int regno = decode_reg_name (name);
if (regno >= 0)
{
tree tail, pred;
for (tail = *uses, pred = *uses; tail; tail = TREE_CHAIN (tail))
{
if (regno == decode_reg_name (TREE_STRING_POINTER (TREE_VALUE (tail))))
break;
else
pred = tail;
}
if (tail)
{
if (tail == pred)
*uses = TREE_CHAIN (tail);
else
{
TREE_CHAIN (pred) = TREE_CHAIN (tail);
}
}
}
}
else if (TREE_CODE (var) == VAR_DECL
&& !strcmp(TREE_STRING_POINTER (str), "m"))
TREE_ADDRESSABLE (var) = 1;
}
static tree
iasm_identifier (tree expr)
{
const char *opcodename = IDENTIFIER_POINTER (expr);
int len = IDENTIFIER_LENGTH (expr);
int i;
for (i = 0; i < len; i++)
if (opcodename[i] == '.')
break;
if (i+1 < len)
{
char *buf = (char *) alloca (IDENTIFIER_LENGTH (expr) + 1);
strncpy (buf, opcodename, i);
buf[i] = ' ';
strcpy (buf+i+1, opcodename + i);
return get_identifier (buf);
}
return expr;
}
#ifndef IASM_CANONICALIZE_OPERANDS
#define IASM_CANONICALIZE_OPERANDS(OPCODE, NEW_OPCODE, IARGS, E) (NEW_OPCODE = OPCODE)
#endif
#ifndef IASM_IS_PREFIX
#define IASM_IS_PREFIX(ID)
#endif
#ifndef IASM_PRINT_PREFIX
#define IASM_PRINT_PREFIX(BUF, PREFIX_LIST)
#endif
bool
iasm_is_prefix (tree ARG_UNUSED (id))
{
IASM_IS_PREFIX (id);
return false;
}
static int
iasm_num_constraints_1 (tree io)
{
int num = 0;
while (io)
{
const char *constraints = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (io)));
while (*++constraints)
if (constraints[0] == ',')
++num;
if (num)
return num+1;
io = TREE_CHAIN (io);
}
return num;
}
static int
iasm_num_constraints (tree inputs, tree outputs)
{
int num;
num = iasm_num_constraints_1 (inputs);
if (num)
return num;
num = iasm_num_constraints_1 (outputs);
return num;
}
static void
iasm_set_constraints_1 (int num, tree io)
{
if (num < 2)
return;
while (io)
{
int i;
const char *constraints = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (io)));
if (strchr (constraints, ',') == 0)
{
char *buf = alloca (strlen (constraints) * num + num);
char *p = buf;
while (*constraints == '+' || *constraints == '&' || *constraints == '=')
*p++ = *constraints++;
for (i = 0; i < num; ++i)
{
p = stpcpy (p, constraints);
*p++ = ',';
}
p[-1] = 0;
TREE_VALUE (TREE_PURPOSE (io)) = build_string (strlen (buf), buf);
}
io = TREE_CHAIN (io);
}
}
static void
iasm_set_constraints (int num, tree inputs, tree outputs)
{
iasm_set_constraints_1 (num, inputs);
iasm_set_constraints_1 (num, outputs);
}
#define IASM_MAX_CLOBBERS 3
struct iasm_op_clobber
{
const char *opcode;
const char *clobbers[IASM_MAX_CLOBBERS];
};
static int
iasm_op_clobber_comp (const void *a, const void *b)
{
const struct iasm_op_clobber *x = a;
const struct iasm_op_clobber *y = b;
return strcasecmp (x->opcode, y->opcode);
}
#ifndef TARGET_IASM_EXTRA_CLOBBERS
#define TARGET_IASM_EXTRA_CLOBBERS { "zzzzz", { 0 } }
#endif
static void
iasm_extra_clobbers (const char *opcode, tree *clobbersp)
{
struct iasm_op_clobber db[] = { TARGET_IASM_EXTRA_CLOBBERS };
struct iasm_op_clobber key;
struct iasm_op_clobber *r;
const char **clobbers;
int num;
#ifdef ENABLE_CHECKING
static int once;
if (once == 0)
{
size_t i;
once = 1;
for (i=0; i < sizeof (db) / sizeof(db[0]) - 1; ++i)
gcc_assert (iasm_op_clobber_comp (&db[i+1], &db[i]) >= 0);
}
#endif
key.opcode = opcode;
r = bsearch (&key, db, sizeof (db) / sizeof (db[0]), sizeof (db[0]), iasm_op_clobber_comp);
if (r == 0)
return;
for (clobbers = r->clobbers, num = 0; num < IASM_MAX_CLOBBERS && *clobbers; ++clobbers, ++num)
{
tree reg = build_string (strlen (*clobbers), *clobbers);
*clobbersp = tree_cons (NULL_TREE, reg, *clobbersp);
}
}
tree
iasm_stmt (tree expr, tree args, int lineno)
{
int saved_lineno = input_location.line;
tree sexpr;
tree arg, tail;
tree inputs, outputs, clobbers, uses;
tree prefix_list = NULL_TREE;
tree stmt;
unsigned int n, num_args;
const char *opcodename, *new_opcode;
iasm_md_extra_info e;
char *buf;
memset (&e, 0, sizeof (e));
input_location.line = lineno;
iasm_in_operands = false;
outputs = NULL_TREE;
inputs = NULL_TREE;
clobbers = NULL_TREE;
uses = NULL_TREE;
STRIP_NOPS (expr);
if (TREE_CODE (expr) == TREE_LIST)
{
prefix_list = TREE_CHAIN (expr);
expr = TREE_VALUE (expr);
}
if (TREE_CODE (expr) == ADDR_EXPR)
expr = TREE_OPERAND (expr, 0);
expr = iasm_identifier (expr);
opcodename = IDENTIFIER_POINTER (expr);
if (strcmp (opcodename, "entry") == 0)
return iasm_entry (expr, NULL_TREE, TREE_VALUE (args));
else if (strcmp (opcodename, "fralloc") == 0)
{
DECL_IASM_FRAME_SIZE (current_function_decl) = -1;
if (args)
{
arg = TREE_VALUE (args);
STRIP_NOPS (arg);
if (TREE_CODE (arg) == INTEGER_CST)
{
int intval = tree_low_cst (arg, 0);
if (intval >= 0)
DECL_IASM_FRAME_SIZE (current_function_decl) = intval;
else
error ("fralloc argument must be nonnegative");
}
else
error ("fralloc argument is not an integer");
}
return NULL_TREE;
}
else if (strcmp (opcodename, "frfree") == 0)
{
DECL_IASM_NORETURN (current_function_decl) = 1;
if (DECL_IASM_FRAME_SIZE (current_function_decl) == (unsigned int)-2)
DECL_IASM_FRAME_SIZE (current_function_decl) = (unsigned int)-1;
return NULL_TREE;
}
else if (strcmp (opcodename, "nofralloc") == 0)
{
DECL_IASM_NORETURN (current_function_decl) = 1;
DECL_IASM_FRAME_SIZE (current_function_decl) = -2;
return NULL_TREE;
}
else if (strcmp (opcodename, "machine") == 0)
return NULL_TREE;
else if (strcmp (opcodename, "opword") == 0)
opcodename = " .long";
else if (strncmp (opcodename, "_emit", 5) == 0)
opcodename = " .byte";
if (iasm_buffer == NULL)
iasm_buffer = xmalloc (4000);
sprintf(iasm_buffer, "%s \"%s\"", ".file", input_filename);
sexpr = build_string (strlen (iasm_buffer), iasm_buffer);
stmt = build_stmt (ASM_EXPR, sexpr, NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
ASM_VOLATILE_P (stmt) = 1;
(void)add_stmt (stmt);
sprintf(iasm_buffer, "%s %d", ".line", lineno);
sexpr = build_string (strlen (iasm_buffer), iasm_buffer);
stmt = build_stmt (ASM_EXPR, sexpr, NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
ASM_VOLATILE_P (stmt) = 1;
(void)add_stmt (stmt);
iasm_buffer[0] = '\0';
IASM_CANONICALIZE_OPERANDS (opcodename, new_opcode, args, &e);
IASM_PRINT_PREFIX(iasm_buffer, prefix_list);
if (strcmp (opcodename, " .machine") == 0)
e.no_label_map = true;
strcat (iasm_buffer, new_opcode);
strcat (iasm_buffer, " ");
n = 1;
for (tail = args; tail; tail = TREE_CHAIN (tail))
{
arg = TREE_VALUE (tail);
if (tail != args)
strcat (iasm_buffer, ", ");
iasm_print_operand (iasm_buffer, arg, n, &uses, false, false, &e);
++n;
}
num_args = n-1;
for (n = 0; (int)n < e.num; ++n)
iasm_process_arg (opcodename, n,
&outputs, &inputs, &uses, num_args, &e);
buf = iasm_buffer + strlen (iasm_buffer);
{
int i = 0;
for (n = 0; (int)n < e.num; ++n)
{
if (e.dat[n].was_output)
{
gcc_assert (i < 10);
e.dat[n].arg_p[0] = '0' + i++;
}
}
for (n = 0; (int)n < e.num; ++n)
{
if (! e.dat[n].was_output)
{
gcc_assert (i < 10);
e.dat[n].arg_p[0] = '0' + i++;
}
}
}
sexpr = build_string (strlen (iasm_buffer), iasm_buffer);
clobbers = uses;
if (iasm_memory_clobber (opcodename))
{
clobbers = tree_cons (NULL_TREE,
build_string (6, "memory"),
clobbers);
}
for (tail = inputs; tail; tail = TREE_CHAIN (tail))
TREE_VALUE (tail) = iasm_default_function_conversion (TREE_VALUE (tail));
iasm_set_constraints (iasm_num_constraints (inputs, outputs), inputs, outputs);
iasm_extra_clobbers (opcodename, &clobbers);
stmt = build_stmt (ASM_EXPR, sexpr, outputs, inputs, clobbers, uses);
ASM_VOLATILE_P (stmt) = 1;
stmt = add_stmt (stmt);
input_location.line = saved_lineno;
return stmt;
}
static int
iasm_field_offset (tree arg)
{
return (tree_low_cst (DECL_FIELD_OFFSET (arg), 0)
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (arg), 0) / BITS_PER_UNIT);
}
static bool
iasm_simple_expr (tree arg)
{
if (TREE_CODE (arg) == FIELD_DECL)
return true;
if (TREE_CODE (arg) == INTEGER_CST)
return true;
if (TREE_CODE (arg) == REAL_CST)
return true;
if (TREE_CODE (arg) == PLUS_EXPR
|| TREE_CODE (arg) == MINUS_EXPR)
return iasm_simple_expr (TREE_OPERAND (arg, 0))
&& iasm_simple_expr (TREE_OPERAND (arg, 1));
if (TREE_CODE (arg) == NEGATE_EXPR)
return iasm_simple_expr (TREE_OPERAND (arg, 0));
if (TREE_CODE (arg) == ARRAY_REF
&& TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST
&& TREE_INT_CST_LOW (TREE_OPERAND (arg, 1)) == 0)
return iasm_simple_expr (TREE_OPERAND (arg, 0));
return false;
}
static int
iasm_expr_val (tree arg)
{
if (TREE_CODE (arg) == FIELD_DECL)
return iasm_field_offset (arg);
if (TREE_CODE (arg) == INTEGER_CST)
return int_cst_value (arg);
if (TREE_CODE (arg) == REAL_CST)
return int_cst_value (convert (integer_type_node, arg));
if (TREE_CODE (arg) == PLUS_EXPR)
return iasm_expr_val (TREE_OPERAND (arg, 0))
+ iasm_expr_val (TREE_OPERAND (arg, 1));
if (TREE_CODE (arg) == MINUS_EXPR)
return iasm_expr_val (TREE_OPERAND (arg, 0))
- iasm_expr_val (TREE_OPERAND (arg, 1));
if (TREE_CODE (arg) == NEGATE_EXPR)
return - iasm_expr_val (TREE_OPERAND (arg, 0));
if (TREE_CODE (arg) == ARRAY_REF
&& TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST
&& TREE_INT_CST_LOW (TREE_OPERAND (arg, 1)) == 0)
return iasm_expr_val (TREE_OPERAND (arg, 0));
error ("invalid operand for arithmetic in assembly block");
return 0;
}
#ifndef TARGET_IASM_PRINT_OP
#define TARGET_IASM_PRINT_OP(BUF, ARG, ARGNUM, USES, MUST_BE_REG, MUST_NOT_BE_REG, E) false
#endif
#ifndef IASM_IMMED_PREFIX
#define IASM_IMMED_PREFIX(E, BUF)
#endif
#ifndef IASM_OFFSET_PREFIX
#define IASM_OFFSET_PREFIX(E, BUF)
#endif
#ifndef IASM_HIDE_REG
#define IASM_HIDE_REG(R) false
#endif
#ifndef IASM_SEE_IMMEDIATE
#define IASM_SEE_IMMEDIATE(E)
#endif
#ifndef IASM_SEE_NO_IMMEDIATE
#define IASM_SEE_NO_IMMEDIATE(E)
#endif
#ifndef IASM_FUNCTION_MODIFIER
#define IASM_FUNCTION_MODIFIER ""
#endif
#ifndef IASM_VALID_PIC
#define IASM_VALID_PIC(D,E)
#endif
void
iasm_force_constraint (const char *c, iasm_md_extra_info *e)
{
e->dat[e->num].constraint = c;
}
static void
iasm_maybe_force_mem (tree arg, char *buf, unsigned argnum, bool must_be_reg, iasm_md_extra_info *e)
{
#if defined (TARGET_386)
if (! (TREE_CODE (arg) == VAR_DECL && DECL_HARD_REGISTER (arg))
&& e->dat[e->num].constraint == 0)
iasm_force_constraint ("m", e);
#endif
iasm_get_register_var (arg, "", buf, argnum, must_be_reg, e);
#if defined (TARGET_386)
iasm_force_constraint (0, e);
#endif
}
void
iasm_print_operand (char *buf, tree arg, unsigned argnum,
tree *uses,
bool must_be_reg, bool must_not_be_reg, iasm_md_extra_info *e)
{
HOST_WIDE_INT bitsize, bitpos;
tree offset;
enum machine_mode mode;
int unsignedp, volatilep;
tree op0;
STRIP_NOPS (arg);
switch (TREE_CODE (arg))
{
case INTEGER_CST:
IASM_IMMED_PREFIX (e, buf);
sprintf (buf + strlen (buf), HOST_WIDE_INT_PRINT_DEC, tree_low_cst (arg, 0));
break;
case LABEL_DECL:
TREE_USED (arg) = 1;
if (e->no_label_map
&& strncmp (IDENTIFIER_POINTER (DECL_NAME (arg)),
"LASM$", 5) == 0)
{
const char *name = IDENTIFIER_POINTER (DECL_NAME (arg)) + 5;
#if defined(TARGET_TOC)
if (strcmp (name, "all") == 0)
{
if (TARGET_64BIT)
name = "ppc64";
else
name = "ppc970";
}
#endif
sprintf (buf + strlen (buf), "%s", name);
break;
}
IASM_OFFSET_PREFIX (e, buf);
arg = build1 (ADDR_EXPR, ptr_type_node, arg);
iasm_force_constraint ("X", e);
iasm_get_register_var (arg, "l", buf, argnum, must_be_reg, e);
iasm_force_constraint (0, e);
break;
case IDENTIFIER_NODE:
#if defined(TARGET_386)
arg = iasm_raise_reg (arg);
if (TREE_CODE (arg) == VAR_DECL)
{
iasm_get_register_var (arg, "", buf, argnum, must_be_reg, e);
break;
}
#endif
if (IDENTIFIER_LENGTH (arg) > 0 && IDENTIFIER_POINTER (arg)[0] == '%')
strcat (buf, "%");
strcat (buf, IDENTIFIER_POINTER (arg));
{
int regno = decode_reg_name (IDENTIFIER_POINTER (arg));
if (IASM_HIDE_REG (regno))
regno = -1;
if (regno >= 0)
{
tree tail;
for (tail = *uses; tail; tail = TREE_CHAIN (tail))
if (regno == decode_reg_name (TREE_STRING_POINTER (TREE_VALUE (tail))))
break;
if (!tail)
{
const char *id = IDENTIFIER_POINTER (arg);
*uses = tree_cons (NULL_TREE,
build_string (strlen (id), id),
*uses);
}
}
}
break;
case VAR_DECL:
case PARM_DECL:
if (TREE_CODE (arg) == VAR_DECL
&& TREE_STATIC (arg)
&& MEM_P (DECL_RTL (arg)))
{
const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (arg));
const char *real_name;
tree id;
IASM_VALID_PIC (arg, e);
IASM_OFFSET_PREFIX (e, buf);
mark_referenced (DECL_ASSEMBLER_NAME (arg));
real_name = targetm.strip_name_encoding (name);
id = maybe_get_identifier (real_name);
if (id)
mark_referenced (id);
if (name[0] == '*')
strcat (buf, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (arg)) + 1);
else
{
sprintf (buf + strlen (buf), "%s", user_label_prefix);
strcat (buf, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (arg)));
}
mark_decl_referenced (arg);
}
else
iasm_maybe_force_mem (arg, buf, argnum, must_be_reg, e);
break;
case FUNCTION_DECL:
iasm_get_register_var (arg, IASM_FUNCTION_MODIFIER, buf, argnum, must_be_reg, e);
break;
case COMPOUND_EXPR:
iasm_print_operand (buf, TREE_OPERAND (arg, 0), argnum, uses,
false, true, e);
strcat (buf, "(");
iasm_print_operand (buf, TREE_OPERAND (arg, 1), argnum, uses,
! must_not_be_reg, must_not_be_reg, e);
strcat (buf, ")");
break;
case MINUS_EXPR:
case PLUS_EXPR:
if (iasm_simple_expr (arg))
{
sprintf (buf + strlen (buf), "%d", iasm_expr_val (arg));
break;
}
iasm_print_operand (buf, TREE_OPERAND (arg, 0), argnum, uses,
false, true, e);
if (TREE_CODE (arg) == MINUS_EXPR)
strcat (buf, "-");
else
strcat (buf, "+");
IASM_SEE_IMMEDIATE(e);
iasm_print_operand (buf, TREE_OPERAND (arg, 1), argnum, uses,
false, true, e);
IASM_SEE_NO_IMMEDIATE(e);
break;
case FIELD_DECL:
sprintf (buf + strlen (buf), "%d", iasm_field_offset (arg));
break;
case COMPONENT_REF:
op0 = TREE_OPERAND (arg, 0);
if (TREE_CODE (op0) == VAR_DECL || TREE_CODE (op0) == COMPONENT_REF)
iasm_get_register_var (arg, "", buf, argnum, false, e);
else
{
get_inner_reference (arg, &bitsize, &bitpos, &offset, &mode,
&unsignedp, &volatilep, false);
sprintf (buf + strlen (buf), "%lld",
(long long int) (bitpos / BITS_PER_UNIT));
strcat (buf, "(");
iasm_print_operand (buf, TREE_OPERAND (op0, 0), argnum, uses,
true, false, e);
strcat (buf, ")");
}
break;
case ARRAY_REF:
if (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL)
{
iasm_maybe_force_mem (arg, buf, argnum, must_be_reg, e);
break;
}
if (TREE_CODE (TREE_OPERAND (arg, 1)) != INTEGER_CST
|| TREE_INT_CST_LOW (TREE_OPERAND (arg, 1)) != 0)
error ("array references, other than [0], not supported");
else
sprintf (buf + strlen (buf), "%d", iasm_field_offset (TREE_OPERAND (arg, 0)));
break;
case NEGATE_EXPR:
strcat (buf, "-");
iasm_print_operand (buf, TREE_OPERAND (arg, 0), argnum, uses,
must_be_reg, must_not_be_reg, e);
break;
case INDIRECT_REF:
iasm_get_register_var (arg, "", buf, argnum, must_be_reg, e);
break;
default:
if (TARGET_IASM_PRINT_OP (buf, arg, argnum, uses,
must_be_reg, must_not_be_reg, e))
break;
error ("block assembly operand not recognized");
break;
}
}
void
iasm_get_register_var (tree var, const char *modifier, char *buf, unsigned argnum,
bool must_be_reg, iasm_md_extra_info *e)
{
unsigned int n;
buf += strlen (buf);
for (n = 0; (int)n < e->num; ++n)
{
if (var == e->dat[n].var)
{
sprintf (buf, "%%%s", modifier);
buf += strlen (buf);
gcc_assert (n < 10);
sprintf (buf, "%d", n);
e->dat[n].arg_p = buf;
return;
}
}
e->dat[n].var = var;
e->dat[n].argnum = argnum;
e->dat[n].must_be_reg = must_be_reg;
sprintf (buf, "%%%s", modifier);
buf += strlen (buf);
gcc_assert (n < 10);
sprintf (buf, "%d", n);
e->dat[n].arg_p = buf;
++(e->num);
}
tree
iasm_reg_name (tree id)
{
#ifdef IASM_REGISTER_NAME
char buf[100];
const char *newname = IASM_REGISTER_NAME (IDENTIFIER_POINTER (id), buf);
if (newname)
return get_identifier (newname);
#else
if (decode_reg_name (IDENTIFIER_POINTER (id)) >= 0)
return id;
#endif
return NULL_TREE;
}
tree
iasm_label (tree labid, int atsign)
{
tree sexpr;
tree inputs = NULL_TREE, outputs = NULL_TREE, clobbers = NULL_TREE;
tree stmt;
tree label, l;
tree str, one;
STRIP_NOPS (labid);
if (iasm_buffer == NULL)
iasm_buffer = xmalloc (4000);
if (TREE_CODE (labid) == INTEGER_CST)
{
sprintf (iasm_buffer, HOST_WIDE_INT_PRINT_UNSIGNED, tree_low_cst (labid, 0));
labid = get_identifier (iasm_buffer);
}
if (atsign)
labid = prepend_char_identifier (labid, '@');
iasm_buffer[0] = '\0';
label = iasm_get_label (labid);
#if 0
stmt = add_stmt (build_stmt (LABEL_EXPR, label));
#else
#if 0
strcat (iasm_buffer, IDENTIFIER_POINTER (DECL_NAME (label)));
strcat (iasm_buffer, ":");
#else
sprintf (iasm_buffer, "%%l0: # %s", IDENTIFIER_POINTER (DECL_NAME (label)));
#endif
l = build1 (ADDR_EXPR, ptr_type_node, label);
str = build_string (1, "X");
one = build_tree_list (build_tree_list (NULL_TREE, str), l);
inputs = chainon (NULL_TREE, one);
sexpr = build_string (strlen (iasm_buffer), iasm_buffer);
stmt = build_stmt (ASM_EXPR, sexpr, outputs, inputs, clobbers, NULL_TREE);
ASM_VOLATILE_P (stmt) = 1;
stmt = add_stmt (stmt);
#endif
return stmt;
}
tree
prepend_char_identifier (tree ident, char ch)
{
char *buf = (char *) alloca (IDENTIFIER_LENGTH (ident) + 20);
buf[0] = ch;
strcpy (buf + 1, IDENTIFIER_POINTER (ident));
return get_identifier (buf);
}
tree
iasm_get_identifier (tree id, const char *str)
{
char *buf;
int len = strlen (str);
buf = (char *) alloca (IDENTIFIER_LENGTH (id) + len + 1);
memcpy (buf, IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
memcpy (buf + IDENTIFIER_LENGTH (id), str, len);
buf[IDENTIFIER_LENGTH (id) + len] = 0;
return get_identifier (buf);
}
void
iasm_clear_labels (void)
{
if (!iasm_labels)
VARRAY_TREE_INIT (iasm_labels, 40, "iasm_labels");
if (!iasm_labels_uniq)
VARRAY_TREE_INIT (iasm_labels_uniq, 40, "iasm_labels_uniq");
VARRAY_POP_ALL (iasm_labels);
VARRAY_POP_ALL (iasm_labels_uniq);
}
static GTY(()) tree iasm_ha16;
static GTY(()) tree iasm_hi16;
static GTY(()) tree iasm_lo16;
tree
iasm_do_id (tree id)
{
tree newid;
if ((newid = iasm_reg_name (id)))
return newid;
#ifdef IASM_SPECIAL_LABEL
if ((newid = IASM_SPECIAL_LABEL (id)))
return newid;
#endif
#if defined (TARGET_386)
{
const char *s = IDENTIFIER_POINTER (id);
if (strcasecmp (s, "byte") == 0
|| strcasecmp (s, "word") == 0
|| strcasecmp (s, "dword") == 0
|| strcasecmp (s, "qword") == 0
|| strcasecmp (s, "oword") == 0
|| strcasecmp (s, "real4") == 0
|| strcasecmp (s, "real8") == 0
|| strcasecmp (s, "real10") == 0
|| strcasecmp (s, "tbyte") == 0)
return id;
}
#endif
return iasm_get_label (id);
}
static tree
iasm_get_label (tree labid)
{
unsigned int n;
const char *labname;
char *buf;
tree newid;
if (!iasm_ha16)
{
iasm_ha16 = get_identifier ("ha16");
iasm_hi16 = get_identifier ("hi16");
iasm_lo16 = get_identifier ("lo16");
}
if (labid == iasm_lo16)
return iasm_lo16;
else if (labid == iasm_ha16)
return iasm_ha16;
else if (labid == iasm_hi16)
return iasm_hi16;
for (n = 0; n < VARRAY_ACTIVE_SIZE (iasm_labels); ++n)
{
if (labid == VARRAY_TREE (iasm_labels, n))
return VARRAY_TREE (iasm_labels_uniq, n);
}
VARRAY_PUSH_TREE (iasm_labels, labid);
buf = (char *) alloca (IDENTIFIER_LENGTH (labid) + 20);
sprintf (buf, "LASM$");
labname = IDENTIFIER_POINTER (labid);
if (*labname == '@')
{
strcat (buf, "$");
++labname;
}
strcat (buf, labname);
newid = get_identifier (buf);
newid = define_label (input_location, newid);
VARRAY_PUSH_TREE (iasm_labels_uniq, newid);
return newid;
}
tree
iasm_build_register_offset (tree offset, tree regname)
{
tree t;
t = make_node (COMPOUND_EXPR);
TREE_TYPE (t) = NULL_TREE;
TREE_OPERAND (t, 0) = offset;
TREE_OPERAND (t, 1) = regname;
return t;
}
tree
iasm_entry (tree keyword, tree scspec, tree fn)
{
int externify = 0;
tree stmt, inputs, str, one, strlab;
if (strcmp (IDENTIFIER_POINTER (keyword), "entry") != 0)
{
error ("invalid asm entry statement syntax");
return error_mark_node;
}
if (scspec == NULL || strcmp (IDENTIFIER_POINTER (scspec), "extern") == 0)
externify = 1;
else if (strcmp (IDENTIFIER_POINTER (scspec), "static") == 0)
;
else
{
error ("entry point storage class much be `static' or `extern'");
return error_mark_node;
}
if (fn == NULL_TREE || TREE_CODE (fn) != FUNCTION_DECL)
{
error ("entry point not recognized as a function");
return error_mark_node;
}
fn = iasm_default_function_conversion (fn);
str = build_string (1, "s");
one = build_tree_list (build_tree_list (NULL_TREE, str), fn);
inputs = chainon (NULL_TREE, one);
if (externify)
{
strlab = build_string (9, ".globl %0");
stmt = build_stmt (ASM_EXPR, strlab, NULL_TREE, inputs, NULL_TREE, NULL_TREE);
ASM_VOLATILE_P (stmt) = 1;
stmt = add_stmt (stmt);
}
strlab = build_string (3, "%0:");
stmt = build_stmt (ASM_EXPR, strlab, NULL_TREE, inputs, NULL_TREE, NULL_TREE);
ASM_VOLATILE_P (stmt) = 1;
stmt = add_stmt (stmt);
return stmt;
}
#include "gt-c-common.h"