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

1.3. 为非一元表达式创建节点

函数build可被用于为表达式创建节点。但它只接受表达式作为参数，把它们合成为更为复杂的表达式。它不可以被用于创建第一级的表达式（也就是由解析器解析出的语法成分，合成出表达式。这些步骤需要远为复杂的函数来处理，在后面我们可以看到一些代码片断）。尽管如此，build还是被广泛使用，因为在C/C++程序中，表达式的表现力在于它的嵌套能力及它能出现的地方。把简单表达式节点，复合成复杂表达式节点，正是build的任务。

1.3.1. 节点的创建

我们已经知道，源代码将前端转换为语义相同的树形式。而树的节点有多种形式以对应不同的语义成分。这里函数build将表达式创建tree_exp类型的节点。

1.3.1.1. tree_exp类型

在前端，表达式由tree_exp类型节点来表示。它的定义如下：

852 struct tree_exp GTY(()) in tree.h
853 {
854 struct tree_common common;
855 int complexity;
856 tree GTY ((special ("tree_exp"),
857 desc ("TREE_CODE ((tree) &%0)")))
858 operands[1];
859 };

作为树节点的一种，tree_exp也是由make_node来分配所需的内存。

2295 tree
2296 build (enum tree_code code, tree tt, ...) in tree.c
2297 {
2298 tree t;
2299 int length;
2300 int i;
2301 int fro;
2302 int constant;
2303 va_list p;
2304 tree node;
2305
2306 va_start (p, tt);
2307
2308 t = make_node (code);
2309 length = TREE_CODE_LENGTH (code);
2310 TREE_TYPE (t) = tt;

注意2306行的va_start，它不是我们程序中的那个va_start。在GCC中，它是所谓的内建函数（builtin function）。在后面我们会碰到内建函数。

1.3.1.2. 操作数的预处理

函数build接受的参数的数量是可变的，因此函数首先要确定参数的数目。这个数目取决于表达式的类型（通过树码）。

build (continued)

2312 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2313 result based on those same flags for the arguments. But if the
2314 arguments aren't really even `tree' expressions, we shouldn't be trying
2315 to do this. */
2316 fro = first_rtl_op (code);
2317
2318 /* Expressions without side effects may be constant if their
2319 arguments are as well. */
2320 constant = (TREE_CODE_CLASS (code) == '<'
2321 || TREE_CODE_CLASS (code) == '1'
2322 || TREE_CODE_CLASS (code) == '2'
2323 || TREE_CODE_CLASS (code) == 'c');

在上面2316行，first_rtl_op可以根据要创建的表达式找出对应的参数的数目。

1448 int
1449 first_rtl_op (enum tree_code code) in tree.c
1450 {
1451 switch (code)
1452 {
1453 case SAVE_EXPR:
1454 return 2;
1455 case GOTO_SUBROUTINE_EXPR:
1456 case RTL_EXPR:
1457 return 0;
1458 case WITH_CLEANUP_EXPR:
1459 return 2;
1460 default:
1461 return TREE_CODE_LENGTH (code);
1462 }
1463 }

在2330行，比较表达式（类别“<”），一元算术表达式（类别“1”），二元算术表达式（类别“2”），常量表达式（类别“c”）是没有副作用（side effect）的表达式，只要它们的实参没有副作用，而且它们是常量性的如果实参是常量性的。

build (continued)

2325 if (length == 2)
2326 {
2327 /* This is equivalent to the loop below, but faster. */
2328 tree arg0 = va_arg (p, tree);
2329 tree arg1 = va_arg (p, tree);
2330
2331 TREE_OPERAND (t, 0) = arg0;
2332 TREE_OPERAND (t, 1) = arg1;
2333 TREE_READONLY (t) = 1;
2334 if (arg0 && fro > 0)
2335 {
2336 if (TREE_SIDE_EFFECTS (arg0))
2337 TREE_SIDE_EFFECTS (t) = 1;
2338 if (!TREE_READONLY (arg0))
2339 TREE_READONLY (t) = 0;
2340 if (!TREE_CONSTANT (arg0))
2341 constant = 0;
2342 }
2343
2344 if (arg1 && fro > 1)
2345 {
2346 if (TREE_SIDE_EFFECTS (arg1))
2347 TREE_SIDE_EFFECTS (t) = 1;
2348 if (!TREE_READONLY (arg1))
2349 TREE_READONLY (t) = 0;
2350 if (!TREE_CONSTANT (arg1))
2351 constant = 0;
2352 }
2353 }
2354 else if (length == 1)
2355 {
2356 tree arg0 = va_arg (p, tree);
2357
2358 /* The only one-operand cases we handle here are those with side-effects.
2359 Others are handled with build1. So don't bother checked if the
2360 arg has side-effects since we'll already have set it.
2361
2362 ??? This really should use build1 too. */
2363 if (TREE_CODE_CLASS (code) != 's')
2364 abort ();
2365 TREE_OPERAND (t, 0) = arg0;
2366 }
2367 else
2368 {
2369 for (i = 0; i < length; i++)
2370 {
2371 tree operand = va_arg (p, tree);
2372
2373 TREE_OPERAND (t, i) = operand;
2374 if (operand && fro > i)
2375 {
2376 if (TREE_SIDE_EFFECTS (operand))
2377 TREE_SIDE_EFFECTS (t) = 1;
2378 if (!TREE_CONSTANT (operand))
2379 constant = 0;
2380 }
2381 }
2382 }
2383 va_end (p);

1.3.2. 对于CALL_EXPR节点的处理

对于除CALL_EXPR外的表达式，其节点就已经创建好了。但对于CALL_EXPR，其副作用取决于其调用的函数，而不在CALL_EXPR节点本身（对于刚创建的CALL_EXPR节点，TREE_SIDE_EFFECTS一定为0）。因此，需要额外代码走入调用函数来确定其副作用。

build (continued)

2385 TREE_CONSTANT (t) = constant;
2386
2387 if (code == CALL_EXPR && !TREE_SIDE_EFFECTS (t))
2388 {
2389 /* Calls have side-effects, except those to const or
2390 pure functions. */
2391 i = call_expr_flags (t);
2392 if (!(i & (ECF_CONST | ECF_PURE)))
2393 TREE_SIDE_EFFECTS (t) = 1;
2394
2395 /* And even those have side-effects if their arguments do. */
2396 else for (node = TREE_OPERAND (t, 1); node; node = TREE_CHAIN (node))
2397 if (TREE_SIDE_EFFECTS (TREE_VALUE (node)))
2398 {
2399 TREE_SIDE_EFFECTS (t) = 1;
2400 break;
2401 }
2402 }
2403
2404 return t;
2405 }

