* c-common.h (enum rid): Remove RID_BOUNDED, RID_UNBOUNDED.

	* c-parse.in (reswords): Remove __bounded__ and __unbounded__.
	(rid_to_yy): Remove RID_BOUNDED, RID_UNBOUNDED slots.
	* print-tree.c (print_node): Remove ambient-boundedness.
	* tree.h (tree_common): Remove bounded_flag.
	(BOUNDED_INDIRECT_YPE_P, BOUNDED_POINTER_TYPE_P,
	BOUNDED_REFERENCE_TYPE_P, MAYBE_BOUNDED_INDIRECT_TYPE_P,
	MAYBE_BOUNDED_POINTER_TYPE_P, MAYBE_BOUNDED_REFERENCE_TYPE_P,
	TREE_BOUNDED, TYPE_MAIN_VARIANTS_PHYSICALLY_EQUAL_P,
	TYPE_MAIN_PHYSICAL_VARIANT, TYPE_BOUNDED, TYPE_QUAL_BOUNDED):
	Remove.
	(TYPE_QUALS): Remove BOUNDED.
	(TREE_EXPR_QUALS, TREE_FUNC_QUALS): Remove.
	(TYPE_BOUNDED_VALUE, TYPE_BOUNDED_BASE, TYPE_BOUNDED_EXTENT,
	TYPE_BOUNDED_SUBTYPE, TYPE_UNBOUNDED_VARIANT, TYPE_POINTER_DEPTH,
	TYPE_AMBIENT_BOUNDEDNESS, MAX_POINTER_DEPT,
	VA_LIST_POINTER_DEPTH): Remove.
	(struct tree_type): Remove pointer_depth.
treelang:
	* treetree.c (reswords): Remove __bounded__, __unbounded__.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@67058 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 6 insertions, 189 deletions

diff --git a/gcc/tree.h b/gcc/tree.h
index 47562b284ab..2c5f2d92e10 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -145,8 +145,8 @@ struct tree_common GTY(())
   unsigned public_flag : 1;
   unsigned private_flag : 1;
   unsigned protected_flag : 1;
-  unsigned bounded_flag : 1;
   unsigned deprecated_flag : 1;
+  unsigned unused_1 : 1;
 
   unsigned lang_flag_0 : 1;
   unsigned lang_flag_1 : 1;
@@ -155,7 +155,7 @@ struct tree_common GTY(())
   unsigned lang_flag_4 : 1;
   unsigned lang_flag_5 : 1;
   unsigned lang_flag_6 : 1;
