GCC-3.4.6源代码学习笔记（181）

5.13.5.3.2.4.2.3.3.            构建返回变量

加入为形参构建的局部变量后，紧接着这些变量，（可能）声明用于返回的变量。

 

expand_call_inline (continue)

 

1467   /* Declare the return variable for the function.  */

1468   COMPOUND_BODY (stmt)

1469     = chainon (COMPOUND_BODY (stmt),

1470               declare_return_variable (id, return_slot_addr, &use_stmt));

1471 #else /* INLINER_FOR_JAVA */

      ….

1483 #endif /* INLINER_FOR_JAVA */

 

上面的 return_slot_addr ，如果使用具名返回值优化（ NRVO ）通过形参返回聚集对象时，用于指向这个对象；否则就是 NULL （在前面拷贝形参列表时，我们专门去掉了对这个对象的处理）。

 

913  #ifndef INLINER_FOR_JAVA

914  static tree

915  declare_return_variable (struct inline_data *id, tree return_slot_addr,      in tree-inline.c

916                       tree *use_stmt)

917  #else /* INLINER_FOR_JAVA */

       …

921  #endif /* INLINER_FOR_JAVA */

922  {

923    tree fn = VARRAY_TOP_TREE (id->fns);

924    tree result = DECL_RESULT (fn);

925  #if ndef INLINER_FOR_JAVA

926    tree var;

927  #endif /* not INLINER_FOR_JAVA */

928    int need_return_decl = 1;

929 

930    /* We don't need to do anything for functions that don't return

931       anything.  */

932    if (!result || VOID_TYPE_P (TREE_TYPE (result)))

933    {

934  #ifndef INLINER_FOR_JAVA

935      *use_stmt = NULL_TREE;

936  #else /* INLINER_FOR_JAVA */

       …

938  #endif /* INLINER_FOR_JAVA */

939      return NULL_TREE;

940    }

941 

942  #ifndef INLINER_FOR_JAVA

943    var = ((*lang_hooks .tree_inlining.copy_res_decl_for_inlining )

944            (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map,

945            &need_return_decl, return_slot_addr));

946 

947    /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that

948      way, when the RESULT_DECL is encountered, it will be

949      automatically replaced by the VAR_DECL.  */

950    splay_tree_insert (id->decl_map,

951                    (splay_tree_key) result,

952                    (splay_tree_value) var);

953 

954    /* Build the USE_STMT. If the return type of the function was

955       promoted, convert it back to the expected type.  */

956    if (TREE_TYPE (var) == TREE_TYPE (TREE_TYPE (fn)))

957      *use_stmt = build_stmt (EXPR_STMT, var);

958    else

959      *use_stmt = build_stmt (EXPR_STMT,

960                           build1 (NOP_EXPR, TREE_TYPE (TREE_TYPE (fn)),

961                                 var));

962    TREE_ADDRESSABLE (*use_stmt) = 1;

963 

964    /* Build the declaration statement if FN does not return an

965      aggregate.  */

966    if (need_return_decl)

967      return build_stmt (DECL_STMT, var);

968  #else /* INLINER_FOR_JAVA */

    ...

979  #endif /* INLINER_FOR_JAVA */

980    /* If FN does return an aggregate, there's no need to declare the

981      return variable; we're using a variable in our caller's frame.  */

982    else

983      return NULL_TREE;

984  }

 

如果没有返回值或返回值是 NULL ，显然什么都不用做，否则就要拷贝返回值。在对下面函数的调用中， result 是函数的返回值声明， fn 是当前被调用函数， caller 是调用者。因为调用返回聚集对象的函数，调用者需要传入返回地址（ NRVO 的做法），这个变量由调用者负责声明，我们不需要管；但其他返回值，在这里我们需要为它们声明对应的变量，因此相应设置 need_decl （ 2171 行）。

 

2147 tree

2148 cp_copy_res_decl_for_inlining (tree result,                                                                in tree.c

2149                           tree fn,

2150                           tree caller,

2151                           void* decl_map_,

2152                           int* need_decl,

2153                           tree return_slot_addr)

2154 {

2155   splay_tree decl_map = (splay_tree)decl_map_;

2156   tree var;

2157

2158   /* If FN returns an aggregate then the caller will always pass the

2159     address of the return slot explicitly. If we were just to

2160     create a new VAR_DECL here, then the result of this function

2161     would be copied (bitwise) into the variable initialized by the

2162     TARGET_EXPR. That's incorrect, so we must transform any

2163     references to the RESULT into references to the target.  */

2164

2165   /* We should have an explicit return slot iff the return type is

2166     TREE_ADDRESSABLE. See simplify_aggr_init_expr.  */

2167   if (TREE_ADDRESSABLE (TREE_TYPE (result))

2168       != (return_slot_addr != NULL_TREE))

2169     abort ();

2170

2171   *need_decl = !return_slot_addr;

2172   if (return_slot_addr)

2173   {

2174     var = build_indirect_ref (return_slot_addr, "");

2175     if (! same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (var),

2176                                              TREE_TYPE (result)))

2177       abort ();

2178   }

