[multiple changes]

2004-09-09  Vincent Celier  <celier@gnat.com>

	* a-direct.ads: Add pragma Ada_05
	(Directory_Entry_Type): Give default value to component Kind to avoid
	not initialized warnings.

	* a-direct.adb (Current_Directory): Remove directory separator at the
	end.
	(Delete_Directory, Delete_Tree): Raise Name_Error if Directory is not
	an existing directory.
	(Fetch_Next_Entry): Give default value to variable Kind to avoid warning
	(Size (String)): Function C_Size returns Long_Integer, not File_Size.
	Convert the result to File_Size.

	* prj.ads: (Project_Error): New exception

	* prj-attr.adb: Except in procedure Initialize, Fail comes from
	Prj.Com, not from Osint.
	(Attrs, Package_Attributes): Tables moved to private part of spec
	(Add_Attribute, Add_Unknown_Package): Moved to new child package
	Prj.Attr.PM.
	(Register_New_Package (Name, Attributes), Register_New_Attribute): Raise
	Prj.Project_Error after call to Fail.
	(Register_New_Package (Name, Id)): Set Id to Empty_Package after calling
	Fail. Check that package name is not already in use.

	* prj-attr.ads: Comment updates to indicate that all subprograms may be
	used by tools, not only by the project manager, and to indicate that
	exception Prj.Prj_Error may be raised in case of problem.
	(Add_Unknown_Package, Add_Attribute): Moved to new child package
	Prj.Attr.PM.
	(Attrs, Package_Attributes): Table instantiations moved from the body to
	the private part to be accessible from Prj.Attr.PM body.

	* prj-dect.adb (Parse_Package_Declaration): Call Add_Unknown_Package
	from new package Prj.Attr.PM.
	(Parse_Attribute_Declaration): Call Add_Attribute from new package
	Prj.Attr.PM.

	* Makefile.in: Add prj-attr-pm.o to gnatmake object list

	* gnatbind.adb (Gnatbind): Correct warning message (Elaboration_Check
	instead of Elaboration_Checks).

	* a-calend.adb: Minor reformatting

2004-09-09  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>

	* gigi.h (maybe_pad_type): New declaration.
	(create_subprog_type): New arg RETURNS_BY_TARGET_PTR.

	* ada-tree.h: (TYPE_RETURNS_BY_TARGET_PTR_P): New macro.

	* cuintp.c: Convert to use buildN.

	* decl.c (maybe_pad_type): No longer static.
	(gnat_to_gnu_entity, case E_Function): Handle case of returning by
	target pointer.
	Convert to use buildN.

	* trans.c (call_to_gnu): Add arg GNU_TARGET; support
	TYPE_RETURNS_BY_TARGET_PTR_P.  All callers changed.
	(gnat_to_gnu, case N_Assignment_Statement): Call call_to_gnu if call on
	RHS.
	(gnat_to_gnu, case N_Return): Handle TYPE_RETURN_BY_TARGET_PTR_P.
	(gnat_gimplify_expr, case ADDR_EXPR): New case.
	Convert to use buildN.

	* utils2.c (gnat_build_constructor): Also set TREE_INVARIANT and
	TREE_READONLY for const.
	Convert to use buildN.

	* utils.c (create_subprog_type): New operand RETURNS_BY_TARGET_PTR.
	(create_var_decl): Refine when TREE_STATIC is set.
	Convert to use buildN.

2004-09-09  Gary Dismukes  <dismukes@gnat.com>

	* gnat_ugn.texi: Delete text relating to checking of ali and object
	consistency.

	* a-except.adb (Rcheck_*): Add pragmas No_Return for each of these
	routines.

