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

5.13.3.      为基本类型产生tinfo

操持完 PCH 文件，回到 finish_file 中继续为汇编代码的生成而奋斗。接下来编译器将为基本类型准备 tinfo 。

 

finish_file (continue)

 

2546     /* Otherwise, GDB can get confused, because in only knows

2547       about source for LINENO-1 lines.  */

2548     input_line -= 1;

2549  

2550     interface_unknown = 1;

2551     interface_only = 0;

2552  

2553     /* We now have to write out all the stuff we put off writing out.

2554       These include:

2555  

2556       o Template specializations that we have not yet instantiated,

2557         but which are needed.

2558       o Initialization and destruction for non-local objects with

2559         static storage duration. (Local objects with static storage

2560         duration are initialized when their scope is first entered,

2561         and are cleaned up via atexit.)

2562       o Virtual function tables. 

2563  

2564       All of these may cause others to be needed. For example,

2565       instantiating one function may cause another to be needed, and

2566       generating the initializer for an object may cause templates to be

2567       instantiated, etc., etc.  */

2568  

2569     timevar_push (TV_VARCONST);

2570  

2571     emit_support_tinfos ();

 

所有这样的 tinfo 将可以在名字空间 abi_node 中找到。在 get_tinfo_decl 中，这些 tinfo 将被串入 unemitted_tinfo_decls 。注意到数组 fundamentals 的内容是基本类型的节点，它们是在建立编译器环境时构建的。

 

1353   void

1354   emit_support_tinfos (void)                                                                                     in rtti.c

1355   {

1356     static tree *const fundamentals[] =

1357     {

1358        &void_type_node,

1359       &boolean_type_node,

1360       &wchar_type_node,

1361       &char_type_node, &signed_char_type_node, &unsigned_char_type_node,

1362       &short_integer_type_node, &short_unsigned_type_node,

1363       &integer_type_node, &unsigned_type_node,

1364       &long_integer_type_node, &long_unsigned_type_node,

1365       &long_long_integer_type_node, &long_long_unsigned_type_node,

1366       &float_type_node, &double_type_node, &long_double_type_node,

1367       0

1368     };

1369     int ix;

1370     tree bltn_type, dtor;

1371    

1372     push_nested_namespace (abi_node );

1373     bltn_type = xref_tag (class_type,

1374                       get_identifier ("__fundamental_type_info"),

1375                        true, false);

1376     pop_nested_namespace (abi_node );

1377     if (!COMPLETE_TYPE_P (bltn_type))

1378       return ;

1379     dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);

1380     if (DECL_EXTERNAL (dtor))

1381       return ;

1382     doing_runtime = 1;

1383     for (ix = 0; fundamentals[ix]; ix++)

1384     {

1385       tree bltn = *fundamentals[ix];

1386       tree bltn_ptr = build_pointer_type (bltn);

1387       tree bltn_const_ptr = build_pointer_type

1388                                (build_qualified_type (bltn, TYPE_QUAL_CONST));

1389       tree tinfo;

1390        

1391       tinfo = get_tinfo_decl (bltn);

1392       TREE_USED (tinfo) = 1;

1393       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;

1394        

1395       tinfo = get_tinfo_decl (bltn_ptr);

1396       TREE_USED (tinfo) = 1;

1397       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;

1398        

1399       tinfo = get_tinfo_decl (bltn_const_ptr);

1400       TREE_USED (tinfo) = 1;

1401       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;

1402     }

1403   }

 

看到对于每个基本类型，需要产生 3 个 tinfo ， 一个对应朴素（ plain ）类型，一个对应指针，还有一个对应常量指针。

5.13.4.      稳定中间树

下面的庞大的 DO WHILE 循环不断重复，直到没有任何相关的东西发生改变。在 2582 行， instantiate_pending_templates 具现仍未了结的模板。在前端内部，一个全局的 tree_list 链表 pending_tempaltes 保存了所有具现被延迟的模板，它们要么定义还未知，要么我们推迟了这个具现。每个节点的 tree_purose 或者是一个 DECL （对于一个函数或者静态数据成员），或一个 TYPE （对于一个类），它代表我们所期望的具现形式。而 tree_value 不被使用。

 

finish_file (continue)

 

2573     do