2179   /* Otherwise, make an appropriate copy.  */

2180   else

2181     var = copy_decl_for_inlining (result, fn, caller);

2182

2183   if (DECL_SAVED_FUNCTION_DATA (fn))

2184   {

2185     tree nrv = DECL_SAVED_FUNCTION_DATA (fn)->x_return_value;

2186     if (nrv)

2187     {

2188         /* We have a named return value; copy the name and source

2189          position so we can get reasonable debugging information, and

2190          register the return variable as its equivalent.  */

2191        if (TREE_CODE (var) == VAR_DECL

2192              /* But not if we're initializing a variable from the

2193              enclosing function which already has its own name.  */

2194            && DECL_NAME (var) == NULL_TREE)

2195        {

2196          DECL_NAME (var) = DECL_NAME (nrv);

2197          DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (nrv);

2198          DECL_ABSTRACT_ORIGIN (var) = DECL_ORIGIN (nrv);

2199          /* Don't lose initialization info.  */

2200          DECL_INITIAL (var) = DECL_INITIAL (nrv);

2201          /* Don't forget that it needs to go in the stack.  */

2202          TREE_ADDRESSABLE (var) = TREE_ADDRESSABLE (nrv);

2203        }

2204

2205        splay_tree_insert (decl_map,

2206                       (splay_tree_key) nrv,

2207                       (splay_tree_value) var);

2208     }

2209   }

2210

2211   return var;

2212 }

 

DECL_SAVED_FUNCTION_DATA 保存了描述该函数的 language_function 对象（它在被 finsh_function 调用的 save_function_data 设置）。而其中的 x_return_value 域专门用于 NRVO 的目的（它在被 check_return_expr 设置为返回值）。因为在 2174 行已经为这个返回值构建了 return_slot_addr 所指向对象的 INDRECT_REF 节点，这是真正用于返回值的对象，因此根据 x_return_value 域来设置它，并把它作为 x_return_value 的替代。

如果返回值不需要声明， declare_return_variable 将返回 NULL ，否则就是相应的 DECL_STMT ，这个 STMT 在 expand_call_inline 的 1470 行插入到为形参声明的变量后。而 use_stmt 则要在展开末尾才能插入（作为 ret_label 的对象）。

5.13.5.3.2.4.2.3.4.            拷贝函数体

在声明了对应于形参及返回值的局部变量后，可以拷贝函数体并使用这些变量替换形参及返回值，这由下面的 copy_body 函数来进行。

 

expand_call_inline (continue)

 

1485   /* After we've initialized the parameters, we insert the body of the

1486     function itself.  */

1487 #ifndef INLINER_FOR_JAVA

1488   inlined_body = &COMPOUND_BODY (stmt);

1489   while (*inlined_body)

1490     inlined_body = &TREE_CHAIN (*inlined_body);

1491   *inlined_body = copy_body (id);

1492 #else /* INLINER_FOR_JAVA */

       …

1503 #endif /* INLINER_FOR_JAVA */

1504

1505   /* After the body of the function comes the RET_LABEL. This must come

1506     before we evaluate the returned value below, because that evaluation

1507     may cause RTL to be generated.  */

1508 #ifndef INLINER_FOR_JAVA

1509   COMPOUND_BODY (stmt)

1510     = chainon (COMPOUND_BODY (stmt),

1511               build_stmt (LABEL_STMT, id->ret_label));

1512 #else /* INLINER_FOR_JAVA */

       …

1519 #endif /* INLINER_FOR_JAVA */

1520

1521   /* Finally, mention the returned value so that the value of the

1522     statement-expression is the returned value of the function.  */

1523 #ifndef INLINER_FOR_JAVA

1524   COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), use_stmt);

1525

1526   /* Close the block for the parameters.  */

1527   scope_stmt = build_stmt (SCOPE_STMT, DECL_INITIAL (fn));

1528   SCOPE_NO_CLEANUPS_P (scope_stmt) = 1;

1529   remap_block (scope_stmt, NULL_TREE, id);

1530   COMPOUND_BODY (stmt)

1531     = chainon (COMPOUND_BODY (stmt), scope_stmt);

1532 #else /* INLINER_FOR_JAVA */

 

DECL_SAVED_TREE 保存的就是代表函数体的 COMPOUND_STMT 或对等物。

 

704  static tree

705  copy_body (inline_data *id)                                                               in tree-inline.c

706  {

707    tree body;

708 

709    body = DECL_SAVED_TREE (VARRAY_TOP_TREE (id->fns));

710    walk_tree (&body, copy_body_r , id, NULL);

711  

712    return body;

713  }

 

函数 copy_body_r 的大部我们前面已经看过，除了下面对 RETURN_STMT 的处理。这里首先为前面准备的 ret_label 构建一个 GOTO_STMT 。如果有返回值，还要在 GOTO_STMT 之前插入包含了返回值表达式的 EXPR_STMT 。

 

copy_body_r (continue)

 