1.3.2.1. 确定被调用的函数

1.3.2.1.1. CALL_EXPR节点
首先看一下CALL_EXPR节点。
CALL_EXPR[2]
² 这个节点用于表示对函数包括非静态成员方法的调用。其第一个参数是指向被调用函数的指针，它应该是类型为POINTER_TYPE 的表达式。第二个参数是一个TREE_LIST，函数调用的参数按从左到右的次序出现在这个链表中。其中节点的TREE_VALUE包含实参的表达式（节点1的TREE_PURPOSE值不被使用，应被忽略）。对于非静态的成员方法，会有一个对应于this指针的参数。所有的参数在链表中都应该有对应的表达式，就算函数被声明有缺省参数，而一些实参在调用处没有显式给出。

751 int
752 call_expr_flags (tree t) in calls.c
753 {
754 int flags;
755 tree decl = get_callee_fndecl (t);
756
757 if (decl)
758 flags = flags_from_decl_or_type (decl);
759 else
760 {
761 t = TREE_TYPE (TREE_OPERAND (t, 0));
762 if (t && TREE_CODE (t) == POINTER_TYPE)
763 flags = flags_from_decl_or_type (TREE_TYPE (t));
764 else
765 flags = 0;
766 }
767
768 return flags;
769 }

在上面755行，get_callee_fndecl被用于确定被调用函数的地址。正如上述CALL_EXPR所揭示的，它的第一个参数是指向被调用函数的指针，它是类型为POINTER_TYPE 的表达式。我们首先要看一下何为FUNCTION_DECL节点，它是这个指针所指向的对象。
1.3.2.1.2. 找出调用的函数
FUNCTION_DECL节点是什么呢？
FUNCTION_DECL[2]
² 函数在前端由FUNCTION_DECL节点来表示。而一组重载函数有时由一个OVERLOAD节点来代表。
一个OVERLOAD节点不代表一个声明，因此不能将用于DECL_*的宏用于OVERLOAD节点。一个OVERLOAD节点类似于一个TREE_LIST。用宏OVL_CURRENT可以获取与之关联的函数；而用OVL_NEXT则得到重载函数链表中的下一个OVERLOAD节点。 宏OVL_CURRENT和OVL_NEXT实际上是多态的（polymorphic）；你也可以把它们用于FUNCTION_DECL节点。在用于FUNCTION_DECL节点时，OVL_CURRENT将永远返回函数本身，而OVL_NEXT则永远返回NULL_TREE。
为了确定函数的绑定域（the scope of a function），你可以使用宏DECL_CONTEXT。这个宏会返回类（以RECORD_TYPE节点或者UNION_TYPE节点)或者名字空间（以NAMESPACE_DECL节点），而函数则是其中的成员。对于虚函数，这个宏返回函数被真正定义的类，而不是只是声明它的基类。
如果一个友元函数被定义于一个类的作用域，宏DECL_FRIEND_CONTEXT可以被用于确定定义该函数的类。例如，在代码：“class C { friend void f() {} };”中，对应于f的DECL_CONTEXT会是全局名字空间global_namespace。但是相应的，f的DECL_FRIEND_CONTEXT将是类C的RECORD_TYPE节点。
在C语言中，一个函数的DECL_CONTEXT可能是另一个函数。这个形式表明GNU的嵌套函数的扩展正被使用。至于嵌套函数详细的语言，参考GCC的手册[6]。被嵌套的函数可以访问包含函数的局部变量。这种访问不会在树结构中显式给出，后端必须查看被引用的VAR_DECL的DECL_CONTEXT。如果被引用的VAR_DECL的DECL_CONTEXT不是当前被处理的函数，而且VAR_DECL不持有DECL_EXTERNAL及DECL_STATIC，那么该引用即是对包含函数的局部变量，后端将采取相应的行为。
在下面4482行，STRIP_NOPS剥除最上层不改变机器模式的NON_LVALUE_EXPR和NOP_EXPR节点（更准确的，是跳过这些节点，逐级进入其操作数）。对于普通的函数调用，通过STRIP_NOP后，可能就会碰到FUNCTION_DECL节点。
在4485行的DECL_P，如果是非0值，表明addr是声明。而如果addr是声明，但不是 FUNCTION_DECL，它就被假定为函数指针，而且如果它是只读和非易变的（read-only and non-volatile），那么它的初始值包含了我们需要的地址。
在4492行，我们期望得到包含FUNCTION_DECL的ADDR_EXPR。其所包含的FUNCTION_DECL正是我们所寻求的。