2004-09-09  Jose Ruiz  <ruiz@act-europe.fr>

	* gnat_ugn.texi: Add Detect_Blocking to the list of configuration
	pragmas recognized by GNAT.

	* gnat_rm.texi: Document pragma Detect_Blocking.

	* s-solita.adb (Timed_Delay_T): When pragma Detect_Blocking is active,
	raise Program_Error if called from a protected operation.

	* s-taprob.adb (Lock): When pragma Detect_Blocking is active increase
	the protected action nesting level.
	(Lock_Read_Only): When pragma Detect_Blocking is active increase the
	protected action nesting level.
	(Unlock): When pragma Detect_Blocking is active decrease the protected
	action nesting level.

	* s-taskin.adb (Initialize_ATCB): Initialize to 0 the
	Protected_Action_Nesting.

	* s-taskin.ads: Adding the field Protected_Action_Nesting to the
	Common_ATCB record. It contains the dynamic level of protected action
	nesting for each task. It is needed for checking whether potentially
	blocking operations are called from protected operations.
	(Detect_Blocking): Adding a Boolean constant reflecting whether pragma
	Detect_Blocking is active or not in the partition.

	* s-tasren.adb (Call_Simple): When pragma Detect_Blocking is active,
	raise Program_Error if called from a protected operation.
	(Task_Entry_Call): When pragma Detect_Blocking is active, raise
	Program_Error if called from a protected operation.
	(Timed_Task_Entry_Call): When pragma Detect_Blocking is active, raise
	Program_Error if called from a protected operation.

	* s-tassta.adb (Abort_Tasks): When pragma Detect_Blocking is active,
	raise Program_Error if called from a protected operation.

	* s-tpoben.adb (Lock_Entries): When pragma Detect_Blocking is active,
	raise Program_Error if called from a protected operation, and increase
	the protected action nesting level.
	(Lock_Read_Only_Entries): When pragma Detect_Blocking is active, raise
	Program_Error if called from a protected operation, and increase the
	protected action nesting level.
	(Unlock_Entries): When pragma Detect_Blocking is active decrease the
	protected action nesting level.

	* s-tposen.adb (Lock_Entry): When pragma Detect_Blocking is active,
	raise Program_Error if called from a protected operation, and increase
	the protected action nesting level.
	(Lock_Read_Only_Entry): When pragma Detect_Blocking is active, raise
	Program_Error if called from a protected operation, and increase the
	protected action nesting level.
	(Protected_Single_Entry_Call): When pragma Detect_Blocking is active,
	raise Program_Error if called from a protected operation.
	(Timed_Protected_Single_Entry_Call): When pragma Detect_Blocking is
	active, raise Program_Error if called from a protected operation.
	(Unlock_Entry): When pragma Detect_Blocking is active decrease the
	protected action nesting level.

	* sem_util.adb (Check_Potentially_Blocking_Operation): Remove the
	insertion of the statement raising Program_Error. The run time
	contains the required machinery for handling that.

	* sem_util.ads: Change comment associated to procedure
	Check_Potentially_Blocking_Operation.
	This procedure does not insert a call for raising the exception because
	that is currently done by the run time.

	* raise.h (__gnat_set_globals): Pass the detect_blocking parameter.

	* init.c: Add the global variable __gl_detect_blocking that indicates
	whether pragma Detect_Blocking is active (1) or not (0). Needed for
	making the pragma available at run time.
	(__gnat_set_globals): Pass and update the detect_blocking parameter.

	* lib-writ.adb (Write_ALI): Set the DB flag in the ali file if
	pragma Detect_Blocking is active.

	* lib-writ.ads: Document the Detect_Blocking flag (DB) in ali files.

	* ali.adb (Scan_ALI): Set the Detect_Blocking value to true if the flag
	DB is found in the ali file. Any unit compiled with pragma
	Detect_Blocking active forces its effect in the whole partition.

	* a-retide.adb (Delay_Until): Raise Program_Error if pragma
	Detect_Blocking is active and delay is called from a protected
	operation.

	* bindgen.adb (Gen_Adainit_Ada): When generating the call to
	__gnat_set_globals, pass 1 as Detect_Blocking parameter if pragma
	Detect_Blocking is active (0 otherwise).
	(Gen_Adainit_C): When generating the call to __gnat_set_globals, pass 1
	as Detect_Blocking parameter if pragma Detect_Blocking is active (0
	otherwise).

