move vector code out of scalar_to_cil (in new function vector_to_cil)

add function type_to_cil
use new functions


git-svn-id: https://gcc.gnu.org/svn/gcc/branches/st/cli-be@149477 138bc75d-0d04-0410-961f-82ee72b054a4

4 files changed, 139 insertions, 125 deletions

diff --git a/gcc/config/cil32/cil-dump.c b/gcc/config/cil32/cil-dump.c
index 8dcfef3f01c..966573b0d5c 100644
--- a/gcc/config/cil32/cil-dump.c
+++ b/gcc/config/cil32/cil-dump.c
@@ -167,24 +167,24 @@ dump_type (const_tree type)
     {
       printf ("void");
     }
-  else if (value_type_p(type))
-    {
-      if (TREE_CODE (type) == COMPLEX_TYPE)
-	{
-	  printf ("complex_type ");
-	  dump_type (TREE_TYPE (type));
-	}
-      else
-	{
-	  printf ("value_type ");
-	  dump_valuetype_name (TYPE_MAIN_VARIANT (type));
-	}
-    }
   else
     {
       cil_type_t cil_type = scalar_to_cil (type);
-      if (cil_type == CIL_POINTER)
+      switch (cil_type)
 	{
+	case CIL_VALUE_TYPE:
+	  if (TREE_CODE (type) == COMPLEX_TYPE)
+	    {
+	      printf ("complex_type ");
+	      dump_type (TREE_TYPE (type));
+	    }
+	  else
+	    {
+	      printf ("value_type ");
+	      dump_valuetype_name (TYPE_MAIN_VARIANT (type));
+	    }
+	  break;
+	case CIL_POINTER:
 	  if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 	    {
 	      printf ("method_pointer");
@@ -194,9 +194,11 @@ dump_type (const_tree type)
 	      dump_type (TREE_TYPE (type));
 	      printf (" *");
 	    }
+	  break;
+	default:
+	  printf ("%s", cil_type_names [cil_type]);
+	  break;
 	}
-      else
-	printf ("%s", cil_type_names [cil_type]);
     }
 }
 
