Lines Matching defs:FIELD
72 FIELD, /* Declaration inside struct or union */
164 chained together by the ->prev field, which (as the name implies)
166 a given identifier are chained by the ->shadowed field, which runs
169 The ->decl field usually points to a DECL node, but there are two
176 The ->u.type field stores the type of the declaration in this scope;
177 if NULL, the type is the type of the ->decl field. This is only of
182 object, visible or not. The ->inner_comp field (used only at file
186 The ->u.label field is used for labels. It points to a structure
189 The depth field is copied from the scope structure that holds this
191 field (see bind()) and also for a handful of special-case checks.
211 BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */
345 /* The bindings in the scope field which were defined at the point
594 /* If warn_cxx_compat, a list of field names which have bindings,
597 field of the c_bindings structure. */
4947 false otherwise. The field for the contained declarator is left to
5008 element initializes a flexible array field, add the size of that
5119 do go through here. Structure field declarations are done by
5329 tree field;
5330 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5333 if (TREE_CODE (field) != FIELD_DECL)
5335 field_type = strip_array_types (TREE_TYPE (field));
5342 inform (DECL_SOURCE_LOCATION (field), "%qD should be initialized", field);
5609 error ("cannot put object with volatile field into register");
6089 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
6103 /* Detect and ignore out of range field width and process valid
6104 field widths. */
6107 error_at (loc, "bit-field %qs width not an integer constant", name);
6117 "bit-field %qs width not an integer constant expression",
6122 error_at (loc, "bit-field %qs width not an integer constant", name);
6128 error_at (loc, "negative width in bit-field %qs", name);
6133 error_at (loc, "zero width for bit-field %qs", name);
6138 /* Detect invalid bit-field type. */
6143 error_at (loc, "bit-field %qs has invalid type", name);
6149 error_at (loc, "cannot declare bit-field %qs with %<warn_if_not_aligned%> type",
6160 "type of bit-field %qs is a GCC extension", name);
6267 FIELD for a struct or union field; make a FIELD_DECL.
6270 representing the width of the bit-field.
6392 || (decl_context == FIELD
6419 if ((decl_context == NORMAL || decl_context == FIELD)
6426 error_at (loc, "variably modified field at file scope");
6454 /* Adjust the type if a bit-field is being declared,
6550 case FIELD:
6553 "field %qE", name);
6555 error_at (loc, "storage class specified for structure field");
6817 if ((decl_context == NORMAL || decl_context == FIELD)
6827 else if ((decl_context == NORMAL || decl_context == FIELD)
6913 else if (decl_context == FIELD)
6917 /* Field names can in fact have function prototype
6919 the field variably modified, not through being
7309 else if (decl_context == FIELD)
7312 error ("%qs specified for structure field %qE",
7315 error ("%qs specified for structure field",
7320 /* Check the type and width of a bit-field. */
7326 make bit-field accesses atomic, so disallow them. */
7330 error_at (loc, "bit-field %qE has atomic type", name);
7332 error_at (loc, "bit-field has atomic type");
7355 error_at (loc, "alignment specified for bit-field %qE", name);
7357 error_at (loc, "alignment specified for unnamed bit-field");
7371 "alignment of unnamed field");
7453 if (pedantic && decl_context == FIELD
7468 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
7474 error_at (loc, "variable or field %qE declared void", name);
7560 else if (decl_context == FIELD)
7567 /* Structure field. It may not be a function. */
7571 error_at (loc, "field %qE declared as a function", name);
7578 error_at (loc, "field %qE has incomplete type", name);
7580 error_at (loc, "unnamed field has incomplete type");
8445 value = grokdeclarator (declarator, declspecs, FIELD, false,
8456 /* If we currently have a binding for this field, set the
8457 in_struct field in the binding, so that we warn about lookups
8462 /* If the in_struct field is not yet set, push it on a list
8477 which are both fields in the same struct, have duplicate field
8486 /* When using -fplan9-extensions, an anonymous field whose name is a
8487 typedef can duplicate a field name. */
8545 /* When using -fplan9-extensions, an anonymous field whose
8546 name is a typedef can duplicate a field name. */
8560 /* Generate an error for any duplicate field names in FIELDLIST. Munge
8576 the C frontend should proceed with the standard field duplicate
8655 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
8660 would thus be the field rather than the typedef. */
8677 ("using %qD as both field and typedef name is "
8686 /* For each field which has a binding and which was not defined in
8687 an enclosing struct, clear the in_struct field. */
8794 /* Install struct as DECL_CONTEXT of each field decl.
8795 Also process specified field sizes, found in the DECL_INITIAL,
8809 /* If any field is const, the structure type is pseudo-const. */
8814 /* A field that is pseudo-const makes the structure likewise. */
8820 /* Any field that is volatile means variables of this type must be
8825 /* Any field of nominal variable size implies structure is too. */
8897 for (tree field = fieldlist; field; field = DECL_CHAIN (field))
8899 if (TREE_CODE (field) == FIELD_DECL
8900 && DECL_INITIAL (field)
8901 && TREE_TYPE (field) != error_mark_node)
8904 = tree_to_uhwi (DECL_INITIAL (field));
8905 tree type = TREE_TYPE (field);
8908 TREE_TYPE (field)
8910 SET_DECL_MODE (field, TYPE_MODE (TREE_TYPE (field)));
8912 DECL_INITIAL (field) = NULL_TREE;
8915 && TREE_CODE (field) == FIELD_DECL
8916 && TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
8918 tree ftype = TREE_TYPE (field);
8929 TREE_TYPE (field)
8936 && TREE_CODE (field) == FIELD_DECL
8937 && AGGREGATE_TYPE_P (TREE_TYPE (field)))
8939 tree ftype = TREE_TYPE (field);
8945 warning_at (DECL_SOURCE_LOCATION (field),
8951 /* Now we have the truly final field list.
9313 /* Record the min/max values so that we can warn about bit-field
11731 "C++ lookup of %qD would return a field, not a type",
11734 /* If we are parsing a struct, record that a struct field
11993 "signed int" in the case of a bit-field with
Indexes created Mon Apr 13 00:22:24 UTC 2026