Then GCC will finialize the choice of inlining functions to flag_inline_trees , and abandon others. For ptrmemfunc_vbit_in_pfn at line 2983, it is enum type ptrmemfunc_vbit_where_t .
2048 enum ptrmemfunc_vbit_where_t in tree.h
2049 {
2050 ptrmemfunc_vbit_in_pfn,
2051 ptrmemfunc_vbit_in_delta
2052 };
It is needed because GCC needs to compile program written by various languages, so a pointer-to-function member type in the system looks like:
struct {
__P __pfn;
ptrdiff_t __delta;
};
If __pfn is NULL, it is a NULL pointer-to-member-function. (Because the vtable is always the first thing in the object, we don't need its offset.) If the function is virtual, then PFN is one plus twice the index into the vtable (the offset from the head of vtable, and lowest significant bit will be 1); otherwise, it is just a pointer to the function (normally, alignment is required on function addresses, and lowest significant bit will be 0, for that case, the lowest bit can tell if the function is virtual or not).
Unfortunately, using the lowest bit of PFN doesn't work in architectures that don't impose alignment requirements on function addresses, or that use the lowest bit to tell one ISA from another, for example. For such architectures, we use the lowest bit of DELTA instead of the lowest bit of the PFN, and DELTA will be multiplied by 2.
No doubt macro TARGET_PTRMEMFUNC_VBIT_LOCATION tells where is bit telling virtual function from common function. For x86, it’s ptrmemfunc_vbit_in_pfn . And variable force_align_functions_log keeps the forced alignment of function (log of radix 2). Of course if it’s 0, means no alignment requirement, which needs be adjusted to 1 (aligned at boundary of even byte).
cxx_init_decl_processing (continue)
2967 /* Adjust various flags based on command-line settings. */
2968 if (!flag_permissive )
2969 flag_pedantic_errors = 1;
2970 if (!flag_no_inline )
2971 {
2972 flag_inline_trees = 1;
2973 flag_no_inline = 1;
2974 }
2975 if (flag_inline_functions )
2976 {
2977 flag_inline_trees = 2;
2978 flag_inline_functions = 0;
2979 }
2980
2981 /* Force minimum function alignment if using the least significant
2982 bit of function pointers to store the virtual bit. */
2983 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2984 && force_align_functions_log < 1)
2985 force_align_functions_log = 1;
2986
2987 /* Initially, C. */
2988 current_lang_name = lang_name_c;
2989
2990 build_common_tree_nodes (flag_signed_char );
2991
2992 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2993 TREE_TYPE (error_mark_list ) = error_mark_node;
In section Create node for internal types , we have seen details about creating tree nodes for internal type below function. Here is the place where these builtin type get generated.
4834 void
4835 build_common_tree_nodes (int signed_char) in tree.c
4836 {
4837 error_mark_node = make_node (ERROR_MARK);
4838 TREE_TYPE (error_mark_node) = error_mark_node;
4839
4840 initialize_sizetypes ();
4841
4842 /* Define both `signed char' and `unsigned char'. */
4843 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4844 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4845
4846 /* Define `char', which is like either `signed char' or `unsigned char'
4847 but not the same as either. */
4848 char_type_node
4849 = (signed_char
4850 ? make_signed_type (CHAR_TYPE_SIZE)
4851 : make_unsigned_type (CHAR_TYPE_SIZE));
4852
4853 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4854 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4855 integer_type_node = make_signed_type (INT_TYPE_SIZE);
4856 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4857 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4858 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4859 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4860 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4861
4862 /* Define a boolean type. This type only represents boolean values but
4863 may be larger than char depending on the value of BOOL_TYPE_SIZE.
4864 Front ends which want to override this size (i.e. Java) can redefine
4865 boolean_type_node before calling build_common_tree_nodes_2. */
4866 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
4867 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
4868 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
4869 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
4870 TYPE_PRECISION (boolean_type_node) = 1;
4871
4872 /* Fill in the rest of the sized types. Reuse existing type nodes
4873 when possible. */
4874 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
4875 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
4876 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
4877 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
4878 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
4879
4880 unsigned_intQI_type_node =make_or_reuse_type(GET_MODE_BITSIZE (QImode), 1);
4881 unsigned_intHI_type_node =make_or_reuse_type(GET_MODE_BITSIZE (HImode), 1);
4882 unsigned_intSI_type_node = make_or_reuse_type(GET_MODE_BITSIZE (SImode), 1);
4883 unsigned_intDI_type_node =make_or_reuse_type(GET_MODE_BITSIZE (DImode), 1);
4884 unsigned_intTI_type_node = make_or_reuse_type(GET_MODE_BITSIZE (TImode), 1);
4885
4886 access_public_node = get_identifier ("public");
4887 access_protected_node = get_identifier ("protected");
4888 access_private_node = get_identifier ("private");
4889 }
In C++, builtin type short, unsighed short, int, etc., whose size depend on the platform. Then in the compiler’s implementation, it binds nodes of these builtin type with nodes of standard size. The nodes of standard size are those intQI_type_node , intHI_type_node , etc. above. The binding is done by make_or_reuse_type . It favors instant knowing the mode of builtin types (that is memory usage), for example, if short_integer_type_node is intHI_type_node , it means type short is of HI mode.
4809 static tree
4810 make_or_reuse_type (unsigned size, int unsignedp) in tree.c
4811 {
4812 if (size == INT_TYPE_SIZE)
4813 return unsignedp ? unsigned_type_node : integer_type_node;
4814 if (size == CHAR_TYPE_SIZE)
4815 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
4816 if (size == SHORT_TYPE_SIZE)
4817 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
4818 if (size == LONG_TYPE_SIZE)
4819 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
4820 if (size == LONG_LONG_TYPE_SIZE)
4821 return (unsignedp ? long_long_unsigned_type_node
4822 : long_long_integer_type_node);
4823
4824 if (unsignedp)
4825 return make_unsigned_type (size);
4826 else
4827 return make_signed_type (size);
4828 }
What’s more, line 4886 ~ 4888, generate nodes for keywords: public, protected, and private.