Changeset 1394 for trunk/src/gcc/gcc/cp/semantics.c

Timestamp:

Apr 28, 2004, 6:58:06 AM (21 years ago)

Author:

bird

Message:

#1040: Joined the GCC 3.3.3 with the trunk.

File:

• trunk/src/gcc/gcc/cp/semantics.c (modified) (54 diffs, 1 prop)

trunk/src/gcc/gcc/cp/semantics.c

@@ -57 +57 @@
 static void genrtl_eh_spec_block PARAMS ((tree));
 static void genrtl_handler PARAMS ((tree));
-static void genrtl_ctor_stmt PARAMS ((tree));
-static void genrtl_subobject PARAMS ((tree));
 static void genrtl_named_return_value PARAMS ((void));
 static void cp_expand_stmt PARAMS ((tree));
@@ -82 +80 @@
   } while (0)
 
-/* Returns non-zero if the current statement is a full expression,
+/* Returns nonzero if the current statement is a full expression,
    i.e. temporaries created during that statement should be destroyed
    at the end of the statement.  */
@@ -100 +98 @@
 {
   return (cfun 
-          ? &cfun->language->x_stmt_tree 
+          ? &cfun->language->base.x_stmt_tree 
           : &scope_chain->x_stmt_tree);
 }
@@ -112 +110 @@
      tree node;
 {
-  return (CLASS_TYPE_P (node) && TYPE_LANG_SPECIFIC(node)->anon_aggr);
+  return ANON_AGGR_TYPE_P (node);
 }
 
@@ -269 +267 @@
 {
   RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
-  last_tree = if_stmt;
   return if_stmt;
 }
@@ -295 +292 @@
 finish_if_stmt ()
 {
+  finish_stmt ();
   do_poplevel ();
-  finish_stmt ();
-}
-
-void
-clear_out_block ()
-{
-  /* If COND wasn't a declaration, clear out the
-     block we made for it and start a new one here so the
-     optimization in expand_end_loop will work.  */
-  if (getdecls () == NULL_TREE)
-    {
-      do_poplevel ();
-      do_pushlevel ();
-    }
 }
 
@@ -334 +318 @@
 {
   cond = maybe_convert_cond (cond);
-  FINISH_COND (cond, while_stmt, WHILE_COND (while_stmt));
-  clear_out_block ();
+  if (processing_template_decl)
+    /* Don't mess with condition decls in a template.  */
+    FINISH_COND (cond, while_stmt, WHILE_COND (while_stmt));
+  else if (getdecls () == NULL_TREE)
+    /* It was a simple condition; install it.  */
+    WHILE_COND (while_stmt) = cond;
+  else
+    {
+      /* If there was a declaration in the condition, we can't leave it
+         there; transform
+            while (A x = 42) { }
+         to
+            while (true) { A x = 42; if (!x) break; }  */
+      tree if_stmt;
+      WHILE_COND (while_stmt) = boolean_true_node;
+
+      if_stmt = begin_if_stmt ();
+      cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
+      finish_if_stmt_cond (cond, if_stmt);
+      finish_break_stmt ();
+      finish_then_clause (if_stmt);
+      finish_if_stmt ();
+    }
 }
 
@@ -420 +425 @@
                   NULL_TREE, NULL_TREE);
   NEW_FOR_SCOPE_P (r) = flag_new_for_scope > 0;
-  add_stmt (r);
   if (NEW_FOR_SCOPE_P (r))
     {
@@ -426 +430 @@
       note_level_for_for ();
     }
+  add_stmt (r);
 
   return r;
