re PR ada/12806 (Program_Error sinput.adb:397)

	* sysdep.c: Problem discovered during IA64 VMS port.
	[VMS] #include <unixio.h> to get proper prototypes.

	* adaint.c:
	Issues discovered/problems fixed during IA64 VMS port.
	[VMS] #define _POSIX_EXIT for proper semantics.
	[VMS] #include <unixio.h> for proper prototypes.
	[VMS] (fork): #define IA64 version.
	(__gnat_os_exit): Remove unnecessary VMS specific code.

	* 3vtrasym.adb: Minor reformatting
	Use terminology encoded/decoded name, rather than C++ specific notion
	of mangling (this is the terminology used throughout GNAT).

	* einfo.h: Regenerated

	* einfo.ads, einfo.adb: Add new flag Is_Thread_Body

	* exp_ch6.adb:
	(Expand_N_Subprogram_Body): Handle expansion of thread body procedure

	* par-prag.adb: Add dummy entry for Thread_Body pragma

	* rtsfind.ads:
	Add entries for System.Threads entities for thread body processing

	* sem_attr.adb:
	(Analyze_Pragma, Access attributes): Check these are not applied to a
	thread body, since this is not permitted

	* sem_prag.adb: Add processing for Thread_Body pragma.
	Minor comment fix.

	* sem_res.adb:
	(Resolve_Call): Check for incorrect attempt to call a thread body
	 procedure with a direct call.

	* snames.ads, snames.adb: Add entry for Thread_Body pragma
	Add names associated with thread body expansion

	* snames.h: Add entry for Thread_Body pragma

	* s-thread.adb: Add entries for thread body processing
	These are dummy bodies so far

	* s-thread.ads: Add documentation on thread body handling.
	Add entries for thread body processing.

	* sem_ch10.adb:
	(Build_Limited_Views): Return after posting an error in case of limited
	with_clause on subprograms, generics, instances or generic renamings
	(Install_Limited_Withed_Unit): Do nothing in case of limited with_clause
	on subprograms, generics, instances or generic renamings

	* raise.c (setup_to_install): Correct mistake in last revision; two
	arguments out of order.

	* trans.c, cuintp.c, argv.c, aux-io.c, cal.c, errno.c, exit.c,
	gnatbl.c, init.c, stringt.h, utils.c, utils2.c: Update copyright
	notice, missed in previous change.
	Remove trailing blanks and other style errors introduced in previous
	change.

	* decl.c (gnat_to_gnu_field): Adjust the conditions under which we get
	rid of the wrapper for a LJM type, ensuring we don't do that if the
	field is addressable.  This avoids potential low level type view
	mismatches later on, for instance in a by-reference argument passing
	process.

	* decl.c (gnat_to_gnu_field): No longer check for BLKmode being
	aligned at byte boundary.

	* decl.c (components_to_record): Do not delete the empty variants from
	the end of the union type.

	* exp_ch4.adb (Expand_N_Op_Eq): Use base type when locating primitive
	operation for a derived type, an explicit declaration may use a local
	subtype of Boolean.

	* make.adb (Gnatmake): Allow main sources on the command line with a
	library project when it is only for compilation (no binding or
	linking).

	Part of PR ada/12806:

	* ada-tree.h (TYPE_DIGITS_VALUE, SET_TYPE_DIGITS_VALUE): Save count as
	tree, not integer.

	* decl.c:
	(gnat_to_gnu_entity, case E_Floating_Point_Type): Save count as tree,
	not integer.

	* targtyps.c, decl.c, misc.c,
	gigi.h (fp_prec_to_size, fp_size_to_prec): Temporary
	routines to work around change in FP sizing semantics in GCC.

	* utils.c:
	(build_vms_descriptor): TYPE_DIGITS_VALUE is tree, not integer.

	* gigi.h: (enumerate_modes): New function.

	* Make-lang.in: (ada/misc.o): Add real.h.

	* misc.c: (enumerate_modes): New function.

From-SVN: r73250

1 files changed, 14 insertions, 14 deletions

diff --git a/gcc/ada/utils2.c b/gcc/ada/utils2.c
index 736e8b7..a8f228d 100644
--- a/gcc/ada/utils2.c
+++ b/gcc/ada/utils2.c
@@ -153,8 +153,8 @@ known_alignment (tree exp)
      We always compute a type_alignment value and return the MAX of it
      compared with what we get from the expression tree. Just set the
      type_alignment value to 0 when the type information is to be ignored.  */