2574     {

2575       tree t;

2576       size_t n_old, n_new;

2577  

2578       reconsider = false;

2579  

2580       /* If there are templates that we've put off instantiating, do

2581         them now.  */

2582       instantiate_pending_templates ();

2583       ggc_collect ();

2584  

2585       /* Write out virtual tables as required. Note that writing out

2586          the virtual table for a template class may cause the

2587         instantiation of members of that class. If we write out

2588          vtables then we remove the class from our list so we don't

2589          have to look at it again.  */

2590  

2591       while (keyed_classes != NULL_TREE

2592              && maybe_emit_vtables (TREE_VALUE (keyed_classes )))

2593       {

2594         reconsider = true;

2595         keyed_classes = TREE_CHAIN (keyed_classes );

2596       }

2597  

2598       t = keyed_classes ;

2599       if (t != NULL_TREE)

2600        {

2601         tree next = TREE_CHAIN (t);

2602  

2603         while (next)

2604           {

2605             if (maybe_emit_vtables (TREE_VALUE (next)))

2606            {

2607              reconsider = true;

2608              TREE_CHAIN (t) = TREE_CHAIN (next);

2609            }

2610            else

2611              t = next;

2612  

2613            next = TREE_CHAIN (t);

2614         }

2615       }

2616  

2617      /* Write out needed type info variables. We have to be careful

2618         looping through unemitted decls, because emit_tinfo_decl may

2619         cause other variables to be needed. We stick new elements

2620         (and old elements that we may need to reconsider) at the end

2621        of the array, then shift them back to the beginning once we're

2622         done.  */

2623    

2624       n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls );

2625       for (i = 0; i < n_old; ++i)

2626       {

2627         tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls , i);

2628         if (emit_tinfo_decl (tinfo_decl))

2629           reconsider = true;

2630         else

2631           VARRAY_PUSH_TREE (unemitted_tinfo_decls , tinfo_decl);

2632       }

2633    

2634        /* The only elements we want to keep are the new ones. Copy

2635         them to the beginning of the array, then get rid of the

2636         leftovers.  */

2637       n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls ) - n_old;

2638       if (n_new)

2639         memmove (&VARRAY_TREE (unemitted_tinfo_decls , 0),

2640                   &VARRAY_TREE (unemitted_tinfo_decls , n_old),

2641                   n_new * sizeof (tree));

2642       memset (&VARRAY_TREE (unemitted_tinfo_decls , n_new),

2643               0, n_old * sizeof (tree));

2644       VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls ) = n_new;

2645  

2646       /* The list of objects with static storage duration is built up

2647          i n reverse order. We clear STATIC_AGGREGATES so that any new

2648          aggregates added during the initialization of these will be

2649          initialized in the correct order when we next come around the

2650          loop.  */

2651       vars = prune_vars_needing_no_initialization (&static_aggregates );

2652  

2653       if (vars)

2654       {

2655         tree v;

2656  

2657          /* We need to start a new initialization function each time

2658           through the loop. That's because we need to know which

2659            vtables have been referenced, and TREE_SYMBOL_REFERENCED

2660            isn't computed until a function is finished, and written

2661            out. That's a deficiency in the back-end. When this is

2662            fixed, these initialization functions could all become

2663            inline, with resulting performance improvements.  */

2664         tree ssdf_body;

2665  

2666          /* Set the line and file, so that it is obviously not from

2667            the source file.  */

2668         input_location = locus;

2669         ssdf_body = start_static_storage_duration_function (ssdf_count);

2670  

2671         /* Make sure the back end knows about all the variables.  */

2672         write_out_vars (vars);

2673  

2674         /* First generate code to do all the initializations.  */

2675         for (v = vars; v; v = TREE_CHAIN (v))

2676           do_static_initialization (TREE_VALUE (v),

2677                               TREE_PURPOSE (v));

2678  

2679         /* Then, generate code to do all the destructions. Do these

2680            i n reverse order so that the most recently constructed

2681            variable is the first destroyed. If we're using

2682            __cxa_atexit, then we don't need to do this; functions

2683            were registered at initialization time to destroy the

2684            local statics.  */

2685         if (!flag_use_cxa_atexit )

2686         {

2687           vars = nreverse (vars);

2688           for (v = vars; v; v = TREE_CHAIN (v))

2689             do_static_destruction (TREE_VALUE (v));

2690         }

2691         else

2692           vars = NULL_TREE;

2693  

2694          /* Finish up the static storage duration function for this

2695            round.  */

2696         input_location = locus;

2697         finish_static_storage_duration_function (ssdf_body);

2698  

2699         /* All those initializations and finalizations might cause

2700            us to need more inline functions, more template

2701            instantiations, etc.  */

2702         reconsider = true;

2703         ssdf_count++;

2704         locus.line++;

2705       }

2706        

2707       for (i = 0; i < deferred_fns_used ; ++i)

