Merge from 'main' to 'sycl-web' (5 commits)

dwoodwor-intel · dwoodwor-intel · commit 7c5d8fd97d82 · 2022-07-20T17:04:07.000-04:00
CONFLICT (content): Merge conflict in clang/include/clang/Driver/Options.h
diff --git a/clang-tools-extra/clangd/CompileCommands.cpp b/clang-tools-extra/clangd/CompileCommands.cpp
@@ -423,6 +423,8 @@ unsigned char getModes(const llvm::opt::Option &Opt) {
   if (!Opt.hasFlag(driver::options::NoDriverOption)) {
     if (Opt.hasFlag(driver::options::CLOption)) {
       Result |= DM_CL;
+    } else if (Opt.hasFlag(driver::options::CLDXCOption)) {
+      Result |= DM_CL;
     } else {
       Result |= DM_GCC;
       if (Opt.hasFlag(driver::options::CoreOption)) {
diff --git a/clang/include/clang/Driver/Options.h b/clang/include/clang/Driver/Options.h
@@ -36,8 +36,9 @@ enum ClangFlags {
   FC1Option = (1 << 15),
   FlangOnlyOption = (1 << 16),
   DXCOption = (1 << 17),
-  Ignored = (1 << 18),
-  Deprecated = (1 << 19),
+  CLDXCOption = (1 << 18),
+  Ignored = (1 << 19),
+  Deprecated = (1 << 20),
 };
 
 enum ID {
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
@@ -53,6 +53,10 @@ def CC1AsOption : OptionFlag;
 // are made available when the driver is running in DXC compatibility mode.
 def DXCOption : OptionFlag;
 
+// CLDXCOption - This is a cl.exe/dxc.exe compatibility option. Options with this flag
+// are made available when the driver is running in CL/DXC compatibility mode.
+def CLDXCOption : OptionFlag;
+
 // NoDriverOption - This option should not be accepted by the driver.
 def NoDriverOption : OptionFlag;
 
@@ -6577,7 +6581,7 @@ def defsym : Separate<["-"], "defsym">,
 // clang-cl Options
 //===----------------------------------------------------------------------===//
 
-def cl_Group : OptionGroup<"<clang-cl options>">, Flags<[CLOption]>,
+def cl_Group : OptionGroup<"<clang-cl options>">, Flags<[CLDXCOption]>,
   HelpText<"CL.EXE COMPATIBILITY OPTIONS">;
 
 def cl_compile_Group : OptionGroup<"<clang-cl compile-only options>">,
@@ -6607,6 +6611,9 @@ class CLIgnoredJoined<string name> : Option<["/", "-"], name, KIND_JOINED>,
 class CLJoinedOrSeparate<string name> : Option<["/", "-"], name,
   KIND_JOINED_OR_SEPARATE>, Group<cl_Group>, Flags<[CLOption, NoXarchOption]>;
 
+class CLDXCJoinedOrSeparate<string name> : Option<["/", "-"], name,
+  KIND_JOINED_OR_SEPARATE>, Group<cl_Group>, Flags<[CLDXCOption, NoXarchOption]>;
+
 class CLCompileJoinedOrSeparate<string name> : Option<["/", "-"], name,
   KIND_JOINED_OR_SEPARATE>, Group<cl_compile_Group>,
   Flags<[CLOption, NoXarchOption]>;
@@ -6684,7 +6691,7 @@ def _SLASH_help : CLFlag<"help">, Alias<help>,
 def _SLASH_HELP : CLFlag<"HELP">, Alias<help>;
 def _SLASH_hotpatch : CLFlag<"hotpatch">, Alias<fms_hotpatch>,
   HelpText<"Create hotpatchable image">;
-def _SLASH_I : CLJoinedOrSeparate<"I">,
+def _SLASH_I : CLDXCJoinedOrSeparate<"I">,
   HelpText<"Add directory to include search path">, MetaVarName<"<dir>">,
   Alias<I>;
 def _SLASH_J : CLFlag<"J">, HelpText<"Make char type unsigned">,
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
@@ -8883,17 +8883,22 @@ Driver::getIncludeExcludeOptionFlagMasks(bool IsClCompatMode) const {
   if (IsClCompatMode) {
     // Include CL and Core options.
     IncludedFlagsBitmask |= options::CLOption;
+    IncludedFlagsBitmask |= options::CLDXCOption;
     IncludedFlagsBitmask |= options::CoreOption;
   } else {
     ExcludedFlagsBitmask |= options::CLOption;
   }
   if (IsDXCMode()) {
     // Include DXC and Core options.
     IncludedFlagsBitmask |= options::DXCOption;
+    IncludedFlagsBitmask |= options::CLDXCOption;
     IncludedFlagsBitmask |= options::CoreOption;
   } else {
     ExcludedFlagsBitmask |= options::DXCOption;
   }
+  if (!IsClCompatMode && !IsDXCMode())
+    ExcludedFlagsBitmask |= options::CLDXCOption;
+
   return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
 }
 
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -3622,6 +3622,7 @@ static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs,
                               types::ID InputType) {
   const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
                                          options::OPT_D,
+                                         options::OPT_I,
                                          options::OPT_S,
                                          options::OPT_emit_llvm,
                                          options::OPT_disable_llvm_passes,
diff --git a/clang/test/Driver/dxc_I.hlsl b/clang/test/Driver/dxc_I.hlsl
@@ -0,0 +1,4 @@
+// RUN: %clang_dxc -I test  -### %s 2>&1 | FileCheck %s
+
+// Make sure -I send to cc1.
+// CHECK:"-I" "test"
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineShifts.cpp b/llvm/lib/Transforms/InstCombine/InstCombineShifts.cpp
@@ -566,6 +566,13 @@ static bool canEvaluateShifted(Value *V, unsigned NumBits, bool IsLeftShift,
         return false;
     return true;
   }
+  case Instruction::Mul: {
+    const APInt *MulConst;
+    // We can fold (shr (mul X, -(1 << C)), C) -> (and (neg X), C`)
+    return !IsLeftShift && match(I->getOperand(1), m_APInt(MulConst)) &&
+           MulConst->isNegatedPowerOf2() &&
+           MulConst->countTrailingZeros() == NumBits;
+  }
   }
 }
 
@@ -680,6 +687,17 @@ static Value *getShiftedValue(Value *V, unsigned NumBits, bool isLeftShift,
                                               isLeftShift, IC, DL));
     return PN;
   }
+  case Instruction::Mul: {
+    assert(!isLeftShift && "Unexpected shift direction!");
+    auto *Neg = BinaryOperator::CreateNeg(I->getOperand(0));
+    IC.InsertNewInstWith(Neg, *I);
+    unsigned TypeWidth = I->getType()->getScalarSizeInBits();
+    APInt Mask = APInt::getLowBitsSet(TypeWidth, TypeWidth - NumBits);
+    auto *And = BinaryOperator::CreateAnd(Neg,
+                                          ConstantInt::get(I->getType(), Mask));
+    And->takeName(I);
+    return IC.InsertNewInstWith(And, *I);
+  }
   }
 }
 
