Studying note of GCC-3.4.6 source (111)

5.12.3.2.1.2.1.3.    Finish function handling

Then finish_function will finish filling-up of node of FUNCTION_DECL for the function. We will go back to this function later again for other example.

 

10815 tree

10816 finish_function (int flags)                                                                               in decl.c

10817 {

10818   tree fndecl = current_function_decl ;

10819   tree fntype, ctype = NULL_TREE;

10820   int inclass_inline = (flags & 2) != 0;

10821   int nested;

10822

10823   /* When we get some parse errors, we can end up without a

10824     current_function_decl, so cope.  */

10825   if (fndecl == NULL_TREE)

10826     return error_mark_node;

10827

10828   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)

10829      && DECL_VIRTUAL_P (fndecl)

10830      && ! processing_template_decl )

10831   {

10832     tree fnclass = DECL_CONTEXT (fndecl);

10833     if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))

10834        keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);

10835   }

10836

10837   nested = function_depth > 1;

10838   fntype = TREE_TYPE (fndecl);

10839

10840   /* TREE_READONLY (fndecl) = 1;

10841     This caused &foo to be of type ptr-to-const-function

10842     which then got a warning when stored in a ptr-to-function variable.  */

10843

10844   my_friendly_assert (building_stmt_tree (), 20000911);

10845  

10846   /* For a cloned function, we've already got all the code we need;

10847     there's no need to add any extra bits.  */

10848   if (!DECL_CLONED_FUNCTION_P (fndecl))

10849   {

10850     if (DECL_MAIN_P (current_function_decl ))

10851     {

10852       /* Make it so that `main' always returns 0 by default.  */

10853 #if VMS_TARGET

10854       finish_return_stmt (integer_one_node);

10855 #else

10856       finish_return_stmt (integer_zero_node);

10857 #endif

10858     }

10859

10860     /* Finish dealing with exception specifiers.  */

10861     if (flag_exceptions && ! processing_template_decl

10862        && flag_enforce_eh_specs

10863        && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl )))

10864       finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS

10865                         (TREE_TYPE (current_function_decl )),

10866                         current_eh_spec_block);

10867   }

10868

10869   finish_fname_decls ();

10870

10871   /* If we're saving up tree structure, tie off the function now.  */

10872   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));

 

If assignment statements are generated for “__FUNCTION__” and like, field TREE_VALUE of the associated item in saved_function_name_decls will record the statements. As there may be more than one assignments kept in saved_function_name_decls (correspond to “__FUNCTION__”, “__func__”, “__PRETTY_FUNCTION__”), so below at line 1019, FOR loop integrates these statements.

 

1012   void

1013   finish_fname_decls (void)                                                                 in c-common.c

1014   {

1015     unsigned ix;

1016     tree body = NULL_TREE;

1017     tree stack = saved_function_name_decls;

1018  

1019     for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))

1020       body = chainon (TREE_VALUE (stack), body);

1021  

1022     if (body)

1023     {

1024       /* They were called into existence, so add to statement tree. Add

1025         the DECL_STMTs inside the outermost scope.  */

1026       tree *p = &DECL_SAVED_TREE (current_function_decl );

1027       /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK.  */

1028       while (TREE_CODE (*p) != COMPOUND_STMT)

1029       {

1030         if (TREE_CODE (*p) == EXPR_STMT)

1031           p = &TREE_CHAIN (*p);

1032         else

1033           p = &TREE_OPERAND(*p, 0);

1034       }

1035  

1036       p = &COMPOUND_BODY (*p);

1037       if (TREE_CODE (*p) == SCOPE_STMT)

1038         p = &TREE_CHAIN (*p);

1039  

1040       body = chainon (body, *p);

1041       *p = body;

1042     }

1043  

1044     for (ix = 0; fname_vars [ix].decl; ix++)

1045       *fname_vars [ix].decl = NULL_TREE;

1046  

1047     if (stack)

1048     {

1049       /* We had saved values, restore them.  */

1050       tree saved;

1051  

1052       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))

1053       {

1054         tree decl = TREE_PURPOSE (saved);

1055         unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));

1056  

1057         *fname_vars [ix].decl = decl;

1058       }

1059       stack = TREE_CHAIN (stack);

1060     }

1061     saved_function_name_decls = stack;

1062   }

 

IF block At line 1012 puts these statements at head of the function-body. As these statements are saved by fname_vars [ix].decl before, now they got handled, and at exitting the function, they no longer valid; FOR loop at line 1044 cleans fname_vars [ix]. And FOR loop at line 1052 in fact restores fname_vars [ix].decl’s initial value.

 

165    void

166    finish_stmt_tree (tree *t)                                                                   in c-semantics.c

167    {

168      tree stmt;

169   

170      /* Remove the fake extra statement added in begin_stmt_tree.  */

171      stmt = TREE_CHAIN (*t);

172      *t = stmt;

173      last_tree = NULL_TREE;

174   

175      if (cfun && stmt)

176      {

177        /* The line-number recorded in the outermost statement in a function

178           is the line number of the end of the function.  */

179        STMT_LINENO (stmt) = input_line;

180        STMT_LINENO_FOR_FN_P (stmt) = 1;

181      }

182    }

 

In begin_stmt_tree , a fake statement of void_zero_node is created because seeing in above address of it is needed for inserting the statements. Now as statements are all linked in, this fake node can be removed.

 

finish_function (continue)

 

10874   /* If this function can't throw any exceptions, remember that.  */

10875   if (!processing_template_decl

10876       && !cp_function_chain->can_throw

10877       && !flag_non_call_exceptions )

10878     TREE_NOTHROW (fndecl) = 1;

10879

10880   /* This must come after expand_function_end because cleanups might

10881     have declarations (from inline functions) that need to go into

10882     this function's blocks.  */