2708       {

2709         tree decl = VARRAY_TREE (deferred_fns , i);

2710  

2711         /* Does it need synthesizing?  */

2712         if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)

2713            && TREE_USED (decl)

2714            && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))

2715         {

2716           /* Even though we're already at the top-level, we push

2717              there again. That way, when we pop back a few lines

2718              hence, all of our state is restored. Otherwise,

2719              finish_function doesn't clean things up, and we end

2720              up with CURRENT_FUNCTION_DECL set.  */

2721           push_to_top_level ();

2722           synthesize_method (decl);

2723           pop_from_top_level ();

2724           reconsider = true;

2725         }

2726  

2727         /* If the function has no body, avoid calling

2728            import_export_decl. On a system without weak symbols,

2729            calling import_export_decl will make an inline template

2730            instantiation "static", which will result in errors about

2731            the use of undefined functions if there is no body for

2732            the function.  */

2733         if (!DECL_SAVED_TREE (decl))

2734           continue ;

2735  

2736         import_export_decl (decl);

2737  

2738         /* We lie to the back-end, pretending that some functions

2739            are not defined when they really are. This keeps these

2740            functions from being put out unnecessarily. But, we must

2741            stop lying when the functions are referenced, or if they

2742            are not comdat since they need to be put out now. This

2743            is done in a separate for cycle, because if some deferred

2744            function is contained in another deferred function later

2745            i n deferred_fns varray, rest_of_compilation would skip

2746            this function and we really cannot expand the same

2747            function twice.  */

2748         if (DECL_NOT_REALLY_EXTERN (decl)

2749            && DECL_INITIAL (decl)

2750            && DECL_NEEDED_P (decl))

2751           DECL_EXTERNAL (decl) = 0;

2752  

2753         /* If we're going to need to write this function out, and

2754             there's already a body for it, create RTL for it now.

2755            (There might be no body if this is a method we haven't

2756            gotten around to synthesizing yet.)  */

2757         if (!DECL_EXTERNAL (decl)

2758            && DECL_NEEDED_P (decl)

2759            && DECL_SAVED_TREE (decl)

2760            && !TREE_ASM_WRITTEN (decl)

2761            && (!flag_unit_at_a_time

2762                || !cgraph_node (decl)->local.finalized))

2763         {

2764           /* We will output the function; no longer consider it in this

2765              loop.  */

2766           DECL_DEFER_OUTPUT (decl) = 0;

2767           /* Generate RTL for this function now that we know we

2768             need it.  */

2769           expand_or_defer_fn (decl);

2770           /* If we're compiling -fsyntax-only pretend that this

2771              function has been written out so that we don't try to

2772              expand it again.  */

2773           if (flag_syntax_only )

2774             TREE_ASM_WRITTEN (decl) = 1;

2775            reconsider = true;

2776         }

2777       }

2778  

2779       if (walk_namespaces (wrapup_globals_for_namespace , /*data=*/ 0))

2780         reconsider = true;

2781  

2782        /* Static data members are just like namespace-scope globals.  */

2783       for (i = 0; i < pending_statics_used ; ++i)

2784       {

2785         tree decl = VARRAY_TREE (pending_statics , i);

2786         if (var_finalized_p (decl))

2787           continue ;

2788         import_export_decl (decl);

2789         if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))

2790           DECL_EXTERNAL (decl) = 0;

2791       }

2792       if (pending_statics

2793          && wrapup_global_declarations (&VARRAY_TREE (pending_statics , 0),

2794                                     pending_statics_used ))

2795       reconsider = true;

2796  

2797       if (cgraph_assemble_pending_functions ())

2798         reconsider = true;

2799     }

2800     while (reconsider);

5.13.4.1.              迭代 – 发布 vtable

首先，使用中的 vtable 应该被标记，以使编译器为之产生代码。在前面的章节中，我们已经看到对于一个类，其 CLASSTYPE_VTABLES 可能包含了一串 vtable 。这依赖于其基类及其定义。而如果一个类包含了 vtable ，它也同样被记录在 keyed_classes 链表中。在 1565 行， primary_vtbl 指向 ctype 的 vtable 列表。

 

1556   static bool

1557   maybe_emit_vtables (tree ctype)                                                               in decl2.c

1558   {

1559     tree vtbl;

1560     tree primary_vtbl;

1561     bool needed = false;

1562  

1563     /* If the vtables for this class have already been emitted there is

1564       nothing more to do.  */

1565     primary_vtbl = CLASSTYPE_VTABLES (ctype);

1566     if (var_finalized_p (primary_vtbl))

1567       return false;

1568     /* Ignore dummy vtables made by get_vtable_decl.  */

1569     if (TREE_TYPE (primary_vtbl) == void_type_node)

1570       return false;

1571  

1572     import_export_class (ctype);

1573  

1574     /* See if any of the vtables are needed.  */

1575     for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))

