static tree
synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
void *client)
{
tree raises = empty_except_spec;
tree fields = TYPE_FIELDS (type);
tree binfo, base_binfo;
int i;
for (binfo = TYPE_BINFO (type), i = 0;
BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
{
tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
if (fn)
{
tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
raises = merge_exception_specifiers (raises, fn_raises);
}
}
for (; fields; fields = TREE_CHAIN (fields))
{
tree type = TREE_TYPE (fields);
tree fn;
if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
continue;
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
if (!CLASS_TYPE_P (type))
continue;
fn = (*extractor) (type, client);
if (fn)
{
tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
raises = merge_exception_specifiers (raises, fn_raises);
}
}
return raises;
}
static tree
synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
void *client)
{
tree raises = empty_except_spec;
tree fields = TYPE_FIELDS (type);
int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
tree binfos = TYPE_BINFO_BASETYPES (type);
for (i = 0; i != n_bases; i++)
{
tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
tree fn = (*extractor) (base, client);
if (fn)
{
tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
raises = merge_exception_specifiers (raises, fn_raises);
}
}
for (; fields; fields = TREE_CHAIN (fields))
{
tree type = TREE_TYPE (fields);
tree fn;
if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
continue;
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
if (!CLASS_TYPE_P (type))
continue;
fn = (*extractor) (type, client);
if (fn)
{
tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
raises = merge_exception_specifiers (raises, fn_raises);
}
}
return raises;
}
static void
c_type_print_args (struct type *type, struct ui_file *stream)
{
int i, len;
struct field *args;
int printed_any = 0;
fprintf_filtered (stream, "(");
args = TYPE_FIELDS (type);
len = TYPE_NFIELDS (type);
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
if (printed_any)
{
fprintf_filtered (stream, ", ");
wrap_here (" ");
}
c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
printed_any = 1;
}
if (printed_any && TYPE_VARARGS (type))
{
/* Print out a trailing ellipsis for varargs functions. Ignore
TYPE_VARARGS if the function has no named arguments; that
represents unprototyped (K&R style) C functions. */
if (printed_any && TYPE_VARARGS (type))
{
fprintf_filtered (stream, ", ");
wrap_here (" ");
fprintf_filtered (stream, "...");
}
}
else if (!printed_any
&& (TYPE_PROTOTYPED (type)
|| current_language->la_language == language_cplus))
fprintf_filtered (stream, "void");
fprintf_filtered (stream, ")");
}
static void
sdbout_field_types (tree type)
{
tree tail;
for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
/* This condition should match the one for emitting the actual
members below. */
if (TREE_CODE (tail) == FIELD_DECL
&& DECL_NAME (tail)
&& DECL_SIZE (tail)
&& host_integerp (DECL_SIZE (tail), 1)
&& host_integerp (bit_position (tail), 0))
{
if (POINTER_TYPE_P (TREE_TYPE (tail)))
sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
else
sdbout_one_type (TREE_TYPE (tail));
}
}
static void
write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
bool ref_p)
{
if (TREE_CODE (expr) == ENUMERAL_TYPE)
stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
else if (TREE_CODE (expr) == ARRAY_TYPE)
stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
else if (RECORD_OR_UNION_TYPE_P (expr))
streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
else if (TREE_CODE (expr) == FUNCTION_TYPE
|| TREE_CODE (expr) == METHOD_TYPE)
stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
if (!POINTER_TYPE_P (expr))
stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
if (RECORD_OR_UNION_TYPE_P (expr))
stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
}
static tree
build_type ()
{
tree ret_type, i_type, a_type, field_decl;
ret_type = make_node (RECORD_TYPE);
i_type = build_index_type (size_int (sizeof (CTrace) - 1));
a_type = build_array_type (char_type_node, i_type);
field_decl = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE, a_type);
TYPE_FIELDS (ret_type) = field_decl;
TYPE_SIZE_UNIT (ret_type)
= build_int_cst (integer_type_node, sizeof (CTrace));
TYPE_NAME (ret_type) = get_identifier ("__CtraceStruct__");
if (dump_file)
{
fprintf (dump_file, "begin print built type:\n");
print_generic_stmt (dump_file, ret_type, TDF_VERBOSE);
fprintf (dump_file, "end print built type:\n");
}
return ret_type;
}
static void
lto_input_ts_type_non_common_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in,
tree expr)
{
if (TREE_CODE (expr) == ENUMERAL_TYPE)
TYPE_VALUES (expr) = stream_read_tree (ib, data_in);
else if (TREE_CODE (expr) == ARRAY_TYPE)
TYPE_DOMAIN (expr) = stream_read_tree (ib, data_in);
else if (RECORD_OR_UNION_TYPE_P (expr))
TYPE_FIELDS (expr) = streamer_read_chain (ib, data_in);
else if (TREE_CODE (expr) == FUNCTION_TYPE
|| TREE_CODE (expr) == METHOD_TYPE)
TYPE_ARG_TYPES (expr) = stream_read_tree (ib, data_in);
if (!POINTER_TYPE_P (expr))
TYPE_MINVAL (expr) = stream_read_tree (ib, data_in);
TYPE_MAXVAL (expr) = stream_read_tree (ib, data_in);
if (RECORD_OR_UNION_TYPE_P (expr))
TYPE_BINFO (expr) = stream_read_tree (ib, data_in);
}
/* Helper for mudflap_init: construct a tree corresponding to the type
struct __mf_cache { uintptr_t low; uintptr_t high; };
where uintptr_t is the FIELD_TYPE argument. */
static inline tree
mf_make_mf_cache_struct_type (tree field_type)
{
/* There is, abominably, no language-independent way to construct a
RECORD_TYPE. So we have to call the basic type construction
primitives by hand. */
tree fieldlo = build_decl (UNKNOWN_LOCATION,
FIELD_DECL, get_identifier ("low"), field_type);
tree fieldhi = build_decl (UNKNOWN_LOCATION,
FIELD_DECL, get_identifier ("high"), field_type);
tree struct_type = make_node (RECORD_TYPE);
DECL_CONTEXT (fieldlo) = struct_type;
DECL_CONTEXT (fieldhi) = struct_type;
DECL_CHAIN (fieldlo) = fieldhi;
TYPE_FIELDS (struct_type) = fieldlo;
TYPE_NAME (struct_type) = get_identifier ("__mf_cache");
layout_type (struct_type);
return struct_type;
}
static tree mx_xform_instrument_pass2(tree temp)
{
DEBUGLOG("========== Entered mx_xform_instrument_pass2 =============\n");
// TODO figure out what to do with COMPONENT_REFs. ideally this should never come here.
if (TREE_CODE(temp) == COMPONENT_REF)
return NULL_TREE;
tree instr_node = find_instr_node(temp);
// Zahed: New mods
if (instr_node == NULL_TREE)
return NULL_TREE;
tree struct_type = TREE_TYPE(instr_node);
tree rz_orig_val = DECL_CHAIN(TYPE_FIELDS(struct_type));
DEBUGLOG("============ Exiting mx_xform_instrument_pass2 =============\n");
return mf_mark(build3 (COMPONENT_REF, TREE_TYPE(rz_orig_val),
instr_node, rz_orig_val, NULL_TREE));
}
/* Determines if type TYPE is a pascal string type.
Returns 1 if the type is a known pascal type
This function is used by p-valprint.c code to allow better string display.
If it is a pascal string type, then it also sets info needed
to get the length and the data of the string
length_pos, length_size and string_pos are given in bytes.
char_size gives the element size in bytes.
FIXME: if the position or the size of these fields
are not multiple of TARGET_CHAR_BIT then the results are wrong
but this does not happen for Free Pascal nor for GPC. */
int
is_pascal_string_type (struct type *type,int *length_pos,
int *length_size, int *string_pos, int *char_size,
char **arrayname)
{
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
/* Old Borland type pascal strings from Free Pascal Compiler. */
/* Two fields: length and st. */
if (TYPE_NFIELDS (type) == 2
&& strcmp (TYPE_FIELDS (type)[0].name, "length") == 0
&& strcmp (TYPE_FIELDS (type)[1].name, "st") == 0)
{
if (length_pos)
*length_pos = TYPE_FIELD_BITPOS (type, 0) / TARGET_CHAR_BIT;
if (length_size)
*length_size = TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0));
if (string_pos)
*string_pos = TYPE_FIELD_BITPOS (type, 1) / TARGET_CHAR_BIT;
if (char_size)
*char_size = 1;
if (arrayname)
*arrayname = TYPE_FIELDS (type)[1].name;
return 2;
};
/* GNU pascal strings. */
/* Three fields: Capacity, length and schema$ or _p_schema. */
if (TYPE_NFIELDS (type) == 3
&& strcmp (TYPE_FIELDS (type)[0].name, "Capacity") == 0
&& strcmp (TYPE_FIELDS (type)[1].name, "length") == 0)
{
if (length_pos)
*length_pos = TYPE_FIELD_BITPOS (type, 1) / TARGET_CHAR_BIT;
if (length_size)
*length_size = TYPE_LENGTH (TYPE_FIELD_TYPE (type, 1));
if (string_pos)
*string_pos = TYPE_FIELD_BITPOS (type, 2) / TARGET_CHAR_BIT;
/* FIXME: how can I detect wide chars in GPC ?? */
if (char_size)
*char_size = 1;
if (arrayname)
*arrayname = TYPE_FIELDS (type)[2].name;
return 3;
};
}
return 0;
}
static void
cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
int staticp, struct ui_file *stream)
{
struct field *args = TYPE_FIELDS (mtype);
int nargs = TYPE_NFIELDS (mtype);
int varargs = TYPE_VARARGS (mtype);
int i;
fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
fputs_filtered ("(", stream);
/* Skip the class variable. */
i = staticp ? 0 : 1;
if (nargs > i)
{
while (i < nargs)
{
type_print (args[i++].type, "", stream, 0);
if (i == nargs && varargs)
fprintf_filtered (stream, ", ...");
else if (i < nargs)
fprintf_filtered (stream, ", ");
}
}
else if (varargs)
fprintf_filtered (stream, "...");
/* APPLE LOCAL begin Objective-C++ */
else if (current_language->la_language == language_cplus
|| current_language->la_language == language_objcplus)
/* APPLE LOCAL end Objective-C++ */
fprintf_filtered (stream, "void");
fprintf_filtered (stream, ")");
}
static void
c_type_print_args (struct type *type, struct ui_file *stream)
{
int i;
struct field *args;
fprintf_filtered (stream, "(");
args = TYPE_FIELDS (type);
if (args != NULL)
{
int i;
/* FIXME drow/2002-05-31: Always skips the first argument,
should we be checking for static members? */
for (i = 1; i < TYPE_NFIELDS (type); i++)
{
c_print_type (args[i].type, "", stream, -1, 0);
if (i != TYPE_NFIELDS (type))
{
fprintf_filtered (stream, ",");
wrap_here (" ");
}
}
if (TYPE_VARARGS (type))
fprintf_filtered (stream, "...");
else if (i == 1
&& (current_language->la_language == language_cplus))
fprintf_filtered (stream, "void");
}
else if (current_language->la_language == language_cplus)
{
fprintf_filtered (stream, "void");
}
fprintf_filtered (stream, ")");
}
static tree
vxworks_emutls_var_init (tree var, tree decl, tree tmpl_addr)
{
vec<constructor_elt, va_gc> *v;
vec_alloc (v, 3);
tree type = TREE_TYPE (var);
tree field = TYPE_FIELDS (type);
constructor_elt elt = {field, fold_convert (TREE_TYPE (field), tmpl_addr)};
v->quick_push (elt);
field = DECL_CHAIN (field);
elt.index = field;
elt.value = build_int_cst (TREE_TYPE (field), 0);
v->quick_push (elt);
field = DECL_CHAIN (field);
elt.index = field;
elt.value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
v->quick_push (elt);
return build_constructor (type, v);
}
tree
ubsan_create_data (const char *name, const location_t *ploc,
const struct ubsan_mismatch_data *mismatch, ...)
{
va_list args;
tree ret, t;
tree fields[5];
vec<tree, va_gc> *saved_args = NULL;
size_t i = 0;
location_t loc = UNKNOWN_LOCATION;
/* Firstly, create a pointer to type descriptor type. */
tree td_type = ubsan_type_descriptor_type ();
TYPE_READONLY (td_type) = 1;
td_type = build_pointer_type (td_type);
/* Create the structure type. */
ret = make_node (RECORD_TYPE);
if (ploc != NULL)
{
loc = LOCATION_LOCUS (*ploc);
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
ubsan_source_location_type ());
DECL_CONTEXT (fields[i]) = ret;
i++;
}
va_start (args, mismatch);
for (t = va_arg (args, tree); t != NULL_TREE;
i++, t = va_arg (args, tree))
{
gcc_checking_assert (i < 3);
/* Save the tree arguments for later use. */
vec_safe_push (saved_args, t);
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
td_type);
DECL_CONTEXT (fields[i]) = ret;
if (i)
DECL_CHAIN (fields[i - 1]) = fields[i];
}
va_end (args);
if (mismatch != NULL)
{
/* We have to add two more decls. */
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
pointer_sized_int_node);
DECL_CONTEXT (fields[i]) = ret;
DECL_CHAIN (fields[i - 1]) = fields[i];
i++;
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
unsigned_char_type_node);
DECL_CONTEXT (fields[i]) = ret;
DECL_CHAIN (fields[i - 1]) = fields[i];
i++;
}
TYPE_FIELDS (ret) = fields[0];
TYPE_NAME (ret) = get_identifier (name);
layout_type (ret);
/* Now, fill in the type. */
char tmp_name[32];
static unsigned int ubsan_var_id_num;
ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_data", ubsan_var_id_num++);
tree var = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (tmp_name),
ret);
TREE_STATIC (var) = 1;
TREE_PUBLIC (var) = 0;
DECL_ARTIFICIAL (var) = 1;
DECL_IGNORED_P (var) = 1;
DECL_EXTERNAL (var) = 0;
vec<constructor_elt, va_gc> *v;
vec_alloc (v, i);
tree ctor = build_constructor (ret, v);
/* If desirable, set the __ubsan_source_location element. */
if (ploc != NULL)
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, ubsan_source_location (loc));
size_t nelts = vec_safe_length (saved_args);
for (i = 0; i < nelts; i++)
{
t = (*saved_args)[i];
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, t);
}
if (mismatch != NULL)
{
/* Append the pointer data. */
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, mismatch->align);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, mismatch->ckind);
}
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (var) = ctor;
varpool_finalize_decl (var);
return var;
}
static void
mf_build_check_statement_for (tree base, tree limit,
gimple_stmt_iterator *instr_gsi,
location_t location, tree dirflag)
{
gimple_stmt_iterator gsi;
basic_block cond_bb, then_bb, join_bb;
edge e;
tree cond, t, u, v;
tree mf_base;
tree mf_elem;
tree mf_limit;
gimple g;
gimple_seq seq, stmts;
/* We first need to split the current basic block, and start altering
the CFG. This allows us to insert the statements we're about to
construct into the right basic blocks. */
cond_bb = gimple_bb (gsi_stmt (*instr_gsi));
gsi = *instr_gsi;
gsi_prev (&gsi);
if (! gsi_end_p (gsi))
e = split_block (cond_bb, gsi_stmt (gsi));
else
e = split_block_after_labels (cond_bb);
cond_bb = e->src;
join_bb = e->dest;
/* A recap at this point: join_bb is the basic block at whose head
is the gimple statement for which this check expression is being
built. cond_bb is the (possibly new, synthetic) basic block the
end of which will contain the cache-lookup code, and a
conditional that jumps to the cache-miss code or, much more
likely, over to join_bb. */
/* Create the bb that contains the cache-miss fallback block (mf_check). */
then_bb = create_empty_bb (cond_bb);
make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);
/* Mark the pseudo-fallthrough edge from cond_bb to join_bb. */
e = find_edge (cond_bb, join_bb);
e->flags = EDGE_FALSE_VALUE;
e->count = cond_bb->count;
e->probability = REG_BR_PROB_BASE;
/* Update dominance info. Note that bb_join's data was
updated by split_block. */
if (dom_info_available_p (CDI_DOMINATORS))
{
set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
set_immediate_dominator (CDI_DOMINATORS, join_bb, cond_bb);
}
/* Update loop info. */
if (current_loops)
add_bb_to_loop (then_bb, cond_bb->loop_father);
/* Build our local variables. */
mf_elem = create_tmp_reg (mf_cache_structptr_type, "__mf_elem");
mf_base = create_tmp_reg (mf_uintptr_type, "__mf_base");
mf_limit = create_tmp_reg (mf_uintptr_type, "__mf_limit");
/* Build: __mf_base = (uintptr_t) <base address expression>. */
seq = NULL;
t = fold_convert_loc (location, mf_uintptr_type,
unshare_expr (base));
t = force_gimple_operand (t, &stmts, false, NULL_TREE);
gimple_seq_add_seq (&seq, stmts);
g = gimple_build_assign (mf_base, t);
gimple_set_location (g, location);
gimple_seq_add_stmt (&seq, g);
/* Build: __mf_limit = (uintptr_t) <limit address expression>. */
t = fold_convert_loc (location, mf_uintptr_type,
unshare_expr (limit));
t = force_gimple_operand (t, &stmts, false, NULL_TREE);
gimple_seq_add_seq (&seq, stmts);
g = gimple_build_assign (mf_limit, t);
gimple_set_location (g, location);
gimple_seq_add_stmt (&seq, g);
/* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
& __mf_mask]. */
t = build2 (RSHIFT_EXPR, mf_uintptr_type, mf_base,
flag_mudflap_threads ? mf_cache_shift_decl
: mf_cache_shift_decl_l);
t = build2 (BIT_AND_EXPR, mf_uintptr_type, t,
flag_mudflap_threads ? mf_cache_mask_decl
: mf_cache_mask_decl_l);
t = build4 (ARRAY_REF,
TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
t = force_gimple_operand (t, &stmts, false, NULL_TREE);
gimple_seq_add_seq (&seq, stmts);
g = gimple_build_assign (mf_elem, t);
gimple_set_location (g, location);
gimple_seq_add_stmt (&seq, g);
/* Quick validity check.
if (__mf_elem->low > __mf_base
|| (__mf_elem_high < __mf_limit))
{
__mf_check ();
... and only if single-threaded:
__mf_lookup_shift_1 = f...;
__mf_lookup_mask_l = ...;
}
It is expected that this body of code is rarely executed so we mark
the edge to the THEN clause of the conditional jump as unlikely. */
/* Construct t <-- '__mf_elem->low > __mf_base'. */
t = build3 (COMPONENT_REF, mf_uintptr_type,
build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
TYPE_FIELDS (mf_cache_struct_type), NULL_TREE);
t = build2 (GT_EXPR, boolean_type_node, t, mf_base);
/* Construct '__mf_elem->high < __mf_limit'.
First build:
1) u <-- '__mf_elem->high'
2) v <-- '__mf_limit'.
Then build 'u <-- (u < v). */
u = build3 (COMPONENT_REF, mf_uintptr_type,
build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
DECL_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
v = mf_limit;
u = build2 (LT_EXPR, boolean_type_node, u, v);
/* Build the composed conditional: t <-- 't || u'. Then store the
result of the evaluation of 't' in a temporary variable which we
can use as the condition for the conditional jump. */
t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);
t = force_gimple_operand (t, &stmts, false, NULL_TREE);
gimple_seq_add_seq (&seq, stmts);
cond = create_tmp_reg (boolean_type_node, "__mf_unlikely_cond");
g = gimple_build_assign (cond, t);
gimple_set_location (g, location);
gimple_seq_add_stmt (&seq, g);
/* Build the conditional jump. 'cond' is just a temporary so we can
simply build a void COND_EXPR. We do need labels in both arms though. */
g = gimple_build_cond (NE_EXPR, cond, boolean_false_node, NULL_TREE,
NULL_TREE);
gimple_set_location (g, location);
gimple_seq_add_stmt (&seq, g);
/* At this point, after so much hard work, we have only constructed
the conditional jump,
if (__mf_elem->low > __mf_base
|| (__mf_elem_high < __mf_limit))
The lowered GIMPLE tree representing this code is in the statement
list starting at 'head'.
We can insert this now in the current basic block, i.e. the one that
the statement we're instrumenting was originally in. */
gsi = gsi_last_bb (cond_bb);
gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
/* Now build up the body of the cache-miss handling:
__mf_check();
refresh *_l vars.
This is the body of the conditional. */
seq = NULL;
/* u is a string, so it is already a gimple value. */
u = mf_file_function_line_tree (location);
/* NB: we pass the overall [base..limit] range to mf_check. */
v = fold_build2_loc (location, PLUS_EXPR, mf_uintptr_type,
fold_build2_loc (location,
MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base),
build_int_cst (mf_uintptr_type, 1));
v = force_gimple_operand (v, &stmts, true, NULL_TREE);
gimple_seq_add_seq (&seq, stmts);
g = gimple_build_call (mf_check_fndecl, 4, mf_base, v, dirflag, u);
gimple_seq_add_stmt (&seq, g);
if (! flag_mudflap_threads)
{
if (stmt_ends_bb_p (g))
{
gsi = gsi_start_bb (then_bb);
gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
e = split_block (then_bb, g);
then_bb = e->dest;
seq = NULL;
}
g = gimple_build_assign (mf_cache_shift_decl_l, mf_cache_shift_decl);
gimple_seq_add_stmt (&seq, g);
g = gimple_build_assign (mf_cache_mask_decl_l, mf_cache_mask_decl);
gimple_seq_add_stmt (&seq, g);
}
/* Insert the check code in the THEN block. */
gsi = gsi_start_bb (then_bb);
gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
*instr_gsi = gsi_start_bb (join_bb);
}
static const char *
gen_type (const char *ret_val, tree t, formals_style style)
{
tree chain_p;
/* If there is a typedef name for this type, use it. */
if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
else
{
switch (TREE_CODE (t))
{
case POINTER_TYPE:
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val, NULL);
if (TYPE_VOLATILE (t))
ret_val = concat ("volatile ", ret_val, NULL);
ret_val = concat ("*", ret_val, NULL);
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
ret_val = concat ("(", ret_val, ")", NULL);
ret_val = gen_type (ret_val, TREE_TYPE (t), style);
return ret_val;
case ARRAY_TYPE:
if (!COMPLETE_TYPE_P (t) || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
ret_val = gen_type (concat (ret_val, "[]", NULL),
TREE_TYPE (t), style);
else if (int_size_in_bytes (t) == 0)
ret_val = gen_type (concat (ret_val, "[0]", NULL),
TREE_TYPE (t), style);
else
{
int size = (int_size_in_bytes (t) / int_size_in_bytes (TREE_TYPE (t)));
char buff[10];
sprintf (buff, "[%d]", size);
ret_val = gen_type (concat (ret_val, buff, NULL),
TREE_TYPE (t), style);
}
break;
case FUNCTION_TYPE:
ret_val = gen_type (concat (ret_val,
gen_formal_list_for_type (t, style),
NULL),
TREE_TYPE (t), style);
break;
case IDENTIFIER_NODE:
data_type = IDENTIFIER_POINTER (t);
break;
/* The following three cases are complicated by the fact that a
user may do something really stupid, like creating a brand new
"anonymous" type specification in a formal argument list (or as
part of a function return type specification). For example:
int f (enum { red, green, blue } color);
In such cases, we have no name that we can put into the prototype
to represent the (anonymous) type. Thus, we have to generate the
whole darn type specification. Yuck! */
case RECORD_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
NULL);
chain_p = TREE_CHAIN (chain_p);
data_type = concat (data_type, "; ", NULL);
}
data_type = concat ("{ ", data_type, "}", NULL);
}
data_type = concat ("struct ", data_type, NULL);
break;
case UNION_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
NULL);
chain_p = TREE_CHAIN (chain_p);
data_type = concat (data_type, "; ", NULL);
}
data_type = concat ("{ ", data_type, "}", NULL);
}
data_type = concat ("union ", data_type, NULL);
break;
case ENUMERAL_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_VALUES (t);
while (chain_p)
{
data_type = concat (data_type,
IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)), NULL);
chain_p = TREE_CHAIN (chain_p);
if (chain_p)
data_type = concat (data_type, ", ", NULL);
}
data_type = concat ("{ ", data_type, " }", NULL);
}
data_type = concat ("enum ", data_type, NULL);
break;
case TYPE_DECL:
data_type = IDENTIFIER_POINTER (DECL_NAME (t));
break;
case INTEGER_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
/* Normally, `unsigned' is part of the deal. Not so if it comes
with a type qualifier. */
if (TYPE_UNSIGNED (t) && TYPE_QUALS (t))
data_type = concat ("unsigned ", data_type, NULL);
break;
case REAL_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
break;
case VOID_TYPE:
data_type = "void";
break;
case ERROR_MARK:
data_type = "[ERROR]";
break;
default:
gcc_unreachable ();
}
}
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val, NULL);
if (TYPE_VOLATILE (t))
ret_val = concat ("volatile ", ret_val, NULL);
if (TYPE_RESTRICT (t))
ret_val = concat ("restrict ", ret_val, NULL);
return ret_val;
}
void
print_node (FILE *file, const char *prefix, tree node, int indent)
{
int hash;
struct bucket *b;
machine_mode mode;
enum tree_code_class tclass;
int len;
int i;
expanded_location xloc;
enum tree_code code;
if (node == 0)
return;
code = TREE_CODE (node);
tclass = TREE_CODE_CLASS (code);
/* Don't get too deep in nesting. If the user wants to see deeper,
it is easy to use the address of a lowest-level node
as an argument in another call to debug_tree. */
if (indent > 24)
{
print_node_brief (file, prefix, node, indent);
return;
}
if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
{
print_node_brief (file, prefix, node, indent);
return;
}
/* It is unsafe to look at any other fields of an ERROR_MARK node. */
if (code == ERROR_MARK)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Allow this function to be called if the table is not there. */
if (table)
{
hash = ((uintptr_t) node) % HASH_SIZE;
/* If node is in the table, just mention its address. */
for (b = table[hash]; b; b = b->next)
if (b->node == node)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Add this node to the table. */
b = XNEW (struct bucket);
b->node = node;
b->next = table[hash];
table[hash] = b;
}
/* Indent to the specified column, since this is the long form. */
indent_to (file, indent);
/* Print the slot this node is in, and its code, and address. */
fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
dump_addr (file, " ", node);
/* Print the name, if any. */
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (code == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
}
if (code == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
if (code == INTEGER_CST)
{
if (indent <= 4)
print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
}
else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
{
print_node (file, "type", TREE_TYPE (node), indent + 4);
if (TREE_TYPE (node))
indent_to (file, indent + 3);
}
if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
fputs (" side-effects", file);
if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
fputs (" readonly", file);
if (TYPE_P (node) && TYPE_ATOMIC (node))
fputs (" atomic", file);
if (!TYPE_P (node) && TREE_CONSTANT (node))
fputs (" constant", file);
else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
fputs (" sizes-gimplified", file);
if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
if (TREE_ADDRESSABLE (node))
fputs (" addressable", file);
if (TREE_THIS_VOLATILE (node))
fputs (" volatile", file);
if (TREE_ASM_WRITTEN (node))
fputs (" asm_written", file);
if (TREE_USED (node))
fputs (" used", file);
if (TREE_NOTHROW (node))
fputs (" nothrow", file);
if (TREE_PUBLIC (node))
fputs (" public", file);
if (TREE_PRIVATE (node))
fputs (" private", file);
if (TREE_PROTECTED (node))
fputs (" protected", file);
if (TREE_STATIC (node))
fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
if (TREE_DEPRECATED (node))
fputs (" deprecated", file);
if (TREE_VISITED (node))
fputs (" visited", file);
if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
{
if (TREE_LANG_FLAG_0 (node))
fputs (" tree_0", file);
if (TREE_LANG_FLAG_1 (node))
fputs (" tree_1", file);
if (TREE_LANG_FLAG_2 (node))
fputs (" tree_2", file);
if (TREE_LANG_FLAG_3 (node))
fputs (" tree_3", file);
if (TREE_LANG_FLAG_4 (node))
fputs (" tree_4", file);
if (TREE_LANG_FLAG_5 (node))
fputs (" tree_5", file);
if (TREE_LANG_FLAG_6 (node))
fputs (" tree_6", file);
}
/* DECL_ nodes have additional attributes. */
switch (TREE_CODE_CLASS (code))
{
case tcc_declaration:
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_UNSIGNED (node))
fputs (" unsigned", file);
if (DECL_IGNORED_P (node))
fputs (" ignored", file);
if (DECL_ABSTRACT_P (node))
fputs (" abstract", file);
if (DECL_EXTERNAL (node))
fputs (" external", file);
if (DECL_NONLOCAL (node))
fputs (" nonlocal", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
{
if (DECL_WEAK (node))
fputs (" weak", file);
if (DECL_IN_SYSTEM_HEADER (node))
fputs (" in_system_header", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
&& code != LABEL_DECL
&& code != FUNCTION_DECL
&& DECL_REGISTER (node))
fputs (" regdecl", file);
if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
fputs (" suppress-debug", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_TARGET (node))
fputs (" function-specific-target", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
fputs (" function-specific-opt", file);
if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
fputs (" autoinline", file);
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
fputs (" built-in", file);
if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
fputs (" static-chain", file);
if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
fputs (" tm-clone", file);
if (code == FIELD_DECL && DECL_PACKED (node))
fputs (" packed", file);
if (code == FIELD_DECL && DECL_BIT_FIELD (node))
fputs (" bit-field", file);
if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
fputs (" nonaddressable", file);
if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
fputs (" in-text-section", file);
if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
fputs (" in-constant-pool", file);
if (code == VAR_DECL && DECL_COMMON (node))
fputs (" common", file);
if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
{
fputs (" ", file);
fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_VIRTUAL_P (node))
fputs (" virtual", file);
if (DECL_PRESERVE_P (node))
fputs (" preserve", file);
if (DECL_LANG_FLAG_0 (node))
fputs (" decl_0", file);
if (DECL_LANG_FLAG_1 (node))
fputs (" decl_1", file);
if (DECL_LANG_FLAG_2 (node))
fputs (" decl_2", file);
if (DECL_LANG_FLAG_3 (node))
fputs (" decl_3", file);
if (DECL_LANG_FLAG_4 (node))
fputs (" decl_4", file);
if (DECL_LANG_FLAG_5 (node))
fputs (" decl_5", file);
if (DECL_LANG_FLAG_6 (node))
fputs (" decl_6", file);
if (DECL_LANG_FLAG_7 (node))
fputs (" decl_7", file);
mode = DECL_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
}
if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
&& DECL_BY_REFERENCE (node))
fputs (" passed-by-reference", file);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
fputs (" defer-output", file);
xloc = expand_location (DECL_SOURCE_LOCATION (node));
fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,
xloc.column);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node (file, "size", DECL_SIZE (node), indent + 4);
print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
if (code != FUNCTION_DECL || DECL_BUILT_IN (node))
indent_to (file, indent + 3);
if (DECL_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d", DECL_ALIGN (node));
if (code == FIELD_DECL)
fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
DECL_OFFSET_ALIGN (node));
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
{
if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
else
fprintf (file, " built-in %s:%s",
built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
built_in_names[(int) DECL_FUNCTION_CODE (node)]);
}
}
if (code == FIELD_DECL)
{
print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
indent + 4);
if (DECL_BIT_FIELD_TYPE (node))
print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
indent + 4);
}
print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node_brief (file, "attributes",
DECL_ATTRIBUTES (node), indent + 4);
if (code != PARM_DECL)
print_node_brief (file, "initial", DECL_INITIAL (node),
indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
{
print_node_brief (file, "abstract_origin",
DECL_ABSTRACT_ORIGIN (node), indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
{
print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
}
lang_hooks.print_decl (file, node, indent);
if (DECL_RTL_SET_P (node))
{
indent_to (file, indent + 4);
print_rtl (file, DECL_RTL (node));
}
if (code == PARM_DECL)
{
print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
if (DECL_INCOMING_RTL (node) != 0)
{
indent_to (file, indent + 4);
fprintf (file, "incoming-rtl ");
print_rtl (file, DECL_INCOMING_RTL (node));
}
}
else if (code == FUNCTION_DECL
&& DECL_STRUCT_FUNCTION (node) != 0)
{
print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
indent_to (file, indent + 4);
dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
}
if ((code == VAR_DECL || code == PARM_DECL)
&& DECL_HAS_VALUE_EXPR_P (node))
print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
/* Print the decl chain only if decl is at second level. */
if (indent == 4)
print_node (file, "chain", TREE_CHAIN (node), indent + 4);
else
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_type:
if (TYPE_UNSIGNED (node))
fputs (" unsigned", file);
if (TYPE_NO_FORCE_BLK (node))
fputs (" no-force-blk", file);
if (TYPE_STRING_FLAG (node))
fputs (" string-flag", file);
if (TYPE_NEEDS_CONSTRUCTING (node))
fputs (" needs-constructing", file);
if ((code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE
|| code == ARRAY_TYPE)
&& TYPE_REVERSE_STORAGE_ORDER (node))
fputs (" reverse-storage-order", file);
/* The transparent-union flag is used for different things in
different nodes. */
if ((code == UNION_TYPE || code == RECORD_TYPE)
&& TYPE_TRANSPARENT_AGGR (node))
fputs (" transparent-aggr", file);
else if (code == ARRAY_TYPE
&& TYPE_NONALIASED_COMPONENT (node))
fputs (" nonaliased-component", file);
if (TYPE_PACKED (node))
fputs (" packed", file);
if (TYPE_RESTRICT (node))
fputs (" restrict", file);
if (TYPE_LANG_FLAG_0 (node))
fputs (" type_0", file);
if (TYPE_LANG_FLAG_1 (node))
fputs (" type_1", file);
if (TYPE_LANG_FLAG_2 (node))
fputs (" type_2", file);
if (TYPE_LANG_FLAG_3 (node))
fputs (" type_3", file);
if (TYPE_LANG_FLAG_4 (node))
fputs (" type_4", file);
if (TYPE_LANG_FLAG_5 (node))
fputs (" type_5", file);
if (TYPE_LANG_FLAG_6 (node))
fputs (" type_6", file);
if (TYPE_LANG_FLAG_7 (node))
fputs (" type_7", file);
mode = TYPE_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
print_node (file, "size", TYPE_SIZE (node), indent + 4);
print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
indent_to (file, indent + 3);
if (TYPE_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
(HOST_WIDE_INT) TYPE_ALIAS_SET (node));
if (TYPE_STRUCTURAL_EQUALITY_P (node))
fprintf (file, " structural equality");
else
dump_addr (file, " canonical type ", TYPE_CANONICAL (node));
print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
|| code == FIXED_POINT_TYPE)
{
fprintf (file, " precision %d", TYPE_PRECISION (node));
print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
}
if (code == ENUMERAL_TYPE)
print_node (file, "values", TYPE_VALUES (node), indent + 4);
else if (code == ARRAY_TYPE)
print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
else if (code == VECTOR_TYPE)
fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
else if (code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE)
print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
else if (code == FUNCTION_TYPE
|| code == METHOD_TYPE)
{
if (TYPE_METHOD_BASETYPE (node))
print_node_brief (file, "method basetype",
TYPE_METHOD_BASETYPE (node), indent + 4);
print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
}
else if (code == OFFSET_TYPE)
print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
indent + 4);
if (TYPE_CONTEXT (node))
print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
lang_hooks.print_type (file, node, indent);
if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
indent_to (file, indent + 3);
print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
indent + 4);
print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
indent + 4);
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_expression:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
if (code == BIND_EXPR)
{
print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
break;
}
if (code == CALL_EXPR)
{
call_expr_arg_iterator iter;
tree arg;
print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
indent + 4);
i = 0;
FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
{
char temp[10];
sprintf (temp, "arg %d", i);
print_node (file, temp, arg, indent + 4);
i++;
}
}
void
c_type_print_args (struct type *type, struct ui_file *stream,
int linkage_name, enum language language)
{
int i, len;
struct field *args;
int printed_any = 0;
fprintf_filtered (stream, "(");
args = TYPE_FIELDS (type);
len = TYPE_NFIELDS (type);
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
struct type *param_type;
if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
continue;
if (printed_any)
{
fprintf_filtered (stream, ", ");
wrap_here (" ");
}
param_type = TYPE_FIELD_TYPE (type, i);
if (language == language_cplus && linkage_name)
{
/* C++ standard, 13.1 Overloadable declarations, point 3, item:
- Parameter declarations that differ only in the presence or
absence of const and/or volatile are equivalent.
And the const/volatile qualifiers are not present in the mangled
names as produced by GCC. */
param_type = make_cv_type (0, 0, param_type, NULL);
}
if (language == language_java)
java_print_type (param_type, "", stream, -1, 0);
else
c_print_type (param_type, "", stream, -1, 0);
printed_any = 1;
}
if (printed_any && TYPE_VARARGS (type))
{
/* Print out a trailing ellipsis for varargs functions. Ignore
TYPE_VARARGS if the function has no named arguments; that
represents unprototyped (K&R style) C functions. */
if (printed_any && TYPE_VARARGS (type))
{
fprintf_filtered (stream, ", ");
wrap_here (" ");
fprintf_filtered (stream, "...");
}
}
else if (!printed_any
&& ((TYPE_PROTOTYPED (type) && language != language_java)
|| language == language_cplus))
fprintf_filtered (stream, "void");
fprintf_filtered (stream, ")");
}
tree
build_java_array_type (tree element_type, HOST_WIDE_INT length)
{
tree sig, t, fld, atype, arfld;
char buf[23];
tree elsig = build_java_signature (element_type);
tree el_name = element_type;
buf[0] = '[';
if (length >= 0)
sprintf (buf+1, HOST_WIDE_INT_PRINT_DEC, length);
else
buf[1] = '\0';
sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig),
buf, 0, 0, "");
t = IDENTIFIER_SIGNATURE_TYPE (sig);
if (t != NULL_TREE)
return TREE_TYPE (t);
t = make_class ();
IDENTIFIER_SIGNATURE_TYPE (sig) = build_pointer_type (t);
TYPE_ARRAY_P (t) = 1;
if (TREE_CODE (el_name) == POINTER_TYPE)
el_name = TREE_TYPE (el_name);
el_name = TYPE_NAME (el_name);
if (TREE_CODE (el_name) == TYPE_DECL)
el_name = DECL_NAME (el_name);
{
char suffix[23];
if (length >= 0)
sprintf (suffix, "[%d]", (int)length);
else
strcpy (suffix, "[]");
TYPE_NAME (t)
= TYPE_STUB_DECL (t)
= build_decl (input_location, TYPE_DECL,
identifier_subst (el_name, "", '.', '.', suffix),
t);
TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (t)) = true;
}
set_java_signature (t, sig);
set_super_info (0, t, object_type_node, 0);
if (TREE_CODE (element_type) == RECORD_TYPE)
element_type = promote_type (element_type);
TYPE_ARRAY_ELEMENT (t) = element_type;
/* Add length pseudo-field. */
fld = build_decl (input_location,
FIELD_DECL, get_identifier ("length"), int_type_node);
TYPE_FIELDS (t) = fld;
DECL_CONTEXT (fld) = t;
FIELD_PUBLIC (fld) = 1;
FIELD_FINAL (fld) = 1;
TREE_READONLY (fld) = 1;
atype = build_prim_array_type (element_type, length);
arfld = build_decl (input_location,
FIELD_DECL, get_identifier ("data"), atype);
DECL_CONTEXT (arfld) = t;
DECL_CHAIN (fld) = arfld;
DECL_ALIGN (arfld) = TYPE_ALIGN (element_type);
/* We could layout_class, but that loads java.lang.Object prematurely.
* This is called by the parser, and it is a bad idea to do load_class
* in the middle of parsing, because of possible circularity problems. */
push_super_field (t, object_type_node);
layout_type (t);
return t;
}
static void
dequeue_and_dump (dump_info_p di)
{
dump_queue_p dq;
splay_tree_node stn;
dump_node_info_p dni;
tree t;
unsigned int index;
enum tree_code code;
enum tree_code_class code_class;
const char* code_name;
/* Get the next node from the queue. */
dq = di->queue;
stn = dq->node;
t = (tree) stn->key;
dni = (dump_node_info_p) stn->value;
index = dni->index;
/* Remove the node from the queue, and put it on the free list. */
di->queue = dq->next;
if (!di->queue)
di->queue_end = 0;
dq->next = di->free_list;
di->free_list = dq;
/* Print the node index. */
dump_index (di, index);
/* And the type of node this is. */
if (dni->binfo_p)
code_name = "binfo";
else
code_name = tree_code_name[(int) TREE_CODE (t)];
fprintf (di->stream, "%-16s ", code_name);
di->column = 25;
/* Figure out what kind of node this is. */
code = TREE_CODE (t);
code_class = TREE_CODE_CLASS (code);
/* Although BINFOs are TREE_VECs, we dump them specially so as to be
more informative. */
if (dni->binfo_p)
{
unsigned ix;
tree base;
VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
dump_child ("type", BINFO_TYPE (t));
if (BINFO_VIRTUAL_P (t))
dump_string_field (di, "spec", "virt");
dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
{
tree access = (accesses ? VEC_index (tree, accesses, ix)
: access_public_node);
const char *string = NULL;
if (access == access_public_node)
string = "pub";
else if (access == access_protected_node)
string = "prot";
else if (access == access_private_node)
string = "priv";
else
gcc_unreachable ();
dump_string_field (di, "accs", string);
queue_and_dump_index (di, "binf", base, DUMP_BINFO);
}
goto done;
}
/* We can knock off a bunch of expression nodes in exactly the same
way. */
if (IS_EXPR_CODE_CLASS (code_class))
{
/* If we're dumping children, dump them now. */
queue_and_dump_type (di, t);
switch (code_class)
{
case tcc_unary:
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case tcc_binary:
case tcc_comparison:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case tcc_expression:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
/* These nodes are handled explicitly below. */
break;
default:
gcc_unreachable ();
}
}
else if (DECL_P (t))
{
expanded_location xloc;
/* All declarations have names. */
if (DECL_NAME (t))
dump_child ("name", DECL_NAME (t));
if (DECL_ASSEMBLER_NAME_SET_P (t)
&& DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
if (DECL_ABSTRACT_ORIGIN (t))
dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
/* And types. */
queue_and_dump_type (di, t);
dump_child ("scpe", DECL_CONTEXT (t));
/* And a source position. */
xloc = expand_location (DECL_SOURCE_LOCATION (t));
if (xloc.file)
{
const char *filename = lbasename (xloc.file);
dump_maybe_newline (di);
fprintf (di->stream, "srcp: %s:%-6d ", filename,
xloc.line);
di->column += 6 + strlen (filename) + 8;
}
/* And any declaration can be compiler-generated. */
if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
&& DECL_ARTIFICIAL (t))
dump_string_field (di, "note", "artificial");
if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
dump_child ("chain", DECL_CHAIN (t));
}
else if (code_class == tcc_type)
{
/* All types have qualifiers. */
int quals = lang_hooks.tree_dump.type_quals (t);
if (quals != TYPE_UNQUALIFIED)
{
fprintf (di->stream, "qual: %c%c%c ",
(quals & TYPE_QUAL_CONST) ? 'c' : ' ',
(quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
(quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
di->column += 14;
}
/* All types have associated declarations. */
dump_child ("name", TYPE_NAME (t));
/* All types have a main variant. */
if (TYPE_MAIN_VARIANT (t) != t)
dump_child ("unql", TYPE_MAIN_VARIANT (t));
/* And sizes. */
dump_child ("size", TYPE_SIZE (t));
/* All types have alignments. */
dump_int (di, "algn", TYPE_ALIGN (t));
}
else if (code_class == tcc_constant)
/* All constants can have types. */
queue_and_dump_type (di, t);
/* Give the language-specific code a chance to print something. If
it's completely taken care of things, don't bother printing
anything more ourselves. */
if (lang_hooks.tree_dump.dump_tree (di, t))
goto done;
/* Now handle the various kinds of nodes. */
switch (code)
{
int i;
case IDENTIFIER_NODE:
dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
break;
case TREE_LIST:
dump_child ("purp", TREE_PURPOSE (t));
dump_child ("valu", TREE_VALUE (t));
dump_child ("chan", TREE_CHAIN (t));
break;
case STATEMENT_LIST:
{
tree_stmt_iterator it;
for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, tsi_stmt (it));
}
}
break;
case TREE_VEC:
dump_int (di, "lngt", TREE_VEC_LENGTH (t));
for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, TREE_VEC_ELT (t, i));
}
break;
case INTEGER_TYPE:
case ENUMERAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_child ("min", TYPE_MIN_VALUE (t));
dump_child ("max", TYPE_MAX_VALUE (t));
if (code == ENUMERAL_TYPE)
dump_child ("csts", TYPE_VALUES (t));
break;
case REAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
break;
case FIXED_POINT_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_string_field (di, "saturating",
TYPE_SATURATING (t) ? "saturating": "non-saturating");
break;
case POINTER_TYPE:
dump_child ("ptd", TREE_TYPE (t));
break;
case REFERENCE_TYPE:
dump_child ("refd", TREE_TYPE (t));
break;
case METHOD_TYPE:
dump_child ("clas", TYPE_METHOD_BASETYPE (t));
/* Fall through. */
case FUNCTION_TYPE:
dump_child ("retn", TREE_TYPE (t));
dump_child ("prms", TYPE_ARG_TYPES (t));
break;
case ARRAY_TYPE:
dump_child ("elts", TREE_TYPE (t));
dump_child ("domn", TYPE_DOMAIN (t));
break;
case RECORD_TYPE:
case UNION_TYPE:
if (TREE_CODE (t) == RECORD_TYPE)
dump_string_field (di, "tag", "struct");
else
dump_string_field (di, "tag", "union");
dump_child ("flds", TYPE_FIELDS (t));
dump_child ("fncs", TYPE_METHODS (t));
queue_and_dump_index (di, "binf", TYPE_BINFO (t),
DUMP_BINFO);
break;
case CONST_DECL:
dump_child ("cnst", DECL_INITIAL (t));
break;
case DEBUG_EXPR_DECL:
dump_int (di, "-uid", DEBUG_TEMP_UID (t));
/* Fall through. */
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case RESULT_DECL:
if (TREE_CODE (t) == PARM_DECL)
dump_child ("argt", DECL_ARG_TYPE (t));
else
dump_child ("init", DECL_INITIAL (t));
dump_child ("size", DECL_SIZE (t));
dump_int (di, "algn", DECL_ALIGN (t));
if (TREE_CODE (t) == FIELD_DECL)
{
if (DECL_FIELD_OFFSET (t))
dump_child ("bpos", bit_position (t));
}
else if (TREE_CODE (t) == VAR_DECL
|| TREE_CODE (t) == PARM_DECL)
{
dump_int (di, "used", TREE_USED (t));
if (DECL_REGISTER (t))
dump_string_field (di, "spec", "register");
}
break;
case FUNCTION_DECL:
dump_child ("args", DECL_ARGUMENTS (t));
if (DECL_EXTERNAL (t))
dump_string_field (di, "body", "undefined");
if (TREE_PUBLIC (t))
dump_string_field (di, "link", "extern");
else
dump_string_field (di, "link", "static");
if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
dump_child ("body", DECL_SAVED_TREE (t));
break;
case INTEGER_CST:
if (TREE_INT_CST_HIGH (t))
dump_int (di, "high", TREE_INT_CST_HIGH (t));
dump_int (di, "low", TREE_INT_CST_LOW (t));
break;
case STRING_CST:
fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
case REAL_CST:
dump_real (di, "valu", TREE_REAL_CST_PTR (t));
break;
case FIXED_CST:
dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
break;
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
case INDIRECT_REF:
case CLEANUP_POINT_EXPR:
case SAVE_EXPR:
case REALPART_EXPR:
case IMAGPART_EXPR:
/* These nodes are unary, but do not have code class `1'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case INIT_EXPR:
case MODIFY_EXPR:
case COMPOUND_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
/* These nodes are binary, but do not have code class `2'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case COMPONENT_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case ARRAY_REF:
case ARRAY_RANGE_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
dump_child ("op 3", TREE_OPERAND (t, 3));
break;
case COND_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case TRY_FINALLY_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case CALL_EXPR:
{
int i = 0;
tree arg;
call_expr_arg_iterator iter;
dump_child ("fn", CALL_EXPR_FN (t));
FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, arg);
i++;
}
}
break;
case CONSTRUCTOR:
{
unsigned HOST_WIDE_INT cnt;
tree index, value;
dump_int (di, "lngt", VEC_length (constructor_elt,
CONSTRUCTOR_ELTS (t)));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
{
dump_child ("idx", index);
dump_child ("val", value);
}
}
/* Return the marking bitmap for the class TYPE. For now this is a
single word describing the type. */
tree
get_boehm_type_descriptor (tree type)
{
unsigned int count, log2_size, ubit;
int bit;
int all_bits_set = 1;
int last_set_index = 0;
HOST_WIDE_INT last_view_index = -1;
int pointer_after_end = 0;
tree field, value, value_type;
/* If the GC wasn't requested, just use a null pointer. */
if (! flag_use_boehm_gc)
return null_pointer_node;
value_type = java_type_for_mode (ptr_mode, 1);
wide_int mask = wi::zero (TYPE_PRECISION (value_type));
/* If we have a type of unknown size, use a proc. */
if (int_size_in_bytes (type) == -1)
goto procedure_object_descriptor;
bit = POINTER_SIZE / BITS_PER_UNIT;
/* The size of this node has to be known. And, we only support 32
and 64 bit targets, so we need to know that the log2 is one of
our values. */
log2_size = exact_log2 (bit);
if (bit == -1 || (log2_size != 2 && log2_size != 3))
{
/* This means the GC isn't supported. We should probably
abort or give an error. Instead, for now, we just silently
revert. FIXME. */
return null_pointer_node;
}
bit *= BITS_PER_UNIT;
/* Warning avoidance. */
ubit = (unsigned int) bit;
if (type == class_type_node)
goto procedure_object_descriptor;
field = TYPE_FIELDS (type);
mark_reference_fields (field, &mask, ubit,
&pointer_after_end, &all_bits_set,
&last_set_index, &last_view_index);
/* If the object is all pointers, or if the part with pointers fits
in our bitmap, then we are ok. Otherwise we have to allocate it
a different way. */
if (all_bits_set != -1 || (pointer_after_end && flag_reduced_reflection))
{
/* In this case the initial part of the object is all reference
fields, and the end of the object is all non-reference
fields. We represent the mark as a count of the fields,
shifted. In the GC the computation looks something like
this:
value = DS_LENGTH | WORDS_TO_BYTES (last_set_index + 1);
DS_LENGTH is 0.
WORDS_TO_BYTES shifts by log2(bytes-per-pointer).
In the case of flag_reduced_reflection and the bitmap would
overflow, we tell the gc that the object is all pointers so
that we don't have to emit reflection data for run time
marking. */
count = 0;
mask = wi::zero (TYPE_PRECISION (value_type));
++last_set_index;
while (last_set_index)
{
if ((last_set_index & 1))
mask = wi::set_bit (mask, log2_size + count);
last_set_index >>= 1;
++count;
}
value = wide_int_to_tree (value_type, mask);
}
static void
record_common_node (struct streamer_tree_cache_d *cache, tree node)
{
/* If we recursively end up at nodes we do not want to preload simply don't.
??? We'd want to verify that this doesn't happen, or alternatively
do not recurse at all. */
if (node == char_type_node)
return;
gcc_checking_assert (node != boolean_type_node
&& node != boolean_true_node
&& node != boolean_false_node);
/* We have to make sure to fill exactly the same number of
elements for all frontends. That can include NULL trees.
As our hash table can't deal with zero entries we'll simply stream
a random other tree. A NULL tree never will be looked up so it
doesn't matter which tree we replace it with, just to be sure
use error_mark_node. */
if (!node)
node = error_mark_node;
/* ??? FIXME, devise a better hash value. But the hash needs to be equal
for all frontend and lto1 invocations. So just use the position
in the cache as hash value. */
streamer_tree_cache_append (cache, node, cache->nodes.length ());
switch (TREE_CODE (node))
{
case ERROR_MARK:
case FIELD_DECL:
case FIXED_POINT_TYPE:
case IDENTIFIER_NODE:
case INTEGER_CST:
case INTEGER_TYPE:
case POINTER_BOUNDS_TYPE:
case REAL_TYPE:
case TREE_LIST:
case VOID_CST:
case VOID_TYPE:
/* No recursive trees. */
break;
case ARRAY_TYPE:
case POINTER_TYPE:
case REFERENCE_TYPE:
record_common_node (cache, TREE_TYPE (node));
break;
case COMPLEX_TYPE:
/* Verify that a complex type's component type (node_type) has been
handled already (and we thus don't need to recurse here). */
verify_common_node_recorded (cache, TREE_TYPE (node));
break;
case RECORD_TYPE:
/* The FIELD_DECLs of structures should be shared, so that every
COMPONENT_REF uses the same tree node when referencing a field.
Pointer equality between FIELD_DECLs is used by the alias
machinery to compute overlapping component references (see
nonoverlapping_component_refs_p and
nonoverlapping_component_refs_of_decl_p). */
for (tree f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
record_common_node (cache, f);
break;
default:
/* Unexpected tree code. */
gcc_unreachable ();
}
}
static void
sdbout_one_type (tree type)
{
if (current_function_decl != NULL_TREE
&& DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
; /* Don't change section amid function. */
else
switch_to_section (text_section);
switch (TREE_CODE (type))
{
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
case ENUMERAL_TYPE:
type = TYPE_MAIN_VARIANT (type);
/* Don't output a type twice. */
if (TREE_ASM_WRITTEN (type))
/* James said test TREE_ASM_BEING_WRITTEN here. */
return;
/* Output nothing if type is not yet defined. */
if (!COMPLETE_TYPE_P (type))
return;
TREE_ASM_WRITTEN (type) = 1;
/* This is reputed to cause trouble with the following case,
but perhaps checking TYPE_SIZE above will fix it. */
/* Here is a testcase:
struct foo {
struct badstr *bbb;
} forwardref;
typedef struct intermediate {
int aaaa;
} intermediate_ref;
typedef struct badstr {
int ccccc;
} badtype; */
/* This change, which ought to make better output,
used to make the COFF assembler unhappy.
Changes involving KNOWN_TYPE_TAG may fix the problem. */
/* Before really doing anything, output types we want to refer to. */
/* Note that in version 1 the following two lines
are not used if forward references are in use. */
if (TREE_CODE (type) != ENUMERAL_TYPE)
sdbout_field_types (type);
/* Output a structure type. */
{
int size = int_size_in_bytes (type);
int member_scl = 0;
tree tem;
/* Record the type tag, but not in its permanent place just yet. */
sdbout_record_type_name (type);
PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
switch (TREE_CODE (type))
{
case UNION_TYPE:
case QUAL_UNION_TYPE:
PUT_SDB_SCL (C_UNTAG);
PUT_SDB_TYPE (T_UNION);
member_scl = C_MOU;
break;
case RECORD_TYPE:
PUT_SDB_SCL (C_STRTAG);
PUT_SDB_TYPE (T_STRUCT);
member_scl = C_MOS;
break;
case ENUMERAL_TYPE:
PUT_SDB_SCL (C_ENTAG);
PUT_SDB_TYPE (T_ENUM);
member_scl = C_MOE;
break;
default:
break;
}
PUT_SDB_SIZE (size);
PUT_SDB_ENDEF;
/* Print out the base class information with fields
named after the types they hold. */
/* This is only relevant to aggregate types. TYPE_BINFO is used
for other purposes in an ENUMERAL_TYPE, so we must exclude that
case. */
if (TREE_CODE (type) != ENUMERAL_TYPE && TYPE_BINFO (type))
{
int i;
tree binfo, child;
for (binfo = TYPE_BINFO (type), i = 0;
BINFO_BASE_ITERATE (binfo, i, child); i++)
{
tree child_type = BINFO_TYPE (child);
tree child_type_name;
if (TYPE_NAME (child_type) == 0)
continue;
if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
child_type_name = TYPE_NAME (child_type);
else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
{
child_type_name = DECL_NAME (TYPE_NAME (child_type));
if (child_type_name && template_name_p (child_type_name))
child_type_name
= DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
}
else
continue;
PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
PUT_SDB_SCL (member_scl);
sdbout_type (BINFO_TYPE (child));
PUT_SDB_ENDEF;
}
}
/* Output the individual fields. */
if (TREE_CODE (type) == ENUMERAL_TYPE)
{
for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
{
tree value = TREE_VALUE (tem);
if (TREE_CODE (value) == CONST_DECL)
value = DECL_INITIAL (value);
if (host_integerp (value, 0))
{
PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
PUT_SDB_INT_VAL (tree_low_cst (value, 0));
PUT_SDB_SCL (C_MOE);
PUT_SDB_TYPE (T_MOE);
PUT_SDB_ENDEF;
}
}
}
else /* record or union type */
for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
/* Output the name, type, position (in bits), size (in bits)
of each field. */
/* Omit here the nameless fields that are used to skip bits.
Also omit fields with variable size or position.
Also omit non FIELD_DECL nodes that GNU C++ may put here. */
if (TREE_CODE (tem) == FIELD_DECL
&& DECL_NAME (tem)
&& DECL_SIZE (tem)
&& host_integerp (DECL_SIZE (tem), 1)
&& host_integerp (bit_position (tem), 0))
{
const char *name;
name = IDENTIFIER_POINTER (DECL_NAME (tem));
PUT_SDB_DEF (name);
if (DECL_BIT_FIELD_TYPE (tem))
{
PUT_SDB_INT_VAL (int_bit_position (tem));
PUT_SDB_SCL (C_FIELD);
sdbout_type (DECL_BIT_FIELD_TYPE (tem));
PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
}
else
{
PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
PUT_SDB_SCL (member_scl);
sdbout_type (TREE_TYPE (tem));
}
PUT_SDB_ENDEF;
}
/* Output end of a structure,union, or enumeral definition. */
PUT_SDB_PLAIN_DEF ("eos");
PUT_SDB_INT_VAL (size);
PUT_SDB_SCL (C_EOS);
PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
PUT_SDB_SIZE (size);
PUT_SDB_ENDEF;
break;
}
default:
break;
}
}
static gimple
input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
struct function *fn, enum LTO_tags tag)
{
gimple stmt;
enum gimple_code code;
unsigned HOST_WIDE_INT num_ops;
size_t i;
struct bitpack_d bp;
code = lto_tag_to_gimple_code (tag);
/* Read the tuple header. */
bp = streamer_read_bitpack (ib);
num_ops = bp_unpack_var_len_unsigned (&bp);
stmt = gimple_alloc (code, num_ops);
stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
if (is_gimple_assign (stmt))
stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
stmt->gsbase.subcode = bp_unpack_var_len_unsigned (&bp);
/* Read location information. */
gimple_set_location (stmt, lto_input_location (ib, data_in));
/* Read lexical block reference. */
gimple_set_block (stmt, stream_read_tree (ib, data_in));
/* Read in all the operands. */
switch (code)
{
case GIMPLE_RESX:
gimple_resx_set_region (stmt, streamer_read_hwi (ib));
break;
case GIMPLE_EH_MUST_NOT_THROW:
gimple_eh_must_not_throw_set_fndecl (stmt, stream_read_tree (ib, data_in));
break;
case GIMPLE_EH_DISPATCH:
gimple_eh_dispatch_set_region (stmt, streamer_read_hwi (ib));
break;
case GIMPLE_ASM:
{
/* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
tree str;
stmt->gimple_asm.ni = streamer_read_uhwi (ib);
stmt->gimple_asm.no = streamer_read_uhwi (ib);
stmt->gimple_asm.nc = streamer_read_uhwi (ib);
stmt->gimple_asm.nl = streamer_read_uhwi (ib);
str = streamer_read_string_cst (data_in, ib);
stmt->gimple_asm.string = TREE_STRING_POINTER (str);
}
/* Fallthru */
case GIMPLE_ASSIGN:
case GIMPLE_CALL:
case GIMPLE_RETURN:
case GIMPLE_SWITCH:
case GIMPLE_LABEL:
case GIMPLE_COND:
case GIMPLE_GOTO:
case GIMPLE_DEBUG:
for (i = 0; i < num_ops; i++)
{
tree op = stream_read_tree (ib, data_in);
gimple_set_op (stmt, i, op);
if (!op)
continue;
/* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
by decl merging. */
if (TREE_CODE (op) == ADDR_EXPR)
op = TREE_OPERAND (op, 0);
while (handled_component_p (op))
{
if (TREE_CODE (op) == COMPONENT_REF)
{
tree field, type, tem;
tree closest_match = NULL_TREE;
field = TREE_OPERAND (op, 1);
type = DECL_CONTEXT (field);
for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
{
if (TREE_CODE (tem) != FIELD_DECL)
continue;
if (tem == field)
break;
if (DECL_NONADDRESSABLE_P (tem)
== DECL_NONADDRESSABLE_P (field)
&& gimple_compare_field_offset (tem, field))
{
if (types_compatible_p (TREE_TYPE (tem),
TREE_TYPE (field)))
break;
else
closest_match = tem;
}
}
/* In case of type mismatches across units we can fail
to unify some types and thus not find a proper
field-decl here. */
if (tem == NULL_TREE)
{
/* Thus, emit a ODR violation warning. */
if (warning_at (gimple_location (stmt), 0,
"use of type %<%E%> with two mismatching "
"declarations at field %<%E%>",
type, TREE_OPERAND (op, 1)))
{
if (TYPE_FIELDS (type))
inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type)),
"original type declared here");
inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op, 1)),
"field in mismatching type declared here");
if (TYPE_NAME (TREE_TYPE (field))
&& (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
== TYPE_DECL))
inform (DECL_SOURCE_LOCATION
(TYPE_NAME (TREE_TYPE (field))),
"type of field declared here");
if (closest_match
&& TYPE_NAME (TREE_TYPE (closest_match))
&& (TREE_CODE (TYPE_NAME
(TREE_TYPE (closest_match))) == TYPE_DECL))
inform (DECL_SOURCE_LOCATION
(TYPE_NAME (TREE_TYPE (closest_match))),
"type of mismatching field declared here");
}
/* And finally fixup the types. */
TREE_OPERAND (op, 0)
= build1 (VIEW_CONVERT_EXPR, type,
TREE_OPERAND (op, 0));
}
else
TREE_OPERAND (op, 1) = tem;
}
op = TREE_OPERAND (op, 0);
}
}
if (is_gimple_call (stmt))
{
if (gimple_call_internal_p (stmt))
gimple_call_set_internal_fn
(stmt, streamer_read_enum (ib, internal_fn, IFN_LAST));
else
gimple_call_set_fntype (stmt, stream_read_tree (ib, data_in));
}
break;
case GIMPLE_NOP:
case GIMPLE_PREDICT:
break;
case GIMPLE_TRANSACTION:
gimple_transaction_set_label (stmt, stream_read_tree (ib, data_in));
break;
default:
internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
lto_tag_name (tag));
}
/* Update the properties of symbols, SSA names and labels associated
with STMT. */
if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
{
tree lhs = gimple_get_lhs (stmt);
if (lhs && TREE_CODE (lhs) == SSA_NAME)
SSA_NAME_DEF_STMT (lhs) = stmt;
}
else if (code == GIMPLE_LABEL)
gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
|| DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
else if (code == GIMPLE_ASM)
{
unsigned i;
for (i = 0; i < gimple_asm_noutputs (stmt); i++)
{
tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
if (TREE_CODE (op) == SSA_NAME)
SSA_NAME_DEF_STMT (op) = stmt;
}
}
/* Reset alias information. */
if (code == GIMPLE_CALL)
gimple_call_reset_alias_info (stmt);
/* Mark the statement modified so its operand vectors can be filled in. */
gimple_set_modified (stmt, true);
return stmt;
}
/* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
described above, laid out appropriately for ARCH.
We use this function as the gdbarch per-architecture data
initialization function. */
static void *
build_gdb_vtable_type (struct gdbarch *arch)
{
struct type *t;
struct field *field_list, *field;
int offset;
struct type *void_ptr_type
= builtin_type (arch)->builtin_data_ptr;
struct type *ptr_to_void_fn_type
= builtin_type (arch)->builtin_func_ptr;
/* ARCH can't give us the true ptrdiff_t type, so we guess. */
struct type *ptrdiff_type
= arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
/* We assume no padding is necessary, since GDB doesn't know
anything about alignment at the moment. If this assumption bites
us, we should add a gdbarch method which, given a type, returns
the alignment that type requires, and then use that here. */
/* Build the field list. */
field_list = xmalloc (sizeof (struct field [4]));
memset (field_list, 0, sizeof (struct field [4]));
field = &field_list[0];
offset = 0;
/* ptrdiff_t vcall_and_vbase_offsets[0]; */
FIELD_NAME (*field) = "vcall_and_vbase_offsets";
FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (FIELD_TYPE (*field));
field++;
/* ptrdiff_t offset_to_top; */
FIELD_NAME (*field) = "offset_to_top";
FIELD_TYPE (*field) = ptrdiff_type;
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (FIELD_TYPE (*field));
field++;
/* void *type_info; */
FIELD_NAME (*field) = "type_info";
FIELD_TYPE (*field) = void_ptr_type;
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (FIELD_TYPE (*field));
field++;
/* void (*virtual_functions[0]) (); */
FIELD_NAME (*field) = "virtual_functions";
FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (FIELD_TYPE (*field));
field++;
/* We assumed in the allocation above that there were four fields. */
gdb_assert (field == (field_list + 4));
t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
TYPE_NFIELDS (t) = field - field_list;
TYPE_FIELDS (t) = field_list;
TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
INIT_CPLUS_SPECIFIC (t);
return t;
}
void
browse_tree (tree begin)
{
tree head;
TB_CODE tbc = TB_UNUSED_COMMAND;
ssize_t rd;
char *input = NULL;
long input_size = 0;
fprintf (TB_OUT_FILE, "\nTree Browser\n");
#define TB_SET_HEAD(N) do { \
vec_safe_push (TB_history_stack, N); \
head = N; \
if (TB_verbose) \
if (head) \
{ \
print_generic_expr (TB_OUT_FILE, head, 0); \
fprintf (TB_OUT_FILE, "\n"); \
} \
} while (0)
TB_SET_HEAD (begin);
/* Store in a hashtable information about previous and upper statements. */
{
TB_up_ht = new hash_table<tree_upper_hasher> (1023);
TB_update_up (head);
}
while (24)
{
fprintf (TB_OUT_FILE, "TB> ");
rd = TB_getline (&input, &input_size, TB_IN_FILE);
if (rd == -1)
/* EOF. */
goto ret;
if (rd != 1)
/* Get a new command. Otherwise the user just pressed enter, and thus
she expects the last command to be reexecuted. */
tbc = TB_get_command (input);
switch (tbc)
{
case TB_UPDATE_UP:
TB_update_up (head);
break;
case TB_MAX:
if (head && (INTEGRAL_TYPE_P (head)
|| TREE_CODE (head) == REAL_TYPE
|| TREE_CODE (head) == FIXED_POINT_TYPE))
TB_SET_HEAD (TYPE_MAX_VALUE (head));
else
TB_WF;
break;
case TB_MIN:
if (head && (INTEGRAL_TYPE_P (head)
|| TREE_CODE (head) == REAL_TYPE
|| TREE_CODE (head) == FIXED_POINT_TYPE))
TB_SET_HEAD (TYPE_MIN_VALUE (head));
else
TB_WF;
break;
case TB_ELT:
if (head && TREE_CODE (head) == TREE_VEC)
{
/* This command takes another argument: the element number:
for example "elt 1". */
TB_NIY;
}
else if (head && TREE_CODE (head) == VECTOR_CST)
{
/* This command takes another argument: the element number:
for example "elt 1". */
TB_NIY;
}
else
TB_WF;
break;
case TB_VALUE:
if (head && TREE_CODE (head) == TREE_LIST)
TB_SET_HEAD (TREE_VALUE (head));
else
TB_WF;
break;
case TB_PURPOSE:
if (head && TREE_CODE (head) == TREE_LIST)
TB_SET_HEAD (TREE_PURPOSE (head));
else
TB_WF;
break;
case TB_IMAG:
if (head && TREE_CODE (head) == COMPLEX_CST)
TB_SET_HEAD (TREE_IMAGPART (head));
else
TB_WF;
break;
case TB_REAL:
if (head && TREE_CODE (head) == COMPLEX_CST)
TB_SET_HEAD (TREE_REALPART (head));
else
TB_WF;
break;
case TB_BLOCK:
if (head && TREE_CODE (head) == BIND_EXPR)
TB_SET_HEAD (TREE_OPERAND (head, 2));
else
TB_WF;
break;
case TB_SUBBLOCKS:
if (head && TREE_CODE (head) == BLOCK)
TB_SET_HEAD (BLOCK_SUBBLOCKS (head));
else
TB_WF;
break;
case TB_SUPERCONTEXT:
if (head && TREE_CODE (head) == BLOCK)
TB_SET_HEAD (BLOCK_SUPERCONTEXT (head));
else
TB_WF;
break;
case TB_VARS:
if (head && TREE_CODE (head) == BLOCK)
TB_SET_HEAD (BLOCK_VARS (head));
else if (head && TREE_CODE (head) == BIND_EXPR)
TB_SET_HEAD (TREE_OPERAND (head, 0));
else
TB_WF;
break;
case TB_REFERENCE_TO_THIS:
if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_REFERENCE_TO (head));
else
TB_WF;
break;
case TB_POINTER_TO_THIS:
if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_POINTER_TO (head));
else
TB_WF;
break;
case TB_BASETYPE:
if (head && TREE_CODE (head) == OFFSET_TYPE)
TB_SET_HEAD (TYPE_OFFSET_BASETYPE (head));
else
TB_WF;
break;
case TB_ARG_TYPES:
if (head && (TREE_CODE (head) == FUNCTION_TYPE
|| TREE_CODE (head) == METHOD_TYPE))
TB_SET_HEAD (TYPE_ARG_TYPES (head));
else
TB_WF;
break;
case TB_METHOD_BASE_TYPE:
if (head && (TREE_CODE (head) == FUNCTION_TYPE
|| TREE_CODE (head) == METHOD_TYPE)
&& TYPE_METHOD_BASETYPE (head))
TB_SET_HEAD (TYPE_METHOD_BASETYPE (head));
else
TB_WF;
break;
case TB_FIELDS:
if (head && (TREE_CODE (head) == RECORD_TYPE
|| TREE_CODE (head) == UNION_TYPE
|| TREE_CODE (head) == QUAL_UNION_TYPE))
TB_SET_HEAD (TYPE_FIELDS (head));
else
TB_WF;
break;
case TB_DOMAIN:
if (head && TREE_CODE (head) == ARRAY_TYPE)
TB_SET_HEAD (TYPE_DOMAIN (head));
else
TB_WF;
break;
case TB_VALUES:
if (head && TREE_CODE (head) == ENUMERAL_TYPE)
TB_SET_HEAD (TYPE_VALUES (head));
else
TB_WF;
break;
case TB_ARG_TYPE:
if (head && TREE_CODE (head) == PARM_DECL)
TB_SET_HEAD (DECL_ARG_TYPE (head));
else
TB_WF;
break;
case TB_INITIAL:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_INITIAL (head));
else
TB_WF;
break;
case TB_RESULT:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_RESULT_FLD (head));
else
TB_WF;
break;
case TB_ARGUMENTS:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_ARGUMENTS (head));
else
TB_WF;
break;
case TB_ABSTRACT_ORIGIN:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));
else if (head && TREE_CODE (head) == BLOCK)
TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));
else
TB_WF;
break;
case TB_ATTRIBUTES:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_ATTRIBUTES (head));
else if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_ATTRIBUTES (head));
else
TB_WF;
break;
case TB_CONTEXT:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_CONTEXT (head));
else if (head && TYPE_P (head)
&& TYPE_CONTEXT (head))
TB_SET_HEAD (TYPE_CONTEXT (head));
else
TB_WF;
break;
case TB_OFFSET:
if (head && TREE_CODE (head) == FIELD_DECL)
TB_SET_HEAD (DECL_FIELD_OFFSET (head));
else
TB_WF;
break;
case TB_BIT_OFFSET:
if (head && TREE_CODE (head) == FIELD_DECL)
TB_SET_HEAD (DECL_FIELD_BIT_OFFSET (head));
else
TB_WF;
break;
case TB_UNIT_SIZE:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_SIZE_UNIT (head));
else if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_SIZE_UNIT (head));
else
TB_WF;
break;
case TB_SIZE:
if (head && DECL_P (head))
TB_SET_HEAD (DECL_SIZE (head));
else if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_SIZE (head));
else
TB_WF;
break;
case TB_TYPE:
if (head && TREE_TYPE (head))
TB_SET_HEAD (TREE_TYPE (head));
else
TB_WF;
break;
case TB_DECL_SAVED_TREE:
if (head && TREE_CODE (head) == FUNCTION_DECL
&& DECL_SAVED_TREE (head))
TB_SET_HEAD (DECL_SAVED_TREE (head));
else
TB_WF;
break;
case TB_BODY:
if (head && TREE_CODE (head) == BIND_EXPR)
TB_SET_HEAD (TREE_OPERAND (head, 1));
else
TB_WF;
break;
case TB_CHILD_0:
if (head && EXPR_P (head) && TREE_OPERAND (head, 0))
TB_SET_HEAD (TREE_OPERAND (head, 0));
else
TB_WF;
break;
case TB_CHILD_1:
if (head && EXPR_P (head) && TREE_OPERAND (head, 1))
TB_SET_HEAD (TREE_OPERAND (head, 1));
else
TB_WF;
break;
case TB_CHILD_2:
if (head && EXPR_P (head) && TREE_OPERAND (head, 2))
TB_SET_HEAD (TREE_OPERAND (head, 2));
else
TB_WF;
break;
case TB_CHILD_3:
if (head && EXPR_P (head) && TREE_OPERAND (head, 3))
TB_SET_HEAD (TREE_OPERAND (head, 3));
else
TB_WF;
break;
case TB_PRINT:
if (head)
debug_tree (head);
else
TB_WF;
break;
case TB_PRETTY_PRINT:
if (head)
{
print_generic_stmt (TB_OUT_FILE, head, 0);
fprintf (TB_OUT_FILE, "\n");
}
else
TB_WF;
break;
case TB_SEARCH_NAME:
break;
case TB_SEARCH_CODE:
{
enum tree_code code;
char *arg_text;
arg_text = strchr (input, ' ');
if (arg_text == NULL)
{
fprintf (TB_OUT_FILE, "First argument is missing. This isn't a valid search command. \n");
break;
}
code = TB_get_tree_code (arg_text + 1);
/* Search in the subtree a node with the given code. */
{
tree res;
res = walk_tree (&head, find_node_with_code, &code, NULL);
if (res == NULL_TREE)
{
fprintf (TB_OUT_FILE, "There's no node with this code (reachable via the walk_tree function from this node).\n");
}
else
{
fprintf (TB_OUT_FILE, "Achoo! I got this node in the tree.\n");
TB_SET_HEAD (res);
}
}
break;
}
#define TB_MOVE_HEAD(FCT) do { \
if (head) \
{ \
tree t; \
t = FCT (head); \
if (t) \
TB_SET_HEAD (t); \
else \
TB_WF; \
} \
else \
TB_WF; \
} while (0)
case TB_FIRST:
TB_MOVE_HEAD (TB_first_in_bind);
break;
case TB_LAST:
TB_MOVE_HEAD (TB_last_in_bind);
break;
case TB_UP:
TB_MOVE_HEAD (TB_up_expr);
break;
case TB_PREV:
TB_MOVE_HEAD (TB_prev_expr);
break;
case TB_NEXT:
TB_MOVE_HEAD (TB_next_expr);
break;
case TB_HPREV:
/* This command is a little bit special, since it deals with history
stack. For this reason it should keep the "head = ..." statement
and not use TB_MOVE_HEAD. */
if (head)
{
tree t;
t = TB_history_prev ();
if (t)
{
head = t;
if (TB_verbose)
{
print_generic_expr (TB_OUT_FILE, head, 0);
fprintf (TB_OUT_FILE, "\n");
}
}
else
TB_WF;
}
else
TB_WF;
break;
case TB_CHAIN:
/* Don't go further if it's the last node in this chain. */
if (head && TREE_CODE (head) == BLOCK)
TB_SET_HEAD (BLOCK_CHAIN (head));
else if (head && TREE_CHAIN (head))
TB_SET_HEAD (TREE_CHAIN (head));
else
TB_WF;
break;
case TB_FUN:
/* Go up to the current function declaration. */
TB_SET_HEAD (current_function_decl);
fprintf (TB_OUT_FILE, "Current function declaration.\n");
break;
case TB_HELP:
/* Display a help message. */
{
int i;
fprintf (TB_OUT_FILE, "Possible commands are:\n\n");
for (i = 0; i < TB_UNUSED_COMMAND; i++)
{
fprintf (TB_OUT_FILE, "%20s - %s\n", TB_COMMAND_TEXT (i), TB_COMMAND_HELP (i));
}
}
break;
case TB_VERBOSE:
if (TB_verbose == 0)
{
TB_verbose = 1;
fprintf (TB_OUT_FILE, "Verbose on.\n");
}
else
{
TB_verbose = 0;
fprintf (TB_OUT_FILE, "Verbose off.\n");
}
break;
case TB_EXIT:
case TB_QUIT:
/* Just exit from this function. */
goto ret;
default:
TB_NIY;
}
}
ret:;
delete TB_up_ht;
TB_up_ht = NULL;
return;
}
static tree
build_common_decl (gfc_common_head *com, tree union_type, bool is_init)
{
gfc_symbol *common_sym;
tree decl;
/* Create a namespace to store symbols for common blocks. */
if (gfc_common_ns == NULL)
gfc_common_ns = gfc_get_namespace (NULL, 0);
gfc_get_symbol (com->name, gfc_common_ns, &common_sym);
decl = common_sym->backend_decl;
/* Update the size of this common block as needed. */
if (decl != NULL_TREE)
{
tree size = TYPE_SIZE_UNIT (union_type);
/* Named common blocks of the same name shall be of the same size
in all scoping units of a program in which they appear, but
blank common blocks may be of different sizes. */
if (!tree_int_cst_equal (DECL_SIZE_UNIT (decl), size)
&& strcmp (com->name, BLANK_COMMON_NAME))
gfc_warning ("Named COMMON block '%s' at %L shall be of the "
"same size as elsewhere (%lu vs %lu bytes)", com->name,
&com->where,
(unsigned long) TREE_INT_CST_LOW (size),
(unsigned long) TREE_INT_CST_LOW (DECL_SIZE_UNIT (decl)));
if (tree_int_cst_lt (DECL_SIZE_UNIT (decl), size))
{
DECL_SIZE (decl) = TYPE_SIZE (union_type);
DECL_SIZE_UNIT (decl) = size;
DECL_MODE (decl) = TYPE_MODE (union_type);
TREE_TYPE (decl) = union_type;
layout_decl (decl, 0);
}
}
/* If this common block has been declared in a previous program unit,
and either it is already initialized or there is no new initialization
for it, just return. */
if ((decl != NULL_TREE) && (!is_init || DECL_INITIAL (decl)))
return decl;
/* If there is no backend_decl for the common block, build it. */
if (decl == NULL_TREE)
{
decl = build_decl (input_location,
VAR_DECL, get_identifier (com->name), union_type);
gfc_set_decl_assembler_name (decl, gfc_sym_mangled_common_id (com));
TREE_PUBLIC (decl) = 1;
TREE_STATIC (decl) = 1;
DECL_IGNORED_P (decl) = 1;
if (!com->is_bind_c)
DECL_ALIGN (decl) = BIGGEST_ALIGNMENT;
else
{
/* Do not set the alignment for bind(c) common blocks to
BIGGEST_ALIGNMENT because that won't match what C does. Also,
for common blocks with one element, the alignment must be
that of the field within the common block in order to match
what C will do. */
tree field = NULL_TREE;
field = TYPE_FIELDS (TREE_TYPE (decl));
if (DECL_CHAIN (field) == NULL_TREE)
DECL_ALIGN (decl) = TYPE_ALIGN (TREE_TYPE (field));
}
DECL_USER_ALIGN (decl) = 0;
GFC_DECL_COMMON_OR_EQUIV (decl) = 1;
gfc_set_decl_location (decl, &com->where);
if (com->threadprivate)
DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
/* Place the back end declaration for this common block in
GLOBAL_BINDING_LEVEL. */
common_sym->backend_decl = pushdecl_top_level (decl);
}
/* Has no initial values. */
if (!is_init)
{
DECL_INITIAL (decl) = NULL_TREE;
DECL_COMMON (decl) = 1;
DECL_DEFER_OUTPUT (decl) = 1;
}
else
{
DECL_INITIAL (decl) = error_mark_node;
DECL_COMMON (decl) = 0;
DECL_DEFER_OUTPUT (decl) = 0;
}
return decl;
}
static struct type *
java_link_class_type (struct gdbarch *gdbarch,
struct type *type, struct value *clas)
{
struct value *temp;
const char *unqualified_name;
const char *name = TYPE_TAG_NAME (type);
int ninterfaces, nfields, nmethods;
int type_is_object = 0;
struct fn_field *fn_fields;
struct fn_fieldlist *fn_fieldlists;
struct value *fields;
struct value *methods;
struct value *method = NULL;
struct value *field = NULL;
int i, j;
struct objfile *objfile = get_dynamics_objfile (gdbarch);
struct type *tsuper;
gdb_assert (name != NULL);
unqualified_name = strrchr (name, '.');
if (unqualified_name == NULL)
unqualified_name = name;
temp = clas;
temp = value_struct_elt (&temp, NULL, "superclass", NULL, "structure");
if (strcmp (name, "java.lang.Object") == 0)
{
tsuper = get_java_object_type ();
if (tsuper && TYPE_CODE (tsuper) == TYPE_CODE_PTR)
tsuper = TYPE_TARGET_TYPE (tsuper);
type_is_object = 1;
}
else
tsuper = type_from_class (gdbarch, temp);
#if 1
ninterfaces = 0;
#else
temp = clas;
ninterfaces = value_as_long (value_struct_elt (&temp, NULL, "interface_len",
NULL, "structure"));
#endif
TYPE_N_BASECLASSES (type) = (tsuper == NULL ? 0 : 1) + ninterfaces;
temp = clas;
nfields = value_as_long (value_struct_elt (&temp, NULL, "field_count",
NULL, "structure"));
nfields += TYPE_N_BASECLASSES (type);
nfields++; /* Add one for dummy "class" field. */
TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = (struct field *)
TYPE_ALLOC (type, sizeof (struct field) * nfields);
memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
TYPE_FIELD_PRIVATE_BITS (type) =
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
TYPE_FIELD_PROTECTED_BITS (type) =
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
TYPE_FIELD_IGNORE_BITS (type) =
(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
if (tsuper != NULL)
{
TYPE_BASECLASS (type, 0) = tsuper;
if (type_is_object)
SET_TYPE_FIELD_PRIVATE (type, 0);
}
i = strlen (name);
if (i > 2 && name[i - 1] == ']' && tsuper != NULL)
{
/* FIXME */
TYPE_LENGTH (type) = TYPE_LENGTH (tsuper) + 4; /* size with "length" */
}
else
{
temp = clas;
temp = value_struct_elt (&temp, NULL, "size_in_bytes",
NULL, "structure");
TYPE_LENGTH (type) = value_as_long (temp);
}
fields = NULL;
nfields--; /* First set up dummy "class" field. */
SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields), value_address (clas));
TYPE_FIELD_NAME (type, nfields) = "class";
TYPE_FIELD_TYPE (type, nfields) = value_type (clas);
SET_TYPE_FIELD_PRIVATE (type, nfields);
for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)
{
int accflags;
int boffset;
if (fields == NULL)
{
temp = clas;
fields = value_struct_elt (&temp, NULL, "fields", NULL, "structure");
field = value_ind (fields);
}
else
{ /* Re-use field value for next field. */
CORE_ADDR addr
= value_address (field) + TYPE_LENGTH (value_type (field));
set_value_address (field, addr);
set_value_lazy (field, 1);
}
temp = field;
temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");
TYPE_FIELD_NAME (type, i) =
get_java_utf8_name (&objfile->objfile_obstack, temp);
temp = field;
accflags = value_as_long (value_struct_elt (&temp, NULL, "accflags",
NULL, "structure"));
temp = field;
temp = value_struct_elt (&temp, NULL, "info", NULL, "structure");
boffset = value_as_long (value_struct_elt (&temp, NULL, "boffset",
NULL, "structure"));
if (accflags & 0x0001) /* public access */
{
/* ??? */
}
if (accflags & 0x0002) /* private access */
{
SET_TYPE_FIELD_PRIVATE (type, i);
}
if (accflags & 0x0004) /* protected access */
{
SET_TYPE_FIELD_PROTECTED (type, i);
}
if (accflags & 0x0008) /* ACC_STATIC */
SET_FIELD_PHYSADDR (TYPE_FIELD (type, i), boffset);
else
SET_FIELD_BITPOS (TYPE_FIELD (type, i), 8 * boffset);
if (accflags & 0x8000) /* FIELD_UNRESOLVED_FLAG */
{
TYPE_FIELD_TYPE (type, i) = get_java_object_type (); /* FIXME */
}
else
{
struct type *ftype;
temp = field;
temp = value_struct_elt (&temp, NULL, "type", NULL, "structure");
ftype = type_from_class (gdbarch, temp);
if (TYPE_CODE (ftype) == TYPE_CODE_STRUCT)
ftype = lookup_pointer_type (ftype);
TYPE_FIELD_TYPE (type, i) = ftype;
}
}
temp = clas;
nmethods = value_as_long (value_struct_elt (&temp, NULL, "method_count",
NULL, "structure"));
j = nmethods * sizeof (struct fn_field);
fn_fields = (struct fn_field *)
obstack_alloc (&objfile->objfile_obstack, j);
memset (fn_fields, 0, j);
fn_fieldlists = (struct fn_fieldlist *)
alloca (nmethods * sizeof (struct fn_fieldlist));
methods = NULL;
for (i = 0; i < nmethods; i++)
{
const char *mname;
int k;
if (methods == NULL)
{
temp = clas;
methods = value_struct_elt (&temp, NULL, "methods",
NULL, "structure");
method = value_ind (methods);
}
else
{ /* Re-use method value for next method. */
CORE_ADDR addr
= value_address (method) + TYPE_LENGTH (value_type (method));
set_value_address (method, addr);
set_value_lazy (method, 1);
}
/* Get method name. */
temp = method;
temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");
mname = get_java_utf8_name (&objfile->objfile_obstack, temp);
if (strcmp (mname, "<init>") == 0)
mname = unqualified_name;
/* Check for an existing method with the same name.
* This makes building the fn_fieldslists an O(nmethods**2)
* operation. That could be using hashing, but I doubt it
* is worth it. Note that we do maintain the order of methods
* in the inferior's Method table (as long as that is grouped
* by method name), which I think is desirable. --PB */
for (k = 0, j = TYPE_NFN_FIELDS (type);;)
{
if (--j < 0)
{ /* No match - new method name. */
j = TYPE_NFN_FIELDS (type)++;
fn_fieldlists[j].name = mname;
fn_fieldlists[j].length = 1;
fn_fieldlists[j].fn_fields = &fn_fields[i];
k = i;
break;
}
if (strcmp (mname, fn_fieldlists[j].name) == 0)
{ /* Found an existing method with the same name. */
int l;
if (mname != unqualified_name)
obstack_free (&objfile->objfile_obstack, mname);
mname = fn_fieldlists[j].name;
fn_fieldlists[j].length++;
k = i - k; /* Index of new slot. */
/* Shift intervening fn_fields (between k and i) down. */
for (l = i; l > k; l--)
fn_fields[l] = fn_fields[l - 1];
for (l = TYPE_NFN_FIELDS (type); --l > j;)
fn_fieldlists[l].fn_fields++;
break;
}
k += fn_fieldlists[j].length;
}
fn_fields[k].physname = "";
fn_fields[k].is_stub = 1;
/* FIXME */
fn_fields[k].type = lookup_function_type
(builtin_java_type (gdbarch)->builtin_void);
TYPE_CODE (fn_fields[k].type) = TYPE_CODE_METHOD;
}
j = TYPE_NFN_FIELDS (type) * sizeof (struct fn_fieldlist);
TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
obstack_alloc (&objfile->objfile_obstack, j);
memcpy (TYPE_FN_FIELDLISTS (type), fn_fieldlists, j);
return type;
}
static void
create_common (gfc_common_head *com, segment_info *head, bool saw_equiv)
{
segment_info *s, *next_s;
tree union_type;
tree *field_link;
tree field;
tree field_init = NULL_TREE;
record_layout_info rli;
tree decl;
bool is_init = false;
bool is_saved = false;
/* Declare the variables inside the common block.
If the current common block contains any equivalence object, then
make a UNION_TYPE node, otherwise RECORD_TYPE. This will let the
alias analyzer work well when there is no address overlapping for
common variables in the current common block. */
if (saw_equiv)
union_type = make_node (UNION_TYPE);
else
union_type = make_node (RECORD_TYPE);
rli = start_record_layout (union_type);
field_link = &TYPE_FIELDS (union_type);
/* Check for overlapping initializers and replace them with a single,
artificial field that contains all the data. */
if (saw_equiv)
field = get_init_field (head, union_type, &field_init, rli);
else
field = NULL_TREE;
if (field != NULL_TREE)
{
is_init = true;
*field_link = field;
field_link = &DECL_CHAIN (field);
}
for (s = head; s; s = s->next)
{
build_field (s, union_type, rli);
/* Link the field into the type. */
*field_link = s->field;
field_link = &DECL_CHAIN (s->field);
/* Has initial value. */
if (s->sym->value)
is_init = true;
/* Has SAVE attribute. */
if (s->sym->attr.save)
is_saved = true;
}
finish_record_layout (rli, true);
if (com)
decl = build_common_decl (com, union_type, is_init);
else
decl = build_equiv_decl (union_type, is_init, is_saved);
if (is_init)
{
tree ctor, tmp;
VEC(constructor_elt,gc) *v = NULL;
if (field != NULL_TREE && field_init != NULL_TREE)
CONSTRUCTOR_APPEND_ELT (v, field, field_init);
else
for (s = head; s; s = s->next)
{
if (s->sym->value)
{
/* Add the initializer for this field. */
tmp = gfc_conv_initializer (s->sym->value, &s->sym->ts,
TREE_TYPE (s->field),
s->sym->attr.dimension,
s->sym->attr.pointer
|| s->sym->attr.allocatable, false);
CONSTRUCTOR_APPEND_ELT (v, s->field, tmp);
}
}
gcc_assert (!VEC_empty (constructor_elt, v));
ctor = build_constructor (union_type, v);
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (decl) = ctor;
#ifdef ENABLE_CHECKING
{
tree field, value;
unsigned HOST_WIDE_INT idx;
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), idx, field, value)
gcc_assert (TREE_CODE (field) == FIELD_DECL);
}
#endif
}
/* Build component reference for each variable. */
for (s = head; s; s = next_s)
{
tree var_decl;
var_decl = build_decl (s->sym->declared_at.lb->location,
VAR_DECL, DECL_NAME (s->field),
TREE_TYPE (s->field));
TREE_STATIC (var_decl) = TREE_STATIC (decl);
/* Mark the variable as used in order to avoid warnings about
unused variables. */
TREE_USED (var_decl) = 1;
if (s->sym->attr.use_assoc)
DECL_IGNORED_P (var_decl) = 1;
if (s->sym->attr.target)
TREE_ADDRESSABLE (var_decl) = 1;
/* Fake variables are not visible from other translation units. */
TREE_PUBLIC (var_decl) = 0;
/* To preserve identifier names in COMMON, chain to procedure
scope unless at top level in a module definition. */
if (com
&& s->sym->ns->proc_name
&& s->sym->ns->proc_name->attr.flavor == FL_MODULE)
var_decl = pushdecl_top_level (var_decl);
else
gfc_add_decl_to_function (var_decl);
SET_DECL_VALUE_EXPR (var_decl,
fold_build3_loc (input_location, COMPONENT_REF,
TREE_TYPE (s->field),
decl, s->field, NULL_TREE));
DECL_HAS_VALUE_EXPR_P (var_decl) = 1;
GFC_DECL_COMMON_OR_EQUIV (var_decl) = 1;
if (s->sym->attr.assign)
{
gfc_allocate_lang_decl (var_decl);
GFC_DECL_ASSIGN (var_decl) = 1;
GFC_DECL_STRING_LEN (var_decl) = GFC_DECL_STRING_LEN (s->field);
GFC_DECL_ASSIGN_ADDR (var_decl) = GFC_DECL_ASSIGN_ADDR (s->field);
}
s->sym->backend_decl = var_decl;
next_s = s->next;
free (s);
}
}
/* Recursively mark reference fields. */
static void
mark_reference_fields (tree field,
wide_int *mask,
unsigned int ubit,
int *pointer_after_end,
int *all_bits_set,
int *last_set_index,
HOST_WIDE_INT *last_view_index)
{
/* See if we have fields from our superclass. */
if (DECL_NAME (field) == NULL_TREE)
{
mark_reference_fields (TYPE_FIELDS (TREE_TYPE (field)),
mask, ubit,
pointer_after_end, all_bits_set,
last_set_index, last_view_index);
field = DECL_CHAIN (field);
}
for (; field != NULL_TREE; field = DECL_CHAIN (field))
{
HOST_WIDE_INT offset;
HOST_WIDE_INT size_bytes;
if (FIELD_STATIC (field))
continue;
offset = int_byte_position (field);
size_bytes = int_size_in_bytes (TREE_TYPE (field));
if (JREFERENCE_TYPE_P (TREE_TYPE (field))
/* An `object' of type gnu.gcj.RawData is actually non-Java
data. */
&& TREE_TYPE (field) != rawdata_ptr_type_node)
{
unsigned int count;
unsigned int size_words;
unsigned int i;
/* If this reference slot appears to overlay a slot we think
we already covered, then we are doomed. */
gcc_assert (offset > *last_view_index);
if (offset % (HOST_WIDE_INT) (POINTER_SIZE / BITS_PER_UNIT))
{
*all_bits_set = -1;
*pointer_after_end = 1;
break;
}
count = offset * BITS_PER_UNIT / POINTER_SIZE;
size_words = size_bytes * BITS_PER_UNIT / POINTER_SIZE;
*last_set_index = count;
if (count >= ubit - 2)
*pointer_after_end = 1;
else
/* First word in object corresponds to most significant byte of
bitmap.
In the case of a multiple-word record, we set pointer
bits for all words in the record. This is conservative, but the
size_words != 1 case is impossible in regular java code. */
for (i = 0; i < size_words; ++i)
*mask = wi::set_bit (*mask, ubit - count - i - 1);
/* If we saw a non-reference field earlier, then we can't
use the count representation. We keep track of that in
*ALL_BITS_SET. */
if (! *all_bits_set)
*all_bits_set = -1;
}
else if (*all_bits_set > 0)
*all_bits_set = 0;
*last_view_index = offset;
}
}
