Move vector_type_mode to tree.c

...so that it's possible to use TYPE_MODE in tree.h.

2017-08-21  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
	* stor-layout.h (vector_type_mode): Move to...
	* tree.h (vector_type_mode): ...here.
	* stor-layout.c (vector_type_mode): Move to...
	* tree.c (vector_type_mode): ...here.  Include rtl.h and regs.h.

From-SVN: r251221

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3c3e9ffb3a200d447feb28df535973bf090c878f..eaacdca6fa92e30069f71001ce2d69422a94b8cf 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2017-08-21  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       * stor-layout.h (vector_type_mode): Move to...
+       * tree.h (vector_type_mode): ...here.
+       * stor-layout.c (vector_type_mode): Move to...
+       * tree.c (vector_type_mode): ...here.  Include rtl.h and regs.h.
+
 2017-08-21  Richard Biener  <rguenther@suse.de>
 
         * debug.h (struct gcc_debug_hooks): Add die_ref_for_decl and

diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index 3028d55773a83e2ad674c07e2f140f3640d22c17..2275bfc3df129deabc0c316e339bde832920d759 100644 (file)
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -2494,45 +2494,6 @@ min_align_of_type (tree type)
     }
   return align / BITS_PER_UNIT;
 }
-
-/* Vector types need to re-check the target flags each time we report
-   the machine mode.  We need to do this because attribute target can
-   change the result of vector_mode_supported_p and have_regs_of_mode
-   on a per-function basis.  Thus the TYPE_MODE of a VECTOR_TYPE can
-   change on a per-function basis.  */
-/* ??? Possibly a better solution is to run through all the types
-   referenced by a function and re-compute the TYPE_MODE once, rather
-   than make the TYPE_MODE macro call a function.  */
-
-machine_mode
-vector_type_mode (const_tree t)
-{
-  machine_mode mode;
-
-  gcc_assert (TREE_CODE (t) == VECTOR_TYPE);
-
-  mode = t->type_common.mode;
-  if (VECTOR_MODE_P (mode)
-      && (!targetm.vector_mode_supported_p (mode)
-         || !have_regs_of_mode[mode]))
-    {
-      machine_mode innermode = TREE_TYPE (t)->type_common.mode;
-
-      /* For integers, try mapping it to a same-sized scalar mode.  */
-      if (GET_MODE_CLASS (innermode) == MODE_INT)
-       {
-         mode = mode_for_size (TYPE_VECTOR_SUBPARTS (t)
-                               * GET_MODE_BITSIZE (innermode), MODE_INT, 0);
-
-         if (mode != VOIDmode && have_regs_of_mode[mode])
-           return mode;
-       }
-
-      return BLKmode;
-    }
-
-  return mode;
-}
 \f
 /* Create and return a type for signed integers of PRECISION bits.  */
 

diff --git a/gcc/stor-layout.h b/gcc/stor-layout.h
index 84ca01baea4a57d2f863970b00d90d0a1e2bb976..08c37cabd39f64a4d6d821eb26a58111894835aa 100644 (file)
--- a/gcc/stor-layout.h
+++ b/gcc/stor-layout.h
@@ -114,7 +114,4 @@ extern void relayout_decl (tree);
    belongs to a function parameter.  */
 extern tree variable_size (tree);
 
-/* Vector types need to check target flags to determine type.  */
-extern machine_mode vector_type_mode (const_tree);
-
 #endif  // GCC_STOR_LAYOUT_H

diff --git a/gcc/tree.c b/gcc/tree.c
index 07523a69956b093be67548e7be981b436b564809..4f56892bb85dd323389a256e5c881b7cc0fe37f9 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -64,6 +64,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "selftest.h"
 #include "stringpool.h"
 #include "attribs.h"
+#include "rtl.h"
+#include "regs.h"
 
 /* Tree code classes.  */
 
@@ -12610,9 +12612,47 @@ element_mode (const_tree t)
     t = TREE_TYPE (t);
   return TYPE_MODE (t);
 }
- 
 
-/* Veirfy that basic properties of T match TV and thus T can be a variant of
+/* Vector types need to re-check the target flags each time we report
+   the machine mode.  We need to do this because attribute target can
+   change the result of vector_mode_supported_p and have_regs_of_mode
+   on a per-function basis.  Thus the TYPE_MODE of a VECTOR_TYPE can
+   change on a per-function basis.  */
+/* ??? Possibly a better solution is to run through all the types
+   referenced by a function and re-compute the TYPE_MODE once, rather
+   than make the TYPE_MODE macro call a function.  */
+
+machine_mode
+vector_type_mode (const_tree t)
+{
+  machine_mode mode;
+
+  gcc_assert (TREE_CODE (t) == VECTOR_TYPE);
+
+  mode = t->type_common.mode;
+  if (VECTOR_MODE_P (mode)
+      && (!targetm.vector_mode_supported_p (mode)
+         || !have_regs_of_mode[mode]))
+    {
+      machine_mode innermode = TREE_TYPE (t)->type_common.mode;
+
+      /* For integers, try mapping it to a same-sized scalar mode.  */
+      if (GET_MODE_CLASS (innermode) == MODE_INT)
+       {
+         mode = mode_for_size (TYPE_VECTOR_SUBPARTS (t)
+                               * GET_MODE_BITSIZE (innermode), MODE_INT, 0);
+
+         if (mode != VOIDmode && have_regs_of_mode[mode])
+           return mode;
+       }
+
+      return BLKmode;
+    }
+
+  return mode;
+}
+
+/* Verify that basic properties of T match TV and thus T can be a variant of
    TV.  TV should be the more specified variant (i.e. the main variant).  */
 
 static bool

diff --git a/gcc/tree.h b/gcc/tree.h
index 9fbf6402399a2e769b88bb1905868aa180e2d079..47899ce9c7eda57490813469d84e4c9a1616c698 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1852,7 +1852,8 @@ extern void protected_set_expr_location (tree, location_t);
 #define SET_TYPE_MODE(NODE, MODE) \
   (TYPE_CHECK (NODE)->type_common.mode = (MODE))
 
-extern machine_mode element_mode (const_tree t);
+extern machine_mode element_mode (const_tree);
+extern machine_mode vector_type_mode (const_tree);
 
 /* The "canonical" type for this type node, which is used by frontends to
    compare the type for equality with another type.  If two types are