1576     {

1577       import_export_vtable (vtbl, ctype, 1);

1578       if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))

1579         break ;

1580     }

1581     if (!vtbl)

1582     {

1583       /* If the references to this class' vtables are optimized away,

1584         still emit the appropriate debugging information. See

1585         dfs_debug_mark.  */

1586       if (DECL_COMDAT (primary_vtbl)

1587          && CLASSTYPE_DEBUG_REQUESTED (ctype))

1588         note_debug_info_needed (ctype);

1589       return false;

1590     }

1591     else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl))

1592       needed = true;

 

所有的 vtable 都被编译器声明为公有的 VAR_DECL ，这样类型的节点通过 cgraph_varpool_node 关联起来，在其中如果标记 finalized 被设置，就意味着已经为该节点输出代码。

 

1544   static bool

1545   var_finalized_p (tree var)                                                                         in decl2.c

1546   {

1547     if (flag_unit_at_a_time )

1548       return cgraph_varpool_node (var)->finalized;

1549     else

1550       return TREE_ASM_WRITTEN (var);

1551   }

 

如果 flag_unit_at_a_time 不是 0 ，则为这个 VAR_DECL 构建一个 cgraph_varpool_node 。 在下面，哈希表 cgraph_varpool_hash 是 cgraph_varpool_node 的一个队列，它由 GC 管理。

 

441    struct cgraph_varpool_node *

442    cgraph_varpool_node (tree decl)                                                                in cgraph.c

443    {

444      struct cgraph_varpool_node *node;

445      struct cgraph_varpool_node **slot;

446   

447      if (!DECL_P (decl) || TREE_CODE (decl) == FUNCTION_DECL)

448        abort ();

449   

450      if (!cgraph_varpool_hash)

451        cgraph_varpool_hash = htab_create_ggc (10, cgraph_varpool_hash_node,

452                                         eq_cgraph_varpool_node, NULL);

453      slot = (struct cgraph_varpool_node **)

454        htab_find_slot_with_hash (cgraph_varpool_hash , DECL_ASSEMBLER_NAME (decl),

455                             IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (decl)),

456                             INSERT);

457      if (*slot)

458        return *slot;

459      node = ggc_alloc_cleared (sizeof (*node));

460      node->decl = decl;

461      cgraph_varpool_n_nodes ++;

462      cgraph_varpool_nodes = node;

463      *slot = node;

464      return node;

465    }

 

而结构体 cgraph_varpool_node 具有以下的定义。

 

134    struct cgraph_varpool_node GTY(())                                                         in cgraph.h

135    {

136      tree decl;

137      /* Pointer to the next function in cgraph_varpool_nodes_queue.  */

138      struct cgraph_varpool_node *next_needed;

139   

140      /* Set when function must be output - it is externally visible

141        or it's address is taken.  */

142      bool needed;

143      /* Set once it has been finalized so we consider it to be output.  */

144      bool finalized;

145      /* Set when function is scheduled to be assembled.  */

146      bool output;

147    };

 

上面的 1572 行， import_export_class 确定是否需要在这个编译单元发布该类的整套内容；或者只是发布一个签名，而在链接时刻解析这些引用。

记得编译选项 -fno-implicit-templates 表示不要为隐式具现的非内联模板发布代码。对于这个情形，我们设置 import_export 为 -1 要限制其代码发布。

接着需要确定指定的 vtable 是否是外部的（即便类本身是外部定义的，一旦其某一基类是定义在这个编译单元中，并在这里发布 vtable ，该类的 vtable 也需要在这里发布）。

 

1442   void

1443   import_export_vtable (tree decl, tree type, int final)                                     in decl2.c

1444   {

1445     if (DECL_INTERFACE_KNOWN (decl))

1446       return ;

1447  

1448     if (TYPE_FOR_JAVA (type))

1449     {

1450       TREE_PUBLIC (decl) = 1;

1451       DECL_EXTERNAL (decl) = 1;

1452       DECL_INTERFACE_KNOWN (decl) = 1;

1453     }

1454     else if (CLASSTYPE_INTERFACE_KNOWN (type))

1455     {

1456       TREE_PUBLIC (decl) = 1;

1457       DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);

1458       DECL_INTERFACE_KNOWN (decl) = 1;

1459     }

1460     else