diff --git a/llvm/test/DebugInfo/Generic/pass-by-value.ll b/llvm/test/DebugInfo/Generic/pass-by-value.ll
@@ -3,9 +3,6 @@
 ; RUN:   | FileCheck %s --check-prefix=STRICT --implicit-check-not DW_AT_calling_convention
 ;
 
-; Visibility is unsupported for XCOFF object writing
-; XFAIL: -aix
-
 ; // S is not trivially copyable.
 ; struct S {
 ;    ~S() {}
diff --git a/llvm/test/DebugInfo/cross-cu-scope.ll b/llvm/test/DebugInfo/cross-cu-scope.ll
@@ -2,9 +2,6 @@
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 ; REQUIRES: object-emission
 
-; Visibility is unsupported for XCOFF object writing
-; XFAIL: -aix
-
 ; Reduced test case from PR35212. Two DISubprogram belong to a different CU but
 ; share a scope. Both are declarations and end up in the scope's CU. We want to
 ; check that the CU from the context DIE is used (rather than from the IR).
diff --git a/llvm/test/Transforms/CodeGenPrepare/dead-allocation.ll b/llvm/test/Transforms/CodeGenPrepare/dead-allocation.ll
@@ -1,5 +1,6 @@
 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Eliminate the dead allocation instruction
+; REQUIRES: arm-registered-target
 ; RUN: opt -codegenprepare < %s -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
diff --git a/llvm/test/Transforms/InstCombine/apint-shift.ll b/llvm/test/Transforms/InstCombine/apint-shift.ll
@@ -199,9 +199,9 @@ define <2 x i19> @eq_lshr_shl_splat_vec(<2 x i19> %X) {
 
 define <2 x i7> @lshr_shl_splat_vec(<2 x i7> %X) {
 ; CHECK-LABEL: @lshr_shl_splat_vec(
-; CHECK-NEXT:    [[MUL:%.*]] = mul <2 x i7> [[X:%.*]], <i7 -8, i7 -8>
-; CHECK-NEXT:    [[SH1:%.*]] = lshr exact <2 x i7> [[MUL]], <i7 1, i7 1>
-; CHECK-NEXT:    ret <2 x i7> [[SH1]]
+; CHECK-NEXT:    [[DOTNEG:%.*]] = mul <2 x i7> [[X:%.*]], <i7 60, i7 60>
+; CHECK-NEXT:    [[SH2:%.*]] = and <2 x i7> [[DOTNEG]], <i7 60, i7 60>
+; CHECK-NEXT:    ret <2 x i7> [[SH2]]
 ;
   %mul = mul <2 x i7> %X, <i7 -8, i7 -8>
   %sh1 = lshr exact <2 x i7> %mul, <i7 3, i7 3>
diff --git a/llvm/test/Transforms/InstCombine/shift.ll b/llvm/test/Transforms/InstCombine/shift.ll
@@ -1829,3 +1829,75 @@ define i8 @shl_mask_demand(i8 %x) {
   %r = and i8 %s, 7  ; 0b00000111
   ret i8 %r
 }
+
+define i64 @lshr_mul_negpow2(i64 %x) {
+; CHECK-LABEL: @lshr_mul_negpow2(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i64 0, [[X:%.*]]
+; CHECK-NEXT:    [[A:%.*]] = and i64 [[TMP1]], 4294967295
+; CHECK-NEXT:    ret i64 [[A]]
+;
+  %a = mul i64 %x, -4294967296
+  %b = lshr i64 %a, 32
+  ret i64 %b
+}
+
+define i64 @lshr_mul_negpow2_2(i64 %x) {
+; CHECK-LABEL: @lshr_mul_negpow2_2(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i64 0, [[X:%.*]]
+; CHECK-NEXT:    [[A:%.*]] = and i64 [[TMP1]], 281474976710655
+; CHECK-NEXT:    ret i64 [[A]]
+;
+  %a = mul i64 %x, -65536
+  %b = lshr i64 %a, 16
+  ret i64 %b
+}
+
+define <2 x i32> @lshr_mul_negpow2_3(<2 x i32> %x) {
+; CHECK-LABEL: @lshr_mul_negpow2_3(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i32> zeroinitializer, [[X:%.*]]
+; CHECK-NEXT:    [[A:%.*]] = and <2 x i32> [[TMP1]], <i32 255, i32 255>
+; CHECK-NEXT:    ret <2 x i32> [[A]]
+;
+  %a = mul <2 x i32> %x, <i32 -16777216, i32 -16777216>
+  %b = lshr <2 x i32> %a, <i32 24, i32 24>
+  ret <2 x i32>  %b
+}
+
+define i32 @lshr_mul_negpow2_4(i32 %x) {
+; CHECK-LABEL: @lshr_mul_negpow2_4(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 0, [[X:%.*]]
+; CHECK-NEXT:    [[A:%.*]] = and i32 [[TMP1]], 65535
+; CHECK-NEXT:    [[B:%.*]] = xor i32 [[A]], 1
+; CHECK-NEXT:    ret i32 [[B]]
+;
+  %a = mul i32 %x, -65536
+  %b = xor i32 %a, 65536
+  %c = lshr i32 %b, 16
+  ret i32 %c
+}
+
+define <2 x i32> @lshr_mul_negpow2_5(<2 x i32> %x) {
+; CHECK-LABEL: @lshr_mul_negpow2_5(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i32> zeroinitializer, [[X:%.*]]
+; CHECK-NEXT:    [[A:%.*]] = and <2 x i32> [[TMP1]], <i32 65527, i32 65527>
+; CHECK-NEXT:    [[B:%.*]] = or <2 x i32> [[A]], <i32 8, i32 8>
+; CHECK-NEXT:    ret <2 x i32> [[B]]
+;
+  %a = mul <2 x i32> %x, <i32 -65536, i32 -65536>
+  %b = or <2 x i32> %a, <i32 524288, i32 524288>
+  %c = lshr <2 x i32> %b, <i32 16, i32 16>
+  ret <2 x i32> %c
+}
+
+define i64 @lshr_mul_negpow2_extra_use(i64 %x) {
+; CHECK-LABEL: @lshr_mul_negpow2_extra_use(
+; CHECK-NEXT:    [[A:%.*]] = mul i64 [[X:%.*]], -4294967296
+; CHECK-NEXT:    [[B:%.*]] = lshr exact i64 [[A]], 32
+; CHECK-NEXT:    call void @use(i64 [[A]])
+; CHECK-NEXT:    ret i64 [[B]]
+;
+  %a = mul i64 %x, -4294967296
+  %b = lshr i64 %a, 32
+  call void @use(i64 %a)
+  ret i64 %b
+}

Original file line number	Diff line number	Diff line change
`@@ -566,6 +566,13 @@ static bool canEvaluateShifted(Value *V, unsigned NumBits, bool IsLeftShift,`
`566`	`566`	`return false;`
`567`	`567`	`return true;`
`568`	`568`	`}`
	`569`	`+ case Instruction::Mul: {`
	`570`	`+ const APInt *MulConst;`
	`571`	+ // We can fold (shr (mul X, -(1 << C)), C) -> (and (neg X), C`)
	`572`	`+ return !IsLeftShift && match(I->getOperand(1), m_APInt(MulConst)) &&`
	`573`	`+ MulConst->isNegatedPowerOf2() &&`
	`574`	`+ MulConst->countTrailingZeros() == NumBits;`
	`575`	`+ }`
`569`	`576`	`}`
`570`	`577`	`}`
`571`	`578`
`@@ -680,6 +687,17 @@ static Value getShiftedValue(Value V, unsigned NumBits, bool isLeftShift,`
`680`	`687`	`isLeftShift, IC, DL));`
`681`	`688`	`return PN;`
`682`	`689`	`}`
	`690`	`+ case Instruction::Mul: {`
	`691`	`+ assert(!isLeftShift && "Unexpected shift direction!");`
	`692`	`+ auto *Neg = BinaryOperator::CreateNeg(I->getOperand(0));`
	`693`	`+ IC.InsertNewInstWith(Neg, *I);`
	`694`	`+ unsigned TypeWidth = I->getType()->getScalarSizeInBits();`
	`695`	`+ APInt Mask = APInt::getLowBitsSet(TypeWidth, TypeWidth - NumBits);`
	`696`	`+ auto *And = BinaryOperator::CreateAnd(Neg,`
	`697`	`+ ConstantInt::get(I->getType(), Mask));`
	`698`	`+ And->takeName(I);`
	`699`	`+ return IC.InsertNewInstWith(And, *I);`
	`700`	`+ }`
`683`	`701`	`}`
`684`	`702`	`}`
`685`	`703`
Original file line number	Diff line number	Diff line change
`@@ -3,9 +3,6 @@`
`3`	`3`	`; RUN: \| FileCheck %s --check-prefix=STRICT --implicit-check-not DW_AT_calling_convention`
`4`	`4`	`;`
`5`	`5`
`6`		`-; Visibility is unsupported for XCOFF object writing`
`7`		`-; XFAIL: -aix`
`8`		`-`
`9`	`6`	`; // S is not trivially copyable.`
`10`	`7`	`; struct S {`
`11`	`8`	`; ~S() {}`