528  #ifndef INLINER_FOR_JAVA

529    if (TREE_CODE (*tp) == RETURN_STMT && id->ret_label)

530  #else /* INLINER_FOR_JAVA */

      …

532  #endif /* INLINER_FOR_JAVA */

533    {

534      tree return_stmt = *tp;

535      tree goto_stmt;

536 

537      /* Build the GOTO_STMT.  */

538  #ifndef INLINER_FOR_JAVA

539      goto_stmt = build_stmt (GOTO_STMT, id->ret_label);

540      TREE_CHAIN (goto_stmt) = TREE_CHAIN (return_stmt);

541      GOTO_FAKE_P (goto_stmt) = 1;

542  #else /* INLINER_FOR_JAVA */

      …

546  #endif /* INLINER_FOR_JAVA */

547 

548       /* If we're returning something, just turn that into an

549         assignment into the equivalent of the original

550         RESULT_DECL.  */

551  #ifndef INLINER_FOR_JAVA

552      if (RETURN_STMT_EXPR (return_stmt))

553      {

554         *tp = build_stmt (EXPR_STMT,

555                        RETURN_STMT_EXPR (return_stmt));

556         STMT_IS_FULL_EXPR_P (*tp) = 1;

557         /* And then jump to the end of the function.  */

558         TREE_CHAIN (*tp) = goto_stmt;

559      }

560  #else /* INLINER_FOR_JAVA */

      …

567  #endif /* INLINER_FOR_JAVA */

568      /* If we're not returning anything just do the jump.  */

569      else

570        *tp = goto_stmt;

 

在这里 RETURN_STMT 被（可能出现） EXPR_STMT 及 GOTO_STMT 所代替，不过其主要内容都在 RETURN_STMT_EXPR 域中，现在这个域转入了 EXPR_STMT 里。注意， copy_body_r 总是返回 0 ，那么 walk_tree 仍会进入这些新的 STMT 的内部（ walk_tree 执行前序遍历），把出现在原来 RETURN_STMT_EXPR 域中的 RETURN_DECL （它被视为局部变量）替换掉。

拷贝、替换完函数体后，把先前准备的 use_stmt 附上。那么内联函数的展开实际上是这样一个结果：

double retVal = inline_f1 (int a1, short a2)    =>

double retVal = { int a1; short a2; double ` 匿名返回值 `; { ` 替换后函数体 ` }; ret_lable: ` 匿名返回值 `; }

 

expand_call_inline (continue)

 

1547   /* Clean up.  */

1548   splay_tree_delete (id->decl_map);

1549   id->decl_map = st;

1550

1551   /* Although, from the semantic viewpoint, the new expression has

1552     side-effects only if the old one did, it is not possible, from

1553     the technical viewpoint, to evaluate the body of a function

1554     multiple times without serious havoc.  */

1555   TREE_SIDE_EFFECTS (expr) = 1;

1556

1557   /* Replace the call by the inlined body. Wrap it in an

1558      EXPR_WITH_FILE_LOCATION so that we'll get debugging line notes

1559     pointing to the right place.  */

1560 #ifndef INLINER_FOR_JAVA

1561   chain = TREE_CHAIN (*tp);

1562 #endif /* INLINER_FOR_JAVA */

1563   *tp = build_expr_wfl (expr, DECL_SOURCE_FILE (fn), DECL_SOURCE_LINE (fn),

1564                     /*col=*/ 0);

1565   EXPR_WFL_EMIT_LINE_NOTE (*tp) = 1;

1566 #ifndef INLINER_FOR_JAVA

1567   TREE_CHAIN (*tp) = chain;

1568 #endif /* not INLINER_FOR_JAVA */

1569   pop_srcloc ();

1570

1571   /* If the value of the new expression is ignored, that's OK. We

1572     don't warn about this for CALL_EXPRs, so we shouldn't warn about

1573     the equivalent inlined version either.  */

1574   TREE_USED (*tp) = 1;

1575

1576   /* Update callgraph if needed.  */

1577   if (id->decl)

1578   {

1579     cgraph_remove_call (id->decl, fn);

1580     cgraph_create_edges (id->decl, *inlined_body);

1581   }

1582

1583   /* Recurse into the body of the just inlined function.  */

1584   {

1585     tree old_decl = id->current_decl;

1586     id->current_decl = fn;

1587     expand_calls_inline (inlined_body, id);

1588     id->current_decl = old_decl;

1589   }

1590   VARRAY_POP (id->fns);

1591

1592   /* Don't walk into subtrees. We've already handled them above.  */

1593   *walk_subtrees = 0;

1594

1595   (*lang_hooks .tree_inlining.end_inlining) (fn);

1596

1597   /* Keep iterating.  */

1598   return NULL_TREE;

1599 }

 

上面 inlined_body 指向展开的函数体，因为其中可能有 CALL_EXPR ，继续使用 expand_calls_inline 来展开可能存在的内联函数。看到 expand_calls_inline 总是返回 NULL ，它希望 walk_tree 能完整遍历调用者函数。