Subversion Repositories openrisc

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                             E X P _ F I X D                              --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2010, Free Software Foundation, Inc.         --

--                                                                          --

-- GNAT is free software;  you can  redistribute it  and/or modify it under --

-- terms of the  GNU General Public License as published  by the Free Soft- --

-- ware  Foundation;  either version 3,  or (at your option) any later ver- --

-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --

-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --

-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --

-- for  more details.  You should have  received  a copy of the GNU General --

-- Public License  distributed with GNAT; see file COPYING3.  If not, go to --

-- http://www.gnu.org/licenses for a complete copy of the license.          --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

------------------------------------------------------------------------------

with Atree;    use Atree;

with Checks;   use Checks;

with Einfo;    use Einfo;

with Exp_Util; use Exp_Util;

with Nlists;   use Nlists;

with Nmake;    use Nmake;

with Rtsfind;  use Rtsfind;

with Sem;      use Sem;

with Sem_Eval; use Sem_Eval;

with Sem_Res;  use Sem_Res;

with Sem_Util; use Sem_Util;

with Sinfo;    use Sinfo;

with Stand;    use Stand;

with Tbuild;   use Tbuild;

with Uintp;    use Uintp;

with Urealp;   use Urealp;

package body Exp_Fixd is

   -----------------------

   -- Local Subprograms --

   -----------------------

   --  General note; in this unit, a number of routines are driven by the

   --  types (Etype) of their operands. Since we are dealing with unanalyzed

   --  expressions as they are constructed, the Etypes would not normally be

   --  set, but the construction routines that we use in this unit do in fact

   --  set the Etype values correctly. In addition, setting the Etype ensures

   --  that the analyzer does not try to redetermine the type when the node

   --  is analyzed (which would be wrong, since in the case where we set the

   --  Treat_Fixed_As_Integer or Conversion_OK flags, it would think it was

   --  still dealing with a normal fixed-point operation and mess it up).

   function Build_Conversion

     (N     : Node_Id;

      Typ   : Entity_Id;

      Expr  : Node_Id;

      Rchk  : Boolean := False;

      Trunc : Boolean := False) return Node_Id;

   --  Build an expression that converts the expression Expr to type Typ,

   --  taking the source location from Sloc (N). If the conversions involve

   --  fixed-point types, then the Conversion_OK flag will be set so that the

   --  resulting conversions do not get re-expanded. On return the resulting

   --  node has its Etype set. If Rchk is set, then Do_Range_Check is set

   --  in the resulting conversion node. If Trunc is set, then the

   --  Float_Truncate flag is set on the conversion, which must be from

   --  a floating-point type to an integer type.

   function Build_Divide (N : Node_Id; L, R : Node_Id) return Node_Id;

   --  Builds an N_Op_Divide node from the given left and right operand

   --  expressions, using the source location from Sloc (N). The operands are

   --  either both Universal_Real, in which case Build_Divide differs from

   --  Make_Op_Divide only in that the Etype of the resulting node is set (to

   --  Universal_Real), or they can be integer types. In this case the integer

   --  types need not be the same, and Build_Divide converts the operand with

   --  the smaller sized type to match the type of the other operand and sets

   --  this as the result type. The Rounded_Result flag of the result in this

   --  case is set from the Rounded_Result flag of node N. On return, the

   --  resulting node is analyzed, and has its Etype set.

   function Build_Double_Divide

     (N       : Node_Id;

      X, Y, Z : Node_Id) return Node_Id;

   --  Returns a node corresponding to the value X/(Y*Z) using the source

   --  location from Sloc (N). The division is rounded if the Rounded_Result

   --  flag of N is set. The integer types of X, Y, Z may be different. On

   --  return the resulting node is analyzed, and has its Etype set.

   procedure Build_Double_Divide_Code

     (N        : Node_Id;

      X, Y, Z  : Node_Id;

      Qnn, Rnn : out Entity_Id;

      Code     : out List_Id);

   --  Generates a sequence of code for determining the quotient and remainder

   --  of the division X/(Y*Z), using the source location from Sloc (N).

   --  Entities of appropriate types are allocated for the quotient and

   --  remainder and returned in Qnn and Rnn. The result is rounded if the

   --  Rounded_Result flag of N is set. The Etype fields of Qnn and Rnn are

   --  appropriately set on return.

   function Build_Multiply (N : Node_Id; L, R : Node_Id) return Node_Id;

   --  Builds an N_Op_Multiply node from the given left and right operand

   --  expressions, using the source location from Sloc (N). The operands are

   --  either both Universal_Real, in which case Build_Multiply differs from

   --  Make_Op_Multiply only in that the Etype of the resulting node is set (to

   --  Universal_Real), or they can be integer types. In this case the integer

   --  types need not be the same, and Build_Multiply chooses a type long

   --  enough to hold the product (i.e. twice the size of the longer of the two

   --  operand types), and both operands are converted to this type. The Etype

   --  of the result is also set to this value. However, the result can never

   --  overflow Integer_64, so this is the largest type that is ever generated.

   --  On return, the resulting node is analyzed and has its Etype set.

   function Build_Rem (N : Node_Id; L, R : Node_Id) return Node_Id;

   --  Builds an N_Op_Rem node from the given left and right operand

   --  expressions, using the source location from Sloc (N). The operands are

   --  both integer types, which need not be the same. Build_Rem converts the

   --  operand with the smaller sized type to match the type of the other

   --  operand and sets this as the result type. The result is never rounded

   --  (rem operations cannot be rounded in any case!) On return, the resulting

   --  node is analyzed and has its Etype set.

   function Build_Scaled_Divide

     (N       : Node_Id;

      X, Y, Z : Node_Id) return Node_Id;

   --  Returns a node corresponding to the value X*Y/Z using the source

   --  location from Sloc (N). The division is rounded if the Rounded_Result

   --  flag of N is set. The integer types of X, Y, Z may be different. On

   --  return the resulting node is analyzed and has is Etype set.

   procedure Build_Scaled_Divide_Code

     (N        : Node_Id;

      X, Y, Z  : Node_Id;

      Qnn, Rnn : out Entity_Id;

      Code     : out List_Id);

   --  Generates a sequence of code for determining the quotient and remainder

   --  of the division X*Y/Z, using the source location from Sloc (N). Entities

   --  of appropriate types are allocated for the quotient and remainder and

   --  returned in Qnn and Rrr. The integer types for X, Y, Z may be different.

   --  The division is rounded if the Rounded_Result flag of N is set. The

   --  Etype fields of Qnn and Rnn are appropriately set on return.

   procedure Do_Divide_Fixed_Fixed (N : Node_Id);

   --  Handles expansion of divide for case of two fixed-point operands

   --  (neither of them universal), with an integer or fixed-point result.

   --  N is the N_Op_Divide node to be expanded.

   procedure Do_Divide_Fixed_Universal (N : Node_Id);

   --  Handles expansion of divide for case of a fixed-point operand divided

   --  by a universal real operand, with an integer or fixed-point result. N

   --  is the N_Op_Divide node to be expanded.

   procedure Do_Divide_Universal_Fixed (N : Node_Id);

   --  Handles expansion of divide for case of a universal real operand

   --  divided by a fixed-point operand, with an integer or fixed-point

   --  result. N is the N_Op_Divide node to be expanded.

   procedure Do_Multiply_Fixed_Fixed (N : Node_Id);

   --  Handles expansion of multiply for case of two fixed-point operands

   --  (neither of them universal), with an integer or fixed-point result.

   --  N is the N_Op_Multiply node to be expanded.

   procedure Do_Multiply_Fixed_Universal (N : Node_Id; Left, Right : Node_Id);

   --  Handles expansion of multiply for case of a fixed-point operand

   --  multiplied by a universal real operand, with an integer or fixed-

   --  point result. N is the N_Op_Multiply node to be expanded, and

   --  Left, Right are the operands (which may have been switched).

   procedure Expand_Convert_Fixed_Static (N : Node_Id);

   --  This routine is called where the node N is a conversion of a literal

   --  or other static expression of a fixed-point type to some other type.

   --  In such cases, we simply rewrite the operand as a real literal and

   --  reanalyze. This avoids problems which would otherwise result from

   --  attempting to build and fold expressions involving constants.

   function Fpt_Value (N : Node_Id) return Node_Id;

   --  Given an operand of fixed-point operation, return an expression that

   --  represents the corresponding Universal_Real value. The expression

   --  can be of integer type, floating-point type, or fixed-point type.

   --  The expression returned is neither analyzed and resolved. The Etype

   --  of the result is properly set (to Universal_Real).

   function Integer_Literal

     (N        : Node_Id;

      V        : Uint;

      Negative : Boolean := False) return Node_Id;

   --  Given a non-negative universal integer value, build a typed integer

   --  literal node, using the smallest applicable standard integer type. If

   --  and only if Negative is true a negative literal is built. If V exceeds

   --  2**63-1, the largest value allowed for perfect result set scaling

   --  factors (see RM G.2.3(22)), then Empty is returned. The node N provides

   --  the Sloc value for the constructed literal. The Etype of the resulting

   --  literal is correctly set, and it is marked as analyzed.

   function Real_Literal (N : Node_Id; V : Ureal) return Node_Id;

   --  Build a real literal node from the given value, the Etype of the

   --  returned node is set to Universal_Real, since all floating-point

   --  arithmetic operations that we construct use Universal_Real

   function Rounded_Result_Set (N : Node_Id) return Boolean;

   --  Returns True if N is a node that contains the Rounded_Result flag

   --  and if the flag is true or the target type is an integer type.

   procedure Set_Result

     (N     : Node_Id;

      Expr  : Node_Id;

      Rchk  : Boolean := False;

      Trunc : Boolean := False);

   --  N is the node for the current conversion, division or multiplication

   --  operation, and Expr is an expression representing the result. Expr may

   --  be of floating-point or integer type. If the operation result is fixed-

   --  point, then the value of Expr is in units of small of the result type

   --  (i.e. small's have already been dealt with). The result of the call is

   --  to replace N by an appropriate conversion to the result type, dealing

   --  with rounding for the decimal types case. The node is then analyzed and

   --  resolved using the result type. If Rchk or Trunc are True, then

   --  respectively Do_Range_Check and Float_Truncate are set in the

   --  resulting conversion.

   ----------------------

   -- Build_Conversion --

   ----------------------

   function Build_Conversion

     (N     : Node_Id;

      Typ   : Entity_Id;

      Expr  : Node_Id;

      Rchk  : Boolean := False;

      Trunc : Boolean := False) return Node_Id

   is

      Loc    : constant Source_Ptr := Sloc (N);

      Result : Node_Id;

      Rcheck : Boolean := Rchk;

   begin

      --  A special case, if the expression is an integer literal and the

      --  target type is an integer type, then just retype the integer

      --  literal to the desired target type. Don't do this if we need

      --  a range check.

      if Nkind (Expr) = N_Integer_Literal

        and then Is_Integer_Type (Typ)

        and then not Rchk

      then

         Result := Expr;

      --  Cases where we end up with a conversion. Note that we do not use the

      --  Convert_To abstraction here, since we may be decorating the resulting

      --  conversion with Rounded_Result and/or Conversion_OK, so we want the

      --  conversion node present, even if it appears to be redundant.

      else

         --  Remove inner conversion if both inner and outer conversions are

         --  to integer types, since the inner one serves no purpose (except

         --  perhaps to set rounding, so we preserve the Rounded_Result flag)

         --  and also we preserve the range check flag on the inner operand

         if Is_Integer_Type (Typ)

           and then Is_Integer_Type (Etype (Expr))

           and then Nkind (Expr) = N_Type_Conversion

         then

            Result :=

              Make_Type_Conversion (Loc,

                Subtype_Mark => New_Occurrence_Of (Typ, Loc),

                Expression   => Expression (Expr));

            Set_Rounded_Result (Result, Rounded_Result_Set (Expr));

            Rcheck := Rcheck or Do_Range_Check (Expr);

         --  For all other cases, a simple type conversion will work

         else

            Result :=

              Make_Type_Conversion (Loc,

                Subtype_Mark => New_Occurrence_Of (Typ, Loc),

                Expression   => Expr);

            Set_Float_Truncate (Result, Trunc);

         end if;

         --  Set Conversion_OK if either result or expression type is a

         --  fixed-point type, since from a semantic point of view, we are

         --  treating fixed-point values as integers at this stage.

         if Is_Fixed_Point_Type (Typ)

           or else Is_Fixed_Point_Type (Etype (Expression (Result)))

         then

            Set_Conversion_OK (Result);

         end if;

         --  Set Do_Range_Check if either it was requested by the caller,

         --  or if an eliminated inner conversion had a range check.

         if Rcheck then

            Enable_Range_Check (Result);

         else

            Set_Do_Range_Check (Result, False);

         end if;

      end if;

      Set_Etype (Result, Typ);

      return Result;

   end Build_Conversion;

   ------------------

   -- Build_Divide --

   ------------------

   function Build_Divide (N : Node_Id; L, R : Node_Id) return Node_Id is

      Loc         : constant Source_Ptr := Sloc (N);

      Left_Type   : constant Entity_Id  := Base_Type (Etype (L));

      Right_Type  : constant Entity_Id  := Base_Type (Etype (R));

      Result_Type : Entity_Id;

      Rnode       : Node_Id;

   begin

      --  Deal with floating-point case first

      if Is_Floating_Point_Type (Left_Type) then

         pragma Assert (Left_Type = Universal_Real);

         pragma Assert (Right_Type = Universal_Real);

         Rnode := Make_Op_Divide (Loc, L, R);

         Result_Type := Universal_Real;

      --  Integer and fixed-point cases

      else

         --  An optimization. If the right operand is the literal 1, then we

         --  can just return the left hand operand. Putting the optimization

         --  here allows us to omit the check at the call site.

         if Nkind (R) = N_Integer_Literal and then Intval (R) = 1 then

            return L;

         end if;

         --  If left and right types are the same, no conversion needed

         if Left_Type = Right_Type then

            Result_Type := Left_Type;

            Rnode :=

              Make_Op_Divide (Loc,

                Left_Opnd  => L,

                Right_Opnd => R);

         --  Use left type if it is the larger of the two

         elsif Esize (Left_Type) >= Esize (Right_Type) then

            Result_Type := Left_Type;

            Rnode :=

              Make_Op_Divide (Loc,

                Left_Opnd  => L,

                Right_Opnd => Build_Conversion (N, Left_Type, R));

         --  Otherwise right type is larger of the two, us it

         else

            Result_Type := Right_Type;

            Rnode :=

              Make_Op_Divide (Loc,

                Left_Opnd => Build_Conversion (N, Right_Type, L),

                Right_Opnd => R);

         end if;

      end if;

      --  We now have a divide node built with Result_Type set. First

      --  set Etype of result, as required for all Build_xxx routines

      Set_Etype (Rnode, Base_Type (Result_Type));

      --  Set Treat_Fixed_As_Integer if operation on fixed-point type

      --  since this is a literal arithmetic operation, to be performed

      --  by Gigi without any consideration of small values.

      if Is_Fixed_Point_Type (Result_Type) then

         Set_Treat_Fixed_As_Integer (Rnode);

      end if;

      --  The result is rounded if the target of the operation is decimal

      --  and Rounded_Result is set, or if the target of the operation

      --  is an integer type.

      if Is_Integer_Type (Etype (N))

        or else Rounded_Result_Set (N)

      then

         Set_Rounded_Result (Rnode);

      end if;

      return Rnode;

   end Build_Divide;

   -------------------------

   -- Build_Double_Divide --

   -------------------------

   function Build_Double_Divide

     (N       : Node_Id;

      X, Y, Z : Node_Id) return Node_Id

   is

      Y_Size : constant Int := UI_To_Int (Esize (Etype (Y)));

      Z_Size : constant Int := UI_To_Int (Esize (Etype (Z)));

      Expr   : Node_Id;

   begin

      --  If denominator fits in 64 bits, we can build the operations directly

      --  without causing any intermediate overflow, so that's what we do!

      if Int'Max (Y_Size, Z_Size) <= 32 then

         return

           Build_Divide (N, X, Build_Multiply (N, Y, Z));

      --  Otherwise we use the runtime routine

      --    [Qnn : Interfaces.Integer_64,

      --     Rnn : Interfaces.Integer_64;

      --     Double_Divide (X, Y, Z, Qnn, Rnn, Round);

      --     Qnn]

      else

         declare

            Loc  : constant Source_Ptr := Sloc (N);

            Qnn  : Entity_Id;

            Rnn  : Entity_Id;

            Code : List_Id;

            pragma Warnings (Off, Rnn);

         begin

            Build_Double_Divide_Code (N, X, Y, Z, Qnn, Rnn, Code);

            Insert_Actions (N, Code);

            Expr := New_Occurrence_Of (Qnn, Loc);

            --  Set type of result in case used elsewhere (see note at start)

            Set_Etype (Expr, Etype (Qnn));

            --  Set result as analyzed (see note at start on build routines)

            return Expr;

         end;

      end if;

   end Build_Double_Divide;

   ------------------------------

   -- Build_Double_Divide_Code --

   ------------------------------

   --  If the denominator can be computed in 64-bits, we build

   --    [Nnn : constant typ := typ (X);

   --     Dnn : constant typ := typ (Y) * typ (Z)

   --     Qnn : constant typ := Nnn / Dnn;

   --     Rnn : constant typ := Nnn / Dnn;

   --  If the numerator cannot be computed in 64 bits, we build

   --    [Qnn : typ;

   --     Rnn : typ;

   --     Double_Divide (X, Y, Z, Qnn, Rnn, Round);]

   procedure Build_Double_Divide_Code

     (N        : Node_Id;

      X, Y, Z  : Node_Id;

      Qnn, Rnn : out Entity_Id;

      Code     : out List_Id)

   is

      Loc    : constant Source_Ptr := Sloc (N);

      X_Size : constant Int := UI_To_Int (Esize (Etype (X)));

      Y_Size : constant Int := UI_To_Int (Esize (Etype (Y)));

      Z_Size : constant Int := UI_To_Int (Esize (Etype (Z)));

      QR_Siz : Int;

      QR_Typ : Entity_Id;

      Nnn : Entity_Id;

      Dnn : Entity_Id;

      Quo : Node_Id;

      Rnd : Entity_Id;

   begin

      --  Find type that will allow computation of numerator

      QR_Siz := Int'Max (X_Size, 2 * Int'Max (Y_Size, Z_Size));

      if QR_Siz <= 16 then

         QR_Typ := Standard_Integer_16;

      elsif QR_Siz <= 32 then

         QR_Typ := Standard_Integer_32;

      elsif QR_Siz <= 64 then

         QR_Typ := Standard_Integer_64;

      --  For more than 64, bits, we use the 64-bit integer defined in

      --  Interfaces, so that it can be handled by the runtime routine

      else

         QR_Typ := RTE (RE_Integer_64);

      end if;

      --  Define quotient and remainder, and set their Etypes, so

      --  that they can be picked up by Build_xxx routines.

      Qnn := Make_Temporary (Loc, 'S');

      Rnn := Make_Temporary (Loc, 'R');

      Set_Etype (Qnn, QR_Typ);

      Set_Etype (Rnn, QR_Typ);

      --  Case that we can compute the denominator in 64 bits

      if QR_Siz <= 64 then

         --  Create temporaries for numerator and denominator and set Etypes,

         --  so that New_Occurrence_Of picks them up for Build_xxx calls.

         Nnn := Make_Temporary (Loc, 'N');

         Dnn := Make_Temporary (Loc, 'D');

         Set_Etype (Nnn, QR_Typ);

         Set_Etype (Dnn, QR_Typ);

         Code := New_List (

           Make_Object_Declaration (Loc,

             Defining_Identifier => Nnn,

             Object_Definition   => New_Occurrence_Of (QR_Typ, Loc),

             Constant_Present    => True,

             Expression => Build_Conversion (N, QR_Typ, X)),

           Make_Object_Declaration (Loc,

             Defining_Identifier => Dnn,

             Object_Definition   => New_Occurrence_Of (QR_Typ, Loc),

             Constant_Present    => True,

             Expression =>

               Build_Multiply (N,

                 Build_Conversion (N, QR_Typ, Y),

                 Build_Conversion (N, QR_Typ, Z))));

         Quo :=

           Build_Divide (N,

             New_Occurrence_Of (Nnn, Loc),

             New_Occurrence_Of (Dnn, Loc));

         Set_Rounded_Result (Quo, Rounded_Result_Set (N));

         Append_To (Code,

           Make_Object_Declaration (Loc,

             Defining_Identifier => Qnn,

             Object_Definition   => New_Occurrence_Of (QR_Typ, Loc),

             Constant_Present    => True,

             Expression          => Quo));

         Append_To (Code,

           Make_Object_Declaration (Loc,

             Defining_Identifier => Rnn,

             Object_Definition   => New_Occurrence_Of (QR_Typ, Loc),

             Constant_Present    => True,

             Expression =>

               Build_Rem (N,

                 New_Occurrence_Of (Nnn, Loc),

                 New_Occurrence_Of (Dnn, Loc))));

      --  Case where denominator does not fit in 64 bits, so we have to

      --  call the runtime routine to compute the quotient and remainder

      else

         Rnd := Boolean_Literals (Rounded_Result_Set (N));

         Code := New_List (

           Make_Object_Declaration (Loc,

             Defining_Identifier => Qnn,

             Object_Definition   => New_Occurrence_Of (QR_Typ, Loc)),

           Make_Object_Declaration (Loc,

             Defining_Identifier => Rnn,

             Object_Definition   => New_Occurrence_Of (QR_Typ, Loc)),

           Make_Procedure_Call_Statement (Loc,

             Name => New_Occurrence_Of (RTE (RE_Double_Divide), Loc),

             Parameter_Associations => New_List (

               Build_Conversion (N, QR_Typ, X),

               Build_Conversion (N, QR_Typ, Y),

               Build_Conversion (N, QR_Typ, Z),

               New_Occurrence_Of (Qnn, Loc),

               New_Occurrence_Of (Rnn, Loc),

               New_Occurrence_Of (Rnd, Loc))));

      end if;

   end Build_Double_Divide_Code;

   --------------------

   -- Build_Multiply --

   --------------------

   function Build_Multiply (N : Node_Id; L, R : Node_Id) return Node_Id is

      Loc         : constant Source_Ptr := Sloc (N);

      Left_Type   : constant Entity_Id  := Etype (L);

      Right_Type  : constant Entity_Id  := Etype (R);

      Left_Size   : Int;

      Right_Size  : Int;

      Rsize       : Int;

      Result_Type : Entity_Id;

      Rnode       : Node_Id;

   begin

      --  Deal with floating-point case first

      if Is_Floating_Point_Type (Left_Type) then

         pragma Assert (Left_Type = Universal_Real);

         pragma Assert (Right_Type = Universal_Real);

         Result_Type := Universal_Real;

         Rnode := Make_Op_Multiply (Loc, L, R);

      --  Integer and fixed-point cases

      else

         --  An optimization. If the right operand is the literal 1, then we

         --  can just return the left hand operand. Putting the optimization

         --  here allows us to omit the check at the call site. Similarly, if

         --  the left operand is the integer 1 we can return the right operand.

         if Nkind (R) = N_Integer_Literal and then Intval (R) = 1 then

            return L;

         elsif Nkind (L) = N_Integer_Literal and then Intval (L) = 1 then

            return R;

         end if;

         --  Otherwise we need to figure out the correct result type size

         --  First figure out the effective sizes of the operands. Normally

         --  the effective size of an operand is the RM_Size of the operand.

         --  But a special case arises with operands whose size is known at

         --  compile time. In this case, we can use the actual value of the

         --  operand to get its size if it would fit signed in 8 or 16 bits.

         Left_Size := UI_To_Int (RM_Size (Left_Type));

         if Compile_Time_Known_Value (L) then

            declare

               Val : constant Uint := Expr_Value (L);

            begin

               if Val < Int'(2 ** 7) then

                  Left_Size := 8;

               elsif Val < Int'(2 ** 15) then

                  Left_Size := 16;

               end if;

            end;

         end if;

         Right_Size := UI_To_Int (RM_Size (Right_Type));

         if Compile_Time_Known_Value (R) then

            declare

               Val : constant Uint := Expr_Value (R);

            begin

               if Val <= Int'(2 ** 7) then

                  Right_Size := 8;

               elsif Val <= Int'(2 ** 15) then

                  Right_Size := 16;

               end if;

            end;

         end if;

         --  Now the result size must be at least twice the longer of

         --  the two sizes, to accommodate all possible results.

         Rsize := 2 * Int'Max (Left_Size, Right_Size);

         if Rsize <= 8 then

            Result_Type := Standard_Integer_8;

         elsif Rsize <= 16 then

            Result_Type := Standard_Integer_16;

         elsif Rsize <= 32 then

            Result_Type := Standard_Integer_32;

         else

            Result_Type := Standard_Integer_64;

         end if;

         Rnode :=

            Make_Op_Multiply (Loc,

              Left_Opnd  => Build_Conversion (N, Result_Type, L),

              Right_Opnd => Build_Conversion (N, Result_Type, R));

      end if;

      --  We now have a multiply node built with Result_Type set. First

      --  set Etype of result, as required for all Build_xxx routines

      Set_Etype (Rnode, Base_Type (Result_Type));

      --  Set Treat_Fixed_As_Integer if operation on fixed-point type

      --  since this is a literal arithmetic operation, to be performed

      --  by Gigi without any consideration of small values.

      if Is_Fixed_Point_Type (Result_Type) then

         Set_Treat_Fixed_As_Integer (Rnode);

      end if;

      return Rnode;

   end Build_Multiply;

   ---------------

   -- Build_Rem --

   ---------------

   function Build_Rem (N : Node_Id; L, R : Node_Id) return Node_Id is

      Loc         : constant Source_Ptr := Sloc (N);

      Left_Type   : constant Entity_Id  := Etype (L);

      Right_Type  : constant Entity_Id  := Etype (R);

      Result_Type : Entity_Id;

      Rnode       : Node_Id;

   begin

      if Left_Type = Right_Type then

         Result_Type := Left_Type;

         Rnode :=

           Make_Op_Rem (Loc,

             Left_Opnd  => L,

             Right_Opnd => R);

      --  If left size is larger, we do the remainder operation using the

      --  size of the left type (i.e. the larger of the two integer types).

      elsif Esize (Left_Type) >= Esize (Right_Type) then

         Result_Type := Left_Type;

         Rnode :=

           Make_Op_Rem (Loc,

             Left_Opnd  => L,

             Right_Opnd => Build_Conversion (N, Left_Type, R));

      --  Similarly, if the right size is larger, we do the remainder

      --  operation using the right type.

      else

         Result_Type := Right_Type;

         Rnode :=

           Make_Op_Rem (Loc,

             Left_Opnd => Build_Conversion (N, Right_Type, L),

             Right_Opnd => R);

      end if;

      --  We now have an N_Op_Rem node built with Result_Type set. First

      --  set Etype of result, as required for all Build_xxx routines

      Set_Etype (Rnode, Base_Type (Result_Type));

      --  Set Treat_Fixed_As_Integer if operation on fixed-point type

      --  since this is a literal arithmetic operation, to be performed

      --  by Gigi without any consideration of small values.

      if Is_Fixed_Point_Type (Result_Type) then

         Set_Treat_Fixed_As_Integer (Rnode);

      end if;

      --  One more check. We did the rem operation using the larger of the

      --  two types, which is reasonable. However, in the case where the

      --  two types have unequal sizes, it is impossible for the result of

      --  a remainder operation to be larger than the smaller of the two

      --  types, so we can put a conversion round the result to keep the

      --  evolving operation size as small as possible.

      if Esize (Left_Type) >= Esize (Right_Type) then

         Rnode := Build_Conversion (N, Right_Type, Rnode);

      elsif Esize (Right_Type) >= Esize (Left_Type) then

         Rnode := Build_Conversion (N, Left_Type, Rnode);

      end if;

      return Rnode;

   end Build_Rem;

   -------------------------

   -- Build_Scaled_Divide --

   -------------------------

   function Build_Scaled_Divide

     (N       : Node_Id;

      X, Y, Z : Node_Id) return Node_Id

   is

      X_Size : constant Int := UI_To_Int (Esize (Etype (X)));

      Y_Size : constant Int := UI_To_Int (Esize (Etype (Y)));

      Expr   : Node_Id;

   begin

      --  If numerator fits in 64 bits, we can build the operations directly

      --  without causing any intermediate overflow, so that's what we do!

      if Int'Max (X_Size, Y_Size) <= 32 then

         return

           Build_Divide (N, Build_Multiply (N, X, Y), Z);

      --  Otherwise we use the runtime routine