diff mbox

Rename TYPE_{MIN,MAX}VAL

Message ID 00697666-4e84-5c8e-ec37-8bad1b26abee@acm.org
State New
Headers show

Commit Message

Nathan Sidwell July 18, 2017, 3:19 p.m. UTC 
As I mentioned in my previous patch, we currently have 
TYPE_{MIN,MAX}_VALUES for numeric types and TYPE_{MIN,MAX}VAL for 
type-agnostic access.

This patch renames the latter to TYPE_{MIN,MAX}VAL_RAW, matching 
TYPE_VALUES_RAW, which had a similar problem.

While renaming the macros, I reordered them in tree.h to be grouped by 
the underlying field.  I think that makes more sense here, as the only 
case when grouping as min/max makes most sense is for the numeric types. 
  And mostly when looking at this, I want to discover what things might 
use this field.

Because of that reordering, I'm hesitant to apply the obvious rule.  I'd 
appreciate review.  thanks.

(This patch is not dependent on the TYPE_METHODS removal patch)

nathan

Comments

Richard Biener July 19, 2017, 10:28 a.m. UTC | #1 
On Tue, Jul 18, 2017 at 5:19 PM, Nathan Sidwell <nathan@acm.org> wrote:
> As I mentioned in my previous patch, we currently have TYPE_{MIN,MAX}_VALUES
> for numeric types and TYPE_{MIN,MAX}VAL for type-agnostic access.
>
> This patch renames the latter to TYPE_{MIN,MAX}VAL_RAW, matching
> TYPE_VALUES_RAW, which had a similar problem.
>
> While renaming the macros, I reordered them in tree.h to be grouped by the
> underlying field.  I think that makes more sense here, as the only case when
> grouping as min/max makes most sense is for the numeric types.  And mostly
> when looking at this, I want to discover what things might use this field.
>
> Because of that reordering, I'm hesitant to apply the obvious rule.  I'd
> appreciate review.  thanks.

Looks good but now we have TYPE_MAX_VALUE and TYPE_MAXVAL_RAW.
Why's that not TYPE_MAX_VALUE_RAW?

Ok with some more renaming.

Thanks,
Richard.

> (This patch is not dependent on the TYPE_METHODS removal patch)
>
> nathan
>
> --
> Nathan Sidwell
diff mbox

Patch

2017-07-18  Nathan Sidwell  <nathan@acm.org>

	gcc/ 
	* tree.h (TYPE_MINVAL, TYPE_MAXVAL): Rename to ...
	(TYPE_MINVAL_RAW, TYPE_MAXVAL_RAW): ... these.
	* tree.c (find_decls_types_r, verify_type): Use TYPE_{MIN,MAX}VAL_RAW.
	* lto-streamer-out.c (DFS::DFS_write_tree_body): Likewise.
	(hash_tree): Likewise.
	* tree-streamer-in.c (lto_input_ts_type_non_common_tree_pointers):
	Likewise.
	* tree-streamer-out.c (write_ts_type_non_common_tree_pointers):
	Likewise.

	cp/
	* cp-tree.h (PACK_EXPANSION_PARAMETER_PACKS,
	PACK_EXPANSION_EXTRA_ARGS): Use TYPE_{MIN,MAX}VAL_RAW.

	lto/
	* lto.c (mentions_vars_p_type): Use TYPE_{MIN,MAX}VAL_RAW.
	(compare_tree_sccs_1, lto_fixup_prevailing_decls): Likewise.

	objc/
	* objc-act.h (CLASS_NST_METHODS, CLASS_CLS_METHODS): Use
	TYPE_{MIN,MAX}VAL_RAW.