2004-09-09  Thomas Quinot  <quinot@act-europe.fr>

	* gnat_rm.texi: Rename GNAT.Perfect_Hash.Generators to
	GNAT.Perfect_Hash_Generators, and remove the empty GNAT.Perfect_Hash
	package.

	* s-parint.ads, s-parint.adb (Get_RAS_Info): New subprogram.
	(Register_Receiving_Stub): Add Subp_Info formal parameter.
	Update API in placeholder implemetation of s-parint to reflect changes
	in distribution runtime library.

	* sem_ch3.adb (Expand_Derived_Record): Rename to
	Expand_Record_Extension.

	* sem_disp.adb (Check_Controlling_Formals): Improve error message for
	primitive operations of potentially distributed object types that have
	non-controlling anonymous access formals.

	* sem_dist.ads, sem_dist.adb (Build_RAS_Primitive_Specification): New
	subprogram.
	New implementation of expansion for remote access-to-subprogram types,
	based on the RACW infrastructure.
	This version of sem_dist is compatible with PolyORB/DSA as well as
	GLADE.

	* sem_prag.adb (Analyze_Pragma, case Pragma_Asynchronous): For a pragma
	Asynchrronous that applies to a remote access-to-subprogram type, mark
	the underlying RACW type as asynchronous.

	* link.c: FreeBSD uses GNU ld: set __gnat_objlist_file_supported and
	 __gnat_using_gnu_linker to 1.

	* Makefile.rtl, impunit.adb, g-perhas.ads, g-pehage.ads,
	g-pehage.adb: Rename GNAT.Perfect_Hash.Generators to
	GNAT.Perfect_Hash_Generators, and remove the empty
	GNAT.Perfect_Hash package.

	* atree.adb: Minor reformatting

	* exp_ch3.adb (Expand_Derived_Record): Rename to
	Expand_Record_Extension.
	(Build_Record_Init_Proc.Build_Assignment): The default expression in
	a component declaration must remain attached at that point in the
	tree so New_Copy_Tree copies it if the enclosing record type is derived.
	It is therefore necessary to take a copy of the expression when building
	the corresponding assignment statement in the init proc.
	As a side effect, in the case of a derived record type, we now see the
	original expression, without any rewriting that could have occurred
	during expansion of the ancestor type's init proc, and we do not need
	to go back to Original_Node.

	* exp_ch3.ads (Expand_Derived_Record): Rename to
	Expand_Record_Extension.

	* exp_dist.ads, exp_dist.adb (Underlying_RACW_Type): New subprogram.
	Returns the RACW type used to implement a remote access-to-subprogram
	type.
	(Add_RAS_Proxy_And_Analyze, Build_Remote_Subprogram_Proxy_Type):
	New subprograms. Used to create a proxy tagged object for a remote
	subprogram. The proxy object is used as the designated object
	for RAS values on the same partition (unless All_Calls_Remote applies).
	(Build_Get_Unique_RP_Call): New subprogram. Build a call to
	System.Partition_Interface.Get_Unique_Remote_Pointer.
	(Add_RAS_Access_TSS, Add_RAS_Dereference_TSS):
	Renamed from Add_RAS_*_Attribute.
	(Add_Receiving_Stubs_To_Declarations): Generate a table of local
	subprograms.
	New implementation of expansion for remote access-to-subprogram types,
	based on the RACW infrastructure.

	* exp_dist.ads (Copy_Specification): Update comment to note that this
	function can copy the specification from either a subprogram
	specification or an access-to-subprogram type definition.

2004-09-09  Ed Schonberg  <schonberg@gnat.com>

	* sem_type.adb (Disambiguate): Handle properly an accidental ambiguity
	in an instance, between an explicit subprogram an one inherited from a
	type derived from an actual.

	* exp_ch6.adb (Expand_N_Subprogram_Body): If polling is enabled, do not
	add a polling call if the subprogram is to be inlined by the back-end,
	to avoid repeated calls with multiple inlinings.

	* checks.adb (Apply_Alignment_Check): If the expression in the address
	clause is a call whose name is not a static entity (e.g. a dispatching
	call), treat as dynamic.

2004-09-09  Robert Dewar  <dewar@gnat.com>

	* g-trasym.ads: Minor reformatting

	* exp_ch3.adb (Component_Needs_Simple_Initialization): Don't except
	packed arrays, since unused bits are expected to be zero for a
	comparison.

2004-09-09  Eric Botcazou  <ebotcazou@act-europe.fr>

	* exp_pakd.ads: Fix an inacurracy and a couple of typos in the head
	comment.

