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 中移走，同时强制进行下一次的迭代。
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