@@ -451 +456 @@
 {
   cond = maybe_convert_cond (cond);
-  FINISH_COND (cond, for_stmt, FOR_COND (for_stmt));
-  clear_out_block ();
+  if (processing_template_decl)
+    /* Don't mess with condition decls in a template.  */
+    FINISH_COND (cond, for_stmt, FOR_COND (for_stmt));
+  else if (getdecls () == NULL_TREE)
+    /* It was a simple condition; install it.  */
+    FOR_COND (for_stmt) = cond;
+  else
+    {
+      /* If there was a declaration in the condition, we can't leave it
+         there; transform
+            for (; A x = 42;) { }
+         to
+            for (;;) { A x = 42; if (!x) break; }  */
+      tree if_stmt;
+      FOR_COND (for_stmt) = NULL_TREE;
+
+      if_stmt = begin_if_stmt ();
+      cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
+      finish_if_stmt_cond (cond, if_stmt);
+      finish_break_stmt ();
+      finish_then_clause (if_stmt);
+      finish_if_stmt ();
+    }
 }
 
@@ -505 +531 @@
 {
   tree r;
+  do_pushlevel ();
   r = build_stmt (SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
   add_stmt (r);
-  do_pushlevel ();
   return r;
 }
@@ -563 +589 @@
   RECHAIN_STMTS (switch_stmt, SWITCH_BODY (switch_stmt));
   pop_switch (); 
+  finish_stmt ();
   do_poplevel ();
-  finish_stmt ();
-}
-
-/* Generate the RTL for T, which is a TRY_BLOCK. */
+}
+
+/* Generate the RTL for T, which is a TRY_BLOCK.  */
 
 static void 
@@ -604 +630 @@
 }
 
-/* Generate the RTL for T, which is an EH_SPEC_BLOCK. */
+/* Generate the RTL for T, which is an EH_SPEC_BLOCK.  */
 
 static void 
@@ -713 +739 @@
 }
 
-/* Generate the RTL for T, which is a HANDLER. */
+/* Generate the RTL for T, which is a HANDLER.  */
 
 static void
@@ -782 +808 @@
 }
 
-/* Generate the RTL for T, which is a CTOR_STMT. */
-
-static void
-genrtl_ctor_stmt (t)
-     tree t;
-{
-  if (CTOR_BEGIN_P (t))
-    begin_protect_partials ();
-  else
-    /* After this point, any exceptions will cause the
-       destructor to be executed, so we no longer need to worry
-       about destroying the various subobjects ourselves.  */
-    end_protect_partials ();
-}
-
-/* Begin a compound-statement.  If HAS_NO_SCOPE is non-zero, the
+/* Begin a compound-statement.  If HAS_NO_SCOPE is nonzero, the
    compound-statement does not define a scope.  Returns a new
    COMPOUND_STMT if appropriate.  */
@@ -836 +847 @@
 
 /* Finish a compound-statement, which may be given by COMPOUND_STMT.
-   If HAS_NO_SCOPE is non-zero, the compound statement does not define
+   If HAS_NO_SCOPE is nonzero, the compound statement does not define
    a scope.  */
 
@@ -880 +891 @@
   tree r;
   tree t;
-
-  if (TREE_CHAIN (string))
-    string = combine_strings (string);
 
   if (cv_qualifier != NULL_TREE
@@ -928 +936 @@
 
           constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
-          operand = TREE_VALUE (output_operands);
+          operand = TREE_VALUE (t);
 
           if (!parse_output_constraint (&constraint,
@@ -949 +957 @@
              point.  */
           if (!allows_reg && DECL_P (operand))
-            mark_addressable (operand);
+            cxx_mark_addressable (operand);
         }
     }
@@ -981 +989 @@
 }
 
-/* Generate the RTL for a SUBOBJECT. */
-
-static void 
-genrtl_subobject (cleanup)
-     tree cleanup;
-{
-  add_partial_entry (cleanup);
-}
-
-/* We're in a constructor, and have just constructed a a subobject of
-   *THIS.  CLEANUP is code to run if an exception is thrown before the
-   end of the current function is reached.   */
-
-void 
-finish_subobject (cleanup)
-     tree cleanup;
-{
-  tree r = build_stmt (SUBOBJECT, cleanup);
-  add_stmt (r);
-}
-
 /* When DECL goes out of scope, make sure that CLEANUP is executed.  */
 