4468 tree
4469 get_callee_fndecl (tree call) in tree.c
4470 {
4471 tree addr;
4472
4473 /* It's invalid to call this function with anything but a
4474 CALL_EXPR. */
4475 if (TREE_CODE (call) != CALL_EXPR)
4476 abort ();
4477
4478 /* The first operand to the CALL is the address of the function
4479 called. */
4480 addr = TREE_OPERAND (call, 0);
4481
4482 STRIP_NOPS (addr);
4483
4484 /* If this is a readonly function pointer, extract its initial value. */
4485 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4486 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4487 && DECL_INITIAL (addr))
4488 addr = DECL_INITIAL (addr);
4489
4490 /* If the address is just `&f' for some function `f', then we know
4491 that `f' is being called. */
4492 if (TREE_CODE (addr) == ADDR_EXPR
4493 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4494 return TREE_OPERAND (addr, 0);
4495
4496 /* We couldn't figure out what was being called. Maybe the front
4497 end has some idea. */
4498 return (*lang_hooks.lang_get_callee_fndecl) (call);
4499 }

如果我们仍然不能确定被调用的函数，则在4498行，lang_hooks 中的钩子lang_get_callee_fndecl 被调用。默认的，函数lhd_return_null_tree将被调用，但它不做任何事。前端可以为这个钩子绑定合适的函数。对于C/C++，默认的函数将被使用。
1.3.2.1.3. 确定函数的属性
1.3.2.1.3.1. 获取描述被调用函数的数据
函数flags_from_decl_or_type确定函数的属性。在编译期间GCC会创建一个图（graph）来描述被调用函数和调用者。