2004-09-09  Pascal Obry  <obry@gnat.com>

	* mdll.ads, mdll.adb (Build_Dynamic_Library): New parameter Map_File to
	enable map file generation. Add the right option to generate the map
	file if Map_File is set to True.

	* gnatdll.adb (Gen_Map_File): New variable.
	(Syntax): Add info about new -m (Map_File) option.
	(Parse_Command_Line): Add support for -m option.
	(gnatdll): Pass Gen_Map_File to Build_Dynamic_Library calls.
	Minor reformatting.

2004-09-09  Laurent Pautet  <pautet@act-europe.fr>

	* gnatls.adb: Add a very verbose mode -V. Such mode is required by the
	new gnatdist implementation.
	Define a subpackage isolating the output routines specific to this
	verbose mode.

2004-09-09  Joel Brobecker  <brobecker@gnat.com>

	* Makefile.rtl: (GNATRTL_NONTASKING_OBJS): Add g-dynhta.

	* gnat_ugn.texi (Main Subprograms): Fix typo. Deduced, not deducted.

2004-09-09  Cyrille Comar  <comar@act-europe.fr>

	* opt.adb (Set_Opt_Config_Switches): Use Ada_Version_Runtime to compile
	internal unit.

	* opt.ads: Add Ada_Version_Runtime constant used to decide which
	version of the language is used to compile the run time.

2004-09-09  Arnaud Charlet  <charlet@act-europe.fr>

	* sem_util.adb (Requires_Transient_Scope): Re-enable handling
	of variable length temporaries for function return now that the
	back-end and gigi support it.

From-SVN: r87435

1 files changed, 108 insertions, 107 deletions

diff --git a/gcc/ada/utils2.c b/gcc/ada/utils2.c
index 0163563..6341863 100644
--- a/gcc/ada/utils2.c
+++ b/gcc/ada/utils2.c
@@ -96,9 +96,9 @@ gnat_truthvalue_conversion (tree expr)
     case COND_EXPR:
       /* Distribute the conversion into the arms of a COND_EXPR.  */
       return fold
-	(build (COND_EXPR, type, TREE_OPERAND (expr, 0),
-		gnat_truthvalue_conversion (TREE_OPERAND (expr, 1)),
-		gnat_truthvalue_conversion (TREE_OPERAND (expr, 2))));
+	(build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
+		 gnat_truthvalue_conversion (TREE_OPERAND (expr, 1)),
+		 gnat_truthvalue_conversion (TREE_OPERAND (expr, 2))));
 
     default:
       return build_binary_op (NE_EXPR, type, expr,
@@ -355,8 +355,8 @@ compare_arrays (tree result_type, tree a1, tree a2)
       tree lb2 = TYPE_MIN_VALUE (TYPE_DOMAIN (t2));
       tree ub2 = TYPE_MAX_VALUE (TYPE_DOMAIN (t2));
       tree bt = get_base_type (TREE_TYPE (lb1));
-      tree length1 = fold (build (MINUS_EXPR, bt, ub1, lb1));
-      tree length2 = fold (build (MINUS_EXPR, bt, ub2, lb2));
+      tree length1 = fold (build2 (MINUS_EXPR, bt, ub1, lb1));
+      tree length2 = fold (build2 (MINUS_EXPR, bt, ub2, lb2));
       tree nbt;
       tree tem;
       tree comparison, this_a1_is_null, this_a2_is_null;
@@ -365,8 +365,8 @@ compare_arrays (tree result_type, tree a1, tree a2)
 	 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,
-					  convert (bt, integer_one_node)))))
+	  && !integer_zerop (fold (build2 (PLUS_EXPR, bt, length2,
+					   convert (bt, integer_one_node)))))
 	{
 	  tem = a1, a1 = a2, a2 = tem;
 	  tem = t1, t1 = t2, t2 = tem;
@@ -379,8 +379,8 @@ compare_arrays (tree result_type, tree a1, tree a2)
       /* If the length of this dimension in the second array is the constant
 	 zero, we can just go inside the original bounds for the first
 	 array and see if last < first.  */
-      if (integer_zerop (fold (build (PLUS_EXPR, bt, length2,
-				      convert (bt, integer_one_node)))))
+      if (integer_zerop (fold (build2 (PLUS_EXPR, bt, length2,
+				       convert (bt, integer_one_node)))))
 	{
 	  tree ub = TYPE_MAX_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
 	  tree lb = TYPE_MIN_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
@@ -459,7 +459,7 @@ compare_arrays (tree result_type, tree a1, tree a2)
 	a1 = convert (type, a1), a2 = convert (type, a2);
 
       result = build_binary_op (TRUTH_ANDIF_EXPR, result_type, result,
-				fold (build (EQ_EXPR, result_type, a1, a2)));
+				fold (build2 (EQ_EXPR, result_type, a1, a2)));
 
     }
 
