Studying note of GCC-3.4.6 source (136)

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).