Index: cp/cp-tree.h
===================================================================
--- cp/cp-tree.h	(revision 250309)
+++ cp/cp-tree.h	(working copy)
@@ -3522,13 +3522,13 @@  extern void decl_shadowed_for_var_insert
 #define PACK_EXPANSION_PARAMETER_PACKS(NODE)		\
   *(TREE_CODE (NODE) == EXPR_PACK_EXPANSION		\
     ? &TREE_OPERAND (NODE, 1)				\
-    : &TYPE_MINVAL (TYPE_PACK_EXPANSION_CHECK (NODE)))
+    : &TYPE_MINVAL_RAW (TYPE_PACK_EXPANSION_CHECK (NODE)))
 
 /* Any additional template args to be applied when substituting into
    the pattern, set by tsubst_pack_expansion for partial instantiations.  */
 #define PACK_EXPANSION_EXTRA_ARGS(NODE)		\
   *(TREE_CODE (NODE) == TYPE_PACK_EXPANSION	\
-    ? &TYPE_MAXVAL (NODE)			\
+    ? &TYPE_MAXVAL_RAW (NODE)			\
     : &TREE_OPERAND ((NODE), 2))
 
 /* True iff this pack expansion is within a function context.  */
Index: lto/lto.c
===================================================================
--- lto/lto.c	(revision 250309)
+++ lto/lto.c	(working copy)
@@ -646,8 +646,8 @@  mentions_vars_p_type (tree t)
   CHECK_NO_VAR (TYPE_ATTRIBUTES (t));
   CHECK_NO_VAR (TYPE_NAME (t));
 
-  CHECK_VAR (TYPE_MINVAL (t));
-  CHECK_VAR (TYPE_MAXVAL (t));
+  CHECK_VAR (TYPE_MINVAL_RAW (t));
+  CHECK_VAR (TYPE_MAXVAL_RAW (t));
 
   /* Accessor is for derived node types only. */
   CHECK_NO_VAR (t->type_non_common.binfo);
@@ -1414,9 +1414,10 @@  compare_tree_sccs_1 (tree t1, tree t2, t
       else if (code == FUNCTION_TYPE
 	       || code == METHOD_TYPE)
 	compare_tree_edges (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
+
       if (!POINTER_TYPE_P (t1))
-	compare_tree_edges (TYPE_MINVAL (t1), TYPE_MINVAL (t2));
-      compare_tree_edges (TYPE_MAXVAL (t1), TYPE_MAXVAL (t2));
+	compare_tree_edges (TYPE_MINVAL_RAW (t1), TYPE_MINVAL_RAW (t2));
+      compare_tree_edges (TYPE_MAXVAL_RAW (t1), TYPE_MAXVAL_RAW (t2));
     }
 
   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
@@ -2580,8 +2581,8 @@  lto_fixup_prevailing_decls (tree t)
       LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t));
       LTO_NO_PREVAIL (TYPE_NAME (t));
 
-      LTO_SET_PREVAIL (TYPE_MINVAL (t));
-      LTO_SET_PREVAIL (TYPE_MAXVAL (t));
+      LTO_SET_PREVAIL (TYPE_MINVAL_RAW (t));
+      LTO_SET_PREVAIL (TYPE_MAXVAL_RAW (t));
       LTO_NO_PREVAIL (t->type_non_common.binfo);
 
       LTO_SET_PREVAIL (TYPE_CONTEXT (t));
Index: lto-streamer-out.c
===================================================================
--- lto-streamer-out.c	(revision 250309)
+++ lto-streamer-out.c	(working copy)
@@ -835,8 +835,8 @@  DFS::DFS_write_tree_body (struct output_
 	DFS_follow_tree_edge (TYPE_ARG_TYPES (expr));
 
       if (!POINTER_TYPE_P (expr))
-	DFS_follow_tree_edge (TYPE_MINVAL (expr));
-      DFS_follow_tree_edge (TYPE_MAXVAL (expr));
+	DFS_follow_tree_edge (TYPE_MINVAL_RAW (expr));
+      DFS_follow_tree_edge (TYPE_MAXVAL_RAW (expr));
       if (RECORD_OR_UNION_TYPE_P (expr))
 	DFS_follow_tree_edge (TYPE_BINFO (expr));
     }