@@ -1012 +999 @@
 }
 
-/* Generate the RTL for a RETURN_INIT. */
+/* If the current scope exits with an exception, run CLEANUP.  */
+
+void
+finish_eh_cleanup (cleanup)
+     tree cleanup;
+{
+  tree r = build_stmt (CLEANUP_STMT, NULL_TREE, cleanup);
+  CLEANUP_EH_ONLY (r) = 1;
+  add_stmt (r);
+}
+
+/* Generate the RTL for a RETURN_INIT.  */
 
 static void
@@ -1032 +1030 @@
       SET_DECL_RTL (decl, gen_reg_rtx (GET_MODE (DECL_RTL (decl))));
       if (TREE_ADDRESSABLE (decl))
-        put_var_into_stack (decl);
+        put_var_into_stack (decl, /*rescan=*/true);
     }
 
@@ -1094 +1092 @@
 }
 
-/* The INIT_LIST is a list of mem-initializers, in the order they were
-   written by the user.  The TREE_VALUE of each node is a list of
-   initializers for a particular subobject.  The TREE_PURPOSE is a
-   FIELD_DECL is the initializer is for a non-static data member, and
-   a class type if the initializer is for a base class.  */
-
-void
-finish_mem_initializers (init_list)
-     tree init_list;
-{
-  tree member_init_list;
-  tree base_init_list;
-  tree last_base_warned_about;
-  tree next; 
-  tree init;
-
-  member_init_list = NULL_TREE;
-  base_init_list = NULL_TREE;
-  last_base_warned_about = NULL_TREE;
-
-  for (init = init_list; init; init = next)
-    {
-      next = TREE_CHAIN (init);
-      if (TREE_CODE (TREE_PURPOSE (init)) == FIELD_DECL)
-        {
-          TREE_CHAIN (init) = member_init_list;
-          member_init_list = init;
-
-          /* We're running through the initializers from right to left
-             as we process them here.  So, if we see a data member
-             initializer after we see a base initializer, that
-             actually means that the base initializer preceded the
-             data member initializer.  */
-          if (warn_reorder && last_base_warned_about != base_init_list)
-            {
-              tree base;
-
-              for (base = base_init_list; 
-                   base != last_base_warned_about; 
-                   base = TREE_CHAIN (base))
-                {
-                  warning ("base initializer for `%T'",
-                              TREE_PURPOSE (base));
-                  warning ("   will be re-ordered to precede member initializations");
-                }
-
-              last_base_warned_about = base_init_list;
-            }
-        }
-      else
-        {
-          TREE_CHAIN (init) = base_init_list;
-          base_init_list = init;
-        }
-    }
+/* Begin processing a mem-initializer-list.  */
+
+void
+begin_mem_initializers ()
+{
+  if (! DECL_CONSTRUCTOR_P (current_function_decl))
+    error ("only constructors take base initializers");
+}
+
+/* The MEM_INITS is a list of mem-initializers, in reverse of the
+   order they were written by the user.  Each node is as for
+   emit_mem_initializers.  */
+
+void
+finish_mem_initializers (tree mem_inits)
+{
+  /* Reorder the MEM_INITS so that they are in the order they appeared
+     in the source program.  */
+  mem_inits = nreverse (mem_inits);
 
   if (processing_template_decl)
-    add_stmt (build_min_nt (CTOR_INITIALIZER,
-                            member_init_list, base_init_list));
+    add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
   else
-    emit_base_init (member_init_list, base_init_list);
+    emit_mem_initializers (mem_inits);
 }
 
@@ -1162 +1123 @@
 current_scope_stmt_stack ()
 {
-  return &cfun->language->x_scope_stmt_stack;
+  return &cfun->language->base.x_scope_stmt_stack;
 }
 
@@ -1172 +1133 @@
 {
   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
-    /* This inhibits warnings in truthvalue_conversion.  */
+    /* This inhibits warnings in c_common_truthvalue_conversion.  */
     C_SET_EXP_ORIGINAL_CODE (expr, ERROR_MARK); 
 
@@ -1264 +1225 @@
 }
 
-/* Finish a call to FN with ARGS.  Returns a representation of the
-   call.  */
+/* Generate an expression for `FN (ARGS)'.
+
+   If DISALLOW_VIRTUAL is true, the call to FN will be not generated
+   as a virtual call, even if FN is virtual.  (This flag is set when
+   encountering an expression where the function name is explicitly
+   qualified.  For example a call to `X::f' never generates a virtual
+   call.)
+
+   Returns code for the call.  */
 
 tree 
-finish_call_expr (fn, args, koenig)
-     tree fn;
-     tree args;
-     int koenig;
-{
-  tree result;
-
-  if (koenig)
-    {
-      if (TREE_CODE (fn) == BIT_NOT_EXPR)
-        fn = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND (fn, 0));
-      else if (TREE_CODE (fn) != TEMPLATE_ID_EXPR)
-        fn = do_identifier (fn, 2, args);
-    }
-  result = build_x_function_call (fn, args, current_class_ref);
-
-  if (TREE_CODE (result) == CALL_EXPR
-      && (! TREE_TYPE (result)
-          || TREE_CODE (TREE_TYPE (result)) != VOID_TYPE))
-    result = require_complete_type (result);
-
-  return result;
+finish_call_expr (tree fn, tree args, bool disallow_virtual)
+{
+  if (fn == error_mark_node || args == error_mark_node)
+    return error_mark_node;
+
+  if (processing_template_decl)
+    return build_nt (CALL_EXPR, fn, args, NULL_TREE);
+
+  /* ARGS should be a list of arguments.  */
+  my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
+                      20020712);
+
+  if (BASELINK_P (fn))
+    {
+      tree object;
+
+      /* A call to a member function.  From [over.call.func]:
+
+           If the keyword this is in scope and refers to the class of
+           that member function, or a derived class thereof, then the
+           function call is transformed into a qualified function call
+           using (*this) as the postfix-expression to the left of the
+           . operator.... [Otherwise] a contrived object of type T
+           becomes the implied object argument.  
+
+        This paragraph is unclear about this situation:
+
+          struct A { void f(); };
+          struct B : public A {};
+          struct C : public A { void g() { B::f(); }};
+
+        In particular, for `B::f', this paragraph does not make clear
+        whether "the class of that member function" refers to `A' or 
+        to `B'.  We believe it refers to `B'.  */
+      if (current_class_type 
+          && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
+                             current_class_type)
+          && current_class_ref)
+        object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
+                                     NULL);
+      else
+        {
+          tree representative_fn;
+
+          representative_fn = BASELINK_FUNCTIONS (fn);
+          if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
+            representative_fn = TREE_OPERAND (representative_fn, 0);
+          representative_fn = get_first_fn (representative_fn);
+          object = build_dummy_object (DECL_CONTEXT (representative_fn));
+        }
+
+      return build_new_method_call (object, fn, args, NULL_TREE,
+                                    (disallow_virtual 
+                                     ? LOOKUP_NONVIRTUAL : 0));
+    }
+  else if (is_overloaded_fn (fn))
+    /* A call to a namespace-scope function.  */
+    return build_new_function_call (fn, args);
+  else if (CLASS_TYPE_P (TREE_TYPE (fn)))
+    {
+      /* If the "function" is really an object of class type, it might
+         have an overloaded `operator ()'.  */
+      tree result;
+      result = build_opfncall (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE);
+      if (result)
+        return result;
+    }
+
+  /* A call where the function is unknown.  */
+  return build_function_call (fn, args);
 }
 
