5.12.5.2.2.2.1.4. 完成具现
现在继续我们模板具现例子的处理，在 前端部分的初始化 一节，我们已经看到当使用命令行选项 -frepo 时， init_repo 会产生一个 .rpo 文件，或读入一个已经存在的 .rpo 文件。下面的 repo_template_used 将在对应的 .rpo 文件中记录该模板具现的使用，这个信息将被编译器及 collect2 （ GCC 自带的链接器）在以后使用。
instantiate_class_template (continue)
5473 /* Clear this now so repo_template_used is happy. */
5474 TYPE_BEING_DEFINED (type) = 0;
5475 repo_template_used (type);
5476
5477 /* Now that the class is complete, instantiate default arguments for
5478 any member functions. We don't do this earlier because the
5479 default arguments may reference members of the class. */
5480 if (!PRIMARY_TEMPLATE_P (template))
5481 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5482 if (TREE_CODE (t) == FUNCTION_DECL
5483 /* Implicitly generated member functions will not have template
5484 information; they are not instantiations, but instead are
5485 created "fresh" for each instantiation. */
5486 && DECL_TEMPLATE_INFO (t))
5487 tsubst_default_arguments (t);
5488
5489 popclass ();
5490 pop_from_top_level ();
5491 pop_deferring_access_checks ();
5492 pop_tinst_level ();
5493
5494 if (TYPE_CONTAINS_VPTR_P (type))
5495 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
5496
5497 return type;
5498 }
然后记得通过 popclass 退出类的作用域；接着通过 pop_from_top_level 恢复原有的作用域。还有递减 tinst_depth 并通过 pop_tinst_level 更新 current_tinst_level ，它是 EXPR_WITH_FILE_LOCATION 类型的节点。因为类 C 包含 vtable ，它被视为锁定类（ keyed class ）。
从 instantiate_class_template 退出，我们回到 complete_type ，然后 layout_var_decl 。这个模板是在函数 main 中具现，因此 current_function_decl 指向该函数的作用域，那么在 layout_var_decl 的 4100 行， push_local_name 把这个变量加入函数的作用域。
948 static void
949 push_local_name (tree decl) in decl.c
950 {
951 size_t i, nelts;
952 tree t, name;
953
954 timevar_push (TV_NAME_LOOKUP);
955 if (!local_names)
956 VARRAY_TREE_INIT (local_names, 8, "local_names");
957
958 name = DECL_NAME (decl);
959
960 nelts = VARRAY_ACTIVE_SIZE (local_names);
961 for (i = 0; i < nelts; i++)
962 {
963 t = VARRAY_TREE (local_names, i);
964 if (DECL_NAME (t) == name)
965 {
966 if (!DECL_LANG_SPECIFIC (decl))
967 retrofit_lang_decl (decl);
968 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
969 if (DECL_LANG_SPECIFIC (t))
970 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
971 else
972 DECL_DISCRIMINATOR (decl) = 1;
973
974 VARRAY_TREE (local_names, i) = decl;
975 timevar_pop (TV_NAME_LOOKUP);
976 return ;
977 }
978 }
979
980 VARRAY_PUSH_TREE (local_names, decl);
981 timevar_pop (TV_NAME_LOOKUP);
982 }
上面的 local_names 是一个访问 cfun 的 language 部分 x_local_names 域的宏，这个域是一个可变的数组，保存了在由 cfun 所表示的函数中声明的布局名字。
5.12.5.2.2.2.1.5. 完成 VAR_DECL
现在我们回到了 cp_finish_decl ，曙光就在前面！
cp_finish_decl (continue)
4962 /* Output the assembler code and/or RTL code for variables and functions,
4963 unless the type is an undefined structure or union.
4964 If not, it will get done when the type is completed. */
4965 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4966 {
4967 if (TREE_CODE (decl) == VAR_DECL)
4968 maybe_commonize_var (decl);
4969
4970 make_rtl_for_nonlocal_decl (decl, init, asmspec);
4971
4972 if (TREE_CODE (type) == FUNCTION_TYPE
4973 || TREE_CODE (type) == METHOD_TYPE)
4974 abstract_virtuals_error (decl,
4975 strip_array_types (TREE_TYPE (type)));
4976 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
4977 {
…
4986 }
4987 else
4988 abstract_virtuals_error (decl, type);
4989
4990 if (TREE_CODE (decl) == FUNCTION_DECL
4991 || TREE_TYPE (decl) == error_mark_node)
4992 /* No initialization required. */
4993 ;
4994 else if (DECL_EXTERNAL (decl)
4995 && ! (DECL_LANG_SPECIFIC (decl)
4996 && DECL_NOT_REALLY_EXTERN (decl)))
4997 {
4998 if (init)
4999 DECL_INITIAL (decl) = init;
5000 }
5001 else
5002 {
5003 /* A variable definition. */
5004 if (DECL_FUNCTION_SCOPE_P (decl))
5005 {
5006 /* This is a local declaration. */
5007 maybe_inject_for_scope_var (decl);
5008 /* Initialize the local variable. */
5009 if (processing_template_decl)
5010 {
5011 if (init || DECL_INITIAL (decl) == error_mark_node)
5012 DECL_INITIAL (decl) = init;
5013 }
5014 else if (!TREE_STATIC (decl))
5015 initialize_local_var (decl, init);
5016 }
5017
5018 /* If a variable is defined, and then a subsequent
5019 definintion with external linkage is encountered, we will
5020 get here twice for the same variable. We want to avoid
5021 calling expand_static_init more than once. For variables
5022 that are not static data members, we can call
5023 expand_static_init only when we actually process the
5024 initializer. It is not legal to redeclare a static data
5025 member, so this issue does not arise in that case. */
5026 if (var_definition_p && TREE_STATIC (decl))
5027 expand_static_init (decl, init);
5028 }
5029 finish_end0:
5030
5031 /* Undo call to `pushclass' that was done in `start_decl'
5032 due to initialization of qualified member variable.
5033 i.e., Foo::x = 10; */
5034 {
5035 tree context = CP_DECL_CONTEXT (decl);
5036 if (context
5037 && TYPE_P (context)
5038 && (TREE_CODE (decl) == VAR_DECL
5039 /* We also have a pushclass done that we need to undo here
5040 if we're at top level and declare a method. */
5041 || TREE_CODE (decl) == FUNCTION_DECL)
5042 /* If size hasn't been set, we're still defining it,
5043 and therefore inside the class body; don't pop
5044 the binding level.. */
5045 && COMPLETE_TYPE_P (context)
5046 && context == current_class_type )
5047 pop_nested_class ();
5048 }
5049 }
5050
5051 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5052 reference, insert it in the statement-tree now. */
5053 if (cleanup)
5054 add_stmt (cleanup);
5055
5056 finish_end:
5057
5058 if (was_readonly)
5059 TREE_READONLY (decl) = 1;
5060
5061 /* If this was marked 'used', be sure it will be output. */
5062 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5063 mark_referenced (DECL_ASSEMBLER_NAME (decl));
5064 }
在函数剩余的代码里，为了把模板的具现 obj_ 按照局部变量来处理，在 5015 行调用了 initialize_local_var 。
698 static void
4699 initialize_local_var (tree decl, tree init) in decl.c
4700 {
4701 tree type = TREE_TYPE (decl);
4702 tree cleanup;
4703
4704 my_friendly_assert (TREE_CODE (decl) == VAR_DECL
4705 || TREE_CODE (decl) == RESULT_DECL,
4706 20021010);
4707 my_friendly_assert (!TREE_STATIC (decl), 20021010);
4708
4709 if (DECL_SIZE (decl) == NULL_TREE)
4710 {
4711 /* If we used it already as memory, it must stay in memory. */
4712 DECL_INITIAL (decl) = NULL_TREE;
4713 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4714 }
4715
4716 if (DECL_SIZE (decl) && type != error_mark_node)
4717 {
4718 int already_used;
4719
4720 /* Compute and store the initial value. */
4721 already_used = TREE_USED (decl) || TREE_USED (type);
4722
4723 /* Perform the initialization. */
4724 if (init)
4725 {
4726 int saved_stmts_are_full_exprs_p;
4727
4728 my_friendly_assert (building_stmt_tree (), 20000906);
4729 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4730 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4731 finish_expr_stmt (init);
4732 current_stmt_tree ()->stmts_are_full_exprs_p =
4733 saved_stmts_are_full_exprs_p;
4734 }
4735
4736 /* Set this to 0 so we can tell whether an aggregate which was
4737 initialized was ever used. Don't do this if it has a
4738 destructor, so we don't complain about the 'resource
4739 allocation is initialization' idiom. Now set
4740 attribute((unused)) on types so decls of that type will be
4741 marked used. (see TREE_USED, above.) */
4742 if (TYPE_NEEDS_CONSTRUCTING (type)
4743 && ! already_used
4744 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4745 && DECL_NAME (decl))
4746 TREE_USED (decl) = 0;
4747 else if (already_used)
4748 TREE_USED (decl) = 1;
4749 }
4750
4751 /* Generate a cleanup, if necessary. */
4752 cleanup = cxx_maybe_build_cleanup (decl);
4753 if (DECL_SIZE (decl) && cleanup)
4754 finish_decl_cleanup (decl, cleanup);
4755 }
这里参数 init 来自声明符中跟在“ = ”后面的部分，它是由程序员指定的初始值，而不是在前面我们看到的由编译器指定的。显然，对于我们的例子， init 是 NULL 。
接着看 4752 行的 cxx_maybe_build_cleanup 。编译器可能会插入代码来清除局部变量，在它退出其作用域时。
11215 tree
11216 cxx_maybe_build_cleanup (tree decl) in decl.c
11217 {
11218 tree type = TREE_TYPE (decl);
11219
11220 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
11221 {
11222 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11223 tree rval;
11224
11225 if (TREE_CODE (type) == ARRAY_TYPE)
11226 rval = decl;
11227 else
11228 {
11229 cxx_mark_addressable (decl);
11230 rval = build_unary_op (ADDR_EXPR, decl, 0);
11231 }
11232
11233 /* Optimize for space over speed here. */
11234 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
11235 || flag_expensive_optimizations )
11236 flags |= LOOKUP_NONVIRTUAL;
11237
11238 rval = build_delete (TREE_TYPE (rval), rval,
11239 sfk_complete_destructor, flags, 0);
11240
11241 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
11242 && ! TYPE_HAS_DESTRUCTOR (type))
11243 rval = build_compound_expr (rval, build_vbase_delete (type, decl));
11244
11245 return rval;
11246 }
11247 return NULL_TREE;
11248 }
断言 TYPE_HAS_NONTRIVIAL_DESTRUCTOR 是 true ，如果该类型的析构函数不是平凡的（对于某个类，如果我们没有定义析构函数，并且对于所有的基类及非静态数据成员， TYPE_HAS_NONTRIVIAL_DESTRUCTOR 是 false ，那么对于这个类， TYPE_HAS_NONTRIVIAL_DESTRUCTOR 返回 false ）。
这就是为什么如果析构函数不做任何事就不要定义它。虽然编译器会为你添加一个隐含的析构函数，但只要它的基类及非静态数据成员都具有平凡析构函数，它就会被标记为平凡。结果，在这里不会产生用于清除的代码。
如果期望清除操作，首先从局部变量 decl 构建出一个 ADDR_EXPR ，因为 delete 操作符总是作用于指针。在程序员使用 register 强制把变量放入寄存器的情形下， cxx_mark_addressable 将修改所产生的代码以表示把这个局部变量放入栈中。
2866 tree
2867 build_delete (tree type, tree addr, special_function_kind auto_delete, in init.c
2868 int flags, int use_global_delete)
2869 {
2870 tree expr;
2871
2872 if (addr == error_mark_node)
2873 return error_mark_node;
2874
2875 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2876 set to `error_mark_node' before it gets properly cleaned up. */
2877 if (type == error_mark_node)
2878 return error_mark_node;
2879
2880 type = TYPE_MAIN_VARIANT (type);
2881
2882 if (TREE_CODE (type) == POINTER_TYPE)
2883 {
…
2918 }
2919 else if (TREE_CODE (type) == ARRAY_TYPE)
2920 {
…
2930 }
2931 else
2932 {
2933 /* Don't check PROTECT here; leave that decision to the
2934 destructor. If the destructor is accessible, call it,
2935 else report error. */
2936 addr = build_unary_op (ADDR_EXPR, addr, 0);
2937 if (TREE_SIDE_EFFECTS (addr))
2938 addr = save_expr (addr);
2939
2940 addr = convert_force (build_pointer_type (type), addr, 0);
2941 }
2942
2943 my_friendly_assert (IS_AGGR_TYPE (type), 220);
2944
2945 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2946 {
2947 if (auto_delete != sfk_deleting_destructor)
2948 return void_zero_node;
2949
2950 return build_op_delete_call
2951 (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2952 LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL),
2953 NULL_TREE);
2954 }
2955 else
2956 {
2957 tree do_delete = NULL_TREE;
2958 tree ifexp;
2959
2960 my_friendly_assert (TYPE_HAS_DESTRUCTOR (type), 20011213);
2961
2962 /* For `::delete x', we must not use the deleting destructor
2963 since then we would not be sure to get the global `operator
2964 delete'. */
2965 if (use_global_delete && auto_delete == sfk_deleting_destructor)
2966 {
2967 /* We will use ADDR multiple times so we must save it. */
2968 addr = save_expr (addr);
2969 /* Delete the object. */
2970 do_delete = build_builtin_delete_call (addr);
2971 /* Otherwise, treat this like a complete object destructor
2972 call. */
2973 auto_delete = sfk_complete_destructor;
2974 }
2975 /* If the destructor is non-virtual, there is no deleting
2976 variant. Instead, we must explicitly call the appropriate
2977 `operator delete' here. */
2978 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2979 && auto_delete == sfk_deleting_destructor)
2980 {
2981 /* We will use ADDR multiple times so we must save it. */
2982 addr = save_expr (addr);
2983 /* Build the call. */
2984 do_delete = build_op_delete_call (DELETE_EXPR,
2985 addr,
2986 cxx_sizeof_nowarn (type),
2987 LOOKUP_NORMAL,
2988 NULL_TREE);
2989 /* Call the complete object destructor. */
2990 auto_delete = sfk_complete_destructor;
2991 }
2992 else if (auto_delete == sfk_deleting_destructor
2993 && TYPE_GETS_REG_DELETE (type))
2994 {
2995 /* Make sure we have access to the member op delete, even though
2996 we'll actually be calling it from the destructor. */
2997 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2998 LOOKUP_NORMAL, NULL_TREE);
2999 }
3000
3001 expr = build_dtor_call (build_indirect_ref (addr, NULL),
3002 auto_delete, flags);
3003 if (do_delete)
3004 expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
3005
3006 if (flags & LOOKUP_DESTRUCTOR)
3007 /* Explicit destructor call; don't check for null pointer. */
3008 ifexp = integer_one_node;
3009 else
3010 /* Handle deleting a null pointer. */
3011 ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
3012
3013 if (ifexp != integer_one_node)
3014 expr = build (COND_EXPR, void_type_node,
3015 ifexp, expr, void_zero_node);
3016
3017 return expr;
3018 }
3019 }
指示符 sfk_complete_destructor 表示析构对象但不回收内存，而 sfk_deleting_destructor 则要求回收对象的内存。如果 type 是一个类， delete 操作符可以在类里被重载（ 2993 行的断言 TYPE_GETS_REG_DELETE 会识别出这个情形）。
在 2945 行是对平凡析构函数一个特殊处理。注意到这个函数不仅用于清除越出其作用域的局部变量，还被 delete 表达式用于释放堆上分配的对象。如果没有内存需要被回收，它不做任何事（而是返回 void_zero_node ），否则仅是为 delete 表达式构建节点（类可能会重载 delete 操作符， build_op_delete_call 将找出适合使用的操作符）。
然后在调用 3001 行的 build_dtor_call 之前，首先要设置好参数 auto_delete 。看到在 2973 及 2990 行，它被设置为 sfk_complete_destructor ，表示 build_dtor_call 要找出一个析构函数来析构包括虚拟基类的整个对象。而同时 do_delete 指向这个 delete 表达式。注意到断言 TYPE_GETS_REG_DELETE 只是显示在派生树中是否有重载的 delete 操作符；它可能在基类中定义，而如果这个 delete 操作符被声明为 private ，则它不能从其派生类中访问，因此在 2997 行， build_op_delete_call 将执行这个检查。
回到 cxx_maybe_build_cleanup ，如果一个类包含虚拟基类但没有定义析构函数，那么它不会析构这些虚拟基类。但对虚拟基类的析构是必须的，因此对应的析构操作由 11243 行的 build_vbase_delete 来产生。
3108 tree
3109 build_vbase_delete (tree type, tree decl) in init.c
3110 {
3111 tree vbases = CLASSTYPE_VBASECLASSES (type);
3112 tree result;
3113 tree addr = build_unary_op (ADDR_EXPR, decl, 0);
3114
3115 my_friendly_assert (addr != error_mark_node, 222);
3116
3117 for (result = convert_to_void (integer_zero_node, NULL);
3118 vbases; vbases = TREE_CHAIN (vbases))
3119 {
3120 tree base_addr = convert_force
3121 (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases))), addr, 0);
3122 tree base_delete = build_delete
3123 TREE_TYPE (base_addr), base_addr, sfk_base_destructor,
3124 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
3125
3126 result = build_compound_expr (result, base_delete);
3127 }
3128 return result;
3129 }
再一次看到，如果我们不定义析构函数，或析构函数是平凡的，不会产生任何东西，除了回收内存的行动。而如果产生了某些代码，它被构建入一个 CLEANUP_STMT ，并插入正在构建的语句树中。
1164 void
1165 finish_decl_cleanup (tree decl, tree cleanup) in semantics.c
1166 {
1167 add_stmt (build_stmt (CLEANUP_STMT, decl, cleanup));
1168 }
1191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