1461     {

1462       /* We can only wait to decide if we have real non-inline virtual

1463          functions in our class, or if we come from a template.  */

1464  

1465       int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)

1466                  || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);

1467  

1468       if (final || ! found)

1469       {

1470         comdat_linkage (decl);

1471         DECL_EXTERNAL (decl) = 0;

1472       }

1473       else

1474       {

1475         TREE_PUBLIC (decl) = 1;

1476         DECL_EXTERNAL (decl) = 1;

1477       }

1478     }

1479   }

 

在函数 import_export_vtable 为代表 vtable 的 VAR_DECL 设置了相应标记后， DECL_NEEDED_P 分辨这个 vtable 是否需要发布。断言 DECL_COMDAT 如果成立，表示就是具有 TREE_PUBLIC 属性，也不需要发布，除非这个编译单元需要。类似这样的实体在编译单元间共享（类似弱实体），但保证为任何需要它们的编译单元所产生， 因此不需要在不需要它们的地方发布。 DECL_COMDAT 只是给后端的一个暗示；由前端自由设置这个标记，它保证除了发布 DECL_COMDAT 的对象使得代码膨胀外，对代码没有别的坏处。

 

1730   #define DECL_NEEDED_P (DECL)                               /                           in cp-tree.h

1731     ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL))      /

1732      || (DECL_ASSEMBLER_NAME_SET_P (DECL)                            /

1733        && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (DECL)))/

1734      || (((flag_syntax_only || flag_unit_at_a_time ) && TREE_USED (DECL))))

 

如果 vtable 列表中有任一 vtable 需要发布代码，编译器将为所有的 vtable 发布代码。在这里标记它们。

 

maybe_emit_vtables (continue)

 

1595     /* The ABI requires that we emit all of the vtables if we emit any

1596       of them.  */

1597     for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))

1598     {

1599        /* Write it out.  */

1600       import_export_vtable (vtbl, ctype, 1);

1601       mark_vtable_entries (vtbl);

1602  

1603       /* If we know that DECL is needed, mark it as such for the varpool.  */

1604       if (needed)

1605         cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl));

1606  

1607       if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)

1608       {

1609          /* It had better be all done at compile-time.  */

1610         if (store_init_value (vtbl, DECL_INITIAL (vtbl)))

1611           abort ();

1612       }

1613  

1614       if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)

1615       {

1616         /* Mark the VAR_DECL node representing the vtable itself as a

1617          "gratuitous" one, thereby forcing dwarfout.c to ignore it.

1618          It is rather important that such things be ignored because

1619          any effort to actually generate DWARF for them will run

1620          into trouble when/if we encounter code like:

1621  

1622           #pragma interface

1623          struct S { virtual void member (); };

1624  

1625          because the artificial declaration of the vtable itself (as

1626          manufactured by the g++ front end) will say that the vtable

1627          is a static member of `S' but only *after* the debug output

1628          for the definition of `S' has already been output. This causes

1629          grief because the DWARF entry for the definition of the vtable

1630          will try to refer back to an earlier *declaration* of the

1631          vtable as a static member of `S' and there won't be one.

1632          We might be able to arrange to have the "vtable static member"

1633          attached to the member list for `S' before the debug info for

1634          `S' get written (which would solve the problem) but that would

1635          require more intrusive changes to the g++ front end.  */

1636  

1637         DECL_IGNORED_P (vtbl) = 1;

1638       }

1639  

1640       /* Always make vtables weak.  */

1641       if (flag_weak )

1642         comdat_linkage (vtbl);

1643  

1644       rest_of_decl_compilation (vtbl, NULL, 1, 1);

1645  

1646       /* Because we're only doing syntax-checking, we'll never end up

1647         actually marking the variable as written.  */

1648       if (flag_syntax_only )

1649         TREE_ASM_WRITTEN (vtbl) = 1;

1650     }

1651  

1652     /* Since we're writing out the vtable here, also write the debug

1653       info.  */

1654     note_debug_info_needed (ctype);

1655  

1656     return true;

1657   }

 

下面的函数只是把虚函数标记为可寻址，并设置 in-used 标记来表示编译器需要在后面发布代码。记得总是为 vtable 的初始值构建 CONSTRUCTOR 节点，在调试模式中 CONSTRUCTOR_ELTS 可以执行额外的检查来保证这确实是 CONSTRUCTOR 实体，并获取 vtable 的初始值（参考 initialize_vtable 或 build_vtt 中的 initialize_array 。至于初始值的例子，参考 5.12.5.2.2.2.1.3.11.完成派生类 RECORD_TYPE – 完成 vtable 一节）。

 

