Studying note of GCC-3.4.6 source (56)

4.3.1.7.5. Create nodes of builtins
GCC offers a facility name builtin functions. They just act as functions from library we usually used in coding. In fact you can use these builtins in you program as library function, and you even needn’t include header files.
Obvioulsy, these functions can not be in form of function declaration we see from header file. They can’t appear in any header file. These functions are processed within GCC internal, they must be in form of rtx object. Some builtin functions just indicate the expected operation, and they will be replaced by lines of codes after expansion (for example, the famous and commonly seen in Linux code builtin – builtin_const); some even need invoke function defined in libiberty within itself – the library used by GCC. As a step of system startup, the internal presentation of the builtin functions should be created and pushed into the right namespace – it is done by c_common_nodes_and_builtins.

cxx_init_decl_processing (continue)

3000 c_common_nodes_and_builtins ();
4.3.1.7.5.1. Nodes of builtin integer types
c_common_nodes_and_builtins first creates builtin types. As a common approach, GCC likes to use file to describe the detail. Here again for those builtin types a file “builtin-types.def” is used, which provides a declarative way of describing the types that are used when declaring builtin functions. Before including this file, you must define the following macros:
DEF_PRIMITIVE_TYPE (ENUM, TYPE)
The ENUM is an identifier indicating which type is being defined. TYPE is an expression for a `tree' that represents the type.
DEF_FUNCTION_TYPE_0 (ENUM, RETURN)
DEF_FUNCTION_TYPE_1 (ENUM, RETURN, ARG1)
DEF_FUNCTION_TYPE_2 (ENUM, RETURN, ARG1, ARG2)
DEF_FUNCTION_TYPE_3 (ENUM, RETURN, ARG1, ARG2, ARG3)
DEF_FUNCTION_TYPE_4 (ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)
These macros describe function types. ENUM is as above. The RETURN type is one of the enumerals already defined. ARG1, ARG2, and ARG3 give the types of the arguments, similarly.
DEF_FUNCTION_TYPE_VAR_0 (ENUM, RETURN)
DEF_FUNCTION_TYPE_VAR_1 (ENUM, RETURN, ARG1)
DEF_FUNCTION_TYPE_VAR_2 (ENUM, RETURN, ARG1, ARG2)
DEF_FUNCTION_TYPE_VAR_3 (ENUM, RETURN, ARG1, ARG2, ARG3)
Similar, but for function types that take variable arguments, for example:
DEF_FUNCTION_TYPE_1 (BT_INT_DOUBLE, BT_INT, BT_DOUBLE)
describes the type `int ()(double)', using the enumeral BT_INT_DOUBLE, whereas:
DEF_FUNCTION_TYPE_VAR_1 (BT_INT_DOUBLE_VAR, BT_INT, BT_DOUBLE)
describes the type `int ()(double, ...)'.
DEF_POINTER_TYPE (ENUM, TYPE)
This macro describes a pointer type. ENUM is as above; TYPE is the type pointed to.

3057 void
3058 c_common_nodes_and_builtins (void) in c-common.c
3059 {
3060 enum builtin_type
3061 {
3062 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3063 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3064 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3065 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3066 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3067 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3068 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3069 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3070 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3071 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3072 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3073 #include "builtin-types.def"
3074 #undef DEF_PRIMITIVE_TYPE
3075 #undef DEF_FUNCTION_TYPE_0
3076 #undef DEF_FUNCTION_TYPE_1
3077 #undef DEF_FUNCTION_TYPE_2
3078 #undef DEF_FUNCTION_TYPE_3
3079 #undef DEF_FUNCTION_TYPE_4
3080 #undef DEF_FUNCTION_TYPE_VAR_0
3081 #undef DEF_FUNCTION_TYPE_VAR_1
3082 #undef DEF_FUNCTION_TYPE_VAR_2
3083 #undef DEF_FUNCTION_TYPE_VAR_3
3084 #undef DEF_POINTER_TYPE
3085 BT_LAST
3086 };
3087
3088 typedef enum builtin_type builtin_type;
3089
3090 tree builtin_types[(int) BT_LAST];
3091 int wchar_type_size;
3092 tree array_domain_type;
3093 tree va_list_ref_type_node;
3094 tree va_list_arg_type_node;
3095
3096 /* Define `int' and `char' first so that dbx will output them first. */
3097 record_builtin_type (RID_INT, NULL, integer_type_node);
3098 record_builtin_type (RID_CHAR, "char", char_type_node);
3099
3100 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3101 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3102 but not C. Are the conditionals here needed? */
3103 if (c_dialect_cxx ())
3104 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3105 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3106 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3107 record_builtin_type (RID_MAX, "long unsigned int",
3108 long_unsigned_type_node);
3109 if (c_dialect_cxx ())
3110 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3111 record_builtin_type (RID_MAX, "long long int",
3112 long_long_integer_type_node);
3113 record_builtin_type (RID_MAX, "long long unsigned int",
3114 long_long_unsigned_type_node);
3115 if (c_dialect_cxx ())
3116 record_builtin_type (RID_MAX, "long long unsigned",
3117 long_long_unsigned_type_node);
3118 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3119 record_builtin_type (RID_MAX, "short unsigned int",
3120 short_unsigned_type_node);
3121 if (c_dialect_cxx ())
3122 record_builtin_type (RID_MAX, "unsigned short",
3123 short_unsigned_type_node);
3124
3125 /* Define both `signed char' and `unsigned char'. */
3126 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3127 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);

