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

5.12.5.2.2.2.1.3.6.


完成派生类的

RECORD_TYPE

–

验证成员


接着验证模板具现体的非方法成员的有效性。

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

注意下面的
2996
行，数据成员的上下文（
context
）应该被更新为具现体的
RECORD_TYPE
节点。但对于
TYPE_DECL
或
TEMPLATE_DECL
，正如我们在前面章节所见的，在替换过程中，其上下文已经被相应地替换了。不要动它们。

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

}

注意到在类的定义中，
VAR_DECL
是为静态数据成员所构建的。在联合类型中，不允许出现静态成员及引用类型。进一步的，
GCC
提供了一个特性：一个类可以被定义在一个函数体内，这称之为局部类（
local class
）；而作为一个限制，其中不能使用静态成员。

在
3049
行，
CLASSTYPE_NON_AGGREGATE
不为
0
表示这个类型的一个对象不能使用一个初始化列表来初始化。对于这样的域，如果它是一个引用（
3053
行），或者它是一个常量；这个域只能通过构造函数来初始化。如果违反了这个规则，编译器将给出警告。

进而如果类含有指针成员，如果它没有拷贝构造函数及赋值操作符，通过编译器产生的拷贝构造函数，这个域将得到错误的值。也需要为这个情形给出警告。

C
及
C++
允许整形或枚举的位域（
bit-field
）声明，相关信息参考
位域声明节点的处理

一节。对于这样的域，需要
check_bitfield_decl

来验证域的大小与其取值是否适合。

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

}

而对于普通的域，需要进入类类型的域。看到类型的某些特征由其包含的域确定。需要一个一个域地来收集这些信息。

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

}

对于匿名的
union/struct
域，
check_field_decl

中的检查是不够的——该函数仅验证通常的域是否有效，但是对于匿名的
union/struct
某些域是不允许的。在
2845
行，
abstract_virtuals_error

检查类是否含有纯虚函数（注意到虚基类被跳过了，下面可以看到为什么这样），其中下面的
CLASSTYPE_PURE_VIRTUALS
保存了未被重载的纯虚函数构成的链表。

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

}

进一步的检查在
check_field_decls

的
3158
行的
finish_struct_anon

中进行。

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

}

在代码中，
DECL_ARTIFICIAL
为非
0
值，如果该实体是由编译器产生的而不是由用户声明的。而
DECL_IMPLICIT_TYPEDEF_P
被设置，例如在
RECORD_TYPE
对应的
TYPE_DECL
中，来表示这是该类型的隐含声明的
typedef
（记得该
TYPE_DECL
有标签
DECL_ARTIFICIAL
）。