@@ -1271,8 +1271,8 @@  hash_tree (struct streamer_tree_cache_d
 	       || code == METHOD_TYPE)
 	visit (TYPE_ARG_TYPES (t));
       if (!POINTER_TYPE_P (t))
-	visit (TYPE_MINVAL (t));
-      visit (TYPE_MAXVAL (t));
+	visit (TYPE_MINVAL_RAW (t));
+      visit (TYPE_MAXVAL_RAW (t));
       if (RECORD_OR_UNION_TYPE_P (t))
 	visit (TYPE_BINFO (t));
     }
Index: objc/objc-act.h
===================================================================
--- objc/objc-act.h	(revision 250309)
+++ objc/objc-act.h	(working copy)
@@ -179,8 +179,8 @@  enum objc_property_assign_semantics {
 #define CLASS_SUPER_NAME(CLASS) (TYPE_CONTEXT (CLASS))
 #define CLASS_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0)
 #define CLASS_RAW_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 1)
-#define CLASS_NST_METHODS(CLASS) (TYPE_MINVAL (CLASS))
-#define CLASS_CLS_METHODS(CLASS) (TYPE_MAXVAL (CLASS))
+#define CLASS_NST_METHODS(CLASS) (TYPE_MINVAL_RAW (CLASS))
+#define CLASS_CLS_METHODS(CLASS) (TYPE_MAXVAL_RAW (CLASS))
 #define CLASS_STATIC_TEMPLATE(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 2)
 #define CLASS_CATEGORY_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 3)
 #define CLASS_PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 4)
@@ -189,8 +189,8 @@  enum objc_property_assign_semantics {
 
 #define PROTOCOL_NAME(CLASS) (TYPE_NAME (CLASS))
 #define PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0)
-#define PROTOCOL_NST_METHODS(CLASS) (TYPE_MINVAL (CLASS))
-#define PROTOCOL_CLS_METHODS(CLASS) (TYPE_MAXVAL (CLASS))
+#define PROTOCOL_NST_METHODS(CLASS) (TYPE_MINVAL_RAW (CLASS))
+#define PROTOCOL_CLS_METHODS(CLASS) (TYPE_MAXVAL_RAW (CLASS))
 #define PROTOCOL_FORWARD_DECL(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 1)
 #define PROTOCOL_DEFINED(CLASS) TREE_USED (CLASS)
 #define PROTOCOL_OPTIONAL_CLS_METHODS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 2)
Index: tree-streamer-in.c
===================================================================
--- tree-streamer-in.c	(revision 250309)
+++ tree-streamer-in.c	(working copy)
@@ -821,8 +821,8 @@  lto_input_ts_type_non_common_tree_pointe
     TYPE_ARG_TYPES (expr) = stream_read_tree (ib, data_in);
 
   if (!POINTER_TYPE_P (expr))
-    TYPE_MINVAL (expr) = stream_read_tree (ib, data_in);
-  TYPE_MAXVAL (expr) = stream_read_tree (ib, data_in);
+    TYPE_MINVAL_RAW (expr) = stream_read_tree (ib, data_in);
+  TYPE_MAXVAL_RAW (expr) = stream_read_tree (ib, data_in);
   if (RECORD_OR_UNION_TYPE_P (expr))
     TYPE_BINFO (expr) = stream_read_tree (ib, data_in);
 }
Index: tree-streamer-out.c
===================================================================
--- tree-streamer-out.c	(revision 250309)
+++ tree-streamer-out.c	(working copy)
@@ -704,8 +704,8 @@  write_ts_type_non_common_tree_pointers (
     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 
   if (!POINTER_TYPE_P (expr))
-    stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
-  stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
+    stream_write_tree (ob, TYPE_MINVAL_RAW (expr), ref_p);
+  stream_write_tree (ob, TYPE_MAXVAL_RAW (expr), ref_p);
   if (RECORD_OR_UNION_TYPE_P (expr))
     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 }
Index: tree.c
===================================================================
--- tree.c	(revision 250309)
+++ tree.c	(working copy)
@@ -5633,9 +5633,9 @@  find_decls_types_r (tree *tp, int *ws, v
 	 them and thus do not and want not to reach unused pointer types
 	 this way.  */
       if (!POINTER_TYPE_P (t))
-	fld_worklist_push (TYPE_MINVAL (t), fld);
+	fld_worklist_push (TYPE_MINVAL_RAW (t), fld);
       if (!RECORD_OR_UNION_TYPE_P (t))
-	fld_worklist_push (TYPE_MAXVAL (t), fld);
+	fld_worklist_push (TYPE_MAXVAL_RAW (t), fld);
       fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
       /* Do not walk TYPE_NEXT_VARIANT.  We do not stream it and thus
          do not and want not to reach unused variants this way.  */
@@ -13974,7 +13974,7 @@  verify_type (const_tree t)
    }
 
 
-  /* Check various uses of TYPE_MINVAL.  */
+  /* Check various uses of TYPE_MINVAL_RAW.  */
   if (RECORD_OR_UNION_TYPE_P (t))
     {
       /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
@@ -14069,10 +14069,10 @@  verify_type (const_tree t)
 	  error_found = true;
         } 
     }
