Overwritten with: d361f76 Revert "[InstCombine] canonicalize bitcast …

…after insertelement into undef"

Based on upstream llvm : 1813451 [Test] Add test showing missing opportunity of folding ICmp(Phi(Consts...))

Local changes since da64bde:
d361f76 Revert "[InstCombine] canonicalize bitcast after insertelement into undef"

Added AMD modification notices and removed some GPL files.

Change-Id: Ie47acaf14b1b45591d01ac09a45de776100484b1

llvm/lib/Transforms/InstCombine/InstCombineVectorOps.cpp

@@ -3,6 +3,8 @@
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// Modifications Copyright (c) 2020 Advanced Micro Devices, Inc. All rights reserved.
+// Notified per clause 4(b) of the license.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1050,26 +1052,9 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
           VecOp, ScalarOp, IdxOp, SQ.getWithInstruction(&IE)))
     return replaceInstUsesWith(IE, V);
 
-  // If the scalar is bitcast and inserted into undef, do the insert in the
-  // source type followed by bitcast.
-  // TODO: Generalize for insert into any constant, not just undef?
-  Value *ScalarSrc;
-  if (match(VecOp, m_Undef()) &&
-      match(ScalarOp, m_OneUse(m_BitCast(m_Value(ScalarSrc)))) &&
-      (ScalarSrc->getType()->isIntegerTy() ||
-       ScalarSrc->getType()->isFloatingPointTy())) {
-    // inselt undef, (bitcast ScalarSrc), IdxOp -->
-    //   bitcast (inselt undef, ScalarSrc, IdxOp)
-    Type *ScalarTy = ScalarSrc->getType();
-    Type *VecTy = VectorType::get(ScalarTy, IE.getType()->getElementCount());
-    UndefValue *NewUndef = UndefValue::get(VecTy);
-    Value *NewInsElt = Builder.CreateInsertElement(NewUndef, ScalarSrc, IdxOp);
-    return new BitCastInst(NewInsElt, IE.getType());
-  }
-
   // If the vector and scalar are both bitcast from the same element type, do
   // the insert in that source type followed by bitcast.
-  Value *VecSrc;
+  Value *VecSrc, *ScalarSrc;
   if (match(VecOp, m_BitCast(m_Value(VecSrc))) &&
       match(ScalarOp, m_BitCast(m_Value(ScalarSrc))) &&
       (VecOp->hasOneUse() || ScalarOp->hasOneUse()) &&

llvm/test/Transforms/InstCombine/bitcast-vec-canon.ll

@@ -1,3 +1,5 @@
+; Modifications Copyright (c) 2020 Advanced Micro Devices, Inc. All rights reserved.
+; Notified per clause 4(b) of the license.
 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
@@ -70,47 +72,30 @@ entry:
   ret double %1
 }
 