698 int
699 flags_from_decl_or_type (tree exp) in calls.c
700 {
701 int flags = 0;
702 tree type = exp;
703
704 if (DECL_P (exp))
705 {
706 struct cgraph_rtl_info *i = cgraph_rtl_info (exp);
707 type = TREE_TYPE (exp);
1.3.2.1.3.2. 函数调用关系图
1.3.2.1.3.2.1. 节点结构
上面706行，cgraph_rtl_info通过cgraph_node获取该函数对应的关系图中的节点。如果decl为当前处理的函数（current_function_decl指向当前被处理的函数），直接返回相应的cgraph_rtl_info节点。否则，该函数必须已经被汇编。

348 struct cgraph_rtl_info *
349 cgraph_rtl_info (tree decl) in cgraph.c
350 {
351 struct cgraph_node *node;
352 if (TREE_CODE (decl) != FUNCTION_DECL)
353 abort ();
354 node = cgraph_node (decl);
355 if (decl != current_function_decl
356 && !TREE_ASM_WRITTEN (node->decl))
357 return NULL;
358 return &node->rtl;
359 }

下面的结构体cgraph_node作为图中的一个节点，用于描述调用关系中的一个函数。GCC支持嵌套函数，因此下面域origin，nested，next_nested用于描述该函数在嵌套中的层次和关系。

85 struct cgraph_node GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) in cgraph.h
86 {
87 tree decl;
88 struct cgraph_edge *callees;
89 struct cgraph_edge *callers;
90 struct cgraph_node *next;
91 struct cgraph_node *previous;
92 /* For nested functions points to function the node is nested in. */
93 struct cgraph_node *origin;
94 /* Points to first nested function, if any. */
95 struct cgraph_node *nested;
96 /* Pointer to the next function with same origin, if any. */
97 struct cgraph_node *next_nested;
98 /* Pointer to the next function in cgraph_nodes_queue. */
99 struct cgraph_node *next_needed;
100 PTR GTY ((skip (""))) aux;
101
102 struct cgraph_local_info local;
103 struct cgraph_global_info global;
104 struct cgraph_rtl_info rtl;
105 /* Unique id of the node. */
106 int uid;
107 /* Set when function must be output - it is externally visible
108 or it's address is taken. */
109 bool needed;
110 /* Set when function is reachable by call from other function
111 that is either reachable or needed. */
112 bool reachable;
113 /* Set once the function has been instantiated and its callee
114 lists created. */
115 bool analyzed;
116 /* Set when function is scheduled to be assembled. */
117 bool output;
118 };

在上面的结构体中，cgraph_edge用作连接节点的边，它保存了一个函数作为调用者和被调用者的全部信息。

120 struct cgraph_edge GTY(()) in cgraph.h
121 {
122 struct cgraph_node *caller;
123 struct cgraph_node *callee;
124 struct cgraph_edge *next_caller;
125 struct cgraph_edge *next_callee;
126 /* When NULL, inline this call. When non-NULL, points to the explanation
127 why function was not inlined. */
128 const char *inline_failed;
129 };

在关系图中，调用者和被调用者的关系由cgraph_node和cgraph_edge来共同表示。如下图所示，函数N1调用N3，N3调用N4，N4返回，N2接着调用N3，N3调用N5。图中，N1至N5按创建的次序，通过next域连起来（对previous亦然）。在N3的cgraph_node节点中，域caller指向Edge1-3（第1个调用N3的函数）。Edge1-3的caller指向N1，callee指向N3，同时next_caller指向Edge2-3（第2个调用N3的函数）。另外，在N3的cgraph_node节点中，域callee指向Edge3-4（N3第1个调用的函数），而Edge3-4的next_callee指向Edge3-5（N3第2个调用的函数），如果N3继续调用别的函数，Edge3-5的next_callee继续指向对应的cgraph_edge。而对于N5，Edge3-5则是caller，它的next_caller域指向下一个调用N5的cgraph_edge。



图1 函数调用关系图示例

在cgraph_node定义的102行，结构体cgraph_local_info包含了在本地收集的函数信息。它在函数被分析后可用。

28 struct cgraph_local_info GTY(()) in cgraph.h
29 {
30 /* Size of the function before inlining. */
31 int self_insns;
32
33 /* Set when function function is visible in current compilation unit only
34 and it's address is never taken. */
35 bool local;
36 /* Set once it has been finalized so we consider it to be output. */
37 bool finalized;
38
39 /* False when there something makes inlining impossible (such as va_arg). */
40 bool inlinable;
41 /* True when function should be inlined independently on it's size. */
42 bool disregard_inline_limits;
43 /* True when the function has been originally extern inline, but it is
44 redefined now. */
45 bool redefined_extern_inline;
46 };

而在103行，结构体cgraph_global_info包含了那些当编译结束时，需要全局计算的函数信息。它仅在使用选项-funit-at-time时可用。

51 struct cgraph_global_info GTY(()) in cgraph.h
52 {
53 /* Estimated size of the function after inlining. */
54 int insns;
55
56 /* Number of times given function will be cloned during output. */
57 int cloned_times;
58
59 /* Set when the function will be inlined exactly once. */
60 bool inline_once;
61
62 /* Set to true for all reachable functions before inlining is decided.
63 Once we inline all calls to the function and the function is local,
64 it is set to false. */
65 bool will_be_output;
66
67 /* Set iff at least one of the caller edges has inline_call flag set. */
68 bool inlined;
69 };

在104行，结构体cgraph_rtl_info则包含由后端传播的函数信息。当函数的汇编完成后，该信息才可用。

74 struct cgraph_rtl_info GTY(()) in cgraph.h
75 {
76 bool const_function;
77 bool pure_function;
78 int preferred_incoming_stack_boundary;
79 };
1.3.1.1.1.1.1. 创建cgaph_node节点
函数cgraph_node创建cgraph_node的对象。正如我们前面所见，所有的cgraph_node节点都连成双向链表。

95 struct cgraph_node *
96 cgraph_node (tree decl) in cgraph.c
97 {
98 struct cgraph_node *node;
99 struct cgraph_node **slot;
100
101 if (TREE_CODE (decl) != FUNCTION_DECL)
102 abort ();
103
104 if (!cgraph_hash)
105 cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
106
107 slot = (struct cgraph_node **)
108 htab_find_slot_with_hash (cgraph_hash, DECL_ASSEMBLER_NAME (decl),
109 IDENTIFIER_HASH_VALUE
110 (DECL_ASSEMBLER_NAME (decl)), INSERT);
111 if (*slot)
112 return *slot;
113 node = ggc_alloc_cleared (sizeof (*node));
114 node->decl = decl;
115 node->next = cgraph_nodes;
116 node->uid = cgraph_max_uid++;
117 if (cgraph_nodes)
118 cgraph_nodes->previous = node;
119 node->previous = NULL;
120 cgraph_nodes = node;
121 cgraph_n_nodes++;
122 *slot = node;
123 if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
124 {
125 node->origin = cgraph_node (DECL_CONTEXT (decl));
126 node->next_nested = node->origin->nested;
127 node->origin->nested = node;
128 }
129 return node;
130 }

同时所有的cgraph_node节点都被存放到哈希表里，以保证与函数一一对应。
1.3.1.1.1.2. 确定属性
上面提到cgraph_rtl_info需要函数被汇编后才可用（否则函数cgraph_rtl_info返回NULL）。但如果可用，这个数据是最准确的（汇编已经就绪了）。

flags_from_decl_or_type (continued)

698 if (i)
699 {
700 if (i->pure_function)
701 flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
702 if (i->const_function)
703 flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
704 }
705
706 /* The function exp may have the `malloc' attribute. */
707 if (DECL_IS_MALLOC (exp))
708 flags |= ECF_MALLOC;
709
710 /* The function exp may have the `pure' attribute. */
711 if (DECL_IS_PURE (exp))
712 flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
713
714 if (TREE_NOTHROW (exp))
715 flags |= ECF_NOTHROW;
716
717 if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
718 flags |= ECF_LIBCALL_BLOCK;
719 }
720
721 if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
722 flags |= ECF_CONST;
723
724 if (TREE_THIS_VOLATILE (exp))
725 flags |= ECF_NORETURN;
726
727 /* Mark if the function returns with the stack pointer depressed. We
728 cannot consider it pure or constant in that case. */
729 if (TREE_CODE (type) == FUNCTION_TYPE && TYPE_RETURNS_STACK_DEPRESSED (type))
730 {
731 flags |= ECF_SP_DEPRESSED;
732 flags &= ~(ECF_PURE | ECF_CONST | ECF_LIBCALL_BLOCK);
733 }
734
735 return flags;
736 }