-  else if (TYPE_MAXVAL (t))
+  else if (TYPE_MAXVAL_RAW (t))
     {
-      error ("TYPE_MAXVAL non-NULL");
-      debug_tree (TYPE_MAXVAL (t));
+      error ("TYPE_MAXVAL_RAW non-NULL");
+      debug_tree (TYPE_MAXVAL_RAW (t));
       error_found = true;
     }
 
Index: tree.h
===================================================================
--- tree.h	(revision 250309)
+++ tree.h	(working copy)
@@ -2103,37 +2103,37 @@  extern machine_mode element_mode (const_
 
 #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)
 #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
-#define TYPE_FIELDS(NODE) \
+#define TYPE_FIELDS(NODE)				\
   (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)
 #define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
-#define TYPE_ARG_TYPES(NODE) \
+#define TYPE_ARG_TYPES(NODE)				\
   (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)
 #define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
 
-#define TYPE_METHODS(NODE) \
-  (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
-#define TYPE_VFIELD(NODE) \
-  (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
-#define TYPE_METHOD_BASETYPE(NODE) \
-  (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)
-#define TYPE_OFFSET_BASETYPE(NODE) \
-  (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)
-#define TYPE_MAXVAL(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval)
-#define TYPE_MINVAL(NODE) (TYPE_CHECK (NODE)->type_non_common.minval)
-#define TYPE_NEXT_PTR_TO(NODE) \
+#define TYPE_MIN_VALUE(NODE)				\
+  (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
+#define TYPE_NEXT_PTR_TO(NODE)				\
   (POINTER_TYPE_CHECK (NODE)->type_non_common.minval)
-#define TYPE_NEXT_REF_TO(NODE) \
+#define TYPE_NEXT_REF_TO(NODE)				\
   (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)
-#define TYPE_MIN_VALUE(NODE) \
-  (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
+#define TYPE_VFIELD(NODE)				\
+  (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
+#define TYPE_MINVAL_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.minval)
+
 #define TYPE_MAX_VALUE(NODE) \
   (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)
-
+#define TYPE_METHODS(NODE)				\
+  (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
+#define TYPE_METHOD_BASETYPE(NODE)			\
+  (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)
+#define TYPE_OFFSET_BASETYPE(NODE)			\
+  (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)
 /* If non-NULL, this is an upper bound of the size (in bytes) of an
    object of the given ARRAY_TYPE_NON_COMMON.  This allows temporaries to be
    allocated.  */
 #define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
   (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval)
+#define TYPE_MAXVAL_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval)
 
 /* For record and union types, information about this type, as a base type
    for itself.  */