@@ -1349 +1365 @@
      tree args;
 {
-#if 0
-  /* This is a future direction of this code, but because
-     build_x_function_call cannot always undo what is done in
-     build_component_ref entirely yet, we cannot do this.  */
-
-  tree real_fn = build_component_ref (object, fn, NULL_TREE, 1);
-  return finish_call_expr (real_fn, args);
-#else
   if (DECL_DECLARES_TYPE_P (fn))
     {
@@ -1375 +1383 @@
         }
     }
-
-  return build_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
-#endif
+  
+  if (processing_template_decl || name_p (fn))
+    return build_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
+  else
+    return build_new_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
 }
 
@@ -1416 +1426 @@
 
   return cp_convert (void_type_node, object);
-}
-
-/* Finish a call to a globally qualified member function FN using
-   ARGS.  Returns an expression for the call.  */
-
-tree 
-finish_qualified_call_expr (fn, args)
-     tree fn;
-     tree args;
-{
-  if (processing_template_decl)
-    return build_min_nt (CALL_EXPR, fn, args, NULL_TREE);
-  else
-    return build_member_call (TREE_OPERAND (fn, 0),
-                              TREE_OPERAND (fn, 1),
-                              args);
 }
 
@@ -1468 +1462 @@
 }
 
+/* Return the declaration for the function-name variable indicated by
+   ID.  */
+
+tree
+finish_fname (tree id)
+{
+  tree decl;
+  
+  decl = fname_decl (C_RID_CODE (id), id);
+  if (processing_template_decl)
+    decl = build_min_nt (LOOKUP_EXPR, DECL_NAME (decl));
+  return decl;
+}
+
 static tree current_type_lookups;
 