而上面所用到的标示位的含义如下：
ECF_CONST，如果非零，表示对一个常量函数的调用。
ECF_NORETURN，如果非零，表示对一个volatile函数的调用。
ECF_MALLOC，如果非零，表示一个对malloc或相关函数的调用。
ECF_MAY_BE_ALLOCA，如果非零，貌似表示一个对alloca的调用。
ECF_NOTHROW，如果非零，表示对一个不会抛出异常的函数的调用。
ECF_RETURNS_TWICE，如果非零，表示一个对setjmp或相关函数的调用。
ECF_LONGJMP，如果非零，表示一个对longjmp的调用。
ECF_FORK_OR_EXEC, ECF_SIBCALL，如果非零，这是一个使用当前影像（image）创建新进程的系统调用（syscall）。
ECF_PURE，如果非零，是一个对纯函数（pure function）的调用。在[6]中，对纯函数有如下描述：
许多函数除了返回值外，没有别的影响。而且它们的返回值依赖于函数参数和（或者）全局变量。这样的函数和算术操作符类似，适用于循环优化和共用子表达式消除。这些函数在声明中应该使用属性pure。常见的纯函数例子有strlen和memcmp。
ECF_SP_DEPRESSED，如果非零，是一个返回时不调整栈指针的函数（用于Ada，使得被调用函数可以返回一个调用者不知道大小的对象）。
ECF_ALWAYS_RETURN，如果非零，这个调用已知永远返回。
ECF_LIBCALL_BLOCK，在调用外创建libcall块（emit_libcall_block）。
回到build的最后部分，相应的设置创建的tree_exp对象的side_effects_flag。注意，只要函数是纯的或常量属性的，就认为它有副作用（也即不可随便更改它调用的次数）。