record_builtin_type pushes the declarations of builtin types into global namespace. Parameter rid_index is the index of the builtin type in the array RID_POINTERS; name is the name used when looking up the builtin type; type is the *_TYPE node of the builtin type. See that, type node is created in build_common_tree_nodes.

2729 void
2730 record_builtin_type (enum rid rid_index, in decl.c
2731 const char* name,
2732 tree type)
2733 {
2734 tree rname = NULL_TREE, tname = NULL_TREE;
2735 tree tdecl = NULL_TREE;
2736
2737 if ((int) rid_index < (int) RID_MAX)
2738 rname = ridpointers[(int) rid_index];
2739 if (name)
2740 tname = get_identifier (name);
2741
2742 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2743 eliminated. Built-in types should not be looked up name; their
2744 names are keywords that the parser can recognize. However, there
2745 is code in c-common.c that uses identifier_global_value to look
2746 up built-in types by name. */
2747 if (tname)
2748 {
2749 tdecl = build_decl (TYPE_DECL, tname, type);
2750 DECL_ARTIFICIAL (tdecl) = 1;
2751 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2752 }
2753 if (rname)
2754 {
2755 if (!tdecl)
2756 {
2757 tdecl = build_decl (TYPE_DECL, rname, type);
2758 DECL_ARTIFICIAL (tdecl) = 1;
2759 }
2760 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2761 }
2762
2763 if (!TYPE_NAME (type))
2764 TYPE_NAME (type) = tdecl;
2765
2766 if (tdecl)
2767 {
2768 TREE_CHAIN (tdecl) = builtin_type_decls;
2769 builtin_type_decls = tdecl;
2770 }
2771 }

By carefully checking reswords, it is interesting to find that, for example, above at line 3105, “long” is the word associates with RID_LONG, but here we expect it should be “long int” – it is the name for programmer; while for those won’t be opened to programmer, NULL will be passed as name.
In above code snippet, it is obvious that name passed in if non-null has priority over reswords of rid_index to be used as the type name.

262 #define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) / in cp-tree.h
263 set_namespace_binding ((NODE), global_namespace, (VAL))

Then SET_IDENTIFIER_GLOBAL_VALUE inserts the NODE into global namespace, and as result, we will get a layout as following figure (only RID_LONG shown).



Figure 35: Nodes for builtin types

See that node pushed by set_namespace_binding is expected to be visited by get_identifier. And along chains of namespace_bindings and bindings, all binding scope defining the identifier can be found out.
4.3.1.7.5.1. Nodes of builtin integer type sizes
In previous, we have seen that, for integer types, such as int, short, have different size upon different platform, so the compiler keeps a set of nodes standing for the standard size. Now it needs to push these nodes into global namespace to make them usable.