1323   static void

1324   mark_vtable_entries (tree decl)                                                                 in decl2.c

1325   {

1326     tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));

1327  

1328     for (; entries; entries = TREE_CHAIN (entries))

1329     {

1330       tree fnaddr = TREE_VALUE (entries);

1331       tree fn;

1332  

1333       STRIP_NOPS (fnaddr);

1334  

1335       if (TREE_CODE (fnaddr) != ADDR_EXPR

1336          && TREE_CODE (fnaddr) != FDESC_EXPR)

1337         /* This entry is an offset: a virtual base class offset, a

1338           virtual call offset, an RTTI offset, etc.  */

1339         continue ;

1340  

1341       fn = TREE_OPERAND (fnaddr, 0);

1342       TREE_ADDRESSABLE (fn) = 1;

1343       /* When we don't have vcall offsets, we output thunks whenever

1344         we output the vtables that contain them. With vcall offsets,

1345         we know all the thunks we'll need when we emit a virtual

1346         function, so we emit the thunks there instead.  */

1347       if (DECL_THUNK_P (fn))

1348         use_thunk (fn, /*emit_p=*/ 0);

1349       mark_used (fn);

1350     }

1351   }

 

把 decl 标记为在用可以帮助编译器在后面的优化中移除不使用的代码。这个标记在下面的 2982 行设置。而对于未发布的内联函数（一般而言，除了主管构造函数及析构函数外，内联函数此时都未发布。考虑内联函数定义在头文件中，而头文件可能在同一个编译单元不同的源文件中多处被引用，把它的处理推迟到前端最后完成编译单元的时刻，很有必要。虽然此处调用 mark_used 的地方其实已经前端所执行的最后阶段，但 mark_used 在前端中很多地方被调用），把它缓存入 deferred_fns 。在 2991 行，对于 x86 机器上的 Linux ， assemble_external 是无关重要的。在前面的章节中，我们已经看到编译器会“人工”产生方法（比如，类里的克隆构造函数及析构函数），这样的方法不会自己运行，而是通过用户定义的方法来触发（由 current_function_decl 指向）。在 2998 行，如果 DECL_INITIAL 是空的，这意味着函数还没有被调用序列： start_function ， begin_function_body ， begin_compound_stmt || finish_compound_stmt ] ， finish_function_body ， finish_function 所处理——即没有构建相应的 STMT 节点，并把它链入其触发者的 STMT 链表中。而在下面， synthesize_method 调用上面提及的调用序列来为这些函数产生必要的 STMT 节点，仿佛它来自用户的定义。接着，在 2983 行的 skip_evaluation 被解析器设置。在 C++ 中，存在不要求评估（ evalutaion ）的声明或表达式，例如，在操作符 sizeof 或 typeof 中的表达式。

 

2967   void

2968   mark_used (tree decl)                                                                               in decl2.c

2969   {

2970     /* If DECL is a BASELINK for a single function, then treat it just

2971       like the DECL for the function. Otherwise, if the BASELINK is

2972       for an overloaded function, we don't know which function was

2973       actually used until after overload resolution.  */

2974     if (TREE_CODE (decl) == BASELINK)

2975     {

2976       decl = BASELINK_FUNCTIONS (decl);

2977       if (really_overloaded_fn (decl))

2978         return ;

2979       decl = OVL_CURRENT (decl);

2980     }

2981  

2982     TREE_USED (decl) = 1;

2983     if (processing_template_decl || skip_evaluation )

2984       return ;

2985  

2986     if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)

2987         && !TREE_ASM_WRITTEN (decl))

2988        /* Remember it, so we can check it was defined.  */

2989       defer_fn (decl);

2990  

2991     assemble_external (decl);

2992  

2993     /* Is it a synthesized method that needs to be synthesized?  */

2994     if (TREE_CODE (decl) == FUNCTION_DECL

2995         && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)

2996         && DECL_ARTIFICIAL (decl)

2997         && !DECL_THUNK_P (decl)

2998         && ! DECL_INITIAL (decl)

2999         /* Kludge: don't synthesize for default args.  */

3000         && current_function_decl )

3001     {

3002       synthesize_method (decl);

3003       /* If we've already synthesized the method we don't need to

3004          instantiate it, so we can return right away.  */

3005       return ;

3006     }

3007  

3008     /* If this is a function or variable that is an instance of some

3009       template, we now know that we will need to actually do the

3010       instantiation. We check that DECL is not an explicit

3011       instantiation because that is not checked in instantiate_decl.  */

3012     if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)

3013         && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)