-  unsigned unused_1 : 1;
+  unsigned unused_2 : 1;
 };
 
 /* The following table lists the uses of each of the above flags and
@@ -255,14 +255,6 @@ struct tree_common GTY(())
        TREE_NOTHROW in
            CALL_EXPR, FUNCTION_DECL
 
-   bounded_flag:
-
-       TREE_BOUNDED in
-	   expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL,
-	   IDENTIFIER_NODE
-       TYPE_BOUNDED in
-	   ..._TYPE
-
    deprecated_flag:
 
 	TREE_DEPRECATED in
@@ -471,56 +463,12 @@ extern void tree_operand_check_failed PARAMS ((int, enum tree_code,
    || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
    || TREE_CODE (TYPE) == SET_TYPE)
 
-/* Nonzero if TYPE represents an unbounded pointer or unbounded
-   reference type.  (It should be renamed to INDIRECT_TYPE_P.)  */
+/* Nonzero if TYPE represents a pointer or reference type.
+   (It should be renamed to INDIRECT_TYPE_P.)  */
 
 #define POINTER_TYPE_P(TYPE) \
   (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
 
-/* Nonzero if TYPE represents a bounded pointer or bounded reference type.  */
-
-#define BOUNDED_INDIRECT_TYPE_P(TYPE) \
-  (TREE_CODE (TYPE) == RECORD_TYPE && TREE_TYPE (TYPE))
-
-/* Nonzero if TYPE represents a bounded pointer type.  */
-
-#define BOUNDED_POINTER_TYPE_P(TYPE) \
-  (BOUNDED_INDIRECT_TYPE_P (TYPE) \
-   && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == POINTER_TYPE)
-
-/* Nonzero if TYPE represents a bounded reference type.  Bounded
-   reference types have two specific uses: (1) When a reference is
-   seated to a variable-length RECORD_TYPE that has an array of
-   indeterminate length as its final field.  For all other objects, it
-   is sufficient to check bounds at the time the reference is seated,
-   and assume that all future uses of the reference are safe, since
-   the address of references cannot change.  (2) When a reference
-   supertype is seated to a subtype object.  The bounds "remember"
-   the true size of the complete object, so that subsequent upcasts of
-   the address of the reference will be checked properly (is such a
-   thing valid C++?).  */
-
-#define BOUNDED_REFERENCE_TYPE_P(TYPE) \
-  (BOUNDED_INDIRECT_TYPE_P (TYPE) \
-   && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == REFERENCE_TYPE)
-
-/* Nonzero if TYPE represents a pointer or reference type, either
-   bounded or unbounded.  */
-
-#define MAYBE_BOUNDED_INDIRECT_TYPE_P(TYPE) \
-  (POINTER_TYPE_P (TYPE) || BOUNDED_INDIRECT_TYPE_P (TYPE))
-
-/* Nonzero if TYPE represents a pointer type, either bounded or unbounded.  */
-
-#define MAYBE_BOUNDED_POINTER_TYPE_P(TYPE) \
-  (TREE_CODE (TYPE) == POINTER_TYPE || BOUNDED_POINTER_TYPE_P (TYPE))
-
-/* Nonzero if TYPE represents a reference type, either bounded or
-   unbounded.  */
-
-#define MAYBE_BOUNDED_REFERENCE_TYPE_P(TYPE) \
-  (TREE_CODE (TYPE) == REFERENCE_TYPE || BOUNDED_REFERENCE_TYPE_P (TYPE))
-
 /* Nonzero if this type is a complete type.  */
 #define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
 
@@ -679,40 +627,6 @@ extern void tree_operand_check_failed PARAMS ((int, enum tree_code,
    In a BLOCK node, this is BLOCK_HANDLER_BLOCK.  */
 #define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
 
-/* In a ..._TYPE node, nonzero means that the type's size and layout,
-   (or the size and layout of its arguments and/or return value in the
-   case of a FUNCTION_TYPE or METHOD_TYPE) was changed by the presence
-   of pointer bounds.  Use TYPE_BOUNDED instead of this macro when the
-   node is a type, because eventually we may make that a different
-   bit.  TYPE_BOUNDED doesn't mean that this type is a bounded indirect
-   type--use BOUNDED_POINTER_TYPE_P, BOUNDED_REFERENCE_TYPE_P,
-   BOUNDED_INDIRECT_TYPE_P to test for that.
-
-   In a FUNCTION_DECL, nonzero means that the size and layout of one
-   of its arguments and/or return value was changed by the presence of
-   pointer bounds.  This value can differ from the value of
-   TYPE_BOUNDED (TREE_TYPE (fundecl)) if the function was implicitly
-   declared, then later called with pointer args, or was declared with
-   a variable argument list and is later called with pointer values in
-   the variable argument list.
-
-   In a VAR_DECL, PARM_DECL or FIELD_DECL, TREE_BOUNDED matches the value
-   of the decl's type's BOUNDED_POINTER_TYPE_P.
-
-   In a CONSTRUCTOR or other expression, nonzero means the value is a
-   bounded pointer.  It is insufficient to determine the boundedness
-   of an expression EXP with BOUNDED_POINTER_TYPE_P (TREE_TYPE (EXP)),
-   since we allow pointer to be temporarily cast to integer for
-   rounding up to an alignment boundary in a way that preserves the
-   pointer's bounds.
-
-   In an IDENTIFIER_NODE, nonzero means that the name is prefixed with
-   BP_PREFIX (see varasm.c).  This occurs for the DECL_ASSEMBLER_NAME
-   of a function that has bounded pointer(s) for its return type and/or
-   argument type(s).  */
-
-#define TREE_BOUNDED(NODE) ((NODE)->common.bounded_flag)
-
 /* Nonzero in an IDENTIFIER_NODE if the use of the name is defined as a
    deprecated feature by __attribute__((deprecated)).  */
 #define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag)
@@ -1023,26 +937,6 @@ struct tree_block GTY(())
    structure containing an array.  */
 #define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values)
 
-/* Indirect types present difficulties because they may be represented
-   as either POINTER_TYPE/REFERENCE_TYPE nodes (unbounded) or as
-   RECORD_TYPE nodes (bounded).  Bounded and unbounded pointers might
-   be logically equivalent, but physically different.  Simple
-   comparison of the main variant only tells if the types are
-   logically equivalent.  Use this predicate to compare for physical
-   equivalency.  */
-
-/* Types have the same main variant, and have the same boundedness.  */
-#define TYPE_MAIN_VARIANTS_PHYSICALLY_EQUAL_P(TYPE1, TYPE2)	\
-  (TYPE_MAIN_VARIANT (TYPE1) == TYPE_MAIN_VARIANT (TYPE2)	\
-   && TREE_CODE (TYPE1) == TREE_CODE (TYPE2))
-
-/* Return the type variant that has no qualifiers (i.e., the main variant),
-   except that the boundedness qualifier is preserved.  */
-#define TYPE_MAIN_PHYSICAL_VARIANT(TYPE)		\
-  (BOUNDED_POINTER_TYPE_P (TYPE)			\
-   ? build_qualified_type (TYPE, TYPE_QUAL_BOUNDED)	\
-   : TYPE_MAIN_VARIANT (TYPE))
-
 /* For aggregate types, information about this type, as a base type
    for itself.  Used in a language-dependent way for types that are
    neither a RECORD_TYPE, QUAL_UNION_TYPE, nor a UNION_TYPE.  */
@@ -1114,11 +1008,6 @@ struct tree_block GTY(())
    the term.  */
 #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
 
-/* If nonzero, this type's size and layout, (or the size and layout of
-   its arguments and/or return value in the case of a FUNCTION_TYPE or
-   METHOD_TYPE) was changed by the presence of pointer bounds.  */
-#define TYPE_BOUNDED(NODE) (TYPE_CHECK (NODE)->common.bounded_flag)
-
 /* There is a TYPE_QUAL value for each type qualifier.  They can be
    combined by bitwise-or to form the complete set of qualifiers for a
    type.  */
@@ -1127,25 +1016,12 @@ struct tree_block GTY(())
 #define TYPE_QUAL_CONST    0x1
 #define TYPE_QUAL_VOLATILE 0x2
 #define TYPE_QUAL_RESTRICT 0x4
-#define TYPE_QUAL_BOUNDED  0x8
 
 /* The set of type qualifiers for this type.  */
 #define TYPE_QUALS(NODE)					\
   ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)			\
    | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)		\
-   | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)		\
-   | (BOUNDED_INDIRECT_TYPE_P (NODE) * TYPE_QUAL_BOUNDED))
-
-/* The set of qualifiers pertinent to an expression node.  */
-#define TREE_EXPR_QUALS(NODE)				\
-  ((TREE_READONLY (NODE) * TYPE_QUAL_CONST)		\
-   | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)	\
-   | (TREE_BOUNDED (NODE) * TYPE_QUAL_BOUNDED))
-
-/* The set of qualifiers pertinent to a FUNCTION_DECL node.  */
-#define TREE_FUNC_QUALS(NODE)				\
-  ((TREE_READONLY (NODE) * TYPE_QUAL_CONST)		\
-   | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE))
+   | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
 
 /* These flags are available for each language front end to use internally.  */
 #define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
