[RFC] Moving DECL_RESULT, DECL_ARGUMENTS, and DECL_SAVED_TREE into struct function

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.

So any comments?

Honza

On Fri, Jun 6, 2014 at 10:30 AM, Jan Hubicka <hubicka@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.")