5.12.5.2.2.2.1.3.6. Finish the derived RECORD_TYPE – verify members
Next verify the validity of non-method fields of the template instantiation.
check_bases_and_members (continue)
4169 /* Check all the data member declarations. */
4170 check_field_decls (t, &access_decls,
4171 &cant_have_default_ctor,
4172 &cant_have_const_ctor,
4173 &no_const_asn_ref);
Notice line 2996 below, the context of the data memebers need be updated to the RECORD_TYPE of instantiation. But for TYPE_DECL or TEMPLATE_DECL, during subsititution as we see in previous section, their contexts have been subsitituted accordingly. Don’t touch them.
2917 static void
2918 check_field_decls (tree t, tree *access_decls, in class.c
2919 int *cant_have_default_ctor_p,
2920 int *cant_have_const_ctor_p,
2921 int *no_const_asn_ref_p)
2922 {
2923 tree *field;
2924 tree *next;
2925 int has_pointers;
2926 int any_default_members;
2927
2928 /* Assume there are no access declarations. */
2929 *access_decls = NULL_TREE;
2930 /* Assume this class has no pointer members. */
2931 has_pointers = 0;
2932 /* Assume none of the members of this class have default
2933 initializations. */
2934 any_default_members = 0;
2935
2936 for (field = &TYPE_FIELDS (t); *field; field = next)
2937 {
2938 tree x = *field;
2939 tree type = TREE_TYPE (x);
2940
2941 next = &TREE_CHAIN (x);
2942
2943 if (TREE_CODE (x) == FIELD_DECL)
2944 {
2945 if (TYPE_PACKED (t))
2946 {
2947 if (!pod_type_p (TREE_TYPE (x)) && !TYPE_PACKED (TREE_TYPE (x)))
2948 cp_warning_at
2949 ("ignoring packed attribute on unpacked non-POD field `%#D'",
2950 x);
2951 else
2952 DECL_PACKED (x) = 1;
2953 }
2954
2955 if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
2956 /* We don't treat zero-width bitfields as making a class
2957 non-empty. */
2958 ;
2959 else
2960 {
2961 tree element_type;
2962
2963 /* The class is non-empty. */
2964 CLASSTYPE_EMPTY_P (t) = 0;
2965 /* The class is not even nearly empty. */
2966 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
2967 /* If one of the data members contains an empty class,
2968 so does T. */
2969 element_type = strip_array_types (type);
2970 if (CLASS_TYPE_P (element_type)
2971 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
2972 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
2973 }
2974 }
2975
2976 if (TREE_CODE (x) == USING_DECL)
2977 {
2978 /* Prune the access declaration from the list of fields. */
2979 *field = TREE_CHAIN (x);
2980
2981 /* Save the access declarations for our caller. */
2982 *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2983
2984 /* Since we've reset *FIELD there's no reason to skip to the
2985 next field. */
2986 next = field;
2987 continue ;
2988 }
2989
2990 if (TREE_CODE (x) == TYPE_DECL
2991 || TREE_CODE (x) == TEMPLATE_DECL)
2992 continue ;
2993
2994 /* If we've gotten this far, it's a data member, possibly static,
2995 or an enumerator. */
2996 DECL_CONTEXT (x) = t;
2997
2998 /* When this goes into scope, it will be a non-local reference. */
2999 DECL_NONLOCAL (x) = 1;
3000
3001 if (TREE_CODE (t) == UNION_TYPE)
3002 {
3003 /* [class.union]
3004
3005 If a union contains a static data member, or a member of
3006 reference type, the program is ill-formed. */
3007 if (TREE_CODE (x) == VAR_DECL)
3008 {
3009 cp_error_at ("`%D' may not be static because it is a member of a union", x);
3010 continue ;
3011 }
3012 if (TREE_CODE (type) == REFERENCE_TYPE)
3013 {
3014 cp_error_at ("`%D' may not have reference type `%T' because it is a member of a union",
3015 x, type);
3016 continue ;
3017 }
3018 }
3019
3020 /* ``A local class cannot have static data members.'' ARM 9.4 */
3021 if (current_function_decl && TREE_STATIC (x))
3022 cp_error_at ("field `%D' in local class cannot be static", x);
3023
3024 /* Perform error checking that did not get done in
3025 grokdeclarator. */
3026 if (TREE_CODE (type) == FUNCTION_TYPE)
3027 {
3028 cp_error_at ("field `%D' invalidly declared function type",
3029 x);
3030 type = build_pointer_type (type);
3031 TREE_TYPE (x) = type;
3032 }
3033 else if (TREE_CODE (type) == METHOD_TYPE)
3034 {
3035 cp_error_at ("field `%D' invalidly declared method type", x);
3036 type = build_pointer_type (type);
3037 TREE_TYPE (x) = type;
3038 }
3039
3040 if (type == error_mark_node)
3041 continue ;
3042
3043 if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3044 continue ;
3045
3046 /* Now it can only be a FIELD_DECL. */
3047
3048 if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3049 CLASSTYPE_NON_AGGREGATE (t) = 1;
3050
3051 /* If this is of reference type, check if it needs an init.
3052 Also do a little ANSI jig if necessary. */
3053 if (TREE_CODE (type) == REFERENCE_TYPE)
3054 {
3055 CLASSTYPE_NON_POD_P (t) = 1;
3056 if (DECL_INITIAL (x) == NULL_TREE)
3057 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3058
3059 /* ARM $12.6.2: [A member initializer list] (or, for an
3060 aggregate, initialization by a brace-enclosed list) is the
3061 only way to initialize nonstatic const and reference
3062 members. */
3063 *cant_have_default_ctor_p = 1;
3064 TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3065
3066 if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3067 && extra_warnings )
3068 cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3069 }
3070
3071 type = strip_array_types (type);
3072
3073 if (TYPE_PTR_P (type))
3074 has_pointers = 1;
3075
3076 if (CLASS_TYPE_P (type))
3077 {
3078 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3079 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3080 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3081 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3082 }
3083
3084 if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3085 CLASSTYPE_HAS_MUTABLE (t) = 1;
3086
3087 if (! pod_type_p (type))
3088 /* DR 148 now allows pointers to members (which are POD themselves),
3089 to be allowed in POD structs. */
3090 CLASSTYPE_NON_POD_P (t) = 1;
3091
3092 if (! zero_init_p (type))
3093 CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3094
3095 /* If any field is const, the structure type is pseudo-const. */
3096 if (CP_TYPE_CONST_P (type))
3097 {
3098 C_TYPE_FIELDS_READONLY (t) = 1;
3099 if (DECL_INITIAL (x) == NULL_TREE)
3100 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3101
3102 /* ARM $12.6.2: [A member initializer list] (or, for an
3103 aggregate, initialization by a brace-enclosed list) is the
3104 only way to initialize nonstatic const and reference
3105 members. */
3106 *cant_have_default_ctor_p = 1;
3107 TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3108
3109 if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3110 && extra_warnings )
3111 cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3112 }
3113 /* A field that is pseudo-const makes the structure likewise. */
3114 else if (CLASS_TYPE_P (type))
3115 {
3116 C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3117 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3118 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3119 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3120 }
3121
3122 /* Core issue 80: A nonstatic data member is required to have a
3123 different name from the class iff the class has a
3124 user-defined constructor. */
3125 if (constructor_name_p (DECL_NAME (x), t) && TYPE_HAS_CONSTRUCTOR (t))
3126 cp_pedwarn_at ("field `%#D' with same name as class", x);
3127
3128 /* We set DECL_C_BIT_FIELD in grokbitfield.
3129 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3130 if (DECL_C_BIT_FIELD (x))
3131 check_bitfield_decl (x);
3132 else
3133 check_field_decl (x, t,
3134 cant_have_const_ctor_p,
3135 cant_have_default_ctor_p,
3136 no_const_asn_ref_p,
3137 &any_default_members);
3138 }
3139
3140 /* Effective C++ rule 11. */
3141 if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
3142 && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3143 {
3144 warning ("`%#T' has pointer data members", t);
3145
3146 if (! TYPE_HAS_INIT_REF (t))
3147 {
3148 warning (" but does not override `%T(const %T&)'", t, t);
3149 if (! TYPE_HAS_ASSIGN_REF (t))
3150 warning (" or `operator=(const %T&)'", t);
3151 }
3152 else if (! TYPE_HAS_ASSIGN_REF (t))
3153 warning (" but does not override `operator=(const %T&)'", t);
3154 }
3155
3156
3157 /* Check anonymous struct/anonymous union fields. */
3158 finish_struct_anon (t);
3159
3160 /* We've built up the list of access declarations in reverse order.
3161 Fix that now. */
3162 *access_decls = nreverse (*access_decls);
3163 }
Notice that within class definition, VAR_DECL is created for static data member. In union type, static member and reference type are not allowed. Further, GCC offers a feature that a class can be defined within a function, which is called local class; and as a restriction, no static member is permitted within.
At line 3049, CLASSTYPE_NON_AGGREGATE is nonzero means that an object of this type can not be initialized using an initializer list. For that field, if it is a reference (line 3053), or if it is constant; this field only can only be initialized by constructor. Get warning message, if this rule is broken.
Further if the class contains member of pointer, if it hasn’t copy constructor and assignment operator, this field will get wrong value by the copy constructor generated by the compiler. Need give warning for this case too.
C and C++ allows bit-field declaration for integer or enumeration, refer to section Treatment for Bit Field Decl for relative information. For such field, needs check_bitfield_decl verify if the size of the field is appropriate for its value.
2732 static void
2733 check_bitfield_decl (tree field) in class.c
2734 {
2735 tree type = TREE_TYPE (field);
2736 tree w = NULL_TREE;
2737
2738 /* Detect invalid bit-field type. */
2739 if (DECL_INITIAL (field)
2740 && ! INTEGRAL_TYPE_P (TREE_TYPE (field)))
2741 {
2742 cp_error_at ("bit-field `%#D' with non-integral type", field);
2743 w = error_mark_node;
2744 }
2745
2746 /* Detect and ignore out of range field width. */
2747 if (DECL_INITIAL (field))
2748 {
2749 w = DECL_INITIAL (field);
2750
2751 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2752 STRIP_NOPS (w);
2753
2754 /* detect invalid field size. */
2755 if (TREE_CODE (w) == CONST_DECL)
2756 w = DECL_INITIAL (w);
2757 else
2758 w = decl_constant_value (w);
2759
2760 if (TREE_CODE (w) != INTEGER_CST)
2761 {
2762 cp_error_at ("bit-field `%D' width not an integer constant",
2763 field);
2764 w = error_mark_node;
2765 }
2766 else if (tree_int_cst_sgn (w) < 0)
2767 {
2768 cp_error_at ("negative width in bit-field `%D'", field);
2769 w = error_mark_node;
2770 }
2771 else if (integer_zerop (w) && DECL_NAME (field) != 0)
2772 {
2773 cp_error_at ("zero width for bit-field `%D'", field);
2774 w = error_mark_node;
2775 }
2776 else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2777 && TREE_CODE (type) != ENUMERAL_TYPE
2778 && TREE_CODE (type) != BOOLEAN_TYPE)
2779 cp_warning_at ("width of `%D' exceeds its type", field);
2780 else if (TREE_CODE (type) == ENUMERAL_TYPE
2781 && (0 > compare_tree_int (w,
2782 min_precision (TYPE_MIN_VALUE (type),
2783 TREE_UNSIGNED (type)))
2784 || 0 > compare_tree_int (w,
2785 min_precision
2786 (TYPE_MAX_VALUE (type),
2787 TREE_UNSIGNED (type)))))
2788 cp_warning_at ("`%D' is too small to hold all values of `%#T'",
2789 field, type);
2790 }
2791
2792 /* Remove the bit-field width indicator so that the rest of the
2793 compiler does not treat that value as an initializer. */
2794 DECL_INITIAL (field) = NULL_TREE;
2795
2796 if (w != error_mark_node)
2797 {
2798 DECL_SIZE (field) = convert (bitsizetype, w);
2799 DECL_BIT_FIELD (field) = 1;
2800 }
2801 else
2802 {
2803 /* Non-bit-fields are aligned for their type. */
2804 DECL_BIT_FIELD (field) = 0;
2805 CLEAR_DECL_C_BIT_FIELD (field);
2806 }
2807 }
For normal fields, it needs step into the field of class type. See that some characteristics of the type are determined by its fields. It need collect this information here field by field.
2813 static void
2814 check_field_decl (tree field, in class.c
2815 tree t,
2816 int* cant_have_const_ctor,
2817 int* cant_have_default_ctor,
2818 int* no_const_asn_ref,
2819 int* any_default_members)
2820 {
2821 tree type = strip_array_types (TREE_TYPE (field));
2822
2823 /* An anonymous union cannot contain any fields which would change
2824 the settings of CANT_HAVE_CONST_CTOR and friends. */
2825 if (ANON_UNION_TYPE_P (type))
2826 ;
2827 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2828 structs. So, we recurse through their fields here. */
2829 else if (ANON_AGGR_TYPE_P (type))
2830 {
2831 tree fields;
2832
2833 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2834 if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2835 check_field_decl (fields, t, cant_have_const_ctor,
2836 cant_have_default_ctor, no_const_asn_ref,
2837 any_default_members);
2838 }
2839 /* Check members with class type for constructors, destructors,
2840 etc. */
2841 else if (CLASS_TYPE_P (type))
2842 {
2843 /* Never let anything with uninheritable virtuals
2844 make it through without complaint. */
2845 abstract_virtuals_error (field, type);
2846
2847 if (TREE_CODE (t) == UNION_TYPE)
2848 {
2849 if (TYPE_NEEDS_CONSTRUCTING (type))
2850 cp_error_at ("member `%#D' with constructor not allowed in union",
2851 field);
2852 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2853 cp_error_at ("member `%#D' with destructor not allowed in union",
2854 field);
2855 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2856 cp_error_at ("member `%#D' with copy assignment operator not allowed in union",
2857 field);
2858 }
2859 else
2860 {
2861 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2862 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2863 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2864 TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2865 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2866 }
2867
2868 if (!TYPE_HAS_CONST_INIT_REF (type))
2869 *cant_have_const_ctor = 1;
2870
2871 if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2872 *no_const_asn_ref = 1;
2873
2874 if (TYPE_HAS_CONSTRUCTOR (type)
2875 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2876 *cant_have_default_ctor = 1;
2877 }
2878 if (DECL_INITIAL (field) != NULL_TREE)
2879 {
2880 /* `build_class_init_list' does not recognize
2881 non-FIELD_DECLs. */
2882 if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2883 error ("multiple fields in union `%T' initialized", t);
2884 *any_default_members = 1;
2885 }
2886 }
For annonymous union/struct field, checking in check_field_decl is not enough – the function just verifies the fields are validate in normal, but for annonymous union/struct some fields are not allowed. At line 2845 abstract_virtuals_error checks if class contains pure virtual function is used or not (note that abstract base is skipped, see why in following paragraphes), in which below CLASSTYPE_PURE_VIRTUALS holds the chain of pure virtual functions that have not been overrided.
125 int
126 abstract_virtuals_error (tree decl, tree type) typeck2.c
127 {
128 tree u;
129 tree tu;
130
131 if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type))
132 return 0;
133
134 if (!TYPE_SIZE (type))
135 /* TYPE is being defined, and during that time
136 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
137 return 0;
138
139 if (dependent_type_p (type))
140 /* For a dependent type, we do not yet know which functions are pure
141 virtuals. */
142 return 0;
143
144 u = CLASSTYPE_PURE_VIRTUALS (type);
145 if (decl)
146 {
147 if (TREE_CODE (decl) == RESULT_DECL)
148 return 0;
149
150 if (TREE_CODE (decl) == VAR_DECL)
151 error ("cannot declare variable `%D' to be of type `%T'",
152 decl, type);
153 else if (TREE_CODE (decl) == PARM_DECL)
154 error ("cannot declare parameter `%D' to be of type `%T'",
155 decl, type);
156 else if (TREE_CODE (decl) == FIELD_DECL)
157 error ("cannot declare field `%D' to be of type `%T'",
158 decl, type);
159 else if (TREE_CODE (decl) == FUNCTION_DECL
160 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
161 error ("invalid return type for member function `%#D'", decl);
162 else if (TREE_CODE (decl) == FUNCTION_DECL)
163 error ("invalid return type for function `%#D'", decl);
164 }
165 else
166 error ("cannot allocate an object of type `%T'", type);
167
168 /* Only go through this once. */
169 if (TREE_PURPOSE (u) == NULL_TREE)
170 {
171 TREE_PURPOSE (u) = error_mark_node;
172
173 error (" because the following virtual functions are abstract:");
174 for (tu = u; tu; tu = TREE_CHAIN (tu))
175 cp_error_at ("/t%#D", TREE_VALUE (tu));
176 }
177 else
178 error (" since type `%T' has abstract virtual functions", type);
179
180 return 1;
181 }
The further checking is carried out later in finish_struct_anon at line 3158 in check_field_decls .
2522 static void
2523 finish_struct_anon (tree t) in class.c
2524 {
2525 tree field;
2526
2527 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2528 {
2529 if (TREE_STATIC (field))
2530 continue ;
2531 if (TREE_CODE (field) != FIELD_DECL)
2532 continue ;
2533
2534 if (DECL_NAME (field) == NULL_TREE
2535 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2536 {
2537 tree elt = TYPE_FIELDS (TREE_TYPE (field));
2538 for (; elt; elt = TREE_CHAIN (elt))
2539 {
2540 /* We're generally only interested in entities the user
2541 declared, but we also find nested classes by noticing
2542 the TYPE_DECL that we create implicitly. You're
2543 allowed to put one anonymous union inside another,
2544 though, so we explicitly tolerate that. We use
2545 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2546 we also allow unnamed types used for defining fields. */
2547 if (DECL_ARTIFICIAL (elt)
2548 && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2549 || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2550 continue ;
2551
2552 if (TREE_CODE (elt) != FIELD_DECL)
2553 {
2554 cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
2555 elt);
2556 continue ;
2557 }
2558
2559 if (TREE_PRIVATE (elt))
2560 cp_pedwarn_at ("private member `%#D' in anonymous union",
2561 elt);
2562 else if (TREE_PROTECTED (elt))
2563 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2564 elt);
2565
2566 TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2567 TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2568 }
2569 }
2570 }
2571 }
In the code, DECL_ARTIFICIAL is nonzero, if the entity is generated by the compiler instead by declaration by user. And DECL_IMPLICIT_TYPEDEF_P is set, for example, in TYPE_DECL associated with RECORD_TYPE to indicate the implicit typedef for the type (and remember then the TYPE_DECL has tag DECL_ARTIFICIAL).