@@ -474,10 +474,10 @@ compare_arrays (tree result_type, tree a1, tree a2)
      evaluated would be wrong.  */
 
   if (contains_save_expr_p (a1))
-    result = build (COMPOUND_EXPR, result_type, a1, result);
+    result = build2 (COMPOUND_EXPR, result_type, a1, result);
 
   if (contains_save_expr_p (a2))
-    result = build (COMPOUND_EXPR, result_type, a2, result);
+    result = build2 (COMPOUND_EXPR, result_type, a2, result);
 
   return result;
 }
@@ -500,7 +500,7 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
   /* If this is an addition of a constant, convert it to a subtraction
      of a constant since we can do that faster.  */
   if (op_code == PLUS_EXPR && TREE_CODE (rhs) == INTEGER_CST)
-    rhs = fold (build (MINUS_EXPR, type, modulus, rhs)), op_code = MINUS_EXPR;
+    rhs = fold (build2 (MINUS_EXPR, type, modulus, rhs)), op_code = MINUS_EXPR;
 
   /* For the logical operations, we only need PRECISION bits.  For
      addition and subraction, we need one more and for multiplication we
@@ -532,7 +532,7 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
     }
 
   /* Do the operation, then we'll fix it up.  */
-  result = fold (build (op_code, op_type, lhs, rhs));
+  result = fold (build2 (op_code, op_type, lhs, rhs));
 
   /* For multiplication, we have no choice but to do a full modulus
      operation.  However, we want to do this in the narrowest
@@ -544,32 +544,32 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
       SET_TYPE_MODULUS (div_type, modulus);
       TYPE_MODULAR_P (div_type) = 1;
       result = convert (op_type,
-			fold (build (TRUNC_MOD_EXPR, div_type,
-				     convert (div_type, result), modulus)));
+			fold (build2 (TRUNC_MOD_EXPR, div_type,
+				      convert (div_type, result), modulus)));
     }
 
   /* For subtraction, add the modulus back if we are negative.  */
   else if (op_code == MINUS_EXPR)
     {
       result = save_expr (result);
-      result = fold (build (COND_EXPR, op_type,
-			    build (LT_EXPR, integer_type_node, result,
-				   convert (op_type, integer_zero_node)),
-			    fold (build (PLUS_EXPR, op_type,
-					 result, modulus)),
-			    result));
+      result = fold (build3 (COND_EXPR, op_type,
+			     build2 (LT_EXPR, integer_type_node, result,
+				     convert (op_type, integer_zero_node)),
+			     fold (build2 (PLUS_EXPR, op_type,
+					   result, modulus)),
+			     result));
     }
 
   /* For the other operations, subtract the modulus if we are >= it.  */
   else
     {
       result = save_expr (result);
-      result = fold (build (COND_EXPR, op_type,
-			    build (GE_EXPR, integer_type_node,
-				   result, modulus),
-			    fold (build (MINUS_EXPR, op_type,
-					 result, modulus)),
-			    result));
+      result = fold (build3 (COND_EXPR, op_type,
+			     build2 (GE_EXPR, integer_type_node,
+				     result, modulus),
+			     fold (build2 (MINUS_EXPR, op_type,
+					   result, modulus)),
+			     result));
     }
 
   return convert (type, result);