@@ -1525 +1533 @@
 }
 
-/* Begin a function definition declared with DECL_SPECS and
-   DECLARATOR.  Returns non-zero if the function-declaration is
-   legal.  */
+/* Begin a function definition declared with DECL_SPECS, ATTRIBUTES,
+   and DECLARATOR.  Returns nonzero if the function-declaration is
+   valid.  */
 
 int
-begin_function_definition (decl_specs, declarator)
+begin_function_definition (decl_specs, attributes, declarator)
      tree decl_specs;
+     tree attributes;
      tree declarator;
 {
-  tree specs;
-  tree attrs;
-
-  split_specs_attrs (decl_specs, &specs, &attrs);
-  if (!start_function (specs, declarator, attrs, SF_DEFAULT))
+  if (!start_function (decl_specs, declarator, attributes, SF_DEFAULT))
     return 0;
 
@@ -1590 +1595 @@
     pop_namespace ();
 
-  /* Do file scope __FUNCTION__ et al. */
+  /* Do file scope __FUNCTION__ et al.  */
   finish_fname_decls ();
   
@@ -1633 +1638 @@
 }
 
+/* ARGUMENT is the default-argument value for a template template
+   parameter.  If ARGUMENT is invalid, issue error messages and return
+   the ERROR_MARK_NODE.  Otherwise, ARGUMENT itself is returned.  */
+
+tree
+check_template_template_default_arg (tree argument)
+{
+  if (TREE_CODE (argument) != TEMPLATE_DECL
+      && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
+      && TREE_CODE (argument) != TYPE_DECL
+      && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
+    {
+      error ("invalid default template argument");
+      return error_mark_node;
+    }
+
+  return argument;
+}
+
 /* Finish a parameter list, indicated by PARMS.  If ELLIPSIS is
-   non-zero, the parameter list was terminated by a `...'.  */
+   nonzero, the parameter list was terminated by a `...'.  */
 
 tree
@@ -1662 +1686 @@
     return error_mark_node;
 
-  /* Check the bases are accessible. */
+  /* Check the bases are accessible.  */
   decl_type_access_control (TYPE_NAME (t));
   reset_type_access_control ();
@@ -1732 +1756 @@
           TYPE_FIELDS (t) = NULL_TREE;
           TYPE_METHODS (t) = NULL_TREE;
-          CLASSTYPE_TAGS (t) = NULL_TREE;
+          CLASSTYPE_DECL_LIST (t) = NULL_TREE;
+          CLASSTYPE_NESTED_UDTS (t) = NULL;
           CLASSTYPE_VBASECLASSES (t) = NULL_TREE;
           TYPE_SIZE (t) = NULL_TREE;
@@ -1825 +1850 @@
       TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
       TYPE_METHODS (current_class_type) = decl;
-    }
-  else
+
+      maybe_add_class_template_decl_list (current_class_type, decl, 
+                                          /*friend_p=*/0);
+    }
+  /* Enter the DECL into the scope of the class.  */
+  else if (TREE_CODE (decl) == USING_DECL || pushdecl_class_level (decl))
     {
       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
@@ -1837 +1866 @@
            s.E = 3;
 
-         is legal.  In addition, the FIELD_DECLs must be maintained in
+         is valid.  In addition, the FIELD_DECLs must be maintained in
          declaration order so that class layout works as expected.
          However, we don't need that order until class layout, so we
@@ -1854 +1883 @@
         }
 
-      /* Enter the DECL into the scope of the class.  */
-      if (TREE_CODE (decl) != USING_DECL)
-        pushdecl_class_level (decl);
+      maybe_add_class_template_decl_list (current_class_type, decl, 
+                                          /*friend_p=*/0);
     }
 }
@@ -1911 +1939 @@
   if (current_scope () == current_function_decl)
     do_pending_inlines ();
-}
-
-/* Finish processing the inline function definitions cached during the
-   processing of a class definition.  */
-
-void
-finish_inline_definitions ()
-{
-  if (current_class_type == NULL_TREE)
-    clear_inline_text_obstack (); 
 }
 
@@ -1970 +1988 @@
 /* Finish processing a template-id (which names a type) of the form
    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
-   template-id.  If ENTERING_SCOPE is non-zero we are about to enter
+   template-id.  If ENTERING_SCOPE is nonzero we are about to enter
    the scope of template-id indicated.  */
 
@@ -2031 +2049 @@
   tree result;
 
-  if (! is_aggr_type (base_class, 1))
+  if (base_class == error_mark_node)
+    {
+      error ("invalid base-class specification");
+      result = NULL_TREE;
+    }
+  else if (! is_aggr_type (base_class, 1))
     result = NULL_TREE;
   else
@@ -2059 +2082 @@
 
      We don't just use PROCESSING_TEMPLATE_DECL for the first
-     condition since that would disallow the perfectly legal code, 
+     condition since that would disallow the perfectly valid code, 
      like `template <class T> struct S { int i, j; };'.  */
-  tree scope = current_scope ();
-
-  if (scope && TREE_CODE (scope) == FUNCTION_DECL)
+  if (at_function_scope_p ())
     /* It's OK to write `template <class T> void f() { int i, j;}'.  */
     return;
@@ -2113 +2134 @@
     return build_min_nt (SIZEOF_EXPR, t);
 
-  return TYPE_P (t) ? c_sizeof (t) : expr_sizeof (t);
+  return TYPE_P (t) ? cxx_sizeof (t) : expr_sizeof (t);
 }
 
