Merge from 'main' to 'sycl-web' (#1)

  CONFLICT (content): Merge conflict in clang/include/clang/Basic/CodeGenOptions.def

Author: iclsrc

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp

@@ -84,19 +84,19 @@ void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   // positives if sizeof is applied on template argument.
 
   const auto IntegerExpr = ignoringParenImpCasts(integerLiteral());
-  const auto ConstantExpr = expr(ignoringParenImpCasts(
+  const auto ConstantExpr = ignoringParenImpCasts(
       anyOf(integerLiteral(), unaryOperator(hasUnaryOperand(IntegerExpr)),
-            binaryOperator(hasLHS(IntegerExpr), hasRHS(IntegerExpr)))));
-  const auto IntegerCallExpr = expr(ignoringParenImpCasts(
+            binaryOperator(hasLHS(IntegerExpr), hasRHS(IntegerExpr))));
+  const auto IntegerCallExpr = ignoringParenImpCasts(
       callExpr(anyOf(hasType(isInteger()), hasType(enumType())),
-               unless(isInTemplateInstantiation()))));
+               unless(isInTemplateInstantiation())));
   const auto SizeOfExpr = expr(anyOf(
       sizeOfExpr(
           has(hasUnqualifiedDesugaredType(type().bind("sizeof-arg-type")))),
       sizeOfExpr(has(expr(hasType(
           hasUnqualifiedDesugaredType(type().bind("sizeof-arg-type"))))))));
-  const auto SizeOfZero = expr(
-      sizeOfExpr(has(ignoringParenImpCasts(expr(integerLiteral(equals(0)))))));
+  const auto SizeOfZero =
+      sizeOfExpr(has(ignoringParenImpCasts(integerLiteral(equals(0)))));
 
   // Detect expression like: sizeof(ARRAYLEN);
   // Note: The expression 'sizeof(sizeof(0))' is a portable trick used to know
@@ -111,74 +111,69 @@ void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
 
   // Detect sizeof(f())
   if (WarnOnSizeOfIntegerExpression) {
-    Finder->addMatcher(
-        expr(sizeOfExpr(ignoringParenImpCasts(has(IntegerCallExpr))))
-            .bind("sizeof-integer-call"),
-        this);
+    Finder->addMatcher(sizeOfExpr(ignoringParenImpCasts(has(IntegerCallExpr)))
+                           .bind("sizeof-integer-call"),
+                       this);
   }
 
   // Detect expression like: sizeof(this);
   if (WarnOnSizeOfThis) {
-    Finder->addMatcher(
-        expr(sizeOfExpr(has(ignoringParenImpCasts(expr(cxxThisExpr())))))
-            .bind("sizeof-this"),
-        this);
+    Finder->addMatcher(sizeOfExpr(has(ignoringParenImpCasts(cxxThisExpr())))
+                           .bind("sizeof-this"),
+                       this);
   }
 
   // Detect sizeof(kPtr) where kPtr is 'const char* kPtr = "abc"';
   const auto CharPtrType = pointerType(pointee(isAnyCharacter()));
   const auto ConstStrLiteralDecl =
