[multiple changes]

2011-08-02  Geert Bosch  <bosch@adacore.com>

	* gcc-interface/gigi.h, gcc-interface/misc.c (enumerate_modes): New
	function.
	* gcc-interface/Make-lang.in: Update dependencies.

2011-08-02  Olivier Hainque  <hainque@adacore.com>

	* gcc-interface/trans.c (Subprogram_Body_to_gnu): Set the function
	end_locus.

From-SVN: r177141

1 files changed, 119 insertions, 0 deletions

diff --git a/gcc/ada/gcc-interface/misc.c b/gcc/ada/gcc-interface/misc.c
index 62e7ac7..a03bb0f 100644
--- a/gcc/ada/gcc-interface/misc.c
+++ b/gcc/ada/gcc-interface/misc.c
@@ -39,6 +39,7 @@
 #include "opts.h"
 #include "options.h"
 #include "plugin.h"
+#include "real.h"
 #include "function.h"	/* For pass_by_reference.  */
 
 #include "ada.h"
@@ -636,6 +637,124 @@ must_pass_by_ref (tree gnu_type)
 	      && TREE_CODE (TYPE_SIZE (gnu_type)) != INTEGER_CST));
 }
 
+/* This function is called by the front-end to enumerate all the supported
+   modes for the machine, as well as some predefined C types.  F is a function
+   which is called back with the parameters as listed below, first a string,
+   then six ints.  The name is any arbitrary null-terminated string and has
+   no particular significance, except for the case of predefined C types, where
+   it should be the name of the C type.  For integer types, only signed types
+   should be listed, unsigned versions are assumed.  The order of types should
+   be in order of preference, with the smallest/cheapest types first.
+
+   In particular, C predefined types should be listed before other types,
+   binary floating point types before decimal ones, and narrower/cheaper
+   type versions before more expensive ones.  In type selection the first
+   matching variant will be used.
+
+   NAME		pointer to first char of type name
+   DIGS		number of decimal digits for floating-point modes, else 0
+   COMPLEX_P	nonzero is this represents a complex mode
+   COUNT	count of number of items, nonzero for vector mode
+   FLOAT_REP	Float_Rep_Kind for FP, otherwise undefined
+   SIZE		number of bits used to store data
+   ALIGN	number of bits to which mode is aligned.  */
+
+void
+enumerate_modes (void (*f) (const char *, int, int, int, int, int, int))
+{
+  const tree c_types[]
+    = { float_type_node, double_type_node, long_double_type_node };
+  const char *const c_names[]
+    = { "float", "double", "long double" };
+  int iloop;
+
+  for (iloop = 0; iloop < NUM_MACHINE_MODES; iloop++)
+    {
+      enum machine_mode i = (enum machine_mode) iloop;
+      enum machine_mode inner_mode = i;
+      bool float_p = false;
+      bool complex_p = false;
+      bool vector_p = false;
+      bool skip_p = false;
+      int digs = 0;
+      unsigned int nameloop;
+      Float_Rep_Kind float_rep = IEEE_Binary; /* Until proven otherwise */
+
+      switch (GET_MODE_CLASS (i))
+	{
+	case MODE_INT:
+	  break;
+	case MODE_FLOAT:
+	  float_p = true;
+	  break;
+	case MODE_COMPLEX_INT:
+	  complex_p = true;
+	  inner_mode = GET_MODE_INNER (i);
+	  break;
+	case MODE_COMPLEX_FLOAT:
+	  float_p = true;
+	  complex_p = true;
+	  inner_mode = GET_MODE_INNER (i);
+	  break;
+	case MODE_VECTOR_INT:
+	  vector_p = true;
+	  inner_mode = GET_MODE_INNER (i);
+	  break;
+	case MODE_VECTOR_FLOAT:
+	  float_p = true;
+	  vector_p = true;
+	  inner_mode = GET_MODE_INNER (i);
+	  break;
+	default:
+	  skip_p = true;
+	}
+
+      if (float_p)
+	{
+	  const struct real_format *fmt = REAL_MODE_FORMAT (inner_mode);
+
+	  if (fmt->b == 2)
+	    digs = (fmt->p - 1) * 1233 / 4096; /* scale by log (2) */
+
+	  else if (fmt->b == 10)
+	    digs = fmt->p;
+
+	  else
+	    gcc_unreachable();
+
+	  if (fmt == &vax_f_format
+	      || fmt == &vax_d_format
+	      || fmt == &vax_g_format)
+	    float_rep = VAX_Native;
+	}
+
+      /* First register any C types for this mode that the front end
+	 may need to know about, unless the mode should be skipped.  */
+
+      if (!skip_p)
+	for (nameloop = 0; nameloop < ARRAY_SIZE (c_types); nameloop++)
+	  {
+	    tree typ = c_types[nameloop];
+	    const char *nam = c_names[nameloop];
+
+	    if (TYPE_MODE (typ) == i)
+	      {
+		f (nam, digs, complex_p,
+		   vector_p ? GET_MODE_NUNITS (i) : 0, float_rep,
+		   TYPE_PRECISION (typ), TYPE_ALIGN (typ));
+		skip_p = true;
+	      }
+	  }
+
+      /* If no predefined C types were found, register the mode itself.  */
+
+      if (!skip_p)
+	f (GET_MODE_NAME (i), digs, complex_p,
+	   vector_p ? GET_MODE_NUNITS (i) : 0, float_rep,
+	   GET_MODE_PRECISION (i), GET_MODE_ALIGNMENT (i));
+    }
+}
+
 /* Return the size of the FP mode with precision PREC.  */
 
 int