@@ -2126 +2147 @@
     return build_min_nt (ALIGNOF_EXPR, t);
 
-  return TYPE_P (t) ? c_alignof (complete_type (t)) : c_alignof_expr (t);
+  return TYPE_P (t) ? cxx_alignof (t) : c_alignof_expr (t);
 }
 
@@ -2138 +2159 @@
   switch (TREE_CODE (t))
     {
-    case CTOR_STMT:
-      genrtl_ctor_stmt (t);
-      break;
-
     case TRY_BLOCK:
       genrtl_try_block (t);
@@ -2152 +2169 @@
     case HANDLER:
       genrtl_handler (t);
-      break;
-
-    case SUBOBJECT:
-      genrtl_subobject (SUBOBJECT_CLEANUP (t));
       break;
 
@@ -2212 +2225 @@
       /* Replace the first argument with the address of the third
          argument to the AGGR_INIT_EXPR.  */
-      mark_addressable (slot);
+      cxx_mark_addressable (slot);
       args = tree_cons (NULL_TREE, 
                         build1 (ADDR_EXPR, 
@@ -2272 +2285 @@
   if (DECL_VIRTUAL_P (fn))
     {
-      tree binfo;
-      tree v;
-
-      for (binfo = TYPE_BINFO (DECL_CONTEXT (fn));
-           binfo;
-           binfo = TREE_CHAIN (binfo))
-        for (v = BINFO_VIRTUALS (binfo); v; v = TREE_CHAIN (v))
-          if (BV_FN (v) == fn
-              && (!integer_zerop (BV_DELTA (v))
-                  || BV_USE_VCALL_INDEX_P (v)))
-            {
-              tree thunk;
-              tree vcall_index;
-
-              if (BV_USE_VCALL_INDEX_P (v))
-                {
-                  vcall_index = BV_VCALL_INDEX (v);
-                  my_friendly_assert (vcall_index != NULL_TREE, 20000621);
-                }
-              else
-                vcall_index = NULL_TREE;
-
-              thunk = make_thunk (build1 (ADDR_EXPR,
-                                          vfunc_ptr_type_node,
-                                          fn),
-                                  BV_DELTA (v),
-                                  vcall_index);
-              use_thunk (thunk, /*emit_p=*/1);
-            }
+      tree thunk;
+      for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
+        use_thunk (thunk, /*emit_p=*/1);
     }
 }
@@ -2312 +2299 @@
   int saved_lineno;
   const char *saved_input_filename;
+  tree saved_function;
 
   /* When the parser calls us after finishing the body of a template
@@ -2389 +2377 @@
     return;
 
-  timevar_push (TV_INTEGRATION);
-
-  /* Optimize the body of the function before expanding it.  */
-  optimize_function (fn);
-
-  timevar_pop (TV_INTEGRATION);
-  timevar_push (TV_EXPAND);
-
   /* Save the current file name and line number.  When we expand the
      body of the function, we'll set LINENO and INPUT_FILENAME so that
@@ -2402 +2382 @@
   saved_lineno = lineno;
   saved_input_filename = input_filename;
+  saved_function = current_function_decl;
   lineno = DECL_SOURCE_LINE (fn);
   input_filename = DECL_SOURCE_FILE (fn);
+  current_function_decl = fn;
+
+  timevar_push (TV_INTEGRATION);
+
+  /* Optimize the body of the function before expanding it.  */
+  optimize_function (fn);
+
+  timevar_pop (TV_INTEGRATION);
+  timevar_push (TV_EXPAND);
 
   genrtl_start_function (fn);
@@ -2436 +2426 @@
 
   /* And restore the current source position.  */
+  current_function_decl = saved_function;
   lineno = saved_lineno;
   input_filename = saved_input_filename;
@@ -2463 +2454 @@
     *walk_subtrees = 0;
   else if (TREE_CODE (*tp) == RETURN_STMT)
-    RETURN_EXPR (*tp) = NULL_TREE;
+    RETURN_STMT_EXPR (*tp) = NULL_TREE;
   else if (TREE_CODE (*tp) == CLEANUP_STMT
            && CLEANUP_DECL (*tp) == nrv)
@@ -2517 +2508 @@
          cp_copy_res_decl_for_inlining.  */
       if (! DECL_INLINE (fn))
-        {
-          free (DECL_SAVED_FUNCTION_DATA (fn));
-          DECL_SAVED_FUNCTION_DATA (fn) = NULL;
-        }
+        DECL_SAVED_FUNCTION_DATA (fn) = NULL;
     }