-  type_alignment 
-    = ((POINTER_TYPE_P (TREE_TYPE (exp)) 
+  type_alignment
+    = ((POINTER_TYPE_P (TREE_TYPE (exp))
 	&& ! TYPE_IS_DUMMY_P (TREE_TYPE (TREE_TYPE (exp))))
        ? TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))) : 0);
 
@@ -165,7 +165,7 @@ known_alignment (tree exp)
     case NON_LVALUE_EXPR:
       /* Conversions between pointers and integers don't change the alignment
 	 of the underlying object.  */
-      this_alignment = known_alignment (TREE_OPERAND (exp, 0));	 
+      this_alignment = known_alignment (TREE_OPERAND (exp, 0));	
       break;
 
     case PLUS_EXPR:
@@ -357,7 +357,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
       tree comparison, this_a1_is_null, this_a2_is_null;
 
       /* If the length of the first array is a constant, swap our operands
-	 unless the length of the second array is the constant zero.  
+	 unless the length of the second array is the constant zero.
 	 Note that we have set the `length' values to the length - 1.  */
       if (TREE_CODE (length1) == INTEGER_CST
 	  && ! integer_zerop (fold (build (PLUS_EXPR, bt, length2,
@@ -406,7 +406,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
 	  nbt = get_base_type (TREE_TYPE (ub1));
 
 	  comparison
-	    = build_binary_op (EQ_EXPR, result_type, 
+	    = build_binary_op (EQ_EXPR, result_type,
 			       build_binary_op (MINUS_EXPR, nbt, ub1, lb1),
 			       build_binary_op (MINUS_EXPR, nbt, ub2, lb2));
 
@@ -491,7 +491,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
    modulus.  */
 
 static tree
-nonbinary_modular_operation (enum tree_code op_code, 
+nonbinary_modular_operation (enum tree_code op_code,
                              tree type,
                              tree lhs,
                              tree rhs)
@@ -591,8 +591,8 @@ nonbinary_modular_operation (enum tree_code op_code,
    have to do here is validate the work done by SEM and handle subtypes.  */
 
 tree
-build_binary_op (enum tree_code op_code, 
-                 tree result_type, 
+build_binary_op (enum tree_code op_code,
+                 tree result_type,
                  tree left_operand,
                  tree right_operand)
 {
@@ -937,7 +937,7 @@ build_binary_op (enum tree_code op_code,
 	    gigi_abort (505);
 	}
 
-      /* If we are comparing a fat pointer against zero, we need to 
+      /* If we are comparing a fat pointer against zero, we need to
 	 just compare the data pointer.  */
       else if (TYPE_FAT_POINTER_P (left_base_type)
 	       && TREE_CODE (right_operand) == CONSTRUCTOR
@@ -1651,7 +1651,7 @@ build_simple_component_ref (tree record_variable,
 	  if (DECL_INTERNAL_P (new_field))
 	    {
 	      tree field_ref
-		= build_simple_component_ref (record_variable, 
+		= build_simple_component_ref (record_variable,
 					      NULL_TREE, new_field, no_fold_p);
 	      ref = build_simple_component_ref (field_ref, NULL_TREE, field,
 						no_fold_p);
@@ -1731,7 +1731,7 @@ build_call_alloc_dealloc (tree gnu_obj,
 
   if (Present (gnat_proc))
     {
-      /* The storage pools are obviously always tagged types, but the 
+      /* The storage pools are obviously always tagged types, but the
 	 secondary stack uses the same mechanism and is not tagged */
       if (Is_Tagged_Type (Etype (gnat_pool)))
 	{
@@ -1763,7 +1763,7 @@ build_call_alloc_dealloc (tree gnu_obj,
 					convert (gnu_size_type, gnu_size)));
 	  gnu_args
 	    = chainon (gnu_args,
-		       build_tree_list (NULL_TREE, 
+		       build_tree_list (NULL_TREE,
 					convert (gnu_size_type, gnu_align)));
 
 	  gnu_call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
@@ -1776,7 +1776,7 @@ build_call_alloc_dealloc (tree gnu_obj,
       else
 	{
 	  /* The size is the second parameter */
-	  Entity_Id gnat_size_type 
+	  Entity_Id gnat_size_type
 	    = Etype (Next_Formal (First_Formal (gnat_proc)));
 	  tree gnu_size_type = gnat_to_gnu_type (gnat_size_type);
 	  tree gnu_proc = gnat_to_gnu (gnat_proc);
@@ -1998,7 +1998,7 @@ build_allocator (tree type,
   return convert (result_type, result);
 }
 
-/* Fill in a VMS descriptor for EXPR and return a constructor for it. 
+/* Fill in a VMS descriptor for EXPR and return a constructor for it.
    GNAT_FORMAL is how we find the descriptor record.  */
 
 tree