@@ -791,16 +791,16 @@ build_binary_op (enum tree_code op_code, tree result_type,
     case NE_EXPR:
       /* If either operand is a NULL_EXPR, just return a new one.  */
       if (TREE_CODE (left_operand) == NULL_EXPR)
-	return build (op_code, result_type,
-		      build1 (NULL_EXPR, integer_type_node,
-			      TREE_OPERAND (left_operand, 0)),
-		      integer_zero_node);
+	return build2 (op_code, result_type,
+		       build1 (NULL_EXPR, integer_type_node,
+			       TREE_OPERAND (left_operand, 0)),
+		       integer_zero_node);
 
       else if (TREE_CODE (right_operand) == NULL_EXPR)
-	return build (op_code, result_type,
-		      build1 (NULL_EXPR, integer_type_node,
-			      TREE_OPERAND (right_operand, 0)),
-		      integer_zero_node);
+	return build2 (op_code, result_type,
+		       build1 (NULL_EXPR, integer_type_node,
+			       TREE_OPERAND (right_operand, 0)),
+		       integer_zero_node);
 
       /* If either object is a left-justified modular types, get the
 	 fields from within.  */
@@ -998,11 +998,11 @@ build_binary_op (enum tree_code op_code, tree result_type,
   else if (TREE_CODE (right_operand) == NULL_EXPR)
     return build1 (NULL_EXPR, operation_type, TREE_OPERAND (right_operand, 0));
   else if (op_code == ARRAY_REF || op_code == ARRAY_RANGE_REF)
-    result = fold (build (op_code, operation_type, left_operand, right_operand,
-			  NULL_TREE, NULL_TREE));
+    result = fold (build4 (op_code, operation_type, left_operand,
+			   right_operand, NULL_TREE, NULL_TREE));
   else
     result
-      = fold (build (op_code, operation_type, left_operand, right_operand));
+      = fold (build2 (op_code, operation_type, left_operand, right_operand));
 
   TREE_SIDE_EFFECTS (result) |= has_side_effects;
   TREE_CONSTANT (result)
@@ -1016,8 +1016,8 @@ build_binary_op (enum tree_code op_code, tree result_type,
   /* If we are working with modular types, perform the MOD operation
      if something above hasn't eliminated the need for it.  */
   if (modulus)
-    result = fold (build (FLOOR_MOD_EXPR, operation_type, result,
-			  convert (operation_type, modulus)));
+    result = fold (build2 (FLOOR_MOD_EXPR, operation_type, result,
+			   convert (operation_type, modulus)));
 
   if (result_type && result_type != operation_type)
     result = convert (result_type, result);
@@ -1260,10 +1260,10 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
 	       the straightforward code; the TRUNC_MOD_EXPR below
 	       is an AND operation.  */
 	    if (op_code == NEGATE_EXPR && mod_pow2)
-	      result = fold (build (TRUNC_MOD_EXPR, operation_type,
-				    fold (build1 (NEGATE_EXPR, operation_type,
-						  operand)),
-				    modulus));
+	      result = fold (build2 (TRUNC_MOD_EXPR, operation_type,
+				     fold (build1 (NEGATE_EXPR, operation_type,
+						   operand)),
+				     modulus));
 
 	    /* For nonbinary negate case, return zero for zero operand,
 	       else return the modulus minus the operand.  If the modulus
@@ -1271,22 +1271,24 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
 	       as an XOR since it is equivalent and faster on most machines. */
 	    else if (op_code == NEGATE_EXPR && !mod_pow2)
 	      {
-		if (integer_pow2p (fold (build (PLUS_EXPR, operation_type,
-						modulus,
-						convert (operation_type,
-							 integer_one_node)))))
-		  result = fold (build (BIT_XOR_EXPR, operation_type,
-					operand, modulus));
+		if (integer_pow2p (fold (build2 (PLUS_EXPR, operation_type,
+						 modulus,
+						 convert (operation_type,
+							  integer_one_node)))))
+		  result = fold (build2 (BIT_XOR_EXPR, operation_type,
+					 operand, modulus));
 		else
-		  result = fold (build (MINUS_EXPR, operation_type,
+		  result = fold (build2 (MINUS_EXPR, operation_type,
 					modulus, operand));
 
-		result = fold (build (COND_EXPR, operation_type,
-				      fold (build (NE_EXPR, integer_type_node,
-						   operand,
-						   convert (operation_type,
-							    integer_zero_node))),
-				      result, operand));
+		result = fold (build3 (COND_EXPR, operation_type,
+				       fold (build2 (NE_EXPR,
+						     integer_type_node,
+						     operand,
+						     convert
+						     (operation_type,
+						      integer_zero_node))),
+				       result, operand));
 	      }
 	    else
 	      {
@@ -1295,16 +1297,16 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
 		   XOR against the constant and subtract the operand from
 		   that constant for nonbinary modulus.  */
 
-		tree cnst = fold (build (MINUS_EXPR, operation_type, modulus,
-					 convert (operation_type,
-						  integer_one_node)));
+		tree cnst = fold (build2 (MINUS_EXPR, operation_type, modulus,
+					  convert (operation_type,
+						   integer_one_node)));
 
 		if (mod_pow2)
-		  result = fold (build (BIT_XOR_EXPR, operation_type,
-					operand, cnst));
+		  result = fold (build2 (BIT_XOR_EXPR, operation_type,
+					 operand, cnst));
 		else
-		  result = fold (build (MINUS_EXPR, operation_type,
-					cnst, operand));
+		  result = fold (build2 (MINUS_EXPR, operation_type,
+					 cnst, operand));
 	      }
 
 	    break;
@@ -1360,8 +1362,8 @@ build_cond_expr (tree result_type, tree condition_operand,
       false_operand = build_unary_op (ADDR_EXPR, result_type, false_operand);
     }
 
-  result = fold (build (COND_EXPR, result_type, condition_operand,
-			true_operand, false_operand));
+  result = fold (build3 (COND_EXPR, result_type, condition_operand,
+			 true_operand, false_operand));
 
   /* If either operand is a SAVE_EXPR (possibly surrounded by
      arithmetic, make sure it gets done.  */
@@ -1369,10 +1371,10 @@ build_cond_expr (tree result_type, tree condition_operand,
   false_operand = skip_simple_arithmetic (false_operand);
 
   if (TREE_CODE (true_operand) == SAVE_EXPR)
-    result = build (COMPOUND_EXPR, result_type, true_operand, result);
+    result = build2 (COMPOUND_EXPR, result_type, true_operand, result);
 
   if (TREE_CODE (false_operand) == SAVE_EXPR)
-    result = build (COMPOUND_EXPR, result_type, false_operand, result);
+    result = build2 (COMPOUND_EXPR, result_type, false_operand, result);
 
   /* ??? Seems the code above is wrong, as it may move ahead of the COND
      SAVE_EXPRs with side effects and not shared by both arms.  */
@@ -1390,10 +1392,10 @@ build_cond_expr (tree result_type, tree condition_operand,
 tree
 build_call_1_expr (tree fundecl, tree arg)
 {
-  tree call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
-		     build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
-		     chainon (NULL_TREE, build_tree_list (NULL_TREE, arg)),
-		     NULL_TREE);
+  tree call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
+		      build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
+		      chainon (NULL_TREE, build_tree_list (NULL_TREE, arg)),
+		      NULL_TREE);
 
   TREE_SIDE_EFFECTS (call) = 1;
 
@@ -1406,11 +1408,11 @@ build_call_1_expr (tree fundecl, tree arg)
 tree
 build_call_2_expr (tree fundecl, tree arg1, tree arg2)
 {
-  tree call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
-		     build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
-		     chainon (chainon (NULL_TREE,
-				       build_tree_list (NULL_TREE, arg1)),
-			      build_tree_list (NULL_TREE, arg2)),
+  tree call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
+		      build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
+		      chainon (chainon (NULL_TREE,
+					build_tree_list (NULL_TREE, arg1)),
+			       build_tree_list (NULL_TREE, arg2)),
 		     NULL_TREE);
 
   TREE_SIDE_EFFECTS (call) = 1;
@@ -1423,9 +1425,9 @@ build_call_2_expr (tree fundecl, tree arg1, tree arg2)
 tree
 build_call_0_expr (tree fundecl)
 {
-  tree call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
-		     build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
-		     NULL_TREE, NULL_TREE);
+  tree call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fundecl)),
+		      build_unary_op (ADDR_EXPR, NULL_TREE, fundecl),
+		      NULL_TREE, NULL_TREE);
 
   TREE_SIDE_EFFECTS (call) = 1;
 
@@ -1510,11 +1512,10 @@ gnat_build_constructor (tree type, tree list)
     }
 
   result = build_constructor (type, list);
-  TREE_CONSTANT (result) = allconstant;
-  TREE_STATIC (result) = allconstant;
+  TREE_CONSTANT (result) = TREE_INVARIANT (result)
+    = TREE_STATIC (result) = allconstant;
   TREE_SIDE_EFFECTS (result) = side_effects;
-  TREE_READONLY (result) = TYPE_READONLY (type);
-
+  TREE_READONLY (result) = TYPE_READONLY (type) || allconstant;
   return result;
 }
 
@@ -1596,8 +1597,8 @@ build_simple_component_ref (tree record_variable, tree component,
 
   /* It would be nice to call "fold" here, but that can lose a type
      we need to tag a PLACEHOLDER_EXPR with, so we can't do it.  */
-  ref = build (COMPONENT_REF, TREE_TYPE (field), record_variable, field,
-	       NULL_TREE);
+  ref = build3 (COMPONENT_REF, TREE_TYPE (field), record_variable, field,
+		NULL_TREE);
 
   if (TREE_READONLY (record_variable) || TREE_READONLY (field))
     TREE_READONLY (ref) = 1;
@@ -1688,8 +1689,8 @@ build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, unsigned align,
 		       build_tree_list (NULL_TREE,
 					convert (gnu_size_type, gnu_align)));
 
-	  gnu_call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
-			    gnu_proc_addr, gnu_args, NULL_TREE);
+	  gnu_call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
+			     gnu_proc_addr, gnu_args, NULL_TREE);
 	  TREE_SIDE_EFFECTS (gnu_call) = 1;
 	  return gnu_call;
 	}
