void
pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
{
tree saved_scope = pp->enclosing_scope;
pp_cxx_decl_specifier_seq (pp, t);
pp_cxx_declarator (pp, t);
pp_needs_newline (pp) = true;
pp->enclosing_scope = DECL_CONTEXT (t);
if (DECL_SAVED_TREE (t))
{
tree body = DECL_SAVED_TREE (t);
if (TREE_CODE (body) == COMPOUND_STMT
&& TREE_CODE (COMPOUND_BODY (body)) == CTOR_INITIALIZER)
{
body = COMPOUND_BODY (body);
pp_cxx_ctor_initializer (pp, body);
body = TREE_CHAIN (body);
}
pp_cxx_statement (pp, body);
}
else
{
pp_cxx_semicolon (pp);
pp_needs_newline (pp) = true;
}
pp_flush (pp);
pp->enclosing_scope = saved_scope;
}
void
c_genericize (tree fndecl)
{
FILE *dump_orig;
int local_dump_flags;
struct cgraph_node *cgn;
/* Dump the C-specific tree IR. */
dump_orig = dump_begin (TDI_original, &local_dump_flags);
if (dump_orig)
{
fprintf (dump_orig, "\n;; Function %s",
lang_hooks.decl_printable_name (fndecl, 2));
fprintf (dump_orig, " (%s)\n",
(!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
fprintf (dump_orig, "\n");
if (local_dump_flags & TDF_RAW)
dump_node (DECL_SAVED_TREE (fndecl),
TDF_SLIM | local_dump_flags, dump_orig);
else
print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
fprintf (dump_orig, "\n");
dump_end (TDI_original, dump_orig);
}
/* Dump all nested functions now. */
cgn = cgraph_node (fndecl);
for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
c_genericize (cgn->decl);
}
static enum in_charge_use
compute_use_thunks (tree fn)
{
tree last_arg, fn_parm;
if (DECL_HAS_VTT_PARM_P (fn))
return NO_THUNKS;
if (flag_apple_kext)
return NO_THUNKS;
if (flag_clone_structors)
return NO_THUNKS;
/* Functions that are too small will just get inlined back in anyway.
Let the inliner do something useful instead. */
if (flag_inline_functions
&& estimate_num_insns (DECL_SAVED_TREE (fn)) < MAX_INLINE_INSNS_AUTO)
return NO_THUNKS;
/* If function accepts variable arguments, give up. */
last_arg = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fn)));
if ( ! VOID_TYPE_P (TREE_VALUE (last_arg)))
return NO_THUNKS;
/* If constructor expects vector (AltiVec) arguments, give up. */
for (fn_parm = DECL_ARGUMENTS (fn); fn_parm; fn_parm = TREE_CHAIN (fn_parm))
if (TREE_CODE (fn_parm) == VECTOR_TYPE)
return NO_THUNKS;
if (DECL_HAS_IN_CHARGE_PARM_P (fn))
{
int parmno;
struct thunk_tree_walk_data data;
for (parmno = 0, fn_parm = DECL_ARGUMENTS (fn);
fn_parm;
++parmno, fn_parm = TREE_CHAIN (fn_parm))
if (parmno == 1)
{
data.in_charge_parm = fn_parm;
break;
}
/* If every use of the in-charge parameter ANDs it
with 1, then the functions that have in-charge
set to 1 and 3 are equivalent, likewise 0 and 2.
Check for this (common in practice). Likewise,
if every use tests for equality with 0, then
values 1, 2 and 3 are equivalent. */
gcc_assert (data.in_charge_parm != NULL_TREE);
data.in_charge_use = ALL_THUNKS;
walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
examine_tree_for_in_charge_use,
&data);
return data.in_charge_use;
}
return ALL_THUNKS;
}
static void
cp_ubsan_maybe_instrument_return (tree fndecl)
{
if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl)))
|| DECL_CONSTRUCTOR_P (fndecl)
|| DECL_DESTRUCTOR_P (fndecl)
|| !targetm.warn_func_return (fndecl))
return;
tree t = DECL_SAVED_TREE (fndecl);
while (t)
{
switch (TREE_CODE (t))
{
case BIND_EXPR:
t = BIND_EXPR_BODY (t);
continue;
case TRY_FINALLY_EXPR:
t = TREE_OPERAND (t, 0);
continue;
case STATEMENT_LIST:
{
tree_stmt_iterator i = tsi_last (t);
if (!tsi_end_p (i))
{
t = tsi_stmt (i);
continue;
}
}
break;
case RETURN_EXPR:
return;
default:
break;
}
break;
}
if (t == NULL_TREE)
return;
t = DECL_SAVED_TREE (fndecl);
if (TREE_CODE (t) == BIND_EXPR
&& TREE_CODE (BIND_EXPR_BODY (t)) == STATEMENT_LIST)
{
tree_stmt_iterator i = tsi_last (BIND_EXPR_BODY (t));
t = ubsan_instrument_return (DECL_SOURCE_LOCATION (fndecl));
tsi_link_after (&i, t, TSI_NEW_STMT);
}
}
void
cilk_install_body_with_frame_cleanup (tree fndecl, tree orig_body, void *wd)
{
tree frame = make_cilk_frame (fndecl);
tree dtor = create_cilk_function_exit (frame, false, false);
add_local_decl (cfun, frame);
cfun->language = ggc_cleared_alloc<language_function> ();
location_t loc = EXPR_LOCATION (orig_body);
tree list = alloc_stmt_list ();
DECL_SAVED_TREE (fndecl) = list;
tree fptr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (frame)), frame);
tree body = cilk_install_body_pedigree_operations (fptr);
gcc_assert (TREE_CODE (body) == STATEMENT_LIST);
tree detach_expr = build_call_expr (cilk_detach_fndecl, 1, fptr);
append_to_statement_list (detach_expr, &body);
cilk_outline (fndecl, &orig_body, (struct wrapper_data *) wd);
append_to_statement_list (orig_body, &body);
if (flag_exceptions)
{
tree except_flag = set_cilk_except_flag (frame);
tree except_data = set_cilk_except_data (frame);
tree catch_list = alloc_stmt_list ();
append_to_statement_list (except_flag, &catch_list);
append_to_statement_list (except_data, &catch_list);
body = create_try_catch_expr (body, catch_list);
}
append_to_statement_list (build_stmt (loc, TRY_FINALLY_EXPR, body, dtor),
&list);
}
static void
pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
{
tree saved_scope = pp->enclosing_scope;
pp_cxx_decl_specifier_seq (pp, t);
pp_cxx_declarator (pp, t);
pp_needs_newline (pp) = true;
pp->enclosing_scope = DECL_CONTEXT (t);
if (DECL_SAVED_TREE (t))
pp_cxx_statement (pp, DECL_SAVED_TREE (t));
else
{
pp_cxx_semicolon (pp);
pp_needs_newline (pp) = true;
}
pp_flush (pp);
pp->enclosing_scope = saved_scope;
}
void
c_genericize (tree fndecl)
{
FILE *dump_file;
int local_dump_flags;
struct cgraph_node *cgn;
/* Dump the C-specific tree IR. */
dump_file = dump_begin (TDI_original, &local_dump_flags);
if (dump_file)
{
fprintf (dump_file, "\n;; Function %s",
lang_hooks.decl_printable_name (fndecl, 2));
fprintf (dump_file, " (%s)\n",
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
fprintf (dump_file, ";; enabled by -%s\n", dump_flag_name (TDI_original));
fprintf (dump_file, "\n");
if (local_dump_flags & TDF_RAW)
dump_node (DECL_SAVED_TREE (fndecl),
TDF_SLIM | local_dump_flags, dump_file);
else
print_c_tree (dump_file, DECL_SAVED_TREE (fndecl));
fprintf (dump_file, "\n");
dump_end (TDI_original, dump_file);
}
/* Go ahead and gimplify for now. */
push_context ();
gimplify_function_tree (fndecl);
pop_context ();
/* Dump the genericized tree IR. */
dump_function (TDI_generic, fndecl);
/* Genericize all nested functions now. We do things in this order so
that items like VLA sizes are expanded properly in the context of
the correct function. */
cgn = cgraph_node (fndecl);
for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
c_genericize (cgn->decl);
}
void
pp_c_function_definition (c_pretty_printer *pp, tree t)
{
pp_declaration_specifiers (pp, t);
pp_declarator (pp, t);
pp_needs_newline (pp) = true;
pp_statement (pp, DECL_SAVED_TREE (t));
pp_newline (pp);
pp_flush (pp);
}
void
c_genericize (tree fndecl)
{
FILE *dump_orig;
dump_flags_t local_dump_flags;
struct cgraph_node *cgn;
if (flag_sanitize & SANITIZE_BOUNDS)
{
hash_set<tree> pset;
walk_tree (&DECL_SAVED_TREE (fndecl), ubsan_walk_array_refs_r, &pset,
&pset);
}
if (warn_duplicated_branches)
walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
do_warn_duplicated_branches_r, NULL);
/* Dump the C-specific tree IR. */
dump_orig = get_dump_info (TDI_original, &local_dump_flags);
if (dump_orig)
{
fprintf (dump_orig, "\n;; Function %s",
lang_hooks.decl_printable_name (fndecl, 2));
fprintf (dump_orig, " (%s)\n",
(!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
fprintf (dump_orig, "\n");
if (local_dump_flags & TDF_RAW)
dump_node (DECL_SAVED_TREE (fndecl),
TDF_SLIM | local_dump_flags, dump_orig);
else
print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
fprintf (dump_orig, "\n");
}
/* Dump all nested functions now. */
cgn = cgraph_node::get_create (fndecl);
for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
c_genericize (cgn->decl);
}
void pre_genericize(tree fndecl, void *dummy)
{
(void)dummy;
// get the function body
tree body_chain = DECL_SAVED_TREE(fndecl);
if(errorcount == 0 && sorrycount == 0)
{
walk_tree_without_duplicates(&body_chain, visit_fun, NULL);
}
}
/*
declaration:
block-declaration
function-definition
template-declaration
explicit-instantiation
explicit-specialization
linkage-specification
namespace-definition
block-declaration:
simple-declaration
asm-definition
namespace-alias-definition
using-declaration
using-directive */
void
pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
{
if (!DECL_LANG_SPECIFIC (t))
pp_cxx_simple_declaration (pp, t);
else if (DECL_USE_TEMPLATE (t))
switch (DECL_USE_TEMPLATE (t))
{
case 1:
pp_cxx_template_declaration (pp, t);
break;
case 2:
pp_cxx_explicit_specialization (pp, t);
break;
case 3:
pp_cxx_explicit_instantiation (pp, t);
break;
default:
break;
}
else switch (TREE_CODE (t))
{
case VAR_DECL:
case TYPE_DECL:
pp_cxx_simple_declaration (pp, t);
break;
case FUNCTION_DECL:
if (DECL_SAVED_TREE (t))
pp_cxx_function_definition (pp, t);
else
pp_cxx_simple_declaration (pp, t);
break;
case NAMESPACE_DECL:
if (DECL_NAMESPACE_ALIAS (t))
pp_cxx_namespace_alias_definition (pp, t);
else
pp_cxx_original_namespace_definition (pp, t);
break;
default:
pp_unsupported_tree (pp, t);
break;
}
}
void
cp_genericize (tree fndecl)
{
tree t;
struct pointer_set_t *p_set;
/* Fix up the types of parms passed by invisible reference. */
for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
if (TREE_ADDRESSABLE (TREE_TYPE (t)))
{
/* If a function's arguments are copied to create a thunk,
then DECL_BY_REFERENCE will be set -- but the type of the
argument will be a pointer type, so we will never get
here. */
gcc_assert (!DECL_BY_REFERENCE (t));
gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
TREE_TYPE (t) = DECL_ARG_TYPE (t);
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* Do the same for the return value. */
if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
{
t = DECL_RESULT (fndecl);
TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* If we're a clone, the body is already GIMPLE. */
if (DECL_CLONED_FUNCTION_P (fndecl))
return;
/* We do want to see every occurrence of the parms, so we can't just use
walk_tree's hash functionality. */
p_set = pointer_set_create ();
cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL);
pointer_set_destroy (p_set);
/* Do everything else. */
c_genericize (fndecl);
gcc_assert (bc_label[bc_break] == NULL);
gcc_assert (bc_label[bc_continue] == NULL);
}
static void
execute_mudflap_function_decls (void)
{
/* Don't instrument functions such as the synthetic constructor
built during mudflap_finish_file. */
if (mf_marked_p (current_function_decl) ||
DECL_ARTIFICIAL (current_function_decl))
return;
push_gimplify_context ();
mf_xform_decls (DECL_SAVED_TREE (current_function_decl),
DECL_ARGUMENTS (current_function_decl));
pop_gimplify_context (NULL);
}
void
gcc_genericize (tree fndecl)
{
FILE *dump_orig;
int local_dump_flags;
struct cgraph_node *cgn;
/* Dump the C-specific tree IR. */
dump_orig = gcc_dump_begin (TDI_original, &local_dump_flags);
/*
if(dump_orig)
{
printf("should start dumping original tree.\n");
}else{
printf("no dumping original tree flag.\n");
}
*/
if (dump_orig)
{
fprintf (dump_orig, "\n;; Function %s",
lang_hooks.decl_printable_name (fndecl, 2));
astTreeBuilder->addFunctionName(lang_hooks.decl_printable_name (fndecl, 2));
fprintf (dump_orig, " (%s)\n",
(!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
fprintf (dump_orig, "\n");
//if (local_dump_flags & TDF_RAW)
gcc_dump_node (DECL_SAVED_TREE (fndecl),
TDF_SLIM | local_dump_flags, dump_orig);
// else
// print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
fprintf (dump_orig, "\n");
restore_state();
gcc_dump_end (TDI_original, dump_orig);
}
/* Dump all nested functions now. */
cgn = cgraph_node (fndecl);
for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
gcc_genericize (cgn->decl);
}
// llvm_emit_code_for_current_function - Top level interface for emitting a
// function to the .s file.
void llvm_emit_code_for_current_function(tree fndecl) {
if (cfun->nonlocal_goto_save_area)
sorry("%Jnon-local gotos not supported by LLVM", fndecl);
if (errorcount || sorrycount) {
TREE_ASM_WRITTEN(fndecl) = 1;
return; // Do not process broken code.
}
timevar_push(TV_LLVM_FUNCS);
// Convert the AST to raw/ugly LLVM code.
Function *Fn;
{
TreeToLLVM Emitter(fndecl);
// Set up parameters and prepare for return, for the function.
Emitter.StartFunctionBody();
// Emit the body of the function.
Emitter.Emit(DECL_SAVED_TREE(fndecl), 0);
// Wrap things up.
Fn = Emitter.FinishFunctionBody();
}
#if 0
if (dump_file) {
fprintf (dump_file,
"\n\n;;\n;; Full LLVM generated for this function:\n;;\n");
Fn->dump();
}
#endif
if (PerFunctionPasses)
PerFunctionPasses->run(*Fn);
// TODO: Nuke the .ll code for the function at -O[01] if we don't want to
// inline it or something else.
// There's no need to defer outputting this function any more; we
// know we want to output it.
DECL_DEFER_OUTPUT(fndecl) = 0;
// Finally, we have written out this function!
TREE_ASM_WRITTEN(fndecl) = 1;
timevar_pop(TV_LLVM_FUNCS);
}
static tree
create_cilk_helper_decl (struct wrapper_data *wd)
{
char name[20];
if (wd->type == CILK_BLOCK_FOR)
sprintf (name, "_cilk_for_" HOST_WIDE_INT_PRINT_DEC, cilk_wrapper_count++);
else if (wd->type == CILK_BLOCK_SPAWN)
sprintf (name, "_cilk_spn_" HOST_WIDE_INT_PRINT_DEC, cilk_wrapper_count++);
else
gcc_unreachable ();
clean_symbol_name (name);
tree fndecl = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
FUNCTION_DECL, get_identifier (name), wd->fntype);
TREE_PUBLIC (fndecl) = 0;
TREE_STATIC (fndecl) = 1;
TREE_USED (fndecl) = 1;
DECL_ARTIFICIAL (fndecl) = 0;
DECL_IGNORED_P (fndecl) = 0;
DECL_EXTERNAL (fndecl) = 0;
DECL_CONTEXT (fndecl) = wd->context;
tree block = make_node (BLOCK);
DECL_INITIAL (fndecl) = block;
TREE_USED (block) = 1;
BLOCK_SUPERCONTEXT (block) = fndecl;
gcc_assert (!DECL_SAVED_TREE (fndecl));
/* Inlining would defeat the purpose of this wrapper.
Either it secretly switches stack frames or it allocates
a stable stack frame to hold function arguments even if
the parent stack frame is stolen. */
DECL_UNINLINABLE (fndecl) = 1;
tree result_decl = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
void_type_node);
DECL_ARTIFICIAL (result_decl) = 0;
DECL_IGNORED_P (result_decl) = 1;
DECL_CONTEXT (result_decl) = fndecl;
DECL_RESULT (fndecl) = result_decl;
return fndecl;
}
static tree
build_trivial_generic_function ()
{
auto_vec <tree> param_types;
tree fndecl = make_fndecl (integer_type_node,
"test_fn",
param_types);
ASSERT_TRUE (fndecl != NULL);
/* Populate the function. */
tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
NULL_TREE, integer_type_node);
DECL_ARTIFICIAL (retval) = 1;
DECL_IGNORED_P (retval) = 1;
DECL_RESULT (fndecl) = retval;
/* Create a BIND_EXPR, and within it, a statement list. */
tree stmt_list = alloc_stmt_list ();
tree_stmt_iterator stmt_iter = tsi_start (stmt_list);
tree block = make_node (BLOCK);
tree bind_expr
= build3 (BIND_EXPR, void_type_node, NULL, stmt_list, block);
tree modify_retval = build2 (MODIFY_EXPR,
integer_type_node,
retval,
build_int_cst (integer_type_node, 42));
tree return_stmt = build1 (RETURN_EXPR,
integer_type_node,
modify_retval);
tsi_link_after (&stmt_iter, return_stmt, TSI_CONTINUE_LINKING);
DECL_INITIAL (fndecl) = block;
/* how to add to function? the following appears to be how to
set the body of a fndecl: */
DECL_SAVED_TREE(fndecl) = bind_expr;
/* Ensure that locals appear in the debuginfo. */
BLOCK_VARS (block) = BIND_EXPR_VARS (bind_expr);
return fndecl;
}
static void
build_function (tree fndecl, tree stmts, tree block)
{
DECL_INITIAL(fndecl) = block;
DECL_SAVED_TREE (fndecl) = stmts ;
tree resdecl = build_decl(input_location,RESULT_DECL, NULL_TREE, integer_type_node);
DECL_CONTEXT (resdecl) = fndecl;
DECL_RESULT(fndecl) = resdecl;
current_function_decl = fndecl;
if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
push_struct_function(fndecl);
else
push_cfun(DECL_STRUCT_FUNCTION(fndecl));
cfun->function_end_locus = BUILTINS_LOCATION;
}
void cs502_proj1()
{
num_func = 0;
num_global_var = 0;
num_local_var = 0;
num_statements = 0;
printf("please implenment your analyzer of project here\n");
// count global variables
struct varpool_node *var_node;
tree global_decl;
for (var_node = varpool_nodes; var_node; var_node = var_node->next) {
global_decl = var_node->decl;
num_global_var++;
}
// deal with functions
struct cgraph_node *func_node;
tree fn;
for (func_node = cgraph_nodes; func_node; func_node = func_node->next) {
fn = func_node->decl; //get a function
if (TREE_CODE(fn) == FUNCTION_DECL) {
printf("\nfunction name: %s\n", IDENTIFIER_POINTER(DECL_NAME(fn)));
process_stmt(BIND_EXPR_BODY(DECL_SAVED_TREE(fn)));
}
num_func++;
}
printf("\nnumber of functions: %d\n", num_func);
printf("number of global variables: %d\n", num_global_var);
printf("number of local variables: %d\n", num_local_var);
printf("number of statements: %d\n", num_statements);
FILE *fp = fopen("./output.txt", "w");
fprintf(fp, "#functions: %d\n", num_func);
fprintf(fp, "#global vars: %d\n", num_global_var);
fprintf(fp, "#local vars: %d\n", num_local_var);
fprintf(fp, "#statements: %d\n", num_statements);
fclose(fp);
}
static void
pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
{
tree tmpl = most_general_template (t);
tree level;
int i = 0;
pp_maybe_newline_and_indent (pp, 0);
for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
{
pp_cxx_identifier (pp, "template");
pp_cxx_begin_template_argument_list (pp);
pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
pp_cxx_end_template_argument_list (pp);
pp_newline_and_indent (pp, 3);
i += 3;
}
if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
pp_cxx_function_definition (pp, t);
else
pp_cxx_simple_declaration (pp, t);
}
// generate a block for a declaration, which is either a function or global.
void XIL_GenerateBlock(tree decl)
{
memset(&xil_active_env, 0, sizeof(struct XIL_BlockEnv));
XIL_Var xil_var = NULL;
int annot_type = 0;
if (xil_has_annotation) {
gcc_assert(annotation_name);
gcc_assert(TREE_CODE(decl) == FUNCTION_DECL);
// get the name of the function/global/type being annotated; this looks at
// any annot_global / annot_source attributes on the decl.
const char *full_name = XIL_GlobalName(decl);
const char *name = XIL_SourceName(decl);
if (!strcmp(annotation_class, "func"))
xil_var = XIL_VarFunc(full_name, name);
else if (!strcmp(annotation_class, "init"))
xil_var = XIL_VarGlob(full_name, name);
else if (!strcmp(annotation_class, "comp")) {
xil_var = XIL_VarGlob(full_name, name);
annot_type = 1;
}
gcc_assert(xil_var);
}
else {
xil_var = XIL_TranslateVar(decl);
}
tree type = TREE_TYPE(decl);
XIL_Type xil_type = XIL_TranslateType(type);
// fixup the type for destructors. these have an __in_chrg argument that
// doesn't show up when the functions are called.
if (XIL_IsDestructor(decl)) {
if (TREE_CODE(type) == METHOD_TYPE) {
tree base_type = TYPE_METHOD_BASETYPE(type);
XIL_Type xil_base_type = XIL_TranslateType(base_type);
const char *this_csu = XIL_GetTypeCSUName(xil_base_type);
xil_type = XIL_TypeFunction(XIL_TypeVoid(), this_csu, false, NULL, 0);
}
else {
TREE_UNEXPECTED(decl);
}
}
// don't deal with extern functions/globals. we will see the definition later
// (hopefully!), including the complete type for arrays and any initializer.
// we still want to process the type for these in case anonymous types are
// being used.
if (DECL_EXTERNAL(decl))
return;
// parse the annotation kind.
XIL_AnnotationKind use_kind = 0;
if (annotation_kind) {
#define XIL_TEST_ANNOT(_, STR, VALUE) \
if (!strcmp(annotation_kind, STR)) use_kind = VALUE;
XIL_ITERATE_ANNOT(XIL_TEST_ANNOT)
#undef XIL_TEST_ANNOT
gcc_assert(use_kind);
}
const char *name = XIL_GetVarName(xil_var);
xil_active_env.decl = decl;
xil_active_env.decl_name = name;
XIL_SetActiveBlock(xil_var, annotation_name, use_kind, annot_type);
const char *decl_file = DECL_SOURCE_FILE(decl);
int decl_line = DECL_SOURCE_LINE(decl);
// get the begin file/line for a function definition. this is somewhat
// trickier than might be expected. the decl's location sometimes comes from
// a header file and not the definition we are interested in, while the
// result variable's location corresponds to the ')' for the function,
// not the function symbol which we want. solution: use the decl's location
// unless it looks like it came from a declaration (in a different file
// than the result, or many lines earlier).
if (TREE_CODE(decl) == FUNCTION_DECL) {
tree result = DECL_RESULT(decl);
if (result) {
const char *res_decl_file = DECL_SOURCE_FILE(result);
int res_decl_line = DECL_SOURCE_LINE(result);
if (strcmp(decl_file, res_decl_file) ||
res_decl_line > decl_line + 10) {
decl_file = res_decl_file;
decl_line = res_decl_line;
}
}
}
XIL_Location begin_loc = XIL_MakeLocation(decl_file, decl_line);
// get the end file/line from the parser's current position, unless the
// parser has no current position.
const char *end_file = input_filename;
int end_line = input_line;
if (!input_filename) {
end_file = decl_file;
end_line = decl_line;
}
// the begin/end points of the declaration should be in the same file.
if (strcmp(decl_file, end_file))
TREE_UNEXPECTED(decl);
XIL_Location end_loc = XIL_MakeLocation(end_file, end_line);
XIL_CFGSetCommand(xil_command);
XIL_CFGSetBeginLocation(begin_loc);
XIL_CFGSetEndLocation(end_loc);
xil_active_env.entry_point = xil_active_env.last_point = XIL_CFGAddPoint(begin_loc);
xil_active_env.exit_point = XIL_CFGAddPoint(end_loc);
XIL_CFGSetEntryPoint(xil_active_env.entry_point);
XIL_CFGSetExitPoint(xil_active_env.exit_point);
// add the decl variable to the active CFG. override any previous type we
// had for the variable, to account for seeing multiple definitions of
// a variable, which gcc allows, e.g. int buf[]; int buf[10];
if (!xil_has_annotation)
XIL_CFGAddVar(xil_var, xil_type, 1);
// current point for traversal of the function/initializer.
XIL_PPoint point = xil_active_env.entry_point;
bool is_function = (TREE_CODE(decl) == FUNCTION_DECL);
if (is_function) {
// handling for function definitions.
tree defn = DECL_SAVED_TREE(decl);
// add the parameters to the active CFG. skip this for destructors
// to avoid the __in_chrg argument.
if (!XIL_IsDestructor(decl)) {
tree param = DECL_ARGUMENTS(decl);
while (param) {
gcc_assert(TREE_CODE(param) == PARM_DECL);
XIL_TranslateVar(param); // forces insertion of the parameter.
param = TREE_CHAIN(param);
}
}
// generate edges for the function body.
XIL_ActivePushScope();
MAKE_ENV(body_env, &point, NULL);
XIL_TranslateTree(&body_env, defn);
XIL_ActivePopScope();
}
else {
// handling for global variables.
tree initial = DECL_INITIAL(decl);
// make an assignment for any initializer. for compound initializers
// this may get fairly involved.
if (initial) {
MAKE_ENV(initial_env, &point, NULL);
initial_env.result_assign = XIL_ExpVar(xil_var);
initial_env.result_assign_type = xil_type;
XIL_TranslateTree(&initial_env, initial);
}
}
// connect any fall through to the exit point.
XIL_CFGEdgeSkip(point, xil_active_env.exit_point);
// for debugging, bail out of compilation at the first error.
//if (xil_active_env.dropped) {
// printf("XIL: Bailing out\n");
// exit(1);
//}
// process any annotations read in from file for the function,
// now that we know all locals.
int count = XIL_GetAnnotationCount(name, !is_function, false);
int ind = 0;
for (; ind < count; ind++) {
const char *where;
const char *point_text, *annot_text;
int trusted;
XIL_GetAnnotation(name, !is_function, false, ind, &where,
&point_text, &annot_text, &trusted);
XIL_ProcessAnnotationRead(decl, where, point_text, annot_text, trusted);
}
// process annotations discovered for CSU types.
while (xil_active_env.annots) {
struct XIL_PendingAnnotation *annot = xil_active_env.annots;
xil_active_env.annots = annot->next;
XIL_ProcessAnnotationAttr(annot->type, annot->attr, NULL, NULL);
}
XIL_ClearActiveBlock(xil_active_env.dropped);
XIL_ClearAssociate(XIL_AscBlock);
memset(&xil_active_env, 0, sizeof(struct XIL_BlockEnv));
}
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);
}
}
void
java_genericize (tree fndecl)
{
walk_tree (&DECL_SAVED_TREE (fndecl), java_replace_references, NULL, NULL);
dump_java_tree (TDI_original, fndecl);
}
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 void
lower_function_body (void)
{
struct lower_data data;
tree *body_p = &DECL_SAVED_TREE (current_function_decl);
tree bind = *body_p;
tree_stmt_iterator i;
tree t, x;
gcc_assert (TREE_CODE (bind) == BIND_EXPR);
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
data.return_statements = NULL_TREE;
*body_p = alloc_stmt_list ();
i = tsi_start (*body_p);
tsi_link_after (&i, bind, TSI_NEW_STMT);
lower_bind_expr (&i, &data);
i = tsi_last (*body_p);
/* If the function falls off the end, we need a null return statement.
If we've already got one in the return_statements list, we don't
need to do anything special. Otherwise build one by hand. */
if (block_may_fallthru (*body_p)
&& (data.return_statements == NULL
|| TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL))
{
x = build (RETURN_EXPR, void_type_node, NULL);
SET_EXPR_LOCATION (x, cfun->function_end_locus);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
{
x = build (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
/* Remove the line number from the representative return statement.
It now fills in for many such returns. Failure to remove this
will result in incorrect results for coverage analysis. */
x = TREE_VALUE (t);
#ifdef USE_MAPPED_LOCATION
SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
#else
SET_EXPR_LOCUS (x, NULL);
#endif
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
}
bool
cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
{
struct cgraph_node *first = (struct cgraph_node *) (void *) 1;
struct cgraph_node *node, *next;
bool changed = false;
int insns = 0;
#ifdef ENABLE_CHECKING
verify_cgraph ();
#endif
if (file)
fprintf (file, "\nReclaiming functions:");
#ifdef ENABLE_CHECKING
for (node = cgraph_nodes; node; node = node->next)
gcc_assert (!node->aux);
#endif
for (node = cgraph_nodes; node; node = node->next)
if (node->needed && !node->global.inlined_to
&& ((!DECL_EXTERNAL (node->decl))
|| !node->analyzed
|| before_inlining_p))
{
node->aux = first;
first = node;
}
else
gcc_assert (!node->aux);
/* Perform reachability analysis. As a special case do not consider
extern inline functions not inlined as live because we won't output
them at all. */
while (first != (void *) 1)
{
struct cgraph_edge *e;
node = first;
first = (struct cgraph_node *) first->aux;
for (e = node->callees; e; e = e->next_callee)
if (!e->callee->aux
&& node->analyzed
&& (!e->inline_failed || !e->callee->analyzed
|| (!DECL_EXTERNAL (e->callee->decl))
|| before_inlining_p))
{
e->callee->aux = first;
first = e->callee;
}
}
/* Remove unreachable nodes. Extern inline functions need special care;
Unreachable extern inline functions shall be removed.
Reachable extern inline functions we never inlined shall get their bodies
eliminated.
Reachable extern inline functions we sometimes inlined will be turned into
unanalyzed nodes so they look like for true extern functions to the rest
of code. Body of such functions is released via remove_node once the
inline clones are eliminated. */
for (node = cgraph_nodes; node; node = next)
{
next = node->next;
if (!node->aux)
{
int local_insns;
tree decl = node->decl;
node->global.inlined_to = NULL;
if (DECL_STRUCT_FUNCTION (decl))
local_insns = node->local.self_insns;
else
local_insns = 0;
if (file)
fprintf (file, " %s", cgraph_node_name (node));
if (!node->analyzed || !DECL_EXTERNAL (node->decl)
|| before_inlining_p)
cgraph_remove_node (node);
else
{
struct cgraph_edge *e;
for (e = node->callers; e; e = e->next_caller)
if (e->caller->aux)
break;
if (e || node->needed)
{
struct cgraph_node *clone;
for (clone = node->next_clone; clone;
clone = clone->next_clone)
if (clone->aux)
break;
if (!clone)
{
cgraph_release_function_body (node);
node->analyzed = false;
}
cgraph_node_remove_callees (node);
node->analyzed = false;
node->local.inlinable = false;
}
else
cgraph_remove_node (node);
}
if (!DECL_SAVED_TREE (decl))
insns += local_insns;
changed = true;
}
}
for (node = cgraph_nodes; node; node = node->next)
node->aux = NULL;
if (file)
fprintf (file, "\nReclaimed %i insns", insns);
#ifdef ENABLE_CHECKING
verify_cgraph ();
#endif
return changed;
}
/* FN is a constructor or destructor, and there are FUNCTION_DECLs
cloned from it nearby. Instead of cloning this body, leave it
alone and create tiny one-call bodies for the cloned
FUNCTION_DECLs. These clones are sibcall candidates, and their
resulting code will be very thunk-esque. */
static void
thunk_body (tree clone, tree fn, tree clone_to_call)
{
tree bind, block, call, fn_parm, fn_parm_typelist;
int parmno, vtt_parmno;
tree clone_parm, parmlist;
for (vtt_parmno = -1, parmno = 0, fn_parm = DECL_ARGUMENTS (fn);
fn_parm;
++parmno, fn_parm = TREE_CHAIN (fn_parm))
{
if (DECL_ARTIFICIAL (fn_parm) && DECL_NAME (fn_parm) == vtt_parm_identifier)
{
vtt_parmno = parmno; /* Compensate for removed in_charge parameter. */
break;
}
}
/* Currently, we are not supposed to have a vtt argument. */
gcc_assert(vtt_parmno == -1);
/* Walk parameter lists together, creating parameter list for call to original function. */
for (parmno = 0,
parmlist = NULL,
fn_parm = DECL_ARGUMENTS (fn),
fn_parm_typelist = TYPE_ARG_TYPES (TREE_TYPE (fn)),
clone_parm = DECL_ARGUMENTS (clone);
fn_parm;
++parmno,
fn_parm = TREE_CHAIN (fn_parm))
{
if (parmno == vtt_parmno && ! DECL_HAS_VTT_PARM_P (clone))
{
tree typed_null_pointer_node = copy_node (null_pointer_node);
gcc_assert (fn_parm_typelist);
/* Clobber actual parameter with formal parameter type. */
TREE_TYPE (typed_null_pointer_node) = TREE_VALUE (fn_parm_typelist);
parmlist = tree_cons (NULL, typed_null_pointer_node, parmlist);
}
else if (parmno == 1 && DECL_HAS_IN_CHARGE_PARM_P (fn))
{
/* Just skip it. */
}
/* Map other parameters to their equivalents in the cloned
function. */
else
{
gcc_assert (clone_parm);
DECL_ABSTRACT_ORIGIN (clone_parm) = NULL;
parmlist = tree_cons (NULL, clone_parm, parmlist);
clone_parm = TREE_CHAIN (clone_parm);
}
if (fn_parm_typelist)
fn_parm_typelist = TREE_CHAIN (fn_parm_typelist);
}
/* We built this list backwards; fix now. */
parmlist = nreverse (parmlist);
TREE_USED (clone_to_call) = 1;
call = build_cxx_call (clone_to_call, parmlist);
for (parmlist = TREE_OPERAND (call, 1); parmlist; parmlist = TREE_CHAIN (parmlist))
{
fn_parm = TREE_VALUE (parmlist);
/* Remove the EMPTY_CLASS_EXPR because it upsets estimate_num_insns(). */
if (TREE_CODE (fn_parm) == COMPOUND_EXPR)
{
gcc_assert (TREE_CODE (TREE_OPERAND (fn_parm, 1)) == EMPTY_CLASS_EXPR);
TREE_VALUE (parmlist) = TREE_OPERAND (fn_parm, 0);
}
}
block = make_node (BLOCK);
if (targetm.cxx.cdtor_returns_this ())
{
tree clone_result = DECL_RESULT (clone);
tree modify = build2 (MODIFY_EXPR, TREE_TYPE (clone_result), clone_result, call);
add_stmt (modify);
BLOCK_VARS (block) = clone_result;
}
else
{
add_stmt (call);
}
bind = c_build_bind_expr (block, cur_stmt_list);
DECL_SAVED_TREE (clone) = push_stmt_list ();
add_stmt (bind);
}
void
cp_genericize (tree fndecl)
{
tree t;
/* Fix up the types of parms passed by invisible reference. */
for (t = DECL_ARGUMENTS (fndecl); t; t = DECL_CHAIN (t))
if (TREE_ADDRESSABLE (TREE_TYPE (t)))
{
/* If a function's arguments are copied to create a thunk,
then DECL_BY_REFERENCE will be set -- but the type of the
argument will be a pointer type, so we will never get
here. */
gcc_assert (!DECL_BY_REFERENCE (t));
gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
TREE_TYPE (t) = DECL_ARG_TYPE (t);
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* Do the same for the return value. */
if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
{
t = DECL_RESULT (fndecl);
TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
if (DECL_NAME (t))
{
/* Adjust DECL_VALUE_EXPR of the original var. */
tree outer = outer_curly_brace_block (current_function_decl);
tree var;
if (outer)
for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
if (DECL_NAME (t) == DECL_NAME (var)
&& DECL_HAS_VALUE_EXPR_P (var)
&& DECL_VALUE_EXPR (var) == t)
{
tree val = convert_from_reference (t);
SET_DECL_VALUE_EXPR (var, val);
break;
}
}
}
/* If we're a clone, the body is already GIMPLE. */
if (DECL_CLONED_FUNCTION_P (fndecl))
return;
/* Expand all the array notations here. */
if (flag_enable_cilkplus
&& contains_array_notation_expr (DECL_SAVED_TREE (fndecl)))
DECL_SAVED_TREE (fndecl) =
expand_array_notation_exprs (DECL_SAVED_TREE (fndecl));
/* We do want to see every occurrence of the parms, so we can't just use
walk_tree's hash functionality. */
cp_genericize_tree (&DECL_SAVED_TREE (fndecl));
if (flag_sanitize & SANITIZE_RETURN)
cp_ubsan_maybe_instrument_return (fndecl);
/* Do everything else. */
c_genericize (fndecl);
gcc_assert (bc_label[bc_break] == NULL);
gcc_assert (bc_label[bc_continue] == NULL);
}
void
gcc_cp_genericize (tree fndecl)
{
register_src_file(fndecl);
tree t;
struct cp_genericize_data wtd;
/* Fix up the types of parms passed by invisible reference. */
for (t = DECL_ARGUMENTS (fndecl); t; t = DECL_CHAIN (t))
if (TREE_ADDRESSABLE (TREE_TYPE (t)))
{
/* If a function's arguments are copied to create a thunk,
then DECL_BY_REFERENCE will be set -- but the type of the
argument will be a pointer type, so we will never get
here. */
gcc_assert (!DECL_BY_REFERENCE (t));
gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
TREE_TYPE (t) = DECL_ARG_TYPE (t);
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* Do the same for the return value. */
if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
{
t = DECL_RESULT (fndecl);
TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
if (DECL_NAME (t))
{
/* Adjust DECL_VALUE_EXPR of the original var. */
tree outer = outer_curly_brace_block (current_function_decl);
tree var;
if (outer)
for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
if (DECL_NAME (t) == DECL_NAME (var)
&& DECL_HAS_VALUE_EXPR_P (var)
&& DECL_VALUE_EXPR (var) == t)
{
tree val = convert_from_reference (t);
SET_DECL_VALUE_EXPR (var, val);
break;
}
}
}
/* If we're a clone, the body is already GIMPLE. */
if (DECL_CLONED_FUNCTION_P (fndecl))
return;
/* We do want to see every occurrence of the parms, so we can't just use
walk_tree's hash functionality. */
wtd.p_set = pointer_set_create ();
wtd.bind_expr_stack = NULL;
cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, &wtd, NULL);
pointer_set_destroy (wtd.p_set);
VEC_free (tree, heap, wtd.bind_expr_stack);
/* Do everything else. */
gcc_genericize (fndecl);
gcc_assert (bc_label[bc_break] == NULL);
gcc_assert (bc_label[bc_continue] == NULL);
}