-      varDecl(isDefinition(), hasType(qualType(hasCanonicalType(CharPtrType))),
+      varDecl(isDefinition(), hasType(hasCanonicalType(CharPtrType)),
               hasInitializer(ignoringParenImpCasts(stringLiteral())));
-  Finder->addMatcher(expr(sizeOfExpr(has(ignoringParenImpCasts(expr(
-                              hasType(qualType(hasCanonicalType(CharPtrType))),
-                              ignoringParenImpCasts(declRefExpr(
-                                  hasDeclaration(ConstStrLiteralDecl))))))))
-                         .bind("sizeof-charp"),
-                     this);
+  Finder->addMatcher(
+      sizeOfExpr(has(ignoringParenImpCasts(
+                     expr(hasType(hasCanonicalType(CharPtrType)),
+                          ignoringParenImpCasts(declRefExpr(
+                              hasDeclaration(ConstStrLiteralDecl)))))))
+          .bind("sizeof-charp"),
+      this);
 
   // Detect sizeof(ptr) where ptr points to an aggregate (i.e. sizeof(&S)).
   // Do not find it if RHS of a 'sizeof(arr) / sizeof(arr[0])' expression.
-  const auto ArrayExpr = expr(ignoringParenImpCasts(
-      expr(hasType(qualType(hasCanonicalType(arrayType()))))));
+  const auto ArrayExpr =
+      ignoringParenImpCasts(hasType(hasCanonicalType(arrayType())));
   const auto ArrayCastExpr = expr(anyOf(
       unaryOperator(hasUnaryOperand(ArrayExpr), unless(hasOperatorName("*"))),
       binaryOperator(hasEitherOperand(ArrayExpr)),
       castExpr(hasSourceExpression(ArrayExpr))));
-  const auto PointerToArrayExpr = expr(ignoringParenImpCasts(expr(
-      hasType(qualType(hasCanonicalType(pointerType(pointee(arrayType()))))))));
-
-  const auto StructAddrOfExpr =
-      unaryOperator(hasOperatorName("&"),
-                    hasUnaryOperand(ignoringParenImpCasts(expr(
-                        hasType(qualType(hasCanonicalType(recordType())))))));
-  const auto PointerToStructType = type(hasUnqualifiedDesugaredType(
-      pointerType(pointee(recordType()))));
-  const auto PointerToStructExpr = expr(ignoringParenImpCasts(expr(
-      hasType(qualType(hasCanonicalType(PointerToStructType))),
-      unless(cxxThisExpr()))));
-
-  const auto ArrayOfPointersExpr = expr(ignoringParenImpCasts(expr(hasType(
-      qualType(hasCanonicalType(arrayType(hasElementType(pointerType()))
-                                    .bind("type-of-array-of-pointers")))))));
+  const auto PointerToArrayExpr = ignoringParenImpCasts(
+      hasType(hasCanonicalType(pointerType(pointee(arrayType())))));
+
+  const auto StructAddrOfExpr = unaryOperator(
+      hasOperatorName("&"), hasUnaryOperand(ignoringParenImpCasts(
+                                hasType(hasCanonicalType(recordType())))));
+  const auto PointerToStructType =
+      hasUnqualifiedDesugaredType(pointerType(pointee(recordType())));
+  const auto PointerToStructExpr = ignoringParenImpCasts(expr(
+      hasType(hasCanonicalType(PointerToStructType)), unless(cxxThisExpr())));
+
+  const auto ArrayOfPointersExpr = ignoringParenImpCasts(
+      hasType(hasCanonicalType(arrayType(hasElementType(pointerType()))
+                                   .bind("type-of-array-of-pointers"))));
   const auto ArrayOfSamePointersExpr =
-      expr(ignoringParenImpCasts(expr(hasType(qualType(hasCanonicalType(
-          arrayType(equalsBoundNode("type-of-array-of-pointers"))))))));
-  const auto ZeroLiteral =
-      expr(ignoringParenImpCasts(integerLiteral(equals(0))));
+      ignoringParenImpCasts(hasType(hasCanonicalType(
+          arrayType(equalsBoundNode("type-of-array-of-pointers")))));
+  const auto ZeroLiteral = ignoringParenImpCasts(integerLiteral(equals(0)));
   const auto ArrayOfSamePointersZeroSubscriptExpr =
-      expr(ignoringParenImpCasts(arraySubscriptExpr(
-          hasBase(ArrayOfSamePointersExpr), hasIndex(ZeroLiteral))));
+      ignoringParenImpCasts(arraySubscriptExpr(hasBase(ArrayOfSamePointersExpr),
+                                               hasIndex(ZeroLiteral)));
   const auto ArrayLengthExprDenom =
-      expr(hasParent(expr(ignoringParenImpCasts(
-               binaryOperator(hasOperatorName("/"),
-                              hasLHS(expr(ignoringParenImpCasts(expr(
-                                  sizeOfExpr(has(ArrayOfPointersExpr)))))))))),
+      expr(hasParent(expr(ignoringParenImpCasts(binaryOperator(
+               hasOperatorName("/"), hasLHS(ignoringParenImpCasts(sizeOfExpr(
+                                         has(ArrayOfPointersExpr)))))))),
            sizeOfExpr(has(ArrayOfSamePointersZeroSubscriptExpr)));
 
-  Finder->addMatcher(expr(anyOf(sizeOfExpr(has(expr(ignoringParenImpCasts(anyOf(
+  Finder->addMatcher(expr(anyOf(sizeOfExpr(has(ignoringParenImpCasts(anyOf(
                                     ArrayCastExpr, PointerToArrayExpr,
-                                    StructAddrOfExpr, PointerToStructExpr))))),
+                                    StructAddrOfExpr, PointerToStructExpr)))),
                                 sizeOfExpr(has(PointerToStructType))),
                           unless(ArrayLengthExprDenom))
                          .bind("sizeof-pointer-to-aggregate"),
@@ -197,8 +192,8 @@ void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   }
 
   // Detect expression like: sizeof(expr, expr); most likely an error.
-  Finder->addMatcher(expr(sizeOfExpr(has(expr(ignoringParenImpCasts(
-                              binaryOperator(hasOperatorName(",")))))))
+  Finder->addMatcher(sizeOfExpr(has(ignoringParenImpCasts(
+                                    binaryOperator(hasOperatorName(",")))))
                          .bind("sizeof-comma-expr"),
                      this);
 
@@ -212,9 +207,9 @@ void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   const auto ElemType =
       arrayType(hasElementType(recordType().bind("elem-type")));
   const auto ElemPtrType = pointerType(pointee(type().bind("elem-ptr-type")));
-  const auto NumType = qualType(hasCanonicalType(
-      type(anyOf(ElemType, ElemPtrType, type())).bind("num-type")));
-  const auto DenomType = qualType(hasCanonicalType(type().bind("denom-type")));
+  const auto NumType = hasCanonicalType(
+      type(anyOf(ElemType, ElemPtrType, type())).bind("num-type"));
+  const auto DenomType = hasCanonicalType(type().bind("denom-type"));
 
   Finder->addMatcher(
       binaryOperator(hasOperatorName("/"),
@@ -246,30 +241,29 @@ void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
 
   // Detect strange double-sizeof expression like: sizeof(sizeof(...));
   // Note: The expression 'sizeof(sizeof(0))' is accepted.
-  Finder->addMatcher(
-      expr(sizeOfExpr(has(ignoringParenImpCasts(expr(
-               hasSizeOfDescendant(8, expr(SizeOfExpr, unless(SizeOfZero))))))))
-          .bind("sizeof-sizeof-expr"),
-      this);
+  Finder->addMatcher(sizeOfExpr(has(ignoringParenImpCasts(hasSizeOfDescendant(
+                                    8, allOf(SizeOfExpr, unless(SizeOfZero))))))
+                         .bind("sizeof-sizeof-expr"),
+                     this);
 
   // Detect sizeof in pointer arithmetic like: N * sizeof(S) == P1 - P2 or
   // (P1 - P2) / sizeof(S) where P1 and P2 are pointers to type S.
   const auto PtrDiffExpr = binaryOperator(
       hasOperatorName("-"),
-      hasLHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
-          hasUnqualifiedDesugaredType(type().bind("left-ptr-type")))))))),
-      hasRHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
-          hasUnqualifiedDesugaredType(type().bind("right-ptr-type")))))))));
+      hasLHS(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
+          hasUnqualifiedDesugaredType(type().bind("left-ptr-type"))))))),
+      hasRHS(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
+          hasUnqualifiedDesugaredType(type().bind("right-ptr-type"))))))));
 
   Finder->addMatcher(
       binaryOperator(
           hasAnyOperatorName("==", "!=", "<", "<=", ">", ">=", "+", "-"),
-          hasOperands(expr(anyOf(ignoringParenImpCasts(SizeOfExpr),
-                                 ignoringParenImpCasts(binaryOperator(
-                                     hasOperatorName("*"),
-                                     hasEitherOperand(
-                                         ignoringParenImpCasts(SizeOfExpr)))))),
-                      ignoringParenImpCasts(PtrDiffExpr)))
+          hasOperands(
+              anyOf(ignoringParenImpCasts(SizeOfExpr),
+                    ignoringParenImpCasts(binaryOperator(
+                        hasOperatorName("*"),
+                        hasEitherOperand(ignoringParenImpCasts(SizeOfExpr))))),
+              ignoringParenImpCasts(PtrDiffExpr)))
           .bind("sizeof-in-ptr-arithmetic-mul"),
       this);
 