@@ -1717,8 +1718,8 @@ build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, unsigned align,
 		       build_tree_list (NULL_TREE,
 					convert (gnu_size_type, gnu_size)));
 
-	  gnu_call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
-			    gnu_proc_addr, gnu_args, NULL_TREE);
+	  gnu_call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
+			     gnu_proc_addr, gnu_args, NULL_TREE);
 	  TREE_SIDE_EFFECTS (gnu_call) = 1;
 	  return gnu_call;
 	}
@@ -1750,7 +1751,7 @@ build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, unsigned align,
       else
 	abort ();
 #if 0
-	return build (ALLOCATE_EXPR, ptr_void_type_node, gnu_size, gnu_align);
+	return build2 (ALLOCATE_EXPR, ptr_void_type_node, gnu_size, gnu_align);
 #endif
     }
   else
@@ -1830,16 +1831,16 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc,
 
 	  return convert
 	    (result_type,
-	     build (COMPOUND_EXPR, storage_ptr_type,
-		    build_binary_op
-		    (MODIFY_EXPR, storage_type,
-		     build_unary_op (INDIRECT_REF, NULL_TREE,
-				     convert (storage_ptr_type, storage)),
-		     gnat_build_constructor (storage_type, template_cons)),
-		    convert (storage_ptr_type, storage)));
+	     build2 (COMPOUND_EXPR, storage_ptr_type,
+		     build_binary_op
+		     (MODIFY_EXPR, storage_type,
+		      build_unary_op (INDIRECT_REF, NULL_TREE,
+				      convert (storage_ptr_type, storage)),
+		      gnat_build_constructor (storage_type, template_cons)),
+		     convert (storage_ptr_type, storage)));
 	}
       else
-	return build
+	return build2
 	  (COMPOUND_EXPR, result_type,
 	   build_binary_op
 	   (MODIFY_EXPR, template_type,
@@ -1910,13 +1911,13 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc,
     {
       result = save_expr (result);
       result
-	= build (COMPOUND_EXPR, TREE_TYPE (result),
-		 build_binary_op
-		 (MODIFY_EXPR, NULL_TREE,
-		  build_unary_op (INDIRECT_REF, TREE_TYPE (TREE_TYPE (result)),
-				  result),
-		  init),
-		 result);
+	= build2 (COMPOUND_EXPR, TREE_TYPE (result),
+		  build_binary_op
+		  (MODIFY_EXPR, NULL_TREE,
+		   build_unary_op (INDIRECT_REF,
+				   TREE_TYPE (TREE_TYPE (result)), result),
+		   init),
+		  result);
     }
 
   return convert (result_type, result);