On Fri, Jun 6, 2014 at 10:30 AM, Jan Hubicka <hubi...@ucw.cz> wrote: > Hi, > an attached patch is an experiment on how much work it would take to move > DECL_RESULT and DECL_ARGUMENTS, DECL_SAVED_TREE into struct function. The > motivation is that middle-end threads them this way already - they are > technically part local declarations and part of the body. Moving those pointer > to struct function should save some memory and make things a bit cleaner. > > The patch does only DECL_RESULT and bootstraps but won't pass fortran > testsuite > and I did not even look into Ada, yet. > > Main problem is that frontends tends to build the return values (and > arguments) > separately from body, since that is how code was structured. I wonder if > there > are any reason why this change won't work or if it seems undesirable for some > reason? > > Other problem is (ab)use of these fileds by frontends for various reasons. > C++ use result for namespace, obj-C for interfaces. I think we could/should > replace those by FE specific data, but I am not quite certain how to do that.
We have decl_lang_specific for FE specific data. > So any comments? Well, I think it's a good idea to move stuff out of the decls if it isn't required for just declarations but definitions only. Richard. > Honza > > Index: c-family/c-ada-spec.c > =================================================================== > --- c-family/c-ada-spec.c (revision 211106) > +++ c-family/c-ada-spec.c (working copy) > @@ -1720,16 +1720,8 @@ dump_ada_template (pretty_printer *buffe > { > /* DECL_VINDEX is DECL_TEMPLATE_INSTANTIATIONS in this context. */ > tree inst = DECL_VINDEX (t); > - /* DECL_RESULT_FLD is DECL_TEMPLATE_RESULT in this context. */ > - tree result = DECL_RESULT_FLD (t); > int num_inst = 0; > > - /* Don't look at template declarations declaring something coming from > - another file. This can occur for template friend declarations. */ > - if (LOCATION_FILE (decl_sloc (result, false)) > - != LOCATION_FILE (decl_sloc (t, false))) > - return 0; > - > while (inst && inst != error_mark_node) > { > tree types = TREE_PURPOSE (inst); > Index: c-family/cilk.c > =================================================================== > --- c-family/cilk.c (revision 211106) > +++ c-family/cilk.c (working copy) > @@ -322,12 +322,6 @@ create_cilk_helper_decl (struct wrapper_ > 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; > } > @@ -544,7 +538,14 @@ create_cilk_wrapper_body (tree stmt, str > (modified) to the wrapped function. Return the wrapper and modified > ARGS > to the caller to generate a function call. */ > fndecl = create_cilk_helper_decl (wd); > - push_struct_function (fndecl); > + > + 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; > + > + push_struct_function (fndecl, result_decl); > if (wd->nested && (wd->type == CILK_BLOCK_FOR)) > { > gcc_assert (TREE_VALUE (wd->arglist) == NULL_TREE); > Index: java/decl.c > =================================================================== > --- java/decl.c (revision 211106) > +++ java/decl.c (working copy) > @@ -1743,16 +1743,14 @@ tree > build_result_decl (tree fndecl) > { > tree restype = TREE_TYPE (TREE_TYPE (fndecl)); > - tree result = DECL_RESULT (fndecl); > - if (! result) > - { > - result = build_decl (DECL_SOURCE_LOCATION (fndecl), > - RESULT_DECL, NULL_TREE, restype); > - DECL_ARTIFICIAL (result) = 1; > - DECL_IGNORED_P (result) = 1; > - DECL_CONTEXT (result) = fndecl; > - DECL_RESULT (fndecl) = result; > - } > + tree result; > + > + result = build_decl (DECL_SOURCE_LOCATION (fndecl), > + RESULT_DECL, NULL_TREE, restype); > + DECL_ARTIFICIAL (result) = 1; > + DECL_IGNORED_P (result) = 1; > + DECL_CONTEXT (result) = fndecl; > + > return result; > } > > @@ -1886,7 +1884,7 @@ finish_method (tree fndecl) > if (DECL_STRUCT_FUNCTION (fndecl)) > set_cfun (DECL_STRUCT_FUNCTION (fndecl)); > else > - allocate_struct_function (fndecl, false); > + allocate_struct_function (fndecl, false, build_result_decl (fndecl)); > cfun->function_end_locus = DECL_FUNCTION_LAST_LINE (fndecl); > > /* Defer inlining and expansion to the cgraph optimizers. */ > Index: java/jcf-parse.c > =================================================================== > --- java/jcf-parse.c (revision 211106) > +++ java/jcf-parse.c (working copy) > @@ -1711,9 +1711,8 @@ java_emit_static_constructor (void) > tree resdecl = build_decl (input_location, > RESULT_DECL, NULL_TREE, void_type_node); > DECL_ARTIFICIAL (resdecl) = 1; > - DECL_RESULT (decl) = resdecl; > current_function_decl = decl; > - allocate_struct_function (decl, false); > + allocate_struct_function (decl, false, resdecl); > > TREE_STATIC (decl) = 1; > TREE_USED (decl) = 1; > Index: java/expr.c > =================================================================== > --- java/expr.c (revision 211106) > +++ java/expr.c (working copy) > @@ -47,6 +47,7 @@ The Free Software Foundation is independ > #include "tree-iterator.h" > #include "target.h" > #include "wide-int.h" > +#include "function.h" > > static void flush_quick_stack (void); > static void push_value (tree); > @@ -2630,6 +2631,8 @@ build_jni_stub (tree method) > tree klass = DECL_CONTEXT (method); > klass = build_class_ref (klass); > > + allocate_struct_function (method, false, build_result_decl (method)); > + > gcc_assert (METHOD_NATIVE (method) && flag_jni); > > DECL_ARTIFICIAL (method) = 1; > @@ -3138,6 +3141,7 @@ expand_byte_code (JCF *jcf, tree method) > stack_pointer = 0; > JCF_SEEK (jcf, DECL_CODE_OFFSET (method)); > byte_ops = jcf->read_ptr; > + allocate_struct_function (method, false, build_result_decl (method)); > > /* We make an initial pass of the line number table, to note > which instructions have associated line number entries. */ > Index: c/c-parser.c > =================================================================== > --- c/c-parser.c (revision 211106) > +++ c/c-parser.c (working copy) > @@ -13245,7 +13245,7 @@ c_parser_omp_declare_reduction (c_parser > tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, > reduc_id, default_function_type); > current_function_decl = fndecl; > - allocate_struct_function (fndecl, true); > + allocate_struct_function (fndecl, true, NULL); > push_scope (); > tree stmt = push_stmt_list (); > /* Intentionally BUILTINS_LOCATION, so that -Wshadow doesn't > Index: c/c-decl.c > =================================================================== > --- c/c-decl.c (revision 211106) > +++ c/c-decl.c (working copy) > @@ -1231,7 +1231,6 @@ pop_scope (void) > DECL_CONTEXT (extp) = current_function_decl; > if (TREE_CODE (p) == FUNCTION_DECL) > { > - DECL_RESULT (extp) = NULL_TREE; > DECL_SAVED_TREE (extp) = NULL_TREE; > DECL_STRUCT_FUNCTION (extp) = NULL; > } > @@ -2463,7 +2462,6 @@ merge_decls (tree newdecl, tree olddecl, > if (!new_is_definition) > { > tree t; > - DECL_RESULT (newdecl) = DECL_RESULT (olddecl); > DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); > DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl); > DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl); > @@ -7871,7 +7869,6 @@ start_function (struct c_declspecs *decl > tree attributes) > { > tree decl1, old_decl; > - tree restype, resdecl; > location_t loc; > > current_function_returns_value = 0; /* Assume, until we see it does. */ > @@ -8075,12 +8072,6 @@ start_function (struct c_declspecs *decl > push_scope (); > declare_parm_level (); > > - restype = TREE_TYPE (TREE_TYPE (current_function_decl)); > - resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype); > - DECL_ARTIFICIAL (resdecl) = 1; > - DECL_IGNORED_P (resdecl) = 1; > - DECL_RESULT (current_function_decl) = resdecl; > - > start_fname_decls (); > > return 1; > @@ -8459,6 +8450,7 @@ store_parm_decls (void) > { > tree fndecl = current_function_decl; > bool proto; > + tree restype, resdecl; > > /* The argument information block for FNDECL. */ > struct c_arg_info *arg_info = current_function_arg_info; > @@ -8486,7 +8478,12 @@ store_parm_decls (void) > gen_aux_info_record (fndecl, 1, 0, proto); > > /* Initialize the RTL code for the function. */ > - allocate_struct_function (fndecl, false); > + restype = TREE_TYPE (TREE_TYPE (current_function_decl)); > + resdecl = build_decl (DECL_SOURCE_LOCATION (fndecl), RESULT_DECL, > NULL_TREE, restype); > + DECL_ARTIFICIAL (resdecl) = 1; > + DECL_IGNORED_P (resdecl) = 1; > + allocate_struct_function (fndecl, false, resdecl); > + > > if (warn_unused_local_typedefs) > cfun->language = ggc_cleared_alloc<language_function> (); > Index: cgraph.c > =================================================================== > --- cgraph.c (revision 211106) > +++ cgraph.c (working copy) > @@ -1722,10 +1722,7 @@ cgraph_release_function_body (struct cgr > { > node->ipa_transforms_to_apply.release (); > if (!node->used_as_abstract_origin && cgraph_state != CGRAPH_STATE_PARSING) > - { > - DECL_RESULT (node->decl) = NULL; > - DECL_ARGUMENTS (node->decl) = NULL; > - } > + DECL_ARGUMENTS (node->decl) = NULL; > /* If the node is abstract and needed, then do not clear DECL_INITIAL > of its associated function function declaration because it's > needed to emit debug info later. */ > @@ -3048,7 +3045,8 @@ cgraph_get_body (struct cgraph_node *nod > size_t len; > tree decl = node->decl; > > - if (DECL_RESULT (decl)) > + /* Do nothing if body is here. */ > + if (DECL_STRUCT_FUNCTION (decl)) > return false; > > gcc_assert (in_lto_p); > @@ -3164,7 +3162,8 @@ gimple_check_call_matching_types (gimple > { > tree lhs; > > - if ((DECL_RESULT (callee) > + if ((DECL_STRUCT_FUNCTION (callee) > + && DECL_RESULT (callee) > && !DECL_BY_REFERENCE (DECL_RESULT (callee)) > && (lhs = gimple_call_lhs (call_stmt)) != NULL_TREE > && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee)), > Index: cgraph.h > =================================================================== > --- cgraph.h (revision 211106) > +++ cgraph.h (working copy) > @@ -909,7 +909,7 @@ void cgraph_process_same_body_aliases (v > void fixup_same_cpp_alias_visibility (symtab_node *, symtab_node *target, > tree); > /* Initialize datastructures so DECL is a function in lowered gimple form. > IN_SSA is true if the gimple is in SSA. */ > -basic_block init_lowered_empty_function (tree, bool); > +basic_block init_lowered_empty_function (tree, bool, tree); > void cgraph_reset_node (struct cgraph_node *); > bool expand_thunk (struct cgraph_node *, bool); > > Index: tree.c > =================================================================== > --- tree.c (revision 211106) > +++ tree.c (working copy) > @@ -5056,7 +5056,6 @@ free_lang_data_in_decl (tree decl) > { > release_function_body (decl); > DECL_ARGUMENTS (decl) = NULL; > - DECL_RESULT (decl) = NULL; > DECL_INITIAL (decl) = error_mark_node; > } > } > @@ -5246,10 +5245,7 @@ find_decls_types_r (tree *tp, int *ws, v > fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld); > > if (TREE_CODE (t) == FUNCTION_DECL) > - { > - fld_worklist_push (DECL_ARGUMENTS (t), fld); > - fld_worklist_push (DECL_RESULT (t), fld); > - } > + fld_worklist_push (DECL_ARGUMENTS (t), fld); > else if (TREE_CODE (t) == TYPE_DECL) > { > fld_worklist_push (DECL_ARGUMENT_FLD (t), fld); > Index: tree.h > =================================================================== > --- tree.h (revision 211106) > +++ tree.h (working copy) > @@ -2460,11 +2460,6 @@ extern void decl_fini_priority_insert (t > #define DECL_NONALIASED(NODE) \ > (VAR_DECL_CHECK (NODE)->base.nothrow_flag) > > -/* This field is used to reference anything in decl.result and is meant only > - for use by the garbage collector. */ > -#define DECL_RESULT_FLD(NODE) \ > - (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result) > - > /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways. > Before the struct containing the FUNCTION_DECL is laid out, > DECL_VINDEX may point to a FUNCTION_DECL in a base class which > @@ -2477,7 +2472,7 @@ extern void decl_fini_priority_insert (t > (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex) > > /* In FUNCTION_DECL, holds the decl for the return value. */ > -#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK > (NODE)->decl_non_common.result) > +#define DECL_RESULT(NODE) (DECL_STRUCT_FUNCTION (NODE)->result) > > /* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */ > #define DECL_UNINLINABLE(NODE) \ > @@ -2667,7 +2662,7 @@ extern vec<tree, va_gc> **decl_debug_arg > > /* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */ > #define DECL_ORIGINAL_TYPE(NODE) \ > - (TYPE_DECL_CHECK (NODE)->decl_non_common.result) > + (TYPE_DECL_CHECK (NODE)->type_decl.original_type) > > /* In a TYPE_DECL nonzero means the detail info about this type is not dumped > into stabs. Instead it will generate cross reference ('x') of names. > Index: omp-low.c > =================================================================== > --- omp-low.c (revision 211106) > +++ omp-low.c (working copy) > @@ -1839,7 +1839,7 @@ create_omp_child_function_name (bool tas > static void > create_omp_child_function (omp_context *ctx, bool task_copy) > { > - tree decl, type, name, t; > + tree decl, type, name, t, resdecl; > > name = create_omp_child_function_name (task_copy); > if (task_copy) > @@ -1887,12 +1887,11 @@ create_omp_child_function (omp_context * > = tree_cons (get_identifier ("omp declare target"), > NULL_TREE, DECL_ATTRIBUTES (decl)); > > - t = build_decl (DECL_SOURCE_LOCATION (decl), > - RESULT_DECL, NULL_TREE, void_type_node); > - DECL_ARTIFICIAL (t) = 1; > - DECL_IGNORED_P (t) = 1; > - DECL_CONTEXT (t) = decl; > - DECL_RESULT (decl) = t; > + resdecl = build_decl (DECL_SOURCE_LOCATION (decl), > + RESULT_DECL, NULL_TREE, void_type_node); > + DECL_ARTIFICIAL (resdecl) = 1; > + DECL_IGNORED_P (resdecl) = 1; > + DECL_CONTEXT (resdecl) = decl; > > t = build_decl (DECL_SOURCE_LOCATION (decl), > PARM_DECL, get_identifier (".omp_data_i"), ptr_type_node); > @@ -1922,7 +1921,7 @@ create_omp_child_function (omp_context * > /* Allocate memory for the function structure. The call to > allocate_struct_function clobbers CFUN, so we need to restore > it afterward. */ > - push_struct_function (decl); > + push_struct_function (decl, resdecl); > cfun->function_end_locus = gimple_location (ctx->stmt); > pop_cfun (); > } > Index: objc/objc-act.c > =================================================================== > --- objc/objc-act.c (revision 211106) > +++ objc/objc-act.c (working copy) > @@ -8617,12 +8617,6 @@ objc_start_function (tree name, tree typ > current_function_decl = pushdecl (fndecl); > push_scope (); > declare_parm_level (); > - DECL_RESULT (current_function_decl) > - = build_decl (input_location, > - RESULT_DECL, NULL_TREE, > - TREE_TYPE (TREE_TYPE (current_function_decl))); > - DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1; > - DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1; > start_fname_decls (); > store_parm_decls_from (params); > #endif > Index: objc/objc-act.h > =================================================================== > --- objc/objc-act.h (revision 211106) > +++ objc/objc-act.h (working copy) > @@ -44,7 +44,7 @@ void objc_common_init_ts (void); > /* INSTANCE_METHOD_DECL, CLASS_METHOD_DECL */ > #define METHOD_SEL_NAME(DECL) ((DECL)->decl_minimal.name) > #define METHOD_SEL_ARGS(DECL) ((DECL)->decl_non_common.arguments) > -#define METHOD_ADD_ARGS(DECL) ((DECL)->decl_non_common.result) > +#define METHOD_ADD_ARGS(DECL) ((DECL)->decl_non_common.saved_tree) > #define METHOD_ADD_ARGS_ELLIPSIS_P(DECL) ((DECL)->decl_common.lang_flag_0) > #define METHOD_DEFINITION(DECL) ((DECL)->decl_common.initial) > #define METHOD_ENCODING(DECL) ((DECL)->decl_minimal.context) > @@ -71,7 +71,7 @@ void objc_common_init_ts (void); > #define PROPERTY_GETTER_NAME(DECL) ((DECL)->decl_non_common.arguments) > > /* PROPERTY_SETTER_NAME is the identifier of the setter method. */ > -#define PROPERTY_SETTER_NAME(DECL) ((DECL)->decl_non_common.result) > +#define PROPERTY_SETTER_NAME(DECL) ((DECL)->decl_non_common.saved_tree) > > /* PROPERTY_READONLY can be 0 or 1. */ > #define PROPERTY_READONLY(DECL) DECL_LANG_FLAG_0 (DECL) > Index: cgraphunit.c > =================================================================== > --- cgraphunit.c (revision 211106) > +++ cgraphunit.c (working copy) > @@ -1325,12 +1325,12 @@ mark_functions_to_output (void) > return basic block in the function body. */ > > basic_block > -init_lowered_empty_function (tree decl, bool in_ssa) > +init_lowered_empty_function (tree decl, bool in_ssa, tree result) > { > basic_block bb; > > current_function_decl = decl; > - allocate_struct_function (decl, false); > + allocate_struct_function (decl, false, result); > gimple_register_cfg_hooks (); > init_empty_tree_cfg (); > > @@ -1488,6 +1488,7 @@ expand_thunk (struct cgraph_node *node, > const char *fnname; > tree fn_block; > tree restype = TREE_TYPE (TREE_TYPE (thunk_fndecl)); > + tree resdecl; > > if (!output_asm_thunks) > return false; > @@ -1501,10 +1502,10 @@ expand_thunk (struct cgraph_node *node, > /* Ensure thunks are emitted in their correct sections. */ > resolve_unique_section (thunk_fndecl, 0, flag_function_sections); > > - DECL_RESULT (thunk_fndecl) > + resdecl > = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl), > RESULT_DECL, 0, restype); > - DECL_CONTEXT (DECL_RESULT (thunk_fndecl)) = thunk_fndecl; > + DECL_CONTEXT (resdecl) = thunk_fndecl; > fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl)); > > /* The back end expects DECL_INITIAL to contain a BLOCK, so we > @@ -1512,7 +1513,7 @@ expand_thunk (struct cgraph_node *node, > fn_block = make_node (BLOCK); > BLOCK_VARS (fn_block) = a; > DECL_INITIAL (thunk_fndecl) = fn_block; > - init_function_start (thunk_fndecl); > + init_function_start (thunk_fndecl, resdecl); > cfun->is_thunk = 1; > insn_locations_init (); > set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl)); > @@ -1562,18 +1563,13 @@ expand_thunk (struct cgraph_node *node, > > /* Build the return declaration for the function. */ > restype = TREE_TYPE (TREE_TYPE (thunk_fndecl)); > - if (DECL_RESULT (thunk_fndecl) == NULL_TREE) > - { > - resdecl = build_decl (input_location, RESULT_DECL, 0, restype); > - DECL_ARTIFICIAL (resdecl) = 1; > - DECL_IGNORED_P (resdecl) = 1; > - DECL_RESULT (thunk_fndecl) = resdecl; > - DECL_CONTEXT (DECL_RESULT (thunk_fndecl)) = thunk_fndecl; > - } > - else > - resdecl = DECL_RESULT (thunk_fndecl); > + resdecl = build_decl (input_location, RESULT_DECL, 0, restype); > + DECL_ARTIFICIAL (resdecl) = 1; > + DECL_IGNORED_P (resdecl) = 1; > + DECL_RESULT (thunk_fndecl) = resdecl; > + DECL_CONTEXT (DECL_RESULT (thunk_fndecl)) = thunk_fndecl; > > - bb = then_bb = else_bb = return_bb = init_lowered_empty_function > (thunk_fndecl, true); > + bb = then_bb = else_bb = return_bb = init_lowered_empty_function > (thunk_fndecl, true, resdecl); > > bsi = gsi_start_bb (bb); > > @@ -1769,7 +1765,7 @@ expand_function (struct cgraph_node *nod > current_function_decl = decl; > saved_loc = input_location; > input_location = DECL_SOURCE_LOCATION (decl); > - init_function_start (decl); > + init_function_start (decl, NULL); > > gimple_register_cfg_hooks (); > > Index: cp/cp-tree.h > =================================================================== > --- cp/cp-tree.h (revision 211106) > +++ cp/cp-tree.h (working copy) > @@ -3754,7 +3754,8 @@ more_aggr_init_expr_args_p (const aggr_i > TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE)) > /* For function, method, class-data templates. */ > #define DECL_TEMPLATE_RESULT(NODE) \ > - DECL_RESULT_FLD (TEMPLATE_DECL_CHECK (NODE)) > + TEMPLATE_DECL_CHECK (NODE)->decl_non_common.saved_tree > + > /* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS > lists all instantiations and specializations of the function so that > tsubst_friend_function can reassign them to another template if we find > Index: cp/method.c > =================================================================== > --- cp/method.c (revision 211106) > +++ cp/method.c (working copy) > @@ -294,7 +294,8 @@ use_thunk (tree thunk_fndecl, bool emit_ > return; > > function = THUNK_TARGET (thunk_fndecl); > - if (DECL_RESULT (thunk_fndecl)) > + if ((thunk_node = cgraph_get_node (thunk_fndecl)) != NULL > + && thunk_node->thunk.thunk_p) > /* We already turned this thunk into an ordinary function. > There's no need to process this thunk again. */ > return; > Index: cp/pt.c > =================================================================== > --- cp/pt.c (revision 211106) > +++ cp/pt.c (working copy) > @@ -10631,7 +10631,6 @@ tsubst_decl (tree t, tree args, tsubst_f > > DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, > complain, t); > - DECL_RESULT (r) = NULL_TREE; > > TREE_STATIC (r) = 0; > TREE_PUBLIC (r) = TREE_PUBLIC (t); > Index: cp/decl.c > =================================================================== > --- cp/decl.c (revision 211106) > +++ cp/decl.c (working copy) > @@ -2258,7 +2258,6 @@ duplicate_decls (tree newdecl, tree oldd > Note that if the types do match, we'll preserve inline > info and other bits, but if not, we won't. */ > DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl); > - DECL_RESULT (olddecl) = DECL_RESULT (newdecl); > } > /* If redeclaring a builtin function, it stays built in > if newdecl is a gnu_inline definition, or if newdecl is just > @@ -2294,7 +2293,6 @@ duplicate_decls (tree newdecl, tree oldd > SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); > else if (types_match) > { > - DECL_RESULT (newdecl) = DECL_RESULT (olddecl); > /* Don't clear out the arguments if we're just redeclaring a > function. */ > if (DECL_ARGUMENTS (olddecl)) > @@ -13250,17 +13248,10 @@ start_preparsed_function (tree decl1, tr > /* Build the return declaration for the function. */ > restype = TREE_TYPE (fntype); > > - if (DECL_RESULT (decl1) == NULL_TREE) > - { > - tree resdecl; > - > - resdecl = build_decl (input_location, RESULT_DECL, 0, restype); > - DECL_ARTIFICIAL (resdecl) = 1; > - DECL_IGNORED_P (resdecl) = 1; > - DECL_RESULT (decl1) = resdecl; > - > - cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl); > - } > + tree resdecl = build_decl (input_location, RESULT_DECL, 0, restype); > + DECL_ARTIFICIAL (resdecl) = 1; > + DECL_IGNORED_P (resdecl) = 1; > + cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl); > > /* Let the user know we're compiling this function. */ > announce_function (decl1); > @@ -13346,12 +13337,12 @@ start_preparsed_function (tree decl1, tr > return true; > > /* Initialize RTL machinery. We cannot do this until > - CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this > + CURRENT_FUNCTION_DECL and RESDECL are set up. We do this > even when processing a template; this is how we get > CFUN set up, and our per-function variables initialized. > FIXME factor out the non-RTL stuff. */ > bl = current_binding_level; > - allocate_struct_function (decl1, processing_template_decl); > + allocate_struct_function (decl1, processing_template_decl, resdecl); > > /* Initialize the language data structures. Whenever we start > a new function, we destroy temporaries in the usual way. */ > Index: cgraphclones.c > =================================================================== > --- cgraphclones.c (revision 211106) > +++ cgraphclones.c (working copy) > @@ -335,7 +335,6 @@ duplicate_thunk_for_node (cgraph_node *t > } > gcc_checking_assert (!DECL_STRUCT_FUNCTION (new_decl)); > gcc_checking_assert (!DECL_INITIAL (new_decl)); > - gcc_checking_assert (!DECL_RESULT (new_decl)); > gcc_checking_assert (!DECL_RTL_SET_P (new_decl)); > > DECL_NAME (new_decl) = clone_function_name (thunk->decl, > "artificial_thunk"); > @@ -535,9 +534,6 @@ cgraph_create_virtual_clone (struct cgra > DECL_STRUCT_FUNCTION (new_decl) = NULL; > DECL_ARGUMENTS (new_decl) = NULL; > DECL_INITIAL (new_decl) = NULL; > - DECL_RESULT (new_decl) = NULL; > - /* We can not do DECL_RESULT (new_decl) = NULL; here because of LTO > partitioning > - sometimes storing only clone decl instead of original. */ > > /* Generate a new name for the new version. */ > len = IDENTIFIER_LENGTH (DECL_NAME (old_decl)); > Index: dwarf2out.c > =================================================================== > --- dwarf2out.c (revision 211106) > +++ dwarf2out.c (working copy) > @@ -18594,7 +18594,7 @@ gen_subprogram_die (tree decl, dw_die_re > int tail_call_site_note_count = 0; > > /* Emit a DW_TAG_variable DIE for a named return value. */ > - if (DECL_NAME (DECL_RESULT (decl))) > + if (DECL_STRUCT_FUNCTION (decl) && DECL_NAME (DECL_RESULT (decl))) > gen_decl_die (DECL_RESULT (decl), NULL, subr_die); > > current_function_has_inlines = 0; > Index: tree-browser.c > =================================================================== > --- tree-browser.c (revision 211106) > +++ tree-browser.c (working copy) > @@ -359,9 +359,9 @@ browse_tree (tree begin) > TB_WF; > break; > > - case TB_RESULT: > - if (head && DECL_P (head)) > - TB_SET_HEAD (DECL_RESULT_FLD (head)); > + case TB_ORIGINAL_TYPE: > + if (head && TREE_CODE (head) == TYPE_DECL) > + TB_SET_HEAD (DECL_ORIGINAL_TYPE (head)); > else > TB_WF; > break; > Index: tree-parloops.c > =================================================================== > --- tree-parloops.c (revision 211106) > +++ tree-parloops.c (working copy) > @@ -1445,6 +1445,7 @@ create_loop_fn (location_t loc) > tree decl, type, name, t; > struct function *act_cfun = cfun; > static unsigned loopfn_num; > + tree resdecl; > > loc = LOCATION_LOCUS (loc); > snprintf (buf, 100, "%s.$loopfn", current_function_name ()); > @@ -1468,10 +1469,9 @@ create_loop_fn (location_t loc) > DECL_CONTEXT (decl) = NULL_TREE; > DECL_INITIAL (decl) = make_node (BLOCK); > > - t = build_decl (loc, RESULT_DECL, NULL_TREE, void_type_node); > - DECL_ARTIFICIAL (t) = 1; > - DECL_IGNORED_P (t) = 1; > - DECL_RESULT (decl) = t; > + resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, void_type_node); > + DECL_ARTIFICIAL (resdecl) = 1; > + DECL_IGNORED_P (resdecl) = 1; > > t = build_decl (loc, PARM_DECL, get_identifier (".paral_data_param"), > ptr_type_node); > @@ -1481,7 +1481,7 @@ create_loop_fn (location_t loc) > TREE_USED (t) = 1; > DECL_ARGUMENTS (decl) = t; > > - allocate_struct_function (decl, false); > + allocate_struct_function (decl, false, resdecl); > > /* The call to allocate_struct_function clobbers CFUN, so we need to > restore > it. */ > Index: lto-streamer-in.c > =================================================================== > --- lto-streamer-in.c (revision 211106) > +++ lto-streamer-in.c (working copy) > @@ -916,12 +916,13 @@ input_function (tree fn_decl, struct dat > gimple *stmts; > basic_block bb; > struct cgraph_node *node; > + tree resdecl; > > tag = streamer_read_record_start (ib); > lto_tag_check (tag, LTO_function); > > /* Read decls for parameters and args. */ > - DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in); > + resdecl = stream_read_tree (ib, data_in); > DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in); > > /* Read the tree of lexical scopes for the function. */ > @@ -930,7 +931,7 @@ input_function (tree fn_decl, struct dat > if (!streamer_read_uhwi (ib)) > return; > > - push_struct_function (fn_decl); > + push_struct_function (fn_decl, resdecl); > fn = DECL_STRUCT_FUNCTION (fn_decl); > init_tree_ssa (fn); > /* We input IL in SSA form. */ > Index: fortran/trans-decl.c > =================================================================== > --- fortran/trans-decl.c (revision 211106) > +++ fortran/trans-decl.c (working copy) > @@ -1676,11 +1676,9 @@ gfc_get_extern_function_decl (gfc_symbol > locus old_loc; > > gfc_save_backend_locus (&old_loc); > - push_cfun (NULL); > > gfc_create_function_decl (gsym->ns, true); > > - pop_cfun (); > gfc_restore_backend_locus (&old_loc); > } > > @@ -1955,7 +1953,6 @@ build_function_decl (gfc_symbol * sym, b > DECL_ARTIFICIAL (result_decl) = 1; > DECL_IGNORED_P (result_decl) = 1; > DECL_CONTEXT (result_decl) = fndecl; > - DECL_RESULT (fndecl) = result_decl; > > /* Don't call layout_decl for a RESULT_DECL. > layout_decl (result_decl, 0); */ > @@ -1990,6 +1987,7 @@ build_function_decl (gfc_symbol * sym, b > gfc_set_decl_assembler_name (fndecl, gfc_sym_mangled_function_id (sym)); > > sym->backend_decl = fndecl; > + allocate_struct_function (fndecl, false, result_decl); > } > > > @@ -2350,8 +2348,6 @@ trans_function_start (gfc_symbol * sym) > /* Create RTL for function definition. */ > make_decl_rtl (fndecl); > > - allocate_struct_function (fndecl, false); > - > /* function.c requires a push at the start of the function. */ > pushlevel (); > } > @@ -4661,7 +4657,6 @@ generate_coarray_init (gfc_namespace * n > DECL_ARTIFICIAL (decl) = 1; > DECL_IGNORED_P (decl) = 1; > DECL_CONTEXT (decl) = fndecl; > - DECL_RESULT (fndecl) = decl; > > pushdecl (fndecl); > current_function_decl = fndecl; > @@ -4669,7 +4664,7 @@ generate_coarray_init (gfc_namespace * n > > rest_of_decl_compilation (fndecl, 0, 0); > make_decl_rtl (fndecl); > - allocate_struct_function (fndecl, false); > + allocate_struct_function (fndecl, false, decl); > > pushlevel (); > gfc_init_block (&caf_init_block); > @@ -5185,7 +5180,6 @@ create_main_function (tree fndecl) > DECL_ARTIFICIAL (result_decl) = 1; > DECL_IGNORED_P (result_decl) = 1; > DECL_CONTEXT (result_decl) = ftn_main; > - DECL_RESULT (ftn_main) = result_decl; > > pushdecl (ftn_main); > > @@ -5218,7 +5212,7 @@ create_main_function (tree fndecl) > > rest_of_decl_compilation (ftn_main, 1, 0); > make_decl_rtl (ftn_main); > - allocate_struct_function (ftn_main, false); > + allocate_struct_function (ftn_main, false, result_decl); > pushlevel (); > > gfc_init_block (&body); > Index: function.c > =================================================================== > --- function.c (revision 211106) > +++ function.c (working copy) > @@ -140,7 +140,7 @@ void > push_function_context (void) > { > if (cfun == 0) > - allocate_struct_function (NULL, false); > + allocate_struct_function (NULL, false, NULL); > > function_context_stack.safe_push (cfun); > set_cfun (NULL); > @@ -4495,13 +4495,14 @@ get_last_funcdef_no (void) > placed in object files. */ > > void > -allocate_struct_function (tree fndecl, bool abstract_p) > +allocate_struct_function (tree fndecl, bool abstract_p, tree result) > { > tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE; > > cfun = ggc_cleared_alloc<function> (); > > init_eh_for_function (); > + cfun->result= result; > > if (init_machine_status) > cfun->machine = (*init_machine_status) (); > @@ -4521,8 +4522,7 @@ allocate_struct_function (tree fndecl, b > > if (fndecl != NULL_TREE) > { > - tree result = DECL_RESULT (fndecl); > - if (!abstract_p && aggregate_value_p (result, fndecl)) > + if (!abstract_p && aggregate_value_p (cfun->result, fndecl)) > { > #ifdef PCC_STATIC_STRUCT_RETURN > cfun->returns_pcc_struct = 1; > @@ -4546,7 +4546,7 @@ allocate_struct_function (tree fndecl, b > instead of just setting it. */ > > void > -push_struct_function (tree fndecl) > +push_struct_function (tree fndecl, tree result) > { > /* When in_dummy_function we might be in the middle of a pop_cfun and > current_function_decl and cfun may not match. */ > @@ -4555,7 +4555,7 @@ push_struct_function (tree fndecl) > || (cfun && current_function_decl == cfun->decl)); > cfun_stack.safe_push (cfun); > current_function_decl = fndecl; > - allocate_struct_function (fndecl, false); > + allocate_struct_function (fndecl, false, result); > } > > /* Reset crtl and other non-struct-function variables to defaults as > @@ -4605,7 +4605,7 @@ init_dummy_function_start (void) > { > gcc_assert (!in_dummy_function); > in_dummy_function = true; > - push_struct_function (NULL_TREE); > + push_struct_function (NULL_TREE, NULL_TREE); > prepare_function_start (); > } > > @@ -4614,12 +4614,12 @@ init_dummy_function_start (void) > of the function. */ > > void > -init_function_start (tree subr) > +init_function_start (tree subr, tree result) > { > if (subr && DECL_STRUCT_FUNCTION (subr)) > set_cfun (DECL_STRUCT_FUNCTION (subr)); > else > - allocate_struct_function (subr, false); > + allocate_struct_function (subr, false, result); > prepare_function_start (); > decide_function_section (subr); > > Index: function.h > =================================================================== > --- function.h (revision 211106) > +++ function.h (working copy) > @@ -540,6 +540,9 @@ struct GTY(()) function { > /* Points to the FUNCTION_DECL of this function. */ > tree decl; > > + /* Return value of function. */ > + tree result; > + > /* A PARM_DECL that should contain the static chain for this function. > It will be initialized at the beginning of the function. */ > tree static_chain_decl; > @@ -827,9 +830,9 @@ extern void expand_function_start (tree) > extern void stack_protect_epilogue (void); > extern void init_dummy_function_start (void); > extern void expand_dummy_function_end (void); > -extern void allocate_struct_function (tree, bool); > -extern void push_struct_function (tree fndecl); > -extern void init_function_start (tree); > +extern void allocate_struct_function (tree, bool, tree); > +extern void push_struct_function (tree, tree); > +extern void init_function_start (tree, tree); > extern bool use_register_for_decl (const_tree); > extern void generate_setjmp_warnings (void); > extern void init_temp_slots (void); > Index: stor-layout.c > =================================================================== > --- stor-layout.c (revision 211106) > +++ stor-layout.c (working copy) > @@ -170,6 +170,7 @@ self_referential_size (tree size) > unsigned int i; > char buf[128]; > vec<tree, va_gc> *args = NULL; > + tree resdecl; > > /* Do not factor out simple operations. */ > t = skip_simple_constant_arithmetic (size); > @@ -247,9 +248,8 @@ self_referential_size (tree size) > for (t = param_decl_list; t; t = DECL_CHAIN (t)) > DECL_CONTEXT (t) = fndecl; > DECL_ARGUMENTS (fndecl) = param_decl_list; > - DECL_RESULT (fndecl) > - = build_decl (input_location, RESULT_DECL, 0, return_type); > - DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; > + resdecl = build_decl (input_location, RESULT_DECL, 0, return_type); > + DECL_CONTEXT (resdecl) = fndecl; > > /* The function has been created by the compiler and we don't > want to emit debug info for it. */ > @@ -270,6 +270,7 @@ self_referential_size (tree size) > t = build2 (MODIFY_EXPR, return_type, DECL_RESULT (fndecl), size); > DECL_SAVED_TREE (fndecl) = build1 (RETURN_EXPR, void_type_node, t); > TREE_STATIC (fndecl) = 1; > + allocate_struct_function (fndecl, false, resdecl); > > /* Put it onto the list of size functions. */ > vec_safe_push (size_functions, fndecl); > @@ -293,7 +294,6 @@ finalize_size_functions (void) > > for (i = 0; size_functions && size_functions->iterate (i, &fndecl); i++) > { > - allocate_struct_function (fndecl, false); > set_cfun (NULL); > dump_function (TDI_original, fndecl); > gimplify_function_tree (fndecl); > Index: ipa.c > =================================================================== > --- ipa.c (revision 211106) > +++ ipa.c (working copy) > @@ -806,10 +806,9 @@ cgraph_build_static_cdtor_1 (char which, > resdecl = build_decl (input_location, > RESULT_DECL, NULL_TREE, void_type_node); > DECL_ARTIFICIAL (resdecl) = 1; > - DECL_RESULT (decl) = resdecl; > DECL_CONTEXT (resdecl) = decl; > > - allocate_struct_function (decl, false); > + allocate_struct_function (decl, false, resdecl); > > TREE_STATIC (decl) = 1; > TREE_USED (decl) = 1; > Index: gimplify.c > =================================================================== > --- gimplify.c (revision 211106) > +++ gimplify.c (working copy) > @@ -8784,7 +8784,7 @@ gimplify_function_tree (tree fndecl) > if (DECL_STRUCT_FUNCTION (fndecl)) > push_cfun (DECL_STRUCT_FUNCTION (fndecl)); > else > - push_struct_function (fndecl); > + push_struct_function (fndecl, NULL); > > for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm)) > { > Index: lto/lto.c > =================================================================== > --- lto/lto.c (revision 211106) > +++ lto/lto.c (working copy) > @@ -779,7 +779,6 @@ mentions_vars_p_decl_non_common (tree t) > if (mentions_vars_p_decl_with_vis (t)) > return true; > CHECK_NO_VAR (DECL_ARGUMENT_FLD (t)); > - CHECK_NO_VAR (DECL_RESULT_FLD (t)); > CHECK_NO_VAR (DECL_VINDEX (t)); > return false; > } > @@ -937,6 +936,7 @@ mentions_vars_p (tree t) > return mentions_vars_p_decl_with_vis (t); > > case TYPE_DECL: > + CHECK_NO_VAR (DECL_ORIGINAL_TYPE (t)); > return mentions_vars_p_decl_non_common (t); > > case FUNCTION_DECL: > @@ -1516,7 +1516,6 @@ compare_tree_sccs_1 (tree t1, tree t2, t > a1 || a2; > a1 = TREE_CHAIN (a1), a2 = TREE_CHAIN (a2)) > compare_tree_edges (a1, a2); > - compare_tree_edges (DECL_RESULT (t1), DECL_RESULT (t2)); > } > else if (code == TYPE_DECL) > compare_tree_edges (DECL_ORIGINAL_TYPE (t1), DECL_ORIGINAL_TYPE (t2)); > @@ -2723,7 +2722,6 @@ lto_fixup_prevailing_decls (tree t) > if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) > { > LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t)); > - LTO_NO_PREVAIL (DECL_RESULT_FLD (t)); > LTO_NO_PREVAIL (DECL_VINDEX (t)); > } > if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) > @@ -2736,6 +2734,8 @@ lto_fixup_prevailing_decls (tree t) > LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t)); > LTO_NO_PREVAIL (DECL_FCONTEXT (t)); > } > + if (TREE_CODE (t) == TYPE_DECL) > + LTO_NO_PREVAIL (DECL_ORIGINAL_TYPE (t)); > } > else if (TYPE_P (t)) > { > Index: print-tree.c > =================================================================== > --- print-tree.c (revision 211106) > +++ print-tree.c (working copy) > @@ -531,8 +531,9 @@ print_node (FILE *file, const char *pref > if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) > { > print_node (file, "arguments", DECL_ARGUMENT_FLD (node), indent + > 4); > - print_node (file, "result", DECL_RESULT_FLD (node), indent + 4); > } > + if (TREE_CODE (node) == TYPE_DECL) > + print_node (file, "original_type", DECL_ORIGINAL_TYPE (node), indent > + 4); > > lang_hooks.print_decl (file, node, indent); > > Index: tree-inline.c > =================================================================== > --- tree-inline.c (revision 211106) > +++ tree-inline.c (working copy) > @@ -2180,15 +2180,13 @@ remap_decl_1 (tree decl, void *data) > the cfun to the function of new_fndecl (and current_function_decl too). > */ > > static void > -initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count) > +initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, tree > resdecl) > { > struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); > gcov_type count_scale; > > if (!DECL_ARGUMENTS (new_fndecl)) > DECL_ARGUMENTS (new_fndecl) = DECL_ARGUMENTS (callee_fndecl); > - if (!DECL_RESULT (new_fndecl)) > - DECL_RESULT (new_fndecl) = DECL_RESULT (callee_fndecl); > > if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count) > count_scale > @@ -2201,7 +2199,7 @@ initialize_cfun (tree new_fndecl, tree c > gimple_register_cfg_hooks (); > > /* Get clean struct function. */ > - push_struct_function (new_fndecl); > + push_struct_function (new_fndecl, resdecl); > > /* We will rebuild these, so just sanity check that they are empty. */ > gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL); > @@ -5340,10 +5338,9 @@ tree_function_versioning (tree old_decl, > > old_entry_block = ENTRY_BLOCK_PTR_FOR_FN > (DECL_STRUCT_FUNCTION (old_decl)); > - DECL_RESULT (new_decl) = DECL_RESULT (old_decl); > DECL_ARGUMENTS (new_decl) = DECL_ARGUMENTS (old_decl); > initialize_cfun (new_decl, old_decl, > - old_entry_block->count); > + old_entry_block->count, DECL_RESULT (old_decl)); > DECL_STRUCT_FUNCTION (new_decl)->gimple_df->ipa_pta > = id.src_cfun->gimple_df->ipa_pta; > > Index: tree-core.h > =================================================================== > --- tree-core.h (revision 211106) > +++ tree-core.h (working copy) > @@ -1486,8 +1486,6 @@ struct GTY(()) tree_decl_non_common { > tree saved_tree; > /* C++ uses this in templates. */ > tree arguments; > - /* Almost all FE's use this. */ > - tree result; > /* C++ uses this in namespaces and function_decls. */ > tree vindex; > }; > @@ -1550,7 +1548,7 @@ struct GTY(()) tree_translation_unit_dec > > struct GTY(()) tree_type_decl { > struct tree_decl_non_common common; > - > + tree original_type; > }; > > struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) > tree_statement_list_node > Index: config/i386/i386.c > =================================================================== > --- config/i386/i386.c (revision 211106) > +++ config/i386/i386.c (working copy) > @@ -9152,6 +9152,7 @@ ix86_code_end (void) > { > char name[32]; > tree decl; > + tree resdecl; > > if (!(pic_labels_used & (1 << regno))) > continue; > @@ -9161,8 +9162,7 @@ ix86_code_end (void) > decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, > get_identifier (name), > build_function_type_list (void_type_node, > NULL_TREE)); > - DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL, > - NULL_TREE, void_type_node); > + resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE, > void_type_node); > TREE_PUBLIC (decl) = 1; > TREE_STATIC (decl) = 1; > DECL_IGNORED_P (decl) = 1; > @@ -9202,7 +9202,7 @@ ix86_code_end (void) > > DECL_INITIAL (decl) = make_node (BLOCK); > current_function_decl = decl; > - init_function_start (decl); > + init_function_start (decl, resdecl); > first_function_block_is_cold = false; > /* Make sure unwind info is emitted for the thunk if needed. */ > final_start_function (emit_barrier (), asm_out_file, 1); > @@ -32192,11 +32192,10 @@ make_resolver_func (const tree default_d > t = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE, ptr_type_node); > DECL_ARTIFICIAL (t) = 1; > DECL_IGNORED_P (t) = 1; > - DECL_RESULT (decl) = t; > + /*push_struct_function (DECL_STRUCT_FUNCTION (decl), t); > > - gimplify_function_tree (decl); > - push_cfun (DECL_STRUCT_FUNCTION (decl)); > - *empty_bb = init_lowered_empty_function (decl, false); > + gimplify_function_tree (decl);*/ > + *empty_bb = init_lowered_empty_function (decl, false, t); > > cgraph_add_new_function (decl, true); > cgraph_call_function_insertion_hooks (cgraph_get_create_node (decl)); > @@ -32209,7 +32208,6 @@ make_resolver_func (const tree default_d > = make_attribute ("ifunc", resolver_name, DECL_ATTRIBUTES > (dispatch_decl)); > > /* Create the alias for dispatch to resolver here. */ > - /*cgraph_create_function_alias (dispatch_decl, decl);*/ > cgraph_same_body_alias (NULL, dispatch_decl, decl); > XDELETEVEC (resolver_name); > return decl; > Index: tree-browser.def > =================================================================== > --- tree-browser.def (revision 211106) > +++ tree-browser.def (working copy) > @@ -55,7 +55,7 @@ DEFTBCODE (TB_CONTEXT, "context > DEFTBCODE (TB_ATTRIBUTES, "attributes", "Field accessor.") > DEFTBCODE (TB_ABSTRACT_ORIGIN, "abstract_origin", "Field accessor.") > DEFTBCODE (TB_ARGUMENTS, "arguments", "Field accessor.") > -DEFTBCODE (TB_RESULT, "result", "Field accessor.") > +DEFTBCODE (TB_ORIGINAL_TYPE, "original_type", "Field accessor.") > DEFTBCODE (TB_INITIAL, "initial", "Field accessor.") > DEFTBCODE (TB_ARG_TYPE, "arg-type", "Field accessor.") > DEFTBCODE (TB_ARG_TYPE_AS_WRITTEN, "arg-type-as-written", "Field accessor.")