clang/include/clang/Basic/BuiltinsPPC.def

@@ -600,6 +600,12 @@ BUILTIN(__builtin_truncf128_round_to_odd, "dLLd", "")
 BUILTIN(__builtin_vsx_scalar_extract_expq, "ULLiLLd", "")
 BUILTIN(__builtin_vsx_scalar_insert_exp_qp, "LLdLLdULLi", "")
 
+// Fastmath by default builtins
+BUILTIN(__builtin_ppc_rsqrtf, "V4fV4f", "")
+BUILTIN(__builtin_ppc_rsqrtd, "V2dV2d", "")
+BUILTIN(__builtin_ppc_recipdivf, "V4fV4fV4f", "")
+BUILTIN(__builtin_ppc_recipdivd, "V2dV2dV2d", "")
+
 // HTM builtins
 BUILTIN(__builtin_tbegin, "UiUIi", "")
 BUILTIN(__builtin_tend, "UiUIi", "")

clang/include/clang/Basic/CodeGenOptions.def

@@ -426,8 +426,15 @@ CODEGENOPT(PassByValueIsNoAlias, 1, 0)
 /// according to the field declaring type width.
 CODEGENOPT(AAPCSBitfieldWidth, 1, 1)
 
+<<<<<<< HEAD
 // Whether to instrument SPIR device code with ITT annotations
 CODEGENOPT(SPIRITTAnnotations, 1, 0)