10883  

10884   /* If the current binding level isn't the outermost binding level

10885     for this function, either there is a bug, or we have experienced

10886     syntax errors and the statement tree is malformed.  */

10887   if ( current_binding_level ->kind != sk_function_parms)

10888   {

          …

10904   }

10905   poplevel (1, 0, 1);

10906

10907   /* Statements should always be full-expressions at the outermost set

10908     of curly braces for a function.  */

10909   my_friendly_assert (stmts_are_full_exprs_p (), 19990831);

10910

10911   /* Set up the named return value optimization, if we can. Here, we

10912     eliminate the copy from the nrv into the RESULT_DECL and any cleanup

10913     for the nrv. genrtl_start_function and declare_return_variable

10914     handle making the nrv and RESULT_DECL share space.  */

10915   if (current_function_return_value )

10916   {

          …

10941   }

10942

10943   /* Remember that we were in class scope.  */

10944   if (current_class_name)

10945     ctype = current_class_type ;

10946

10947   /* Must mark the RESULT_DECL as being in this function.  */

10948   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;

10949

10950   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point

10951     to the FUNCTION_DECL node itself.  */

10952   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;

10953

10954   /* Save away current state, if appropriate.  */

10955   if (!processing_template_decl )

10956     save_function_data (fndecl);

 

By the language grammar, function without declaring throws any exception can throw exception of any kind; to declare a function throw no exception, you should use nothrow at the end of the declaration. This information is useful for optimization, needs record it within the FUNCTION_DECL node. And IF block beginning at line 10915 is for named return value optimization purpose, we will come to this topic later.

 

10614 static void

10615 save_function_data (tree decl)                                                                         in decl.c

10616 {

10617   struct language_function *f;

10618

10619   /* Save the language-specific per-function data so that we can

10620     get it back when we really expand this function.  */

10621   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),

10622                   19990908);

10623

10624   /* Make a copy.  */

10625   f = ggc_alloc (sizeof (struct language_function));

10626   memcpy (f, cp_function_chain, sizeof (struct language_function));

10627   DECL_SAVED_FUNCTION_DATA (decl) = f;

10628

10629   /* Clear out the bits we don't need.  */

10630   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;

10631   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;

10632   f->x_named_label_uses = NULL;

10633   f->bindings = NULL;

10634   f->x_local_names = NULL;

10635

10636   /* If we've already decided that we cannot inline this function, we

10637     must remember that fact when we actually go to expand the

10638     function.  */

10639   if (current_function_cannot_inline)

10640   {

10641     f->cannot_inline = current_function_cannot_inline;

10642     DECL_INLINE (decl) = 0;

10643   }

10644 }

 

If it is method of class-template, the method is not the real function declaration. For the real function declaration, it needs remember this associated language_function and release cfun as we get out of the function declaration and scope now. It is done by save_function_data .

 

finish_function (continue)

 

10958   /* If this function calls `setjmp' it cannot be inlined. When

10959     `longjmp' is called it is not guaranteed to restore the value of

10960     local variables that have been modified since the call to

10961     `setjmp'. So, if were to inline this function into some caller

10962     `c', then when we `longjmp', we might not restore all variables

10963     in `c'. (It might seem, at first blush, that there's no way for

10964     this function to modify local variables in `c', but their

10965     addresses may have been stored somewhere accessible to this

10966     function.)  */

10967   if (!processing_template_decl && calls_setjmp_p (fndecl))

10968     DECL_UNINLINABLE (fndecl) = 1;

10969

10970   /* Complain if there's just no return statement.  */

10971   if (warn_return_type

10972       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE

10973        && !dependent_type_p (TREE_TYPE (fntype))

10974       && !current_function_returns_value && !current_function_returns_null

10975        /* Don't complain if we abort or throw.  */

10976       && !current_function_returns_abnormally

10977       && !DECL_NAME (DECL_RESULT (fndecl))

10978       /* Normally, with -Wreturn-type, flow will complain. Unless we're an

10979          inline function, as we might never be compiled separately.  */

10980       && (DECL_INLINE (fndecl) || processing_template_decl ))

10981     warning ("no return statement in function returning non-void");

10982

10983   /* We're leaving the context of this function, so zap cfun. It's still in

10984     DECL_SAVED_INSNS, and we'll restore it in tree_rest_of_compilation.  */

10985   cfun = NULL;

10986   current_function_decl = NULL;

10987

10988   /* If this is an in-class inline definition, we may have to pop the

10989     bindings for the template parameters that we added in

10990     maybe_begin_member_template_processing when start_function was

10991     called.  */

10992   if (inclass_inline)

10993     maybe_end_member_template_processing ();

10994

10995   /* Leave the scope of the class.  */

10996   if (ctype)

10997     pop_nested_class ();

10998

10999   --function_depth ;

11000

11001   /* Clean up.  */

11002   if (! nested)

11003     /* Let the error reporting routines know that we're outside a

11004       function. For a nested function, this value is used in

11005       cxx_pop_function_context and then reset via pop_function_context.  */

11006     current_function_decl = NULL_TREE;

11007

11008   return fndecl;

11009 }

 

Being a method of class, it is either defined outside the class body, or defined as inclass-inline, no matter what kind, ctype at line 10996 points to the class node which forms the context for the method. When finish handling the method, it also steps out of the class (remember for inclass-inline definition, its handling is deferred to the finish of class body). Exitting from the class scope is done by pop_nested_class .

 

5650   void

5651   pop_nested_class (void)                                                                           in class.c

5652   {

5653     tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type ));

5654  

5655     popclass ();

5656     if (context && CLASS_TYPE_P (context))

5657       pop_nested_class ();

5658   }