diff --git a/gcc/config/cil32/cil-lower.c b/gcc/config/cil32/cil-lower.c
index 685ebadd056..6e2c327bf66 100644
--- a/gcc/config/cil32/cil-lower.c
+++ b/gcc/config/cil32/cil-lower.c
@@ -86,7 +86,7 @@ lower_cil_vector_ctor (const_cil_stmt ctor)
 {
   enum cil32_builtin builtin;
   tree type = cil_type (ctor);
-  cil_type_t cil_type = scalar_to_cil (type);
+  cil_type_t cil_type = vector_to_cil (type);
 
   /* Depending on the chosen back end, a VEC_CTOR node translates to different
      constructs. In the case of GCC_SIMD, it is a call to the static method,
@@ -140,7 +140,7 @@ lower_cil_ldvec (const_cil_stmt stmt)
 {
   enum cil32_builtin builtin;
   tree type = cil_type (stmt);
-  cil_type_t cil_type = scalar_to_cil (type);
+  cil_type_t cil_type = vector_to_cil (type);
 
   /* The MONO_SIMD back end has support for aligned accesses.  */
   if ((backend == MONO_SIMD) && (cil_prefix_unaligned (stmt) == 0))
@@ -171,7 +171,7 @@ lower_cil_stvec (const_cil_stmt stmt)
 {
   enum cil32_builtin builtin;
   tree type = cil_type (stmt);
-  cil_type_t cil_type = scalar_to_cil (type);
+  cil_type_t cil_type = vector_to_cil (type);
 
   /* The MONO_SIMD back end has support for aligned accesses.  */
   if ((backend == MONO_SIMD) && (cil_prefix_unaligned (stmt) == 0))
@@ -422,18 +422,18 @@ cil_lower_init (cil_seq init_seq)
       enum cil_opcode opcode = cil_opcode (stmt);
 
       switch (opcode)
-        {
+	{
 	case CIL_VEC_CTOR:
 	  stmt = lower_cil_vector_ctor (stmt);
 	  csi_replace (&csi, stmt);
 	  break;
 
-        case CIL_LDVEC:
+	case CIL_LDVEC:
 	  stmt = lower_cil_ldvec (stmt);
 	  csi_replace (&csi, stmt);
 	  break;
 
-        case CIL_STVEC:
+	case CIL_STVEC:
 	  stmt = lower_cil_stvec (stmt);
 	  csi_replace (&csi, stmt);
 	  break;
@@ -597,3 +597,9 @@ struct tree_opt_pass pass_lower_cil =
   0,                                    /* todo_flags_finish */
   0                                     /* letter */
 };
+
+/*
+ * Local variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/gcc/config/cil32/cil-stack.c b/gcc/config/cil32/cil-stack.c
index 9023d855b53..bfaca5325c0 100644
--- a/gcc/config/cil32/cil-stack.c
+++ b/gcc/config/cil32/cil-stack.c
@@ -47,7 +47,8 @@ Erven Rohou             <erven.rohou@inria.fr>
  * Local functions prototypes                                                 *
  ******************************************************************************/
 
-static bool vector_type_p (tree);
+static bool value_type_p (const_tree);
+static bool vector_type_p (const_tree);
 static cil_type_t cil_binary_op_type (enum cil_opcode, cil_type_t, cil_type_t);
 
 /******************************************************************************
@@ -219,10 +220,7 @@ cil_stack_after_stmt (cil_stack stack, cil_stmt stmt)
       if (opcode == CIL_LDFLD)
 	VEC_pop (cil_type_t, vstack);
 
-      if (value_type_p (type))
-	VEC_safe_push (cil_type_t, heap, vstack, CIL_VALUE_TYPE);
-      else
-	VEC_safe_push (cil_type_t, heap, vstack, scalar_to_cil (type));
+      VEC_safe_push (cil_type_t, heap, vstack, type_to_cil (type));
 
       break;
 
@@ -268,7 +266,7 @@ cil_stack_after_stmt (cil_stack stack, cil_stmt stmt)
     case CIL_LDVEC:
       {
 	tree type = cil_type (stmt);
-	cil_type_t cil_type = scalar_to_cil (type);
+	cil_type_t cil_type = vector_to_cil (type);
 	VEC_pop (cil_type_t, vstack);
 	VEC_quick_push (cil_type_t, vstack, cil_type);
       }
@@ -304,22 +302,13 @@ cil_stack_after_stmt (cil_stack stack, cil_stmt stmt)
       break;
 
     case CIL_LDARG:
-    case CIL_LDLOC:
-      if (opcode == CIL_LDARG)
-	type = DECL_ARG_TYPE (cil_var (stmt));
-      else
-	type = TREE_TYPE (cil_var (stmt));
-
-      if (value_type_p (type))
-	VEC_safe_push (cil_type_t, heap, vstack, CIL_VALUE_TYPE);
-      else if (vector_type_p (type))
-	{
-	  cil_type_t cil_type = scalar_to_cil (type);
-	  VEC_safe_push (cil_type_t, heap, vstack, cil_type);
-	}
-      else
-	VEC_safe_push (cil_type_t, heap, vstack, scalar_to_cil (type));
+      type = DECL_ARG_TYPE (cil_var (stmt));
+      VEC_safe_push (cil_type_t, heap, vstack, type_to_cil (type));
+      break;
 
+    case CIL_LDLOC:
+      type = TREE_TYPE (cil_var (stmt));
+      VEC_safe_push (cil_type_t, heap, vstack, type_to_cil (type));
       break;
 
     case CIL_LDARGA:
@@ -362,14 +351,7 @@ cil_stack_after_stmt (cil_stack stack, cil_stmt stmt)
       type = TREE_TYPE (cil_call_ftype (stmt));
 
       if (!VOID_TYPE_P (type))
-	{
-	  if (vector_type_p (type))
-	    VEC_safe_push (cil_type_t, heap, vstack, scalar_to_cil (type));
-	  else if (value_type_p (type))
-	    VEC_safe_push (cil_type_t, heap, vstack, CIL_VALUE_TYPE);
-	  else
-	    VEC_safe_push (cil_type_t, heap, vstack, scalar_to_cil (type));
-	}
+	VEC_safe_push (cil_type_t, heap, vstack, type_to_cil (type));
 
       break;
 
@@ -382,19 +364,14 @@ cil_stack_after_stmt (cil_stack stack, cil_stmt stmt)
       type = TREE_TYPE (cil_call_ftype (stmt));
 
       if (!VOID_TYPE_P (type))
-	{
-	  if (value_type_p (type))
-	    VEC_safe_push (cil_type_t, heap, vstack, CIL_VALUE_TYPE);
-	  else
-	    VEC_safe_push (cil_type_t, heap, vstack, scalar_to_cil (type));
-	}
+	VEC_safe_push (cil_type_t, heap, vstack, type_to_cil (type));
 
       break;
 
     case CIL_VEC_CTOR:
       {
 	tree type = cil_type (stmt);
-	cil_type_t cil_type = scalar_to_cil (type);
+	cil_type_t cil_type = vector_to_cil (type);
 	unsigned int num_elts = TYPE_VECTOR_SUBPARTS (type);
 
 	while (num_elts-- != 0)
@@ -642,76 +619,98 @@ scalar_to_cil (const_tree type)
     case POINTER_TYPE:
       return CIL_POINTER;
 
-    case VECTOR_TYPE:
-      {
-	cil_type_t ret = CIL_NO_TYPE;
-	tree innertype = TYPE_MAIN_VARIANT (TREE_TYPE (type));
-	HOST_WIDE_INT innersize = tree_low_cst (TYPE_SIZE (innertype), 1);
-	HOST_WIDE_INT vec_size  = tree_low_cst (TYPE_SIZE (type), 1);
-
-	if ((TREE_CODE (innertype) == INTEGER_TYPE) ||
-	    (TREE_CODE (innertype) == POINTER_TYPE))
-	  {
-	    if (vec_size == 128)  /* 16-byte vectors */
-	      {
-		switch (innersize)
-		  {
-		  case  8: ret = CIL_V16QI; break;
-		  case 16: ret = CIL_V8HI;  break;
-		  case 32: ret = CIL_V4SI;  break;
-		  case 64: ret = CIL_V2DI;  break;
-		  default: break;
-		  }
-	      }
-	    else if (vec_size == 64)  /* 8-byte vectors */
-	      {
-		switch (innersize)
-		  {
-		  case  8: ret = CIL_V8QI; break;
-		  case 16: ret = CIL_V4HI;  break;
-		  case 32: ret = CIL_V2SI;  break;
-		  default: break;
-		  }
-	      }
-	    else if (vec_size == 32)  /* 4-byte vectors */
-	      {
-		switch (innersize)
-		  {
-		  case  8: ret = CIL_V4QI; break;
-		  case 16: ret = CIL_V2HI;  break;
-		  default: break;
-		  }
-	      }
-	  }
-	else if (TREE_CODE (innertype) == REAL_TYPE)
-	  {
-	    if (vec_size == 128)
-	      {
-		if (innersize == 32)
-		  ret = CIL_V4SF;
-		else if (innersize == 64)
-		  ret = CIL_V2DF;
-	      }
-	    else if (vec_size == 64)
-	      if (innersize == 32)
-		ret = CIL_V2SF;
-	  }
-	else
-	  {
-	    fprintf (stderr, "Vector of '%s'\n",
-		     tree_code_name[TREE_CODE (innertype)]);
-	  }
-	if (ret == CIL_NO_TYPE)
-	  internal_error ("Unsupported vector type %ld/%ld",
-			  vec_size, innersize);
-	return ret;
-      }
-
     default:
       gcc_unreachable ();
     }
 }
 
+/* Return the CIL stack representation for vector type TYPE.  */
+
+cil_type_t
+vector_to_cil (const_tree type)
+{
+  cil_type_t ret = CIL_NO_TYPE;
+  tree innertype;
+  HOST_WIDE_INT innersize;
+  HOST_WIDE_INT vec_size;
+
+  gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
+
+  innertype = TYPE_MAIN_VARIANT (TREE_TYPE (type));
+  innersize = tree_low_cst (TYPE_SIZE (innertype), 1);
+  vec_size  = tree_low_cst (TYPE_SIZE (type), 1);
+
+  if ((TREE_CODE (innertype) == INTEGER_TYPE) ||
+      (TREE_CODE (innertype) == POINTER_TYPE))
+    {
+      if (vec_size == 128)  /* 16-byte vectors */
+	{
+	  switch (innersize)
+	    {
+	    case  8: ret = CIL_V16QI; break;
+	    case 16: ret = CIL_V8HI;  break;
+	    case 32: ret = CIL_V4SI;  break;
+	    case 64: ret = CIL_V2DI;  break;
+	    default: break;
+	    }
+	}
+      else if (vec_size == 64)  /* 8-byte vectors */
+	{
+	  switch (innersize)
+	    {
+	    case  8: ret = CIL_V8QI; break;
+	    case 16: ret = CIL_V4HI;  break;
+	    case 32: ret = CIL_V2SI;  break;
+	    default: break;
+	    }
+	}
+      else if (vec_size == 32)  /* 4-byte vectors */
+	{
+	  switch (innersize)
+	    {
+	    case  8: ret = CIL_V4QI; break;
+	    case 16: ret = CIL_V2HI;  break;
+	    default: break;
+	    }
+	}
+    }
+  else if (TREE_CODE (innertype) == REAL_TYPE)
+    {
+      if (vec_size == 128)
+	{
+	  if (innersize == 32)
+	    ret = CIL_V4SF;
+	  else if (innersize == 64)
+	    ret = CIL_V2DF;
+	}
+      else if (vec_size == 64)
+	if (innersize == 32)
+	  ret = CIL_V2SF;
+    }
+  else
+    {
+      fprintf (stderr, "Vector of '%s'\n",
+	       tree_code_name[TREE_CODE (innertype)]);
+    }
+  if (ret == CIL_NO_TYPE)
+    internal_error ("Unsupported vector type %ld/%ld",
+		    vec_size, innersize);
+  return ret;
+}
+
+/* Return the CIL stack representation for type TYPE.  */
+
+cil_type_t
+type_to_cil (const_tree type)
+{
+  if (value_type_p (type))
+    return CIL_VALUE_TYPE;
+  else if (vector_type_p  (type))
+    return vector_to_cil(type);
+  else
+    return scalar_to_cil(type);
+}
+
 /* Return TRUE if the type specified by TYPE is loaded on the stack as a
    value type, FALSE otherwise.  */
 
@@ -740,7 +739,7 @@ value_type_p (const_tree type)
    vector type, FALSE otherwise.  */
 
 static bool
-vector_type_p (tree type)
+vector_type_p (const_tree type)
 {
   if (TREE_CODE (type) == VECTOR_TYPE)
     return true;
@@ -886,3 +885,9 @@ cil_set_stack_for_bb (cil_bb_stacks bbs, basic_block bb, cil_stack stack)
 
   bbs->stacks[bb->index] = cil_stack_copy (stack);
 }
+
+/*
+ * Local variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/gcc/config/cil32/cil-stack.h b/gcc/config/cil32/cil-stack.h
index 4edc9b25281..23253837810 100644
--- a/gcc/config/cil32/cil-stack.h
+++ b/gcc/config/cil32/cil-stack.h
@@ -110,6 +110,7 @@ extern bool cil_int_or_smaller_p (cil_type_t);
 extern bool cil_long_p (cil_type_t);
 extern bool cil_unsigned_int_p (cil_type_t);
 extern cil_type_t scalar_to_cil (const_tree);
-extern bool value_type_p (const_tree);
+extern cil_type_t vector_to_cil (const_tree);
+extern cil_type_t type_to_cil (const_tree);
 
 #endif /* CIL_STACK_H */