3014         && (!DECL_EXPLICIT_INSTANTIATION (decl)

3015             || (TREE_CODE (decl) == FUNCTION_DECL

3016                && DECL_INLINE (DECL_TEMPLATE_RESULT

3017                      (template_for_substitution (decl))))))

3018     {

3019       bool defer;

3020  

3021       /* Normally, we put off instantiating functions in order to

3022         improve compile times. Maintaining a stack of active

3023          functions is expensive, and the inliner knows to

3024          instantiate any functions it might need.

3025  

3026          However, if instantiating this function might help us mark

3027          the current function TREE_NOTHROW, we go ahead and

3028          instantiate it now. 

3029       

3030          This is not needed for unit-at-a-time since we reorder the functions

3031          i n topological order anyway.

3032        */

3033       defer = (!flag_exceptions

3034               || flag_unit_at_a_time

3035               || !optimize

3036               || TREE_CODE (decl) != FUNCTION_DECL

3037               /* If the called function can't throw, we don't need to

3038                  generate its body to find that out.  */

3039               || TREE_NOTHROW (decl)

3040               || !cfun

3041               || !current_function_decl

3042               /* If we already know the current function can't throw,

3043                  then we don't need to work hard to prove it.  */

3044               || TREE_NOTHROW (current_function_decl )

3045                /* If we already know that the current function *can*

3046                  throw, there's no point in gathering more

3047                  information.  */

3048               || cp_function_chain ->can_throw);

3049  

3050       instantiate_decl (decl, defer);

3051     }

3052   }

 

我们已经看过 thunk 是一个编译器产生的函数，也应该为它发布代码。不过，在这次调用中，参数 emit_p 是 false ，结果仅是把 thunk 标记为在用，而没有真正为之发布代码。

 

336    void

337    use_thunk (tree thunk_fndecl, bool emit_p)                                                in method.c

338    {

339      tree function, alias;

340      tree virtual_offset;

341      HOST_WIDE_INT fixed_offset, virtual_value;

342      bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);

343   

344      /* We should have called finish_thunk to give it a name.  */

345      my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);

346   

347      /* We should never be using an alias, always refer to the

348        aliased thunk.  */

349      my_friendly_assert (!THUNK_ALIAS (thunk_fndecl), 20031023);

350   

351      if (TREE_ASM_WRITTEN (thunk_fndecl))

352        return ;

353     

354      function = THUNK_TARGET (thunk_fndecl);

355      if (DECL_RESULT (thunk_fndecl))

356        /* We already turned this thunk into an ordinary function.

357          There's no need to process this thunk again.  */

358        return ;

359   

360      if (DECL_THUNK_P (function))

361        /* The target is itself a thunk, process it now.  */

362        use_thunk (function, emit_p);

363     

364      /* Thunks are always addressable; they only appear in vtables.  */

365      TREE_ADDRESSABLE (thunk_fndecl) = 1;

366   

367      /* Figure out what function is being thunked to. It's referenced in

368        this translation unit.  */

369      TREE_ADDRESSABLE (function) = 1;

370      mark_used (function);

371      if (!emit_p)

372        return ;

       …

524    }

 

如果该 vtable 是公有的，而且不是编译单元间共享的，在 maybe_emit_vtables 的 1592 行设置 needed ，然后在 1605 行，调用下面的函数来设置相关联的 cgraph_varpool_node 节点的 needed 标记。

 

568    void

569    cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *node)      in cgraph.c

570    {

571      if (!node->needed && node->finalized)

572      {

573        node->next_needed = cgraph_varpool_nodes_queue ;

574        cgraph_varpool_nodes_queue = node;

575        notice_global_symbol (node->decl);

576      }

577      node->needed = 1;

578    }

 

接着在 maybe_emit_vtables 的 1644 行，调用 rest_of_decl_compilation 根据中间节点来构建对应的 RTL 节点，并如果需要，发布汇编代码（标签定义，存储分配及初始化）。在这里，参数 top_level 及 at_end 都是 1 ，而 asmspec 为 NULL 。注意到在 1957 行，对于 x86/Linux ，没有定义 ASM_FINISH_DECLARE_OBJECT 。

 

1910   void

1911   rest_of_decl_compilation (tree decl,                                                         in toplev.c

1912                         const char *asmspec,

1913                         int top_level,

1914                         int at_end)

1915   {

1916     /* We deferred calling assemble_alias so that we could collect

1917       other attributes such as visibility. Emit the alias now.  */

1918     {

1919       tree alias;

1920       alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));

1921       if (alias)

