Author: Erich Keane Date: 2020-05-19T10:49:45-07:00 New Revision: 81a73fde5cea304d31294fd26c2f051f1685e97c
URL: https://github.com/llvm/llvm-project/commit/81a73fde5cea304d31294fd26c2f051f1685e97c DIFF: https://github.com/llvm/llvm-project/commit/81a73fde5cea304d31294fd26c2f051f1685e97c.diff LOG: Fix aux-target diagnostics for certain builtins When I fixed the targets specific builtins to make sure that aux-targets are checked, it seems I didn't consider cases where the builtins check the target info for further info. This patch bubbles the target-info down to the individual checker functions to ensure that they validate against the aux-target as well. For non-aux-target invocations, this is an NFC. Added: Modified: clang/include/clang/Sema/Sema.h clang/lib/Sema/SemaChecking.cpp clang/test/Sema/check-aux-builtins.c Removed: ################################################################################ diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 15a3d411237e..927685254306 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -12009,32 +12009,41 @@ class Sema final { ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, CallExpr *TheCall); - bool CheckTSBuiltinFunctionCall(llvm::Triple::ArchType Arch, - unsigned BuiltinID, CallExpr *TheCall); + bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall); bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall, unsigned MaxWidth); - bool CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); + bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); - bool CheckCDEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); - bool CheckARMCoprocessorImmediate(const Expr *CoprocArg, bool WantCDE); - bool CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); - - bool CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); + bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); + bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg, + bool WantCDE); + bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); + + bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall); - bool CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); - bool CheckMipsBuiltinCpu(unsigned BuiltinID, CallExpr *TheCall); + bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); + bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall); bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall); bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall); - bool CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); - bool CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); + bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); + bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall); bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall); diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 370eecea6eae..c9fa2b993c1e 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -1380,9 +1380,9 @@ CheckBuiltinTargetSupport(Sema &S, unsigned BuiltinID, CallExpr *TheCall, static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc); -bool Sema::CheckTSBuiltinFunctionCall(llvm::Triple::ArchType Arch, - unsigned BuiltinID, CallExpr *TheCall) { - switch (Arch) { +bool Sema::CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall) { + switch (TI.getTriple().getArch()) { default: // Some builtins don't require additional checking, so just consider these // acceptable. @@ -1391,11 +1391,11 @@ bool Sema::CheckTSBuiltinFunctionCall(llvm::Triple::ArchType Arch, case llvm::Triple::armeb: case llvm::Triple::thumb: case llvm::Triple::thumbeb: - return CheckARMBuiltinFunctionCall(BuiltinID, TheCall); + return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall); case llvm::Triple::aarch64: case llvm::Triple::aarch64_32: case llvm::Triple::aarch64_be: - return CheckAArch64BuiltinFunctionCall(BuiltinID, TheCall); + return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall); case llvm::Triple::bpfeb: case llvm::Triple::bpfel: return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall); @@ -1405,16 +1405,16 @@ bool Sema::CheckTSBuiltinFunctionCall(llvm::Triple::ArchType Arch, case llvm::Triple::mipsel: case llvm::Triple::mips64: case llvm::Triple::mips64el: - return CheckMipsBuiltinFunctionCall(BuiltinID, TheCall); + return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall); case llvm::Triple::systemz: return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall); case llvm::Triple::x86: case llvm::Triple::x86_64: - return CheckX86BuiltinFunctionCall(BuiltinID, TheCall); + return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall); case llvm::Triple::ppc: case llvm::Triple::ppc64: case llvm::Triple::ppc64le: - return CheckPPCBuiltinFunctionCall(BuiltinID, TheCall); + return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall); case llvm::Triple::amdgcn: return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall); } @@ -1921,13 +1921,12 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, "Aux Target Builtin, but not an aux target?"); if (CheckTSBuiltinFunctionCall( - Context.getAuxTargetInfo()->getTriple().getArch(), + *Context.getAuxTargetInfo(), Context.BuiltinInfo.getAuxBuiltinID(BuiltinID), TheCall)) return ExprError(); } else { - if (CheckTSBuiltinFunctionCall( - Context.getTargetInfo().getTriple().getArch(), BuiltinID, - TheCall)) + if (CheckTSBuiltinFunctionCall(Context.getTargetInfo(), BuiltinID, + TheCall)) return ExprError(); } } @@ -2114,7 +2113,8 @@ bool Sema::CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { return HasError; } -bool Sema::CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { +bool Sema::CheckNeonBuiltinFunctionCall(const TargetInfo &TI, + unsigned BuiltinID, CallExpr *TheCall) { llvm::APSInt Result; uint64_t mask = 0; unsigned TV = 0; @@ -2148,12 +2148,11 @@ bool Sema::CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { ExprResult RHS = DefaultFunctionArrayLvalueConversion(Arg); QualType RHSTy = RHS.get()->getType(); - llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch(); + llvm::Triple::ArchType Arch = TI.getTriple().getArch(); bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_32 || Arch == llvm::Triple::aarch64_be; - bool IsInt64Long = - Context.getTargetInfo().getInt64Type() == TargetInfo::SignedLong; + bool IsInt64Long = TI.getInt64Type() == TargetInfo::SignedLong; QualType EltTy = getNeonEltType(NeonTypeFlags(TV), Context, IsPolyUnsigned, IsInt64Long); if (HasConstPtr) @@ -2191,7 +2190,8 @@ bool Sema::CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { } } -bool Sema::CheckCDEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { +bool Sema::CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall) { bool Err = false; switch (BuiltinID) { default: @@ -2202,10 +2202,11 @@ bool Sema::CheckCDEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { if (Err) return true; - return CheckARMCoprocessorImmediate(TheCall->getArg(0), /*WantCDE*/ true); + return CheckARMCoprocessorImmediate(TI, TheCall->getArg(0), /*WantCDE*/ true); } -bool Sema::CheckARMCoprocessorImmediate(const Expr *CoprocArg, bool WantCDE) { +bool Sema::CheckARMCoprocessorImmediate(const TargetInfo &TI, + const Expr *CoprocArg, bool WantCDE) { if (isConstantEvaluated()) return false; @@ -2220,7 +2221,7 @@ bool Sema::CheckARMCoprocessorImmediate(const Expr *CoprocArg, bool WantCDE) { int64_t CoprocNo = CoprocNoAP.getExtValue(); assert(CoprocNo >= 0 && "Coprocessor immediate must be non-negative"); - uint32_t CDECoprocMask = Context.getTargetInfo().getARMCDECoprocMask(); + uint32_t CDECoprocMask = TI.getARMCDECoprocMask(); bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo)); if (IsCDECoproc != WantCDE) @@ -2345,7 +2346,8 @@ bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall, return false; } -bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { +bool Sema::CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall) { if (BuiltinID == ARM::BI__builtin_arm_ldrex || BuiltinID == ARM::BI__builtin_arm_ldaex || BuiltinID == ARM::BI__builtin_arm_strex || @@ -2368,11 +2370,11 @@ bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { BuiltinID == ARM::BI__builtin_arm_wsrp) return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true); - if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall)) + if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall)) return true; if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall)) return true; - if (CheckCDEBuiltinFunctionCall(BuiltinID, TheCall)) + if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall)) return true; // For intrinsics which take an immediate value as part of the instruction, @@ -2415,12 +2417,14 @@ bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { case ARM::BI__builtin_arm_stc2: case ARM::BI__builtin_arm_stc2l: return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15) || - CheckARMCoprocessorImmediate(TheCall->getArg(0), /*WantCDE*/ false); + CheckARMCoprocessorImmediate(TI, TheCall->getArg(0), + /*WantCDE*/ false); } } -bool Sema::CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, - CallExpr *TheCall) { +bool Sema::CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, + unsigned BuiltinID, + CallExpr *TheCall) { if (BuiltinID == AArch64::BI__builtin_arm_ldrex || BuiltinID == AArch64::BI__builtin_arm_ldaex || BuiltinID == AArch64::BI__builtin_arm_strex || @@ -2465,7 +2469,7 @@ bool Sema::CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, if (BuiltinID == AArch64::BI__getReg) return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31); - if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall)) + if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall)) return true; if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall)) @@ -2776,13 +2780,14 @@ bool Sema::CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, return CheckHexagonBuiltinArgument(BuiltinID, TheCall); } -bool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { - return CheckMipsBuiltinCpu(BuiltinID, TheCall) || +bool Sema::CheckMipsBuiltinFunctionCall(const TargetInfo &TI, + unsigned BuiltinID, CallExpr *TheCall) { + return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) || CheckMipsBuiltinArgument(BuiltinID, TheCall); } -bool Sema::CheckMipsBuiltinCpu(unsigned BuiltinID, CallExpr *TheCall) { - const TargetInfo &TI = Context.getTargetInfo(); +bool Sema::CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall) { if (Mips::BI__builtin_mips_addu_qb <= BuiltinID && BuiltinID <= Mips::BI__builtin_mips_lwx) { @@ -2992,15 +2997,13 @@ bool Sema::CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) { SemaBuiltinConstantArgMultiple(TheCall, i, m); } -bool Sema::CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { +bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall) { unsigned i = 0, l = 0, u = 0; bool Is64BitBltin = BuiltinID == PPC::BI__builtin_divde || BuiltinID == PPC::BI__builtin_divdeu || BuiltinID == PPC::BI__builtin_bpermd; - bool IsTarget64Bit = Context.getTargetInfo() - .getTypeWidth(Context - .getTargetInfo() - .getIntPtrType()) == 64; + bool IsTarget64Bit = TI.getTypeWidth(TI.getIntPtrType()) == 64; bool IsBltinExtDiv = BuiltinID == PPC::BI__builtin_divwe || BuiltinID == PPC::BI__builtin_divweu || BuiltinID == PPC::BI__builtin_divde || @@ -3010,14 +3013,13 @@ bool Sema::CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt) << TheCall->getSourceRange(); - if ((IsBltinExtDiv && !Context.getTargetInfo().hasFeature("extdiv")) || - (BuiltinID == PPC::BI__builtin_bpermd && - !Context.getTargetInfo().hasFeature("bpermd"))) + if ((IsBltinExtDiv && !TI.hasFeature("extdiv")) || + (BuiltinID == PPC::BI__builtin_bpermd && !TI.hasFeature("bpermd"))) return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_only_on_pwr7) << TheCall->getSourceRange(); auto SemaVSXCheck = [&](CallExpr *TheCall) -> bool { - if (!Context.getTargetInfo().hasFeature("vsx")) + if (!TI.hasFeature("vsx")) return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_only_on_pwr7) << TheCall->getSourceRange(); return false; @@ -3165,7 +3167,8 @@ bool Sema::CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, /// SemaBuiltinCpuSupports - Handle __builtin_cpu_supports(char *). /// This checks that the target supports __builtin_cpu_supports and /// that the string argument is constant and valid. -static bool SemaBuiltinCpuSupports(Sema &S, CallExpr *TheCall) { +static bool SemaBuiltinCpuSupports(Sema &S, const TargetInfo &TI, + CallExpr *TheCall) { Expr *Arg = TheCall->getArg(0); // Check if the argument is a string literal. @@ -3176,7 +3179,7 @@ static bool SemaBuiltinCpuSupports(Sema &S, CallExpr *TheCall) { // Check the contents of the string. StringRef Feature = cast<StringLiteral>(Arg->IgnoreParenImpCasts())->getString(); - if (!S.Context.getTargetInfo().validateCpuSupports(Feature)) + if (!TI.validateCpuSupports(Feature)) return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_supports) << Arg->getSourceRange(); return false; @@ -3185,7 +3188,7 @@ static bool SemaBuiltinCpuSupports(Sema &S, CallExpr *TheCall) { /// SemaBuiltinCpuIs - Handle __builtin_cpu_is(char *). /// This checks that the target supports __builtin_cpu_is and /// that the string argument is constant and valid. -static bool SemaBuiltinCpuIs(Sema &S, CallExpr *TheCall) { +static bool SemaBuiltinCpuIs(Sema &S, const TargetInfo &TI, CallExpr *TheCall) { Expr *Arg = TheCall->getArg(0); // Check if the argument is a string literal. @@ -3196,7 +3199,7 @@ static bool SemaBuiltinCpuIs(Sema &S, CallExpr *TheCall) { // Check the contents of the string. StringRef Feature = cast<StringLiteral>(Arg->IgnoreParenImpCasts())->getString(); - if (!S.Context.getTargetInfo().validateCpuIs(Feature)) + if (!TI.validateCpuIs(Feature)) return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_is) << Arg->getSourceRange(); return false; @@ -3521,15 +3524,16 @@ static bool isX86_32Builtin(unsigned BuiltinID) { return false; } -bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { +bool Sema::CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, + CallExpr *TheCall) { if (BuiltinID == X86::BI__builtin_cpu_supports) - return SemaBuiltinCpuSupports(*this, TheCall); + return SemaBuiltinCpuSupports(*this, TI, TheCall); if (BuiltinID == X86::BI__builtin_cpu_is) - return SemaBuiltinCpuIs(*this, TheCall); + return SemaBuiltinCpuIs(*this, TI, TheCall); // Check for 32-bit only builtins on a 64-bit target. - const llvm::Triple &TT = Context.getTargetInfo().getTriple(); + const llvm::Triple &TT = TI.getTriple(); if (TT.getArch() != llvm::Triple::x86 && isX86_32Builtin(BuiltinID)) return Diag(TheCall->getCallee()->getBeginLoc(), diag::err_32_bit_builtin_64_bit_tgt); diff --git a/clang/test/Sema/check-aux-builtins.c b/clang/test/Sema/check-aux-builtins.c index a9a836cdcbb7..be674389e89d 100644 --- a/clang/test/Sema/check-aux-builtins.c +++ b/clang/test/Sema/check-aux-builtins.c @@ -1,5 +1,6 @@ // RUN: %clang_cc1 -fopenmp -fopenmp-is-device -triple aarch64 -aux-triple x86_64-linux-pc -fsyntax-only -verify %s void func(void) { + (void)__builtin_cpu_is("atom"); __builtin_cpu_is("INVALID"); // expected-error{{invalid cpu name for builtin}} } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits