[multiple changes]

2012-10-02  Ben Brosgol  <brosgol@adacore.com>

	* gnat_rm.texi: Minor editing.

2012-10-02  Ed Schonberg  <schonberg@adacore.com>

	* sem_ch6.adb (Analyze_Function_Return): Reject a return
	expression whose type is a local access to subprogram type.

2012-10-02  Robert Dewar  <dewar@adacore.com>

	* sem_eval.adb: Minor improvement to Compile_Time_Compare.

2012-10-02  Robert Dewar  <dewar@adacore.com>

	* checks.adb (Apply_Arithmetic_Overflow_Minimized_Eliminated):
	Fix base type problem that resulted in improper conversion.
	(Minimize_Eliminate_Overflow_Checks): Properly handle top
	level case to avoid unnecessary conversion to bignum or LLI.
	(Minimize_Eliminate_Overflow_Checks): Implement uniform two phase
	approach for arithmetic operators and for if/case expressions.
	* checks.ads: Minor comment fix.
	* exp_ch4.adb (Minimized_Eliminated_Overflow_Check): New function,
	implements a uniform way of treating minimized/eliminated checks in
	two phases.
	(Expand_Compare_Minimize_Eliminate_Overflow): Fix cut and
	paste error resulting in wrong results for less than in some
	cases.	(Expand_Membership_Minimize_Eliminate_Overflow):
	Fix error caused by incorrect capture of operand types.
	(Expand_Membership_Minimize_Eliminate_Overflow): Fix error in
	handling of bignum case.
	(Expand_N_Case_Expression): Implement
	proper two phase handling (Expand_N_If_Expression): Implement
	proper two phase handling (Expand_N_Op_Abs): Implement proper
	two phase handling ditto for all other arithmetic operators
	* sem_res.adb (Resolve_If_Expression): Avoid introducing
	unneeded conversions.

From-SVN: r191980

gcc/ada/ChangeLog

+2012-10-02  Ben Brosgol  <brosgol@adacore.com>
+
+	* gnat_rm.texi: Minor editing.
+
+2012-10-02  Ed Schonberg  <schonberg@adacore.com>
+
+	* sem_ch6.adb (Analyze_Function_Return): Reject a return
+	expression whose type is a local access to subprogram type.
+
+2012-10-02  Robert Dewar  <dewar@adacore.com>
+
+	* sem_eval.adb: Minor improvement to Compile_Time_Compare.
+
+2012-10-02  Robert Dewar  <dewar@adacore.com>
+
+	* checks.adb (Apply_Arithmetic_Overflow_Minimized_Eliminated):
+	Fix base type problem that resulted in improper conversion.
+	(Minimize_Eliminate_Overflow_Checks): Properly handle top
+	level case to avoid unnecessary conversion to bignum or LLI.
+	(Minimize_Eliminate_Overflow_Checks): Implement uniform two phase
+	approach for arithmetic operators and for if/case expressions.
+	* checks.ads: Minor comment fix.
+	* exp_ch4.adb (Minimized_Eliminated_Overflow_Check): New function,
+	implements a uniform way of treating minimized/eliminated checks in
+	two phases.
+	(Expand_Compare_Minimize_Eliminate_Overflow): Fix cut and
+	paste error resulting in wrong results for less than in some
+	cases.	(Expand_Membership_Minimize_Eliminate_Overflow):
+	Fix error caused by incorrect capture of operand types.
+	(Expand_Membership_Minimize_Eliminate_Overflow): Fix error in
+	handling of bignum case.
+	(Expand_N_Case_Expression): Implement
+	proper two phase handling (Expand_N_If_Expression): Implement
+	proper two phase handling (Expand_N_Op_Abs): Implement proper
+	two phase handling ditto for all other arithmetic operators
+	* sem_res.adb (Resolve_If_Expression): Avoid introducing
+	unneeded conversions.
+
 2012-10-02  Robert Dewar  <dewar@adacore.com>
 
 	* s-bignum.adb (Big_Exp): 0**0 should be 1, not 0.

gcc/ada/checks.ads

