5.12.3.2.1.2. 完成解析
5.12.3.2.1.2.1. 延迟的内联函数解析
对类“ SingleThreaded ”余下方法的解析基本上与我们已见到的一样。因此我们跳过这些声明，并假设现在解析器看到了类结尾的“ } ”。除了与结构体“ Lock ”相似的处理外，类“ SingleThreaded ”，作为最顶层的类，将经受如下的处理。
cp_parser_class_specifier (continue)
11928 /* If this class is not itself within the scope of another class,
11929 then we need to parse the bodies of all of the queued function
11930 definitions. Note that the queued functions defined in a class
11931 are not always processed immediately following the
11932 class-specifier for that class. Consider:
11933
11934 struct A {
11935 struct B { void f() { sizeof (A); } };
11936 };
11937
11938 If `f' were processed before the processing of `A' were
11939 completed, there would be no way to compute the size of `A'.
11940 Note that the nesting we are interested in here is lexical --
11941 not the semantic nesting given by TYPE_CONTEXT. In particular,
11942 for:
11943
11944 struct A { struct B; };
11945 struct A::B { void f() { } };
11946
11947 there is no need to delay the parsing of `A::B::f'. */
11948 if (--parser->num_classes_being_defined == 0)
11949 {
11950 tree queue_entry;
11951 tree fn;
11952
11953 /* In a first pass, parse default arguments to the functions.
11954 Then, in a second pass, parse the bodies of the functions.
11955 This two-phased approach handles cases like:
11956
11957 struct S {
11958 void f() { g(); }
11959 void g(int i = 3);
11960 };
11961
11962 */
11963 for (TREE_PURPOSE (parser->unparsed_functions_queues)
11964 = nreverse (TREE_PURPOSE (parser->unparsed_functions_queues));
11965 (queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues));
11966 TREE_PURPOSE (parser->unparsed_functions_queues)
11967 = TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues)))
11968 {
11969 fn = TREE_VALUE (queue_entry);
11970 /* Make sure that any template parameters are in scope. */
11971 maybe_begin_member_template_processing (fn);
11972 /* If there are default arguments that have not yet been processed,
11973 take care of them now. */
11974 cp_parser_late_parsing_default_args (parser, fn);
11975 /* Remove any template parameters from the symbol table. */
11976 maybe_end_member_template_processing ();
11977 }
11978 /* Now parse the body of the functions. */
11979 for (TREE_VALUE (parser->unparsed_functions_queues)
11980 = nreverse (TREE_VALUE (parser->unparsed_functions_queues));
11981 (queue_entry = TREE_VALUE (parser->unparsed_functions_queues));
11982 TREE_VALUE (parser->unparsed_functions_queues)
11983 = TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues)))
11984 {
11985 /* Figure out which function we need to process. */
11986 fn = TREE_VALUE (queue_entry);
11987
11988 /* A hack to prevent garbage collection. */
11989 function_depth ++;
11990
11991 /* Parse the function. */
11992 cp_parser_late_parsing_for_member (parser, fn);
11993 function_depth --;
11994 }
11995
11996 }
11997
11998 /* Put back any saved access checks. */
11999 pop_deferring_access_checks ();
12000
12001 /* Restore the count of active template-parameter-lists. */
12002 parser->num_template_parameter_lists
12003 = saved_num_template_parameter_lists;
12004
12005 return type;
12006 }
parser 的 unparsed_functions_queues 是一个 tree_list 节点，其 TREE_PURPOSE 域是记录函数默认参数的链表，而其 TREE_VALUE 域则记录了定义在类定义体中的内联函数。注意这 2 个链表是相互独立的。对于内联函数，记录它的 tree_list 节点的 TREE_VALUE 域是一个 METHOD_TYPE 节点（参见 cp_parser_save_member_function_body ）。在我们退出最顶层类定义体这一刻，我们有足够的信息来处理这些对象。这里使用 2 个循环分别处理默认参数及内联函数。
14759 static void
14760 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function) in parser.c
14761 {
14762 cp_lexer *saved_lexer;
14763
14764 /* If this member is a template, get the underlying
14765 FUNCTION_DECL. */
14766 if (DECL_FUNCTION_TEMPLATE_P (member_function))
14767 member_function = DECL_TEMPLATE_RESULT (member_function);
14768
14769 /* There should not be any class definitions in progress at this
14770 point; the bodies of members are only parsed outside of all class
14771 definitions. */
14772 my_friendly_assert (parser->num_classes_being_defined == 0, 20010816);
14773 /* While we're parsing the member functions we might encounter more
14774 classes. We want to handle them right away, but we don't want
14775 them getting mixed up with functions that are currently in the
14776 queue. */
14777 parser->unparsed_functions_queues
14778 = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
14779
14780 /* Make sure that any template parameters are in scope. */
14781 maybe_begin_member_template_processing (member_function);
14782
14783 /* If the body of the function has not yet been parsed, parse it
14784 now. */
14785 if (DECL_PENDING_INLINE_P (member_function))
14786 {
14787 tree function_scope;
14788 cp_token_cache *tokens;
14789
14790 /* The function is no longer pending; we are processing it. */
14791 tokens = DECL_PENDING_INLINE_INFO (member_function);
14792 DECL_PENDING_INLINE_INFO (member_function) = NULL;
14793 DECL_PENDING_INLINE_P (member_function) = 0;
14794
14795 /* If this is a local class, enter the scope of the containing
14796 function. */
14797 function_scope = current_function_decl ;
14798 if (function_scope)
14799 push_function_context_to (function_scope);
14800
14801 /* Save away the current lexer. */
14802 saved_lexer = parser->lexer;
14803 /* Make a new lexer to feed us the tokens saved for this function. */
14804 parser->lexer = cp_lexer_new_from_tokens (tokens);
14805 parser->lexer->next = saved_lexer;
14806
14807 /* Set the current source position to be the location of the first
14808 token in the saved inline body. */
14809 cp_lexer_peek_token (parser->lexer);
14810
14811 /* Let the front end know that we going to be defining this
14812 function. */
14813 start_function (NULL_TREE, member_function, NULL_TREE,
14814 SF_PRE_PARSED | SF_INCLASS_INLINE);
14815
14816 /* Now, parse the body of the function. */
14817 cp_parser_function_definition_after_declarator (parser,
14818 /*inline_p=*/ true);
14819
14820 /* Leave the scope of the containing function. */
14821 if (function_scope)
14822 pop_function_context_from (function_scope);
14823 /* Restore the lexer. */
14824 parser->lexer = saved_lexer;
14825 }
14826
14827 /* Remove any template parameters from the symbol table. */
14828 maybe_end_member_template_processing ();
14829
14830 /* Restore the queue. */
14831 parser->unparsed_functions_queues
14832 = TREE_CHAIN (parser->unparsed_functions_queues);
14833 }
未处理的内联函数设置了 DECL_PENDING_INLINE_P 。对于我们的例子程序， 至今尚未解析函数 ， 因此 current_function_decl 现在是 null 。我们已经看到，词法分析器在源文件中推进的同时向解析器提供符号。 现在词法分析器停在类定义体的末尾，但是为了解析内联函数，解析器期望得到构成内联函数体的符号，这是当前词法分析器所不能提供的。最好使用一个临时词法分析器来为解析器提供缓存的符号，在完成时将之丢弃。在 14804 行，这个临时词法分析器在 GC 管理的内存中分配，在释放后它会被自动回收。
作为一个扩展， GCC 允许在函数作用域中定义局部类，因此类方法中亦可定义类，并且这个形式可以嵌套。例如，下面的代码在 GCC 中是有效的。
#include <stdio.h>
void func1 () {
struct A {
void funcA() {
struct B {
void funcB() { printf ("funcB/n"); }
};
B b;
b.funcB();
}
};
A a;
a.funcA();
}
main() {
func1();
return 0;
}
那么在处理 funcB 之前 ， cfun 保存了 funcA 的数据 ， 但在处理 funcB 的过程中 ， 它必须更新为 funcB 的数据。然后在处理后 ， 必须把 cfun 恢复为 funcA 的数据。出于这个目的，前端在 14799 行 push_function_context_to 的中，使用 outer_function_chain 来记录函数上下文。
324 void
325 push_function_context_to (tree context) in function.c
326 {
327 struct function *p;
328
329 if (context)
330 {
331 if (context == current_function_decl )
332 cfun ->contains_functions = 1;
333 else
334 {
335 struct function *containing = find_function_data (context);
336 containing->contains_functions = 1;
337 }
338 }
339
340 if (cfun == 0)
341 init_dummy_function_start ();
342 p = cfun ;
343
344 p->outer = outer_function_chain ;
345 outer_function_chain = p;
346 p->fixup_var_refs_queue = 0;
347
348 (*lang_hooks .function.enter_nested ) (p);
349
350 cfun = 0;
351 }
对于上面的例子， outer_function_chain 在处理 funcB 期间，将记录如下的函数上下文： funcB à funcA à func1 。而在 348 行，与语言相关的钩子为 C/C++ 执行如下指定任务，它拷贝 cfun 的 language_function 部分。
6289 void
6290 c_push_function_context (struct function *f) in c-decl.c
6291 {
6292 struct language_function *p;
6293 p = ggc_alloc (sizeof (struct language_function));
6294 f->language = p;
6295
6296 p->base.x_stmt_tree = c_stmt_tree ;
6297 p->base.x_scope_stmt_stack = c_scope_stmt_stack ;
6298 p->x_in_iteration_stmt = c_in_iteration_stmt ;
6299 p->x_in_case_stmt = c_in_case_stmt ;
6300 p->returns_value = current_function_returns_value ;
6301 p->returns_null = current_function_returns_null ;
6302 p->returns_abnormally = current_function_returns_abnormally ;
6303 p->warn_about_return_type = warn_about_return_type ;
6304 p->extern_inline = current_extern_inline ;
6305 }
显然在 14822 行的 pop 操作应该执行相反的过程。
创建了临时的词法分析器后， start_function 将准备并使得函数作用域成为有效作用域。看到参数 flags 表示该内联函数声明已经被解析了，而参数 declarator 指向对应的 METHOD_TYPE 节点。
10181 int
10182 start_function (tree declspecs, tree declarator, tree attrs, int flags) in decl.c
10183 {
10184 tree decl1;
10185 tree ctype = NULL_TREE;
10186 tree fntype;
10187 tree restype;
10188 int doing_friend = 0;
10189 struct cp_binding_level *bl;
10190 tree current_function_parms;
10191
10192 /* Sanity check. */
10193 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
10194 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
10195
10196 /* This should only be done once on the top most decl. */
10197 if (have_extern_spec )
10198 {
10199 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
10200 have_extern_spec = false;
10201 }
10202
10203 if (flags & SF_PRE_PARSED)
10204 {
10205 decl1 = declarator;
10206
10207 fntype = TREE_TYPE (decl1);
10208 if (TREE_CODE (fntype) == METHOD_TYPE)
10209 ctype = TYPE_METHOD_BASETYPE (fntype);
10210
10211 /* ISO C++ 11.4/5. A friend function defined in a class is in
10212 the (lexical) scope of the class in which it is defined. */
10213 if (!ctype && DECL_FRIEND_P (decl1))
10214 {
10215 ctype = DECL_FRIEND_CONTEXT (decl1);
10216
10217 /* CTYPE could be null here if we're dealing with a template;
10218 for example, `inline friend float foo()' inside a template
10219 will have no CTYPE set. */
10220 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10221 ctype = NULL_TREE;
10222 else
10223 doing_friend = 1;
10224 }
10225 }
10226 else
10227 {
…
10257 }
10258
10259 if (DECL_DECLARED_INLINE_P (decl1)
10260 && lookup_attribute ("noinline", attrs))
10261 warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
10262
10263 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10264 /* This is a constructor, we must ensure that any default args
10265 introduced by this definition are propagated to the clones
10266 now. The clones are used directly in overload resolution. */
10267 adjust_clone_args (decl1);
10268
10269 /* Sometimes we don't notice that a function is a static member, and
10270 build a METHOD_TYPE for it. Fix that up now. */
10271 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10272 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10273 {
10274 revert_static_member_fn (decl1);
10275 ctype = NULL_TREE;
10276 }
10277
10278 /* Warn if function was previously implicitly declared
10279 (but not if we warned then). */
10280 if (! warn_implicit
10281 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
10282 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
10283
10284 /* Set up current_class_type, and enter the scope of the class, if
10285 appropriate. */
10286 if (ctype)
10287 push_nested_class (ctype);
10288 else if (DECL_STATIC_FUNCTION_P (decl1))
10289 push_nested_class (DECL_CONTEXT (decl1));
之前，在 cp_parser_class_specifier 的 11925 行， finish_struct 在 5257 行弹出类的作用域，现在当前作用域是包含其的类或名字空间。因此在处理内联函数之前，需要重新加入这个作用域。
5627 void
5628 push_nested_class (tree type) in class.c
5629 {
5630 tree context;
5631
5632 /* A namespace might be passed in error cases, like A::B:C. */
5633 if (type == NULL_TREE
5634 || type == error_mark_node
5635 || TREE_CODE (type) == NAMESPACE_DECL
5636 || ! IS_AGGR_TYPE (type)
5637 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5638 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5639 return ;
5640
5641 context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5642
5643 if (context && CLASS_TYPE_P (context))
5644 push_nested_class (context);
5645 pushclass (type);
5646 }
如果这个类被包含在另一个类里，很可能我们已经退出其作用域，也需要先加会这个作用域。而对于我们的例子，需要恢复“ SingleThreaded ”，然后“ Lock ”的作用域。
start_function (continue)
10291 /* Now that we have entered the scope of the class, we must restore
10292 the bindings for any template parameters surrounding DECL1, if it
10293 is an inline member template. (Order is important; consider the
10294 case where a template parameter has the same name as a field of
10295 the class.) It is not until after this point that
10296 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10297 if (flags & SF_INCLASS_INLINE)
10298 maybe_begin_member_template_processing (decl1);
10299
10300 /* Effective C++ rule 15. */
10301 if (warn_ecpp
10302 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10303 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10304 warning ("`operator=' should return a reference to `*this'");
10305
10306 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10307 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10308 if (!DECL_INITIAL (decl1))
10309 DECL_INITIAL (decl1) = error_mark_node;
10310
10311 /* This function exists in static storage.
10312 (This does not mean `static' in the C sense!) */
10313 TREE_STATIC (decl1) = 1;
10314
10315 /* We must call push_template_decl after current_class_type is set
10316 up. (If we are processing inline definitions after exiting a
10317 class scope, current_class_type will be NULL_TREE until set above
10318 by push_nested_class.) */
10319 if (processing_template_decl )
10320 {
10321 tree newdecl1 = push_template_decl (decl1);
10322 if (newdecl1 != error_mark_node)
10323 decl1 = newdecl1;
10324 }
TEMPLATE_DECL 已经为该方法（非默认构造函数）所构建，因此在 10321 行的 push_template_decl 仅执行一些有效性检查。在函数 finish_struct 的 5254 行，标记 TYPE_BEING_DEFINED 已经被清除。
2770 tree
2771 push_template_decl_real (tree decl, int is_friend) in pt.c
2772 {
2773 tree tmpl;
2774 tree args;
2775 tree info;
2776 tree ctx;
2777 int primary;
2778 int is_partial;
2779 int new_template_p = 0;
2780
2781 /* See if this is a partial specialization. */
2782 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2783 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2784 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2785
2786 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2787
2788 if (is_friend)
2789 /* For a friend, we want the context of the friend function, not
2790 the type of which it is a friend. */
2791 ctx = DECL_CONTEXT (decl);
2792 else if (CP_DECL_CONTEXT (decl)
2793 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2794 /* In the case of a virtual function, we want the class in which
2795 it is defined. */
2796 ctx = CP_DECL_CONTEXT (decl);
2797 else
2798 /* Otherwise, if we're currently defining some class, the DECL
2799 is assumed to be a member of the class. */
2800 ctx = current_scope ();
2801
2802 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2803 ctx = NULL_TREE;
2804
2805 if (!DECL_CONTEXT (decl))
2806 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2807
2808 /* See if this is a primary template. */
2809 primary = template_parm_scope_p ();
2810
2811 if (primary)
2812 {
...
2852 }
2853
2854 /* Check to see that the rules regarding the use of default
2855 arguments are not being violated. */
2856 check_default_tmpl_args (decl, current_template_parms,
2857 primary, is_partial);
2858
2859 if (is_partial)
2860 return process_partial_specialization (decl);
2861
2862 args = current_template_args ();
2863
2864 if (!ctx
2865 || TREE_CODE (ctx) == FUNCTION_DECL
2866 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
2867 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2868 {
...
2904 }
2905 else
2906 {
2907 tree a, t, current, parms;
2908 int i;
2909
2910 if (TREE_CODE (decl) == TYPE_DECL)
2911 {
...
2922 }
2923 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
2924 {
2925 error ("template definition of non-template `%#D'", decl);
2926 return decl;
2927 }
2928 else
2929 tmpl = DECL_TI_TEMPLATE (decl);
2930
2931 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
2932 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
2933 && DECL_TEMPLATE_SPECIALIZATION (decl)
2934 && is_member_template (tmpl))
2935 {
...
2958 }
2959
2960 /* Make sure the template headers we got make sense. */
2961
2962 parms = DECL_TEMPLATE_PARMS (tmpl);
2963 i = TMPL_PARMS_DEPTH (parms);
2964 if (TMPL_ARGS_DEPTH (args) != i)
2965 {
2966 error ("expected %d levels of template parms for `%#D', got %d",
2967 i, decl, TMPL_ARGS_DEPTH (args));
2968 }
2969 else
2970 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
2971 {
2972 a = TMPL_ARGS_LEVEL (args, i);
2973 t = INNERMOST_TEMPLATE_PARMS (parms);
2974
2975 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
2976 {
2977 if (current == decl)
2978 error ("got %d template parameters for `%#D'",
2979 TREE_VEC_LENGTH (a), decl);
2980 else
2981 error ("got %d template parameters for `%#T'",
2982 TREE_VEC_LENGTH (a), current);
2983 error (" but %d required", TREE_VEC_LENGTH (t));
2984 return error_mark_node;
2985 }
2986
2987 /* Perhaps we should also check that the parms are used in the
2988 appropriate qualifying scopes in the declarator? */
2989
2990 if (current == decl)
2991 current = ctx;
2992 else
2993 current = TYPE_CONTEXT (current);
2994 }
2995 }
2996
2997 DECL_TEMPLATE_RESULT (tmpl) = decl;
2998 TREE_TYPE (tmpl) = TREE_TYPE (decl);
2999
3000 /* Push template declarations for global functions and types. Note
3001 that we do not try to push a global template friend declared in a
3002 template class; such a thing may well depend on the template
3003 parameters of the class. */
3004 if (new_template_p && !ctx
3005 && !(is_friend && template_class_depth (current_class_type ) > 0))
3006 tmpl = pushdecl_namespace_level (tmpl);
3007
3008 if (primary)
3009 {
...
3022 }
3023
3024 /* The DECL_TI_ARGS of DECL contains full set of arguments refering
3025 back to its most general template. If TMPL is a specialization,
3026 ARGS may only have the innermost set of arguments. Add the missing
3027 argument levels if necessary. */
3028 if (DECL_TEMPLATE_INFO (tmpl))
3029 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3030
3031 info = tree_cons (tmpl, args, NULL_TREE);
3032
3033 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3034 {
...
3041 }
3042 else if (DECL_LANG_SPECIFIC (decl))
3043 DECL_TEMPLATE_INFO (decl) = info;
3044
3045 return DECL_TEMPLATE_RESULT (tmpl);
3046 }
在 2929 行， tmpl 指向前面所构建的 TEMPLATE_DECL 节点。而对于这个 TEMPLATE_DECL ， DECL_TEMPLATE_INFO 仍然是 null 。那么同样的 info 被同样创建。
start_function (continue)
10326 /* We are now in the scope of the function being defined. */
10327 current_function_decl = decl1;
10328
10329 /* Save the parm names or decls from this function's declarator
10330 where store_parm_decls will find them. */
10331 current_function_parms = DECL_ARGUMENTS (decl1);
10332
10333 /* Make sure the parameter and return types are reasonable. When
10334 you declare a function, these types can be incomplete, but they
10335 must be complete when you define the function. */
10336 if (!processing_template_decl )
10337 check_function_type (decl1, current_function_parms);
10338 /* Make sure no default arg is missing. */
10339 check_default_args (decl1);
10340
10341 /* Build the return declaration for the function. */
10342 restype = TREE_TYPE (fntype);
10343 /* Promote the value to int before returning it. */
10344 if (c_promoting_integer_type_p (restype))
10345 restype = type_promotes_to (restype);
10346 if (DECL_RESULT (decl1) == NULL_TREE)
10347 {
10348 DECL_RESULT (decl1)
10349 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10350 c_apply_type_quals_to_decl (cp_type_quals (restype),
10351 DECL_RESULT (decl1));
10352 }
10353
10354 /* Initialize RTL machinery. We cannot do this until
10355 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10356 even when processing a template; this is how we get
10357 CFUN set up, and our per-function variables initialized.
10358 FIXME factor out the non-RTL stuff. */
10359 bl = current_binding_level ;
10360 allocate_struct_function (decl1);
10361 current_binding_level = bl;
10362
10363 /* Even though we're inside a function body, we still don't want to
10364 call expand_expr to calculate the size of a variable-sized array.
10365 We haven't necessarily assigned RTL to all variables yet, so it's
10366 not safe to try to expand expressions involving them. */
10367 immediate_size_expand = 0;
10368 cfun ->x_dont_save_pending_sizes_p = 1;
10369
10370 /* Start the statement-tree, start the tree now. */
10371 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
在前端中， METHOD_TYPE 的 TREE_TYPE 描述了返回类型。令人惊奇的是，如果返回类型是整形而且其大小小于 int ，它将被提升至 int 类型。
3560 bool
3561 c_promoting_integer_type_p (tree t) in c-common.c
3562 {
3563 switch (TREE_CODE (t))
3564 {
3565 case INTEGER_TYPE:
3566 return (TYPE_MAIN_VARIANT (t) == char_type_node
3567 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3568 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3569 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3570 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3571 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3572
3573 case ENUMERAL_TYPE:
3574 /* ??? Technically all enumerations not larger than an int
3575 promote to an int. But this is used along code paths
3576 that only want to notice a size change. */
3577 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3578
3579 case BOOLEAN_TYPE:
3580 return 1;
3580
3581 default :
3582 return 0;
3583 }
3584 }
提升至 int ，只是意味着找出具有期望大小的内建整数类型。在设立运行时环境的过程中，我们已经见到了这样类型的内部表达形式的创建细节，并且在中间树中查找它们的方法。
1115 tree
1116 type_promotes_to (tree type) in cvt.c
1117 {
1118 if (type == error_mark_node)
1119 return error_mark_node;
1120
1121 type = TYPE_MAIN_VARIANT (type);
1122
1123 /* bool always promotes to int (not unsigned), even if it's the same
1124 size. */
1125 if (type == boolean_type_node)
1126 type = integer_type_node;
1127
1128 /* Normally convert enums to int, but convert wide enums to something
1129 wider. */
1130 else if (TREE_CODE (type) == ENUMERAL_TYPE
1131 || type == wchar_type_node)
1132 {
1133 int precision = MAX (TYPE_PRECISION (type),
1134 TYPE_PRECISION (integer_type_node));
1135 tree totype = c_common_type_for_size (precision, 0);
1136 if (TREE_UNSIGNED (type)
1137 && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1138 type = c_common_type_for_size (precision, 1);
1139 else
1140 type = totype;
1141 }
1142 else if (c_promoting_integer_type_p (type))
1143 {
1144 /* Retain unsignedness if really not getting bigger. */
1145 if (TREE_UNSIGNED (type)
1146 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1147 type = unsigned_type_node;
1148 else
1149 type = integer_type_node;
1150 }
1151 else if (type == float_type_node)
1152 type = double_type_node;
1153
1154 return type;
1155 }
上面从 10346 到 10352 行，这个返回类型，根据 C++ 语言规范，在返回地址的情况下，必须是一个已经被定义或前向声明的类型。那么如果应用了任意的 cv-qualifier ，本质上它与应用在其他地方没有什么不同。但是，前端需要知道该函数的返回类型来进行某些优化，因此为返回类型构建 RESULT_DECL 节点，并链接入对应 FUNCTION_DECL 节点的 DECL_RESULT 域。最后， cv-qualifier 通过 c_apply_type_quals_to_decl 应用到 RESULT_DECL 节点中。
2805 void
2806 c_apply_type_quals_to_decl (int type_quals, tree decl) in c-common.c
2807 {
2808 tree type = TREE_TYPE (decl);
2809
2810 if (type == error_mark_node)
2811 return ;
2812
2813 if (((type_quals & TYPE_QUAL_CONST)
2814 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2815 /* An object declared 'const' is only readonly after it is
2816 initialized. We don't have any way of expressing this currently,
2817 so we need to be conservative and unset TREE_READONLY for types
2818 with constructors. Otherwise aliasing code will ignore stores in
2819 an inline constructor. */
2820 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2821 TREE_READONLY (decl) = 1;
2822 if (type_quals & TYPE_QUAL_VOLATILE)
2823 {
2824 TREE_SIDE_EFFECTS (decl) = 1;
2825 TREE_THIS_VOLATILE (decl) = 1;
2826 }
2827 if (type_quals & TYPE_QUAL_RESTRICT)
2828 {
2829 while (type && TREE_CODE (type) == ARRAY_TYPE)
2830 /* Allow 'restrict' on arrays of pointers.
2831 FIXME currently we just ignore it. */
2832 type = TREE_TYPE (type);
2833 if (!type
2834 || !POINTER_TYPE_P (type)
2835 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2836 error ("invalid use of `restrict'");
2837 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2838 /* Indicate we need to make a unique alias set for this pointer.
2839 We can't do it here because it might be pointing to an
2840 incomplete type. */
2841 DECL_POINTER_ALIAS_SET (decl) = -2;
2842 }
2843 }
这个所谓的 apply-type-quals-to-decl （应用类型限定符至声明）实际上设置对应节点的相关标记。
888
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