1922       {

1923         alias = TREE_VALUE (TREE_VALUE (alias));

1924         alias = get_identifier (TREE_STRING_POINTER (alias));

1925         assemble_alias (decl, alias);

1926       }

1927     }

1928  

1929     /* Forward declarations for nested functions are not "external",

1930       but we need to treat them as if they were.  */

1931     if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)

1932         || TREE_CODE (decl) == FUNCTION_DECL)

1933     {

1934       timevar_push (TV_VARCONST);

1935  

1936       if (asmspec)

1937         make_decl_rtl (decl, asmspec);

1938  

1939       /* Don't output anything when a tentative file-scope definition

1940         is seen. But at end of compilation, do output code for them.

1941  

1942         We do output all variables when unit-at-a-time is active and rely on

1943         callgraph code to defer them except for forward declarations

1944         (see gcc.c-torture/compile/920624-1.c) */

1945       if ((at_end

1946            || !DECL_DEFER_OUTPUT (decl)

1947            || (flag_unit_at_a_time && DECL_INITIAL (decl)))

1948          && !DECL_EXTERNAL (decl))

1949       {

1950         if (flag_unit_at_a_time && !cgraph_global_info_ready

1951            && TREE_CODE (decl) != FUNCTION_DECL && top_level)

1952           cgraph_varpool_finalize_decl (decl);

1953         else

1954           assemble_variable (decl, top_level, at_end, 0);

1955       }

1956  

1957   #ifdef ASM_FINISH_DECLARE_OBJECT

       …

1963   #endif

1964  

1965       timevar_pop (TV_VARCONST);

1966     }

1967     else if (DECL_REGISTER (decl) && asmspec != 0)

1968     {

1969       if (decode_reg_name (asmspec) >= 0)

1970       {

1971         SET_DECL_RTL (decl, NULL_RTX);

1972         make_decl_rtl (decl, asmspec);

1973       }

1974       else

1975       {

1976         error ("invalid register name `%s' for register variable", asmspec);

1977         DECL_REGISTER (decl) = 0;

1978          if (!top_level)

1979           expand_decl (decl);

1980       }

1981     }

        …

2011   }

 

在 1950 行，当整个单元已经被分析过了， cgraph_global_info_ready 就不是 0 ，因此我们可以访问全局的信息（在当前情形下，它依旧是 false ）。而 1946 行的断言 DECL_DEFER_OUTPUT 如果不是 0 ，表示这个 decl 的链接性状况还是未知的，因此它也不应该在现在发布。

因为 vtable 是一个 VAR_DECL ，调用下面的函数来设置相关联的 cgraph_varpool_node 节点的 finialized 标记，来表示将要为之输出代码。

 

580    void

581    cgraph_varpool_finalize_decl (tree decl)                                                     in cgraph.c

582    {

583      struct cgraph_varpool_node *node = cgraph_varpool_node (decl);

584   

585      /* The first declaration of a variable that comes through this function

586        decides whether it is global (in C, has external linkage)

587        or local (in C, has internal linkage). So do nothing more

588        if this function has already run.  */

589      if (node->finalized)

590        return ;

591      if (node->needed)

592      {

593        node->next_needed = cgraph_varpool_nodes_queue ;

594        cgraph_varpool_nodes_queue = node;

595        notice_global_symbol (decl);

596      }

597      node->finalized = true;

598   

599      if (/* Externally visible variables must be output. The exception are

600           COMDAT functions that must be output only when they are needed.  */

601         (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))

602           /* Function whose name is output to the assembler file must be produced.

603            It is possible to assemble the name later after finalizing the function

604            and the fact is noticed in assemble_name then.  */

605          || (DECL_ASSEMBLER_NAME_SET_P (decl)

606            && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))

607      {

608        cgraph_varpool_mark_needed_node (node);

609      }

610    }

 

因为上面在 maybe_emit_vtables 的 1605 行，已经为需要输出的 vtable 调用了 cgraph_varpool_mark_needed_node ；因此对于这样的 vtable ，其 cgraph 节点中的 needed 标记是 true ，在这里这个节点也会被链入 cgraph_varpool_nodes_queue （看到在 cgraph_varpool_mark_needed_node 的 571 行，链入的条件是“ (!node->needed && node->finalized) ”，如果那时没有链入，那么现在在这里链入）；在 608 行，该 vtable 再次被 cgraph_varpool_mark_needed_node 处理，确保 cgraph 节点链入 cgraph_varpool_nodes_queue 。

注意到一旦 maybe_emit_vtables 成功处理了这个类，就把它从 keyed_classes 中移走，同时强制进行下一次的迭代。