@@ -142,7 +142,7 @@ package Checks is
    --  overflow checking for dependent expressions. This routine handles
    --  front end vs back end overflow checks (in the front end case it expands
    --  the necessary check). Note that divide is handled separately using
-   --  Apply_Arithmetic_Divide_Overflow_Check.
+   --  Apply_Divide_Checks.
 
    procedure Apply_Constraint_Check
      (N          : Node_Id;

gcc/ada/gnat_rm.texi

@@ -4147,7 +4147,8 @@ MODE ::= SUPPRESSED | CHECKED | MINIMIZED | ELIMINATED
 
 @noindent
 This pragma sets the current overflow mode to the given mode. For details
-of the meaning of these modes, see section on overflow checking in the
+of the meaning of these modes, please refer to the
+``Overflow Check Handling in GNAT'' appendix in the
 @value{EDITION} User's Guide. If only the @code{General} parameter is present,
 the given mode applies to all expressions. If both parameters are present,
 the @code{General} mode applies to expressions outside assertions, and
@@ -4169,6 +4170,7 @@ The pragma @code{Suppress (Overflow_Check)} sets mode
    General => Suppressed
 @end smallexample
 
+@noindent
 suppressing all overflow checking within and outside
 assertions.
 
@@ -4178,9 +4180,11 @@ The pragam @code{Unsuppress (Overflow_Check)} sets mode
    General => Checked
 @end smallexample
 
+@noindent
 which causes overflow checking of all intermediate overflows.
 This applies both inside and outside assertions.
 
+
 @node Pragma Passive
 @unnumberedsec Pragma Passive
 @findex Passive

gcc/ada/sem_ch6.adb

@@ -869,6 +869,24 @@ package body Sem_Ch6 is
          then
             Rewrite (Expr, Convert_To (R_Type, Relocate_Node (Expr)));
             Analyze_And_Resolve (Expr, R_Type);
+
+         --  If this is a local anonymous access to subprogram, the
+         --  accessibility check can be applied statically. The return is
+         --  illegal if the access type of the return expression is declared
+         --  inside of the subprogram (except if it is the subtype indication
+         --  of an extended return statement).
+
+         elsif  Ekind (R_Type) = E_Anonymous_Access_Subprogram_Type then
+            if not Comes_From_Source (Current_Scope)
+              or else Ekind (Current_Scope) = E_Return_Statement
+            then
+               null;
+
+            elsif
+                Scope_Depth (Scope (Etype (Expr))) >= Scope_Depth (Scope_Id)
+            then
+               Error_Msg_N ("cannot return local access to subprogram", N);
+            end if;
          end if;
 
          --  If the result type is class-wide, then check that the return

gcc/ada/sem_eval.adb

@@ -949,21 +949,31 @@ package body Sem_Eval is
             LLo, LHi : Uint;
             RLo, RHi : Uint;
 
+            Single : Boolean;
+            --  True if each range is a single point
+
          begin
             Determine_Range (L, LOK, LLo, LHi, Assume_Valid);
             Determine_Range (R, ROK, RLo, RHi, Assume_Valid);
 
             if LOK and ROK then
+               Single := (LLo = LHi) and then (RLo = RHi);
+
                if LHi < RLo then
+                  if Single and Assume_Valid then
+                     Diff.all := RLo - LLo;
+                  end if;
+
                   return LT;
 
                elsif RHi < LLo then
+                  if Single and Assume_Valid then
+                     Diff.all := LLo - RLo;
+                  end if;
+
                   return GT;
 
-               elsif LLo = LHi
-                 and then RLo = RHi
-                 and then LLo = RLo
-               then
+               elsif Single and then LLo = RLo then
 
                   --  If the range includes a single literal and we can assume
                   --  validity then the result is known even if an operand is

gcc/ada/sem_res.adb

@@ -7162,7 +7162,7 @@ package body Sem_Res is
       --  a constraint check.
 
       if Is_Scalar_Type (Then_Typ)
-        and then Then_Typ /= Typ
+        and then Base_Type (Then_Typ) /= Base_Type (Typ)
       then
          Rewrite (Then_Expr, Convert_To (Typ, Then_Expr));
          Analyze_And_Resolve (Then_Expr, Typ);