c_common_nodes_and_builtins (continue)

3129 /* These are types that c_common_type_for_size and
3130 c_common_type_for_mode use. */
3131 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3132 intQI_type_node));
3133 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3134 intHI_type_node));
3135 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3136 intSI_type_node));
3137 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3138 intDI_type_node));
3139 #if HOST_BITS_PER_WIDE_INT >= 64
3140 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3141 get_identifier ("__int128_t"),
3142 intTI_type_node));
3143 #endif
3144 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3145 unsigned_intQI_type_node));
3146 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3147 unsigned_intHI_type_node));
3148 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3149 unsigned_intSI_type_node));
3150 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3151 unsigned_intDI_type_node));
3152 #if HOST_BITS_PER_WIDE_INT >= 64
3153 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3154 get_identifier ("__uint128_t"),
3155 unsigned_intTI_type_node));
3156 #endif

int*_type_node are nodes indicating sizes of integer types which are also created in build_common_tree_nodes and are alias of *_type nodes in former section of size no larger than 32 bits. For such nodes, the second parameter passed to build_decl is NULL which will be set in the name field of the TYPE_DECL created as the nodes are NOT associated with identifiers (that is they can’t be visited by user). Hook pushdecl carried by lang_hooks is still pushdecl for C++.

566 tree
567 pushdecl (tree x) in name-lookup.c
568 {
569 tree t;
570 tree name;
571 int need_new_binding;
572
573 timevar_push (TV_NAME_LOOKUP);
574
575 need_new_binding = 1;
…
604 name = DECL_NAME (x);
605 if (name)
606 {
...
1007 }
1008
1009 if (need_new_binding)
1010 add_decl_to_level (x,
1011 DECL_NAMESPACE_SCOPE_P (x)
1012 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1013 : current_binding_level);
1014
1015 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1016 }

For those nodes, name fetched at line 604 is NULL. And the nodes are added in namespace (global here) returned by current_binding_level at line 1013 by add_decl_to_level.
Before executing line 3152 of c_common_nodes_and_builtins, the simplified layout is shown in below figure (nodes related to intTI_type_node are not shown and only the first node linked in names field is given).



Figure 36: Nodes for builtin types 2
Macro HOST_BITS_PER_WIDE_INT has following definition:

47 #if HOST_BITS_PER_LONG >= 64 || !defined NEED_64BIT_HOST_WIDE_INT in hwint.h
48 # define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
49 # define HOST_WIDE_INT long
50 #else
51 # if HOST_BITS_PER_LONGLONG >= 64
52 # define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONGLONG
53 # define HOST_WIDE_INT long long
54 # else
55 # if HOST_BITS_PER___INT64 >= 64
56 # define HOST_BITS_PER_WIDE_INT HOST_BITS_PER___INT64
57 # define HOST_WIDE_INT __int64
58 # else
59 #error "Unable to find a suitable type for HOST_WIDE_INT"
60 # endif
61 # endif
62 #endif

To 32 bits system, NEED_64BIT_HOST_WIDE_INT is not defined. Thus HOST_WIDE_INT is long, and HOST_BITS_PER_WIDE_INT is 32. And from here, it is clearly that for 64 bits system, GCC defines types __int128_t and __uint128_t for programmer.

c_common_nodes_and_builtins (continue)

3158 /* Create the widest literal types. */
3159 widest_integer_literal_type_node
3160 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3161 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3162 widest_integer_literal_type_node));
3163
3164 widest_unsigned_literal_type_node
3165 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3166 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3167 widest_unsigned_literal_type_node));
3168
3169 /* `unsigned long' is the standard type for sizeof.
3170 Note that stddef.h uses `unsigned long',
3171 and this must agree, even if long and int are the same size. */
3172 size_type_node =
3173 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3174 signed_size_type_node = c_common_signed_type (size_type_node);
3175 set_sizetype (size_type_node);

For 32 bits system, widest_integer_literal_type_node and widest_unsigned_literal_type_node correspond to 64 bits signed/unsigned integer type, they are also hidden from programmer. At line 3172, size_type_node is the type of operator sizeof, it is “unsigned int” for x86/Linux.