tree-tailcall.c (find_tail_calls): Convert the operands to the type of the…

tree-tailcall.c (find_tail_calls): Convert the operands to the type of the result before building binary expressions.

	* tree-tailcall.c (find_tail_calls): Convert the operands to the type
	of the result before building binary expressions.

From-SVN: r166260

gcc/ChangeLog

+2010-11-03  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* tree-tailcall.c (find_tail_calls): Convert the operands to the type
+	of the result before building binary expressions.
+
 2010-11-03  H.J. Lu  <hongjiu.lu@intel.com>
 
 	PR rtl-optimization/45865

gcc/testsuite/ChangeLog

+2010-11-03  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/opt8.ad[sb]: New test.
+	* gnat.dg/opt8_pkg.ads: New helper.
+
 2010-11-03  H.J. Lu  <hongjiu.lu@intel.com>
 
 	PR rtl-optimization/45865

gcc/testsuite/gnat.dg/opt8.adb

+-- { dg-do compile }
+-- { dg-options "-O2" }
+
+with Opt8_Pkg;
+
+package body Opt8 is
+
+    function Content_Value (Rec : Kappa_Component_Rec)
+        return Value_Number is
+    begin
+        return Opt8_Pkg.Id_To_VN (Rec.Content_VN);
+    end;
+
+    function Possible_Values_Count (V: Kappa_Component_Ptr) return Natural is
+        Result : Natural := 0;
+        List : Kappa_Component_Ptr := V;
+    begin
+        while List /= null loop
+            Result := Result +1;
+            List := List.Next;
+        end loop;
+        return Result;
+    end;
+
+    function VN_Complexity (Val : Value_Number; N : Natural)
+        return Natural is
+        Result : Natural := 0;
+      begin
+        case Val.Kind is
+            when Membership_VN =>
+                Result :=  VN_Complexity(Val, N);
+            when Selected_Address_VN =>
+                Result :=  VN_Complexity(Val, N) + 1;
+            when Kappa_VN =>
+                Result := Possible_Values_Count(Val.Possible_New_Values)*3;
+                if Val.Use_Default then
+                    if Result < N then
+                      Result := Result +
+                          VN_Complexity(Content_Value (Val.old_Value), N);
+                    end if;
+                end if;
+            when others =>
+              Result := 0;
+          end case;
+        return Result;
+    end;
+
+end Opt8;

gcc/testsuite/gnat.dg/opt8.ads

+package Opt8 is
+
+    type Value_Number_Kind is
+      (Int_Literal_VN,
+       Selected_Address_VN,
+       Membership_VN,
+       Initial_External_Kappa_VN,
+       Aliased_Kappa_VN,
+       Phi_As_Kappa_VN,
+       Multi_Target_Call_Kappa_VN,
+       Final_Value_Of_Seq_Kappa_VN,
+       Block_Kappa_VN);
+
+    subtype Kappa_VN is Value_Number_Kind
+    range Initial_External_Kappa_VN .. Block_Kappa_VN;
+
+    type Value_Number_Id is new Positive;
+
+    type Kappa_Component_Rec;
+
+    type Kappa_Component_Ptr is access Kappa_Component_Rec;
+
+    type Kappa_Component_Rec is record
+        Content_VN : Value_Number_Id;
+        Next : Kappa_Component_Ptr;
+    end record;
+
+    type Value_Number_Rec(Kind : Value_Number_Kind) is record
+        Id: Value_Number_Id;
+        case Kind is
+            when Int_Literal_VN =>
+                Int_Val : Integer;
+            when Kappa_VN =>
+                Old_Value : Kappa_Component_Rec;
+                Possible_New_Values : Kappa_Component_Ptr;
+                Use_Default : Boolean;
+            when Others =>
+                null;
+        end case;
+    end record;
+
+    type Value_Number is access all Value_Number_Rec;
+
+    function VN_Complexity (Val : Value_Number; N : Natural) return Natural;
+
+end Opt8;

gcc/testsuite/gnat.dg/opt8_pkg.ads

+with Opt8; use Opt8;
+
+package Opt8_Pkg is
+
+    function Id_To_VN (Id: Value_Number_Id) return Value_Number;
+
+end Opt8_Pkg;

gcc/tree-tailcall.c

@@ -532,20 +532,22 @@ find_tail_calls (basic_block bb, struct tailcall **ret)
 
       if (tmp_a)
 	{
+	  tree type = TREE_TYPE (tmp_a);
 	  if (a)
-	    a = fold_build2 (PLUS_EXPR, TREE_TYPE (tmp_a), a, tmp_a);
+	    a = fold_build2 (PLUS_EXPR, type, fold_convert (type, a), tmp_a);
 	  else
 	    a = tmp_a;
 	}
       if (tmp_m)
 	{
+	  tree type = TREE_TYPE (tmp_m);
 	  if (m)
-	    m = fold_build2 (MULT_EXPR, TREE_TYPE (tmp_m), m, tmp_m);
+	    m = fold_build2 (MULT_EXPR, type, fold_convert (type, m), tmp_m);
 	  else
 	    m = tmp_m;
 
 	  if (a)
-	    a = fold_build2 (MULT_EXPR, TREE_TYPE (tmp_m), a, tmp_m);
+	    a = fold_build2 (MULT_EXPR, type, fold_convert (type, a), tmp_m);
 	}
     }