-; FP source is ok.
-
 define <3 x i64> @bitcast_inselt_undef(double %x, i32 %idx) {
 ; CHECK-LABEL: @bitcast_inselt_undef(
-; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <3 x double> undef, double [[X:%.*]], i32 [[IDX:%.*]]
-; CHECK-NEXT:    [[I:%.*]] = bitcast <3 x double> [[TMP1]] to <3 x i64>
+; CHECK-NEXT:    [[XB:%.*]] = bitcast double [[X:%.*]] to i64
+; CHECK-NEXT:    [[I:%.*]] = insertelement <3 x i64> undef, i64 [[XB]], i32 [[IDX:%.*]]
 ; CHECK-NEXT:    ret <3 x i64> [[I]]
 ;
   %xb = bitcast double %x to i64
   %i = insertelement <3 x i64> undef, i64 %xb, i32 %idx
   ret <3 x i64> %i
 }
 
-; Integer source is ok; index is anything.
-
 define <3 x float> @bitcast_inselt_undef_fp(i32 %x, i567 %idx) {
 ; CHECK-LABEL: @bitcast_inselt_undef_fp(
-; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <3 x i32> undef, i32 [[X:%.*]], i567 [[IDX:%.*]]
-; CHECK-NEXT:    [[I:%.*]] = bitcast <3 x i32> [[TMP1]] to <3 x float>
+; CHECK-NEXT:    [[XB:%.*]] = bitcast i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[I:%.*]] = insertelement <3 x float> undef, float [[XB]], i567 [[IDX:%.*]]
 ; CHECK-NEXT:    ret <3 x float> [[I]]
 ;
   %xb = bitcast i32 %x to float
   %i = insertelement <3 x float> undef, float %xb, i567 %idx
   ret <3 x float> %i
 }
 
-define <vscale x 3 x float> @bitcast_inselt_undef_vscale(i32 %x, i567 %idx) {
-; CHECK-LABEL: @bitcast_inselt_undef_vscale(
-; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <vscale x 3 x i32> undef, i32 [[X:%.*]], i567 [[IDX:%.*]]
-; CHECK-NEXT:    [[I:%.*]] = bitcast <vscale x 3 x i32> [[TMP1]] to <vscale x 3 x float>
-; CHECK-NEXT:    ret <vscale x 3 x float> [[I]]
-;
-  %xb = bitcast i32 %x to float
-  %i = insertelement <vscale x 3 x float> undef, float %xb, i567 %idx
-  ret <vscale x 3 x float> %i
-}
-
 declare void @use(i64)
 
-; Negative test - extra use prevents canonicalization
-
 define <3 x i64> @bitcast_inselt_undef_extra_use(double %x, i32 %idx) {
 ; CHECK-LABEL: @bitcast_inselt_undef_extra_use(
 ; CHECK-NEXT:    [[XB:%.*]] = bitcast double [[X:%.*]] to i64
@@ -124,8 +109,6 @@ define <3 x i64> @bitcast_inselt_undef_extra_use(double %x, i32 %idx) {
   ret <3 x i64> %i
 }
 
-; Negative test - source type must be scalar
-
 define <3 x i64> @bitcast_inselt_undef_vec_src(<2 x i32> %x, i32 %idx) {
 ; CHECK-LABEL: @bitcast_inselt_undef_vec_src(
 ; CHECK-NEXT:    [[XB:%.*]] = bitcast <2 x i32> [[X:%.*]] to i64
@@ -137,8 +120,6 @@ define <3 x i64> @bitcast_inselt_undef_vec_src(<2 x i32> %x, i32 %idx) {
   ret <3 x i64> %i
 }
 
-; Negative test - source type must be scalar
-
 define <3 x i64> @bitcast_inselt_undef_from_mmx(x86_mmx %x, i32 %idx) {
 ; CHECK-LABEL: @bitcast_inselt_undef_from_mmx(
 ; CHECK-NEXT:    [[XB:%.*]] = bitcast x86_mmx [[X:%.*]] to i64
@@ -150,13 +131,12 @@ define <3 x i64> @bitcast_inselt_undef_from_mmx(x86_mmx %x, i32 %idx) {
   ret <3 x i64> %i
 }
 
-; Reduce number of casts
-
 define <2 x i64> @PR45748(double %x, double %y) {
 ; CHECK-LABEL: @PR45748(
-; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <2 x double> undef, double [[X:%.*]], i32 0
-; CHECK-NEXT:    [[TMP2:%.*]] = insertelement <2 x double> [[TMP1]], double [[Y:%.*]], i32 1
-; CHECK-NEXT:    [[I1:%.*]] = bitcast <2 x double> [[TMP2]] to <2 x i64>
+; CHECK-NEXT:    [[XB:%.*]] = bitcast double [[X:%.*]] to i64
+; CHECK-NEXT:    [[I0:%.*]] = insertelement <2 x i64> undef, i64 [[XB]], i32 0
+; CHECK-NEXT:    [[YB:%.*]] = bitcast double [[Y:%.*]] to i64
+; CHECK-NEXT:    [[I1:%.*]] = insertelement <2 x i64> [[I0]], i64 [[YB]], i32 1
 ; CHECK-NEXT:    ret <2 x i64> [[I1]]
 ;
   %xb = bitcast double %x to i64