+=======
+/// Sets the IEEE bit in the expected default floating point mode register.
+/// Floating point opcodes that support exception flag gathering quiet and
+/// propagate signaling NaN inputs per IEEE 754-2008 (AMDGPU Only)
+CODEGENOPT(EmitIEEENaNCompliantInsts, 1, 1)
+>>>>>>> 0175999805cf05d91c8a127ebd8c9d54a640abe9
 
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -144,6 +144,8 @@ def warn_drv_mismatch_fpga_archive : Warning<
 def err_drv_unsupported_opt_dpcpp : Error<"option '%0' unsupported with DPC++">;
 def err_drv_argument_only_allowed_with : Error<
   "invalid argument '%0' only allowed with '%1'">;
+def err_drv_amdgpu_ieee_without_no_honor_nans : Error<
+  "invalid argument '-mno-amdgpu-ieee' only allowed with relaxed NaN handling">;
 def err_drv_argument_not_allowed_with : Error<
   "invalid argument '%0' not allowed with '%1'">;
 def err_drv_invalid_version_number : Error<

clang/include/clang/Driver/Options.td

@@ -3261,6 +3261,14 @@ def mexec_model_EQ : Joined<["-"], "mexec-model=">, Group<m_wasm_Features_Driver
                      Values<"command,reactor">,
                      HelpText<"Execution model (WebAssembly only)">;
 
+defm amdgpu_ieee : BoolOption<"m", "amdgpu-ieee",
+  CodeGenOpts<"EmitIEEENaNCompliantInsts">, DefaultTrue,
+  PosFlag<SetTrue, [], "Sets the IEEE bit in the expected default floating point "
+  " mode register. Floating point opcodes that support exception flag "
+  "gathering quiet and propagate signaling NaN inputs per IEEE 754-2008. "
+  "This option changes the ABI. (AMDGPU only)">,
+  NegFlag<SetFalse, [CC1Option]>>, Group<m_Group>;
+
 def mcode_object_version_EQ : Joined<["-"], "mcode-object-version=">, Group<m_Group>,
   HelpText<"Specify code object ABI version. Defaults to 3. (AMDGPU only)">,
   MetaVarName<"<version>">, Values<"2,3,4">;

clang/lib/CodeGen/CGBuiltin.cpp

@@ -15119,6 +15119,25 @@ Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
     return Builder.CreateCall(F, X);
   }
 
+  // Fastmath by default
+  case PPC::BI__builtin_ppc_recipdivf:
+  case PPC::BI__builtin_ppc_recipdivd:
+  case PPC::BI__builtin_ppc_rsqrtf:
+  case PPC::BI__builtin_ppc_rsqrtd: {
+    Builder.getFastMathFlags().setFast();
+    llvm::Type *ResultType = ConvertType(E->getType());
+    Value *X = EmitScalarExpr(E->getArg(0));
+
+    if (BuiltinID == PPC::BI__builtin_ppc_recipdivf ||
+        BuiltinID == PPC::BI__builtin_ppc_recipdivd) {
+      Value *Y = EmitScalarExpr(E->getArg(1));
+      return Builder.CreateFDiv(X, Y, "recipdiv");
+    }
+    auto *One = ConstantFP::get(ResultType, 1.0);
+    llvm::Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
+    return Builder.CreateFDiv(One, Builder.CreateCall(F, X), "rsqrt");
+  }
+
   // FMA variations
   case PPC::BI__builtin_vsx_xvmaddadp:
   case PPC::BI__builtin_vsx_xvmaddasp:

clang/lib/CodeGen/TargetInfo.cpp

@@ -9172,6 +9172,9 @@ void AMDGPUTargetCodeGenInfo::setTargetAttributes(
 
   if (M.getContext().getTargetInfo().allowAMDGPUUnsafeFPAtomics())
     F->addFnAttr("amdgpu-unsafe-fp-atomics", "true");
+
+  if (!getABIInfo().getCodeGenOpts().EmitIEEENaNCompliantInsts)
+    F->addFnAttr("amdgpu-ieee", "false");
 }
 
 unsigned AMDGPUTargetCodeGenInfo::getOpenCLKernelCallingConv() const {

clang/lib/Driver/ToolChains/Darwin.cpp

@@ -2671,8 +2671,16 @@ void Darwin::addPlatformVersionArgs(const llvm::opt::ArgList &Args,
     VersionTuple SDKVersion = SDKInfo->getVersion().withoutBuild();
     CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
   } else {
-    // Use a blank SDK version if it's not present.
-    CmdArgs.push_back("0.0.0");
+    // Use an SDK version that's matching the deployment target if the SDK
+    // version is missing. This is preferred over an empty SDK version (0.0.0)
+    // as the system's runtime might expect the linked binary to contain a
+    // valid SDK version in order for the binary to work correctly. It's
+    // reasonable to use the deployment target version as a proxy for the
+    // SDK version because older SDKs don't guarantee support for deployment
+    // targets newer than the SDK versions, so that rules out using some
+    // predetermined older SDK version, which leaves the deployment target
+    // version as the only reasonable choice.
+    CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
   }
 }
 

clang/lib/Frontend/CompilerInvocation.cpp

@@ -1950,6 +1950,11 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
   else if (Args.hasArg(options::OPT_fno_finite_loops))
     Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Never;
 
+  Opts.EmitIEEENaNCompliantInsts =
+      Args.hasFlag(options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee);
+  if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
+    Diags.Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
+
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 

clang/lib/Headers/altivec.h

@@ -8359,6 +8359,16 @@ static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
 }
 #endif
 
+static vector float __ATTRS_o_ai vec_rsqrt(vector float __a) {
+  return __builtin_ppc_rsqrtf(__a);
+}
+
+#ifdef __VSX__
+static vector double __ATTRS_o_ai vec_rsqrt(vector double __a) {
+  return __builtin_ppc_rsqrtd(__a);
+}
+#endif
+
 /* vec_vrsqrtefp */
 
 static __inline__ __vector float __attribute__((__always_inline__))
@@ -9081,6 +9091,11 @@ static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
 }
 
+static __inline__ vector float __ATTRS_o_ai vec_sldw(
+    vector float __a, vector float __b, unsigned const int __c) {
+  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
+}
+
 #ifdef __VSX__
 static __inline__ vector signed long long __ATTRS_o_ai
 vec_sldw(vector signed long long __a, vector signed long long __b,
@@ -9093,6 +9108,11 @@ vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
          unsigned const int __c) {
   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
 }
+
+static __inline__ vector double __ATTRS_o_ai vec_sldw(
+    vector double __a, vector double __b, unsigned const int __c) {
+  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
+}
 #endif
 
 #ifdef __POWER9_VECTOR__
@@ -17897,6 +17917,18 @@ static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
   return __builtin_altivec_vminsb(__a, -__a);
 }
 
+static vector float __ATTRS_o_ai vec_recipdiv(vector float __a,
+                                              vector float __b) {
+  return __builtin_ppc_recipdivf(__a, __b);
+}
+
+#ifdef __VSX__
+static vector double __ATTRS_o_ai vec_recipdiv(vector double __a,
+                                               vector double __b) {
+  return __builtin_ppc_recipdivd(__a, __b);
+}
+#endif
+
 #ifdef __POWER10_VECTOR__
 
 /* vec_extractm */