@@ -1190,65 +1066,6 @@ struct tree_block GTY(())
    compact a way as possible.  */
 #define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
 
-/* A bounded pointer or bounded reference type (collectively called
-   indirect types) is represented as a RECORD_TYPE node containing
-   three pointer fields whose type is the corresponding unbounded
-   POINTER_TYPE or REFERENCE_TYPE.  A RECORD_TYPE node that represents
-   a bounded indirect type differs from a normal RECORD_TYPE node in
-   that its TREE_TYPE is non-NULL and has the pointed-to type just as
-   a POINTER_TYPE or REFERENCE_TYPE node has.  The bounded RECORD_TYPE
-   nodes are stored on the same type variant chain alongside the
-   variants of the underlaying indirect types nodes.  The main variant
-   of such chains is always the unbounded type.  */
-
-/* Access the field decls of a bounded-pointer type.  */
-#define TYPE_BOUNDED_VALUE(TYPE) TYPE_FIELDS (TYPE)
-#define TYPE_BOUNDED_BASE(TYPE) TREE_CHAIN (TYPE_BOUNDED_VALUE (TYPE))
-#define TYPE_BOUNDED_EXTENT(TYPE) TREE_CHAIN (TYPE_BOUNDED_BASE (TYPE))
-
-/* Access the simple-pointer subtype of a bounded-pointer type.  */
-#define TYPE_BOUNDED_SUBTYPE(TYPE) TREE_TYPE (TYPE_BOUNDED_VALUE (TYPE))
-
-/* Find the unbounded counterpart to a type, or return TYPE if it is
-   already unbounded.  */
-#define TYPE_UNBOUNDED_VARIANT(TYPE) \
-  (BOUNDED_POINTER_TYPE_P (TYPE) ? TYPE_BOUNDED_SUBTYPE (TYPE) : (TYPE))
-
-/* This field comprises two bits, for values in the range 0..3:
-
-   depth=0 means that type is a scalar, or an aggregate that contains
-   only depth=0 types, or a function that has only depth=0 types for
-   its return value and argument types.
-
-   depth=1 means that type is a pointer to a depth=0 type, or an
-   aggregate that contains only depth=0 and depth=1 types, or a
-   function that has only depth=0 and depth=1 types for its return
-   value and argument types.
-
-   The meanings of depth=2 and depth=3 are obvious by induction.
-   Varargs functions are depth=3.  The type `va_list' is depth=3.
-
-   The purpose of measuring pointer depth of a type is to determine
-   the eligibility of a function for an automatically-generated
-   bounded-pointer thunk.  A depth=0 functions needs no thunk.  A
-   depth=1 function is eligible for an automatic thunk.  Functions
-   with depth 2 or more are too complex to get automatic thunks.
-
-   Function decls also have a pointer_depth field, since we also
-   consider the actual argument types for functions.  */
-
-#define TYPE_POINTER_DEPTH(TYPE) (TYPE_CHECK (TYPE)->type.pointer_depth)
-
-/* In a FUNCTION_TYPE node, this bit stores the value of
-   default_pointer_boundedness at the time TYPE was created.  It is
-   useful for choosing default boundedness of function arguments for
-   non-prototype function decls and for varargs/stdarg lists.  */
-#define TYPE_AMBIENT_BOUNDEDNESS(TYPE) \
-  (FUNCTION_TYPE_CHECK (TYPE)->type.transparent_union_flag)
-
-#define MAX_POINTER_DEPTH 2
-#define VA_LIST_POINTER_DEPTH 3
-
 struct die_struct;
 
 struct tree_type GTY(())
@@ -1269,7 +1086,7 @@ struct tree_type GTY(())
   unsigned transparent_union_flag : 1;
   unsigned packed_flag : 1;
   unsigned restrict_flag : 1;
-  unsigned pointer_depth : 2;
+  unsigned spare : 2;
 
   unsigned lang_flag_0 : 1;
   unsigned lang_flag_1 : 1;