/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaChecking.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaChecking.cpp
Warning:	line 10829, column 7 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaChecking.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaChecking.cpp
1//===- SemaChecking.cpp - Extra Semantic Checking -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements extra semantic analysis beyond what is enforced
10//  by the C type system.
11//
12//===----------------------------------------------------------------------===//

14#include "clang/AST/APValue.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/AttrIterator.h"
18#include "clang/AST/CharUnits.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclBase.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/EvaluatedExprVisitor.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/ExprCXX.h"
27#include "clang/AST/ExprObjC.h"
28#include "clang/AST/ExprOpenMP.h"
29#include "clang/AST/FormatString.h"
30#include "clang/AST/NSAPI.h"
31#include "clang/AST/NonTrivialTypeVisitor.h"
32#include "clang/AST/OperationKinds.h"
33#include "clang/AST/RecordLayout.h"
34#include "clang/AST/Stmt.h"
35#include "clang/AST/TemplateBase.h"
36#include "clang/AST/Type.h"
37#include "clang/AST/TypeLoc.h"
38#include "clang/AST/UnresolvedSet.h"
39#include "clang/Basic/AddressSpaces.h"
40#include "clang/Basic/CharInfo.h"
41#include "clang/Basic/Diagnostic.h"
42#include "clang/Basic/IdentifierTable.h"
43#include "clang/Basic/LLVM.h"
44#include "clang/Basic/LangOptions.h"
45#include "clang/Basic/OpenCLOptions.h"
46#include "clang/Basic/OperatorKinds.h"
47#include "clang/Basic/PartialDiagnostic.h"
48#include "clang/Basic/SourceLocation.h"
49#include "clang/Basic/SourceManager.h"
50#include "clang/Basic/Specifiers.h"
51#include "clang/Basic/SyncScope.h"
52#include "clang/Basic/TargetBuiltins.h"
53#include "clang/Basic/TargetCXXABI.h"
54#include "clang/Basic/TargetInfo.h"
55#include "clang/Basic/TypeTraits.h"
56#include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
57#include "clang/Sema/Initialization.h"
58#include "clang/Sema/Lookup.h"
59#include "clang/Sema/Ownership.h"
60#include "clang/Sema/Scope.h"
61#include "clang/Sema/ScopeInfo.h"
62#include "clang/Sema/Sema.h"
63#include "clang/Sema/SemaInternal.h"
64#include "llvm/ADT/APFloat.h"
65#include "llvm/ADT/APInt.h"
66#include "llvm/ADT/APSInt.h"
67#include "llvm/ADT/ArrayRef.h"
68#include "llvm/ADT/DenseMap.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/None.h"
71#include "llvm/ADT/Optional.h"
72#include "llvm/ADT/STLExtras.h"
73#include "llvm/ADT/SmallBitVector.h"
74#include "llvm/ADT/SmallPtrSet.h"
75#include "llvm/ADT/SmallString.h"
76#include "llvm/ADT/SmallVector.h"
77#include "llvm/ADT/StringRef.h"
78#include "llvm/ADT/StringSet.h"
79#include "llvm/ADT/StringSwitch.h"
80#include "llvm/ADT/Triple.h"
81#include "llvm/Support/AtomicOrdering.h"
82#include "llvm/Support/Casting.h"
83#include "llvm/Support/Compiler.h"
84#include "llvm/Support/ConvertUTF.h"
85#include "llvm/Support/ErrorHandling.h"
86#include "llvm/Support/Format.h"
87#include "llvm/Support/Locale.h"
88#include "llvm/Support/MathExtras.h"
89#include "llvm/Support/SaveAndRestore.h"
90#include "llvm/Support/raw_ostream.h"
91#include <algorithm>
92#include <bitset>
93#include <cassert>
94#include <cctype>
95#include <cstddef>
96#include <cstdint>
97#include <functional>
98#include <limits>
99#include <string>
100#include <tuple>
101#include <utility>

103using namespace clang;
104using namespace sema;

106SourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL,
                                                  unsigned ByteNo) const {
return SL->getLocationOfByte(ByteNo, getSourceManager(), LangOpts,
                             Context.getTargetInfo());
110}

112/// Checks that a call expression's argument count is the desired number.
113/// This is useful when doing custom type-checking.  Returns true on error.
114static bool checkArgCount(Sema &S, CallExpr *call, unsigned desiredArgCount) {
unsigned argCount = call->getNumArgs();
if (argCount == desiredArgCount) return false;

if (argCount < desiredArgCount)
  return S.Diag(call->getEndLoc(), diag::err_typecheck_call_too_few_args)
         << 0 /*function call*/ << desiredArgCount << argCount
         << call->getSourceRange();

// Highlight all the excess arguments.
SourceRange range(call->getArg(desiredArgCount)->getBeginLoc(),
                  call->getArg(argCount - 1)->getEndLoc());

return S.Diag(range.getBegin(), diag::err_typecheck_call_too_many_args)
  << 0 /*function call*/ << desiredArgCount << argCount
  << call->getArg(1)->getSourceRange();
130}

132/// Check that the first argument to __builtin_annotation is an integer
133/// and the second argument is a non-wide string literal.
134static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
if (checkArgCount(S, TheCall, 2))
  return true;

// First argument should be an integer.
Expr *ValArg = TheCall->getArg(0);
QualType Ty = ValArg->getType();
if (!Ty->isIntegerType()) {
  S.Diag(ValArg->getBeginLoc(), diag::err_builtin_annotation_first_arg)
      << ValArg->getSourceRange();
  return true;
}

// Second argument should be a constant string.
Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
StringLiteral *Literal = dyn_cast<StringLiteral>(StrArg);
if (!Literal || !Literal->isAscii()) {
  S.Diag(StrArg->getBeginLoc(), diag::err_builtin_annotation_second_arg)
      << StrArg->getSourceRange();
  return true;
}

TheCall->setType(Ty);
return false;
158}

160static bool SemaBuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) {
// We need at least one argument.
if (TheCall->getNumArgs() < 1) {
  S.Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
      << 0 << 1 << TheCall->getNumArgs()
      << TheCall->getCallee()->getSourceRange();
  return true;
}

// All arguments should be wide string literals.
for (Expr *Arg : TheCall->arguments()) {
  auto *Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
  if (!Literal || !Literal->isWide()) {
    S.Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
        << Arg->getSourceRange();
    return true;
  }
}

return false;
180}

182/// Check that the argument to __builtin_addressof is a glvalue, and set the
183/// result type to the corresponding pointer type.
184static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall) {
if (checkArgCount(S, TheCall, 1))
  return true;

ExprResult Arg(TheCall->getArg(0));
QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getBeginLoc());
if (ResultType.isNull())
  return true;

TheCall->setArg(0, Arg.get());
TheCall->setType(ResultType);
return false;
196}

198/// Check the number of arguments and set the result type to
199/// the argument type.
200static bool SemaBuiltinPreserveAI(Sema &S, CallExpr *TheCall) {
if (checkArgCount(S, TheCall, 1))
  return true;

TheCall->setType(TheCall->getArg(0)->getType());
return false;
206}

208/// Check that the value argument for __builtin_is_aligned(value, alignment) and
209/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer
210/// type (but not a function pointer) and that the alignment is a power-of-two.
211static bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {
if (checkArgCount(S, TheCall, 2))
  return true;

clang::Expr *Source = TheCall->getArg(0);
bool IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;

auto IsValidIntegerType = [](QualType Ty) {
  return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
};
QualType SrcTy = Source->getType();
// We should also be able to use it with arrays (but not functions!).
if (SrcTy->canDecayToPointerType() && SrcTy->isArrayType()) {
  SrcTy = S.Context.getDecayedType(SrcTy);
}
if ((!SrcTy->isPointerType() && !IsValidIntegerType(SrcTy)) ||
    SrcTy->isFunctionPointerType()) {
  // FIXME: this is not quite the right error message since we don't allow
  // floating point types, or member pointers.
  S.Diag(Source->getExprLoc(), diag::err_typecheck_expect_scalar_operand)
      << SrcTy;
  return true;
}

clang::Expr *AlignOp = TheCall->getArg(1);
if (!IsValidIntegerType(AlignOp->getType())) {
  S.Diag(AlignOp->getExprLoc(), diag::err_typecheck_expect_int)
      << AlignOp->getType();
  return true;
}
Expr::EvalResult AlignResult;
unsigned MaxAlignmentBits = S.Context.getIntWidth(SrcTy) - 1;
// We can't check validity of alignment if it is value dependent.
if (!AlignOp->isValueDependent() &&
    AlignOp->EvaluateAsInt(AlignResult, S.Context,
                           Expr::SE_AllowSideEffects)) {
  llvm::APSInt AlignValue = AlignResult.Val.getInt();
  llvm::APSInt MaxValue(
      llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
  if (AlignValue < 1) {
    S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_small) << 1;
    return true;
  }
  if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
    S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_big)
        << toString(MaxValue, 10);
    return true;
  }
  if (!AlignValue.isPowerOf2()) {
    S.Diag(AlignOp->getExprLoc(), diag::err_alignment_not_power_of_two);
    return true;
  }
  if (AlignValue == 1) {
    S.Diag(AlignOp->getExprLoc(), diag::warn_alignment_builtin_useless)
        << IsBooleanAlignBuiltin;
  }
}

ExprResult SrcArg = S.PerformCopyInitialization(
    InitializedEntity::InitializeParameter(S.Context, SrcTy, false),
    SourceLocation(), Source);
if (SrcArg.isInvalid())
  return true;
TheCall->setArg(0, SrcArg.get());
ExprResult AlignArg =
    S.PerformCopyInitialization(InitializedEntity::InitializeParameter(
                                    S.Context, AlignOp->getType(), false),
                                SourceLocation(), AlignOp);
if (AlignArg.isInvalid())
  return true;
TheCall->setArg(1, AlignArg.get());
// For align_up/align_down, the return type is the same as the (potentially
// decayed) argument type including qualifiers. For is_aligned(), the result
// is always bool.
TheCall->setType(IsBooleanAlignBuiltin ? S.Context.BoolTy : SrcTy);
return false;
287}

289static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall,
                              unsigned BuiltinID) {
if (checkArgCount(S, TheCall, 3))
  return true;

// First two arguments should be integers.
for (unsigned I = 0; I < 2; ++I) {
  ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(I));
  if (Arg.isInvalid()) return true;
  TheCall->setArg(I, Arg.get());

  QualType Ty = Arg.get()->getType();
  if (!Ty->isIntegerType()) {
    S.Diag(Arg.get()->getBeginLoc(), diag::err_overflow_builtin_must_be_int)
        << Ty << Arg.get()->getSourceRange();
    return true;
  }
}

// Third argument should be a pointer to a non-const integer.
// IRGen correctly handles volatile, restrict, and address spaces, and
// the other qualifiers aren't possible.
{
  ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(2));
  if (Arg.isInvalid()) return true;
  TheCall->setArg(2, Arg.get());

  QualType Ty = Arg.get()->getType();
  const auto *PtrTy = Ty->getAs<PointerType>();
  if (!PtrTy ||
      !PtrTy->getPointeeType()->isIntegerType() ||
      PtrTy->getPointeeType().isConstQualified()) {
    S.Diag(Arg.get()->getBeginLoc(),
           diag::err_overflow_builtin_must_be_ptr_int)
      << Ty << Arg.get()->getSourceRange();
    return true;
  }
}

// Disallow signed ExtIntType args larger than 128 bits to mul function until
// we improve backend support.
if (BuiltinID == Builtin::BI__builtin_mul_overflow) {
  for (unsigned I = 0; I < 3; ++I) {
    const auto Arg = TheCall->getArg(I);
    // Third argument will be a pointer.
    auto Ty = I < 2 ? Arg->getType() : Arg->getType()->getPointeeType();
    if (Ty->isExtIntType() && Ty->isSignedIntegerType() &&
        S.getASTContext().getIntWidth(Ty) > 128)
      return S.Diag(Arg->getBeginLoc(),
                    diag::err_overflow_builtin_ext_int_max_size)
             << 128;
  }
}

return false;
344}

346static bool SemaBuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall) {
if (checkArgCount(S, BuiltinCall, 2))
  return true;

SourceLocation BuiltinLoc = BuiltinCall->getBeginLoc();
Expr *Builtin = BuiltinCall->getCallee()->IgnoreImpCasts();
Expr *Call = BuiltinCall->getArg(0);
Expr *Chain = BuiltinCall->getArg(1);

if (Call->getStmtClass() != Stmt::CallExprClass) {
  S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)
      << Call->getSourceRange();
  return true;
}

auto CE = cast<CallExpr>(Call);
if (CE->getCallee()->getType()->isBlockPointerType()) {
  S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)
      << Call->getSourceRange();
  return true;
}

const Decl *TargetDecl = CE->getCalleeDecl();
if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
  if (FD->getBuiltinID()) {
    S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)
        << Call->getSourceRange();
    return true;
  }

if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {
  S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)
      << Call->getSourceRange();
  return true;
}

ExprResult ChainResult = S.UsualUnaryConversions(Chain);
if (ChainResult.isInvalid())
  return true;
if (!ChainResult.get()->getType()->isPointerType()) {
  S.Diag(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)
      << Chain->getSourceRange();
  return true;
}

QualType ReturnTy = CE->getCallReturnType(S.Context);
QualType ArgTys[2] = { ReturnTy, ChainResult.get()->getType() };
QualType BuiltinTy = S.Context.getFunctionType(
    ReturnTy, ArgTys, FunctionProtoType::ExtProtoInfo());
QualType BuiltinPtrTy = S.Context.getPointerType(BuiltinTy);

Builtin =
    S.ImpCastExprToType(Builtin, BuiltinPtrTy, CK_BuiltinFnToFnPtr).get();

BuiltinCall->setType(CE->getType());
BuiltinCall->setValueKind(CE->getValueKind());
BuiltinCall->setObjectKind(CE->getObjectKind());
BuiltinCall->setCallee(Builtin);
BuiltinCall->setArg(1, ChainResult.get());

return false;
407}

409namespace {

411class EstimateSizeFormatHandler
  : public analyze_format_string::FormatStringHandler {
size_t Size;

415public:
EstimateSizeFormatHandler(StringRef Format)
    : Size(std::min(Format.find(0), Format.size()) +
           1 /* null byte always written by sprintf */) {}

bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
                           const char *, unsigned SpecifierLen) override {

  const size_t FieldWidth = computeFieldWidth(FS);
  const size_t Precision = computePrecision(FS);

  // The actual format.
  switch (FS.getConversionSpecifier().getKind()) {
  // Just a char.
  case analyze_format_string::ConversionSpecifier::cArg:
  case analyze_format_string::ConversionSpecifier::CArg:
    Size += std::max(FieldWidth, (size_t)1);
    break;
  // Just an integer.
  case analyze_format_string::ConversionSpecifier::dArg:
  case analyze_format_string::ConversionSpecifier::DArg:
  case analyze_format_string::ConversionSpecifier::iArg:
  case analyze_format_string::ConversionSpecifier::oArg:
  case analyze_format_string::ConversionSpecifier::OArg:
  case analyze_format_string::ConversionSpecifier::uArg:
  case analyze_format_string::ConversionSpecifier::UArg:
  case analyze_format_string::ConversionSpecifier::xArg:
  case analyze_format_string::ConversionSpecifier::XArg:
    Size += std::max(FieldWidth, Precision);
    break;

  // %g style conversion switches between %f or %e style dynamically.
  // %f always takes less space, so default to it.
  case analyze_format_string::ConversionSpecifier::gArg:
  case analyze_format_string::ConversionSpecifier::GArg:

  // Floating point number in the form '[+]ddd.ddd'.
  case analyze_format_string::ConversionSpecifier::fArg:
  case analyze_format_string::ConversionSpecifier::FArg:
    Size += std::max(FieldWidth, 1 /* integer part */ +
                                     (Precision ? 1 + Precision
                                                : 0) /* period + decimal */);
    break;

  // Floating point number in the form '[-]d.ddde[+-]dd'.
  case analyze_format_string::ConversionSpecifier::eArg:
  case analyze_format_string::ConversionSpecifier::EArg:
    Size +=
        std::max(FieldWidth,
                 1 /* integer part */ +
                     (Precision ? 1 + Precision : 0) /* period + decimal */ +
                     1 /* e or E letter */ + 2 /* exponent */);
    break;

  // Floating point number in the form '[-]0xh.hhhhp±dd'.
  case analyze_format_string::ConversionSpecifier::aArg:
  case analyze_format_string::ConversionSpecifier::AArg:
    Size +=
        std::max(FieldWidth,
                 2 /* 0x */ + 1 /* integer part */ +
                     (Precision ? 1 + Precision : 0) /* period + decimal */ +
                     1 /* p or P letter */ + 1 /* + or - */ + 1 /* value */);
    break;

  // Just a string.
  case analyze_format_string::ConversionSpecifier::sArg:
  case analyze_format_string::ConversionSpecifier::SArg:
    Size += FieldWidth;
    break;

  // Just a pointer in the form '0xddd'.
  case analyze_format_string::ConversionSpecifier::pArg:
    Size += std::max(FieldWidth, 2 /* leading 0x */ + Precision);
    break;

  // A plain percent.
  case analyze_format_string::ConversionSpecifier::PercentArg:
    Size += 1;
    break;

  default:
    break;
  }

  Size += FS.hasPlusPrefix() || FS.hasSpacePrefix();

  if (FS.hasAlternativeForm()) {
    switch (FS.getConversionSpecifier().getKind()) {
    default:
      break;
    // Force a leading '0'.
    case analyze_format_string::ConversionSpecifier::oArg:
      Size += 1;
      break;
    // Force a leading '0x'.
    case analyze_format_string::ConversionSpecifier::xArg:
    case analyze_format_string::ConversionSpecifier::XArg:
      Size += 2;
      break;
    // Force a period '.' before decimal, even if precision is 0.
    case analyze_format_string::ConversionSpecifier::aArg:
    case analyze_format_string::ConversionSpecifier::AArg:
    case analyze_format_string::ConversionSpecifier::eArg:
    case analyze_format_string::ConversionSpecifier::EArg:
    case analyze_format_string::ConversionSpecifier::fArg:
    case analyze_format_string::ConversionSpecifier::FArg:
    case analyze_format_string::ConversionSpecifier::gArg:
    case analyze_format_string::ConversionSpecifier::GArg:
      Size += (Precision ? 0 : 1);
      break;
    }
  }
  assert(SpecifierLen <= Size && "no underflow")((void)0);
  Size -= SpecifierLen;
  return true;
}

size_t getSizeLowerBound() const { return Size; }

534private:
static size_t computeFieldWidth(const analyze_printf::PrintfSpecifier &FS) {
  const analyze_format_string::OptionalAmount &FW = FS.getFieldWidth();
  size_t FieldWidth = 0;
  if (FW.getHowSpecified() == analyze_format_string::OptionalAmount::Constant)
    FieldWidth = FW.getConstantAmount();
  return FieldWidth;
}

static size_t computePrecision(const analyze_printf::PrintfSpecifier &FS) {
  const analyze_format_string::OptionalAmount &FW = FS.getPrecision();
  size_t Precision = 0;

  // See man 3 printf for default precision value based on the specifier.
  switch (FW.getHowSpecified()) {
  case analyze_format_string::OptionalAmount::NotSpecified:
    switch (FS.getConversionSpecifier().getKind()) {
    default:
      break;
    case analyze_format_string::ConversionSpecifier::dArg: // %d
    case analyze_format_string::ConversionSpecifier::DArg: // %D
    case analyze_format_string::ConversionSpecifier::iArg: // %i
      Precision = 1;
      break;
    case analyze_format_string::ConversionSpecifier::oArg: // %d
    case analyze_format_string::ConversionSpecifier::OArg: // %D
    case analyze_format_string::ConversionSpecifier::uArg: // %d
    case analyze_format_string::ConversionSpecifier::UArg: // %D
    case analyze_format_string::ConversionSpecifier::xArg: // %d
    case analyze_format_string::ConversionSpecifier::XArg: // %D
      Precision = 1;
      break;
    case analyze_format_string::ConversionSpecifier::fArg: // %f
    case analyze_format_string::ConversionSpecifier::FArg: // %F
    case analyze_format_string::ConversionSpecifier::eArg: // %e
    case analyze_format_string::ConversionSpecifier::EArg: // %E
    case analyze_format_string::ConversionSpecifier::gArg: // %g
    case analyze_format_string::ConversionSpecifier::GArg: // %G
      Precision = 6;
      break;
    case analyze_format_string::ConversionSpecifier::pArg: // %d
      Precision = 1;
      break;
    }
    break;
  case analyze_format_string::OptionalAmount::Constant:
    Precision = FW.getConstantAmount();
    break;
  default:
    break;
  }
  return Precision;
}
587};

589} // namespace

591/// Check a call to BuiltinID for buffer overflows. If BuiltinID is a
592/// __builtin_*_chk function, then use the object size argument specified in the
593/// source. Otherwise, infer the object size using __builtin_object_size.
594void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
                                             CallExpr *TheCall) {
// FIXME: There are some more useful checks we could be doing here:
//  - Evaluate strlen of strcpy arguments, use as object size.

if (TheCall->isValueDependent() || TheCall->isTypeDependent() ||
    isConstantEvaluated())
  return;

unsigned BuiltinID = FD->getBuiltinID(/*ConsiderWrappers=*/true);
if (!BuiltinID)
  return;

const TargetInfo &TI = getASTContext().getTargetInfo();
unsigned SizeTypeWidth = TI.getTypeWidth(TI.getSizeType());

unsigned DiagID = 0;
bool IsChkVariant = false;
Optional<llvm::APSInt> UsedSize;
unsigned SizeIndex, ObjectIndex;
switch (BuiltinID) {
default:
  return;
case Builtin::BIsprintf:
case Builtin::BI__builtin___sprintf_chk: {
  size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
  auto *FormatExpr = TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();

  if (auto *Format = dyn_cast<StringLiteral>(FormatExpr)) {

    if (!Format->isAscii() && !Format->isUTF8())
      return;

    StringRef FormatStrRef = Format->getString();
    EstimateSizeFormatHandler H(FormatStrRef);
    const char *FormatBytes = FormatStrRef.data();
    const ConstantArrayType *T =
        Context.getAsConstantArrayType(Format->getType());
    assert(T && "String literal not of constant array type!")((void)0);
    size_t TypeSize = T->getSize().getZExtValue();

    // In case there's a null byte somewhere.
    size_t StrLen =
        std::min(std::max(TypeSize, size_t(1)) - 1, FormatStrRef.find(0));
    if (!analyze_format_string::ParsePrintfString(
            H, FormatBytes, FormatBytes + StrLen, getLangOpts(),
            Context.getTargetInfo(), false)) {
      DiagID = diag::warn_fortify_source_format_overflow;
      UsedSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())
                     .extOrTrunc(SizeTypeWidth);
      if (BuiltinID == Builtin::BI__builtin___sprintf_chk) {
        IsChkVariant = true;
        ObjectIndex = 2;
      } else {
        IsChkVariant = false;
        ObjectIndex = 0;
      }
      break;
    }
  }
  return;
}
case Builtin::BI__builtin___memcpy_chk:
case Builtin::BI__builtin___memmove_chk:
case Builtin::BI__builtin___memset_chk:
case Builtin::BI__builtin___strlcat_chk:
case Builtin::BI__builtin___strlcpy_chk:
case Builtin::BI__builtin___strncat_chk:
case Builtin::BI__builtin___strncpy_chk:
case Builtin::BI__builtin___stpncpy_chk:
case Builtin::BI__builtin___memccpy_chk:
case Builtin::BI__builtin___mempcpy_chk: {
  DiagID = diag::warn_builtin_chk_overflow;
  IsChkVariant = true;
  SizeIndex = TheCall->getNumArgs() - 2;
  ObjectIndex = TheCall->getNumArgs() - 1;
  break;
}

case Builtin::BI__builtin___snprintf_chk:
case Builtin::BI__builtin___vsnprintf_chk: {
  DiagID = diag::warn_builtin_chk_overflow;
  IsChkVariant = true;
  SizeIndex = 1;
  ObjectIndex = 3;
  break;
}

case Builtin::BIstrncat:
case Builtin::BI__builtin_strncat:
case Builtin::BIstrncpy:
case Builtin::BI__builtin_strncpy:
case Builtin::BIstpncpy:
case Builtin::BI__builtin_stpncpy: {
  // Whether these functions overflow depends on the runtime strlen of the
  // string, not just the buffer size, so emitting the "always overflow"
  // diagnostic isn't quite right. We should still diagnose passing a buffer
  // size larger than the destination buffer though; this is a runtime abort
  // in _FORTIFY_SOURCE mode, and is quite suspicious otherwise.
  DiagID = diag::warn_fortify_source_size_mismatch;
  SizeIndex = TheCall->getNumArgs() - 1;
  ObjectIndex = 0;
  break;
}

case Builtin::BImemcpy:
case Builtin::BI__builtin_memcpy:
case Builtin::BImemmove:
case Builtin::BI__builtin_memmove:
case Builtin::BImemset:
case Builtin::BI__builtin_memset:
case Builtin::BImempcpy:
case Builtin::BI__builtin_mempcpy: {
  DiagID = diag::warn_fortify_source_overflow;
  SizeIndex = TheCall->getNumArgs() - 1;
  ObjectIndex = 0;
  break;
}
case Builtin::BIsnprintf:
case Builtin::BI__builtin_snprintf:
case Builtin::BIvsnprintf:
case Builtin::BI__builtin_vsnprintf: {
  DiagID = diag::warn_fortify_source_size_mismatch;
  SizeIndex = 1;
  ObjectIndex = 0;
  break;
}
}

llvm::APSInt ObjectSize;
// For __builtin___*_chk, the object size is explicitly provided by the caller
// (usually using __builtin_object_size). Use that value to check this call.
if (IsChkVariant) {
  Expr::EvalResult Result;
  Expr *SizeArg = TheCall->getArg(ObjectIndex);
  if (!SizeArg->EvaluateAsInt(Result, getASTContext()))
    return;
  ObjectSize = Result.Val.getInt();

// Otherwise, try to evaluate an imaginary call to __builtin_object_size.
} else {
  // If the parameter has a pass_object_size attribute, then we should use its
  // (potentially) more strict checking mode. Otherwise, conservatively assume
  // type 0.
  int BOSType = 0;
  if (const auto *POS =
          FD->getParamDecl(ObjectIndex)->getAttr<PassObjectSizeAttr>())
    BOSType = POS->getType();

  Expr *ObjArg = TheCall->getArg(ObjectIndex);
  uint64_t Result;
  if (!ObjArg->tryEvaluateObjectSize(Result, getASTContext(), BOSType))
    return;
  // Get the object size in the target's size_t width.
  ObjectSize = llvm::APSInt::getUnsigned(Result).extOrTrunc(SizeTypeWidth);
}

// Evaluate the number of bytes of the object that this call will use.
if (!UsedSize) {
  Expr::EvalResult Result;
  Expr *UsedSizeArg = TheCall->getArg(SizeIndex);
  if (!UsedSizeArg->EvaluateAsInt(Result, getASTContext()))
    return;
  UsedSize = Result.Val.getInt().extOrTrunc(SizeTypeWidth);
}

if (UsedSize.getValue().ule(ObjectSize))
  return;

StringRef FunctionName = getASTContext().BuiltinInfo.getName(BuiltinID);
// Skim off the details of whichever builtin was called to produce a better
// diagnostic, as it's unlikley that the user wrote the __builtin explicitly.
if (IsChkVariant) {
  FunctionName = FunctionName.drop_front(std::strlen("__builtin___"));
  FunctionName = FunctionName.drop_back(std::strlen("_chk"));
} else if (FunctionName.startswith("__builtin_")) {
  FunctionName = FunctionName.drop_front(std::strlen("__builtin_"));
}

DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
                    PDiag(DiagID)
                        << FunctionName << toString(ObjectSize, /*Radix=*/10)
                        << toString(UsedSize.getValue(), /*Radix=*/10));
777}

779static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
                                   Scope::ScopeFlags NeededScopeFlags,
                                   unsigned DiagID) {
// Scopes aren't available during instantiation. Fortunately, builtin
// functions cannot be template args so they cannot be formed through template
// instantiation. Therefore checking once during the parse is sufficient.
if (SemaRef.inTemplateInstantiation())
  return false;

Scope *S = SemaRef.getCurScope();
while (S && !S->isSEHExceptScope())
  S = S->getParent();
if (!S || !(S->getFlags() & NeededScopeFlags)) {
  auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
  SemaRef.Diag(TheCall->getExprLoc(), DiagID)
      << DRE->getDecl()->getIdentifier();
  return true;
}

return false;
799}

801static inline bool isBlockPointer(Expr *Arg) {
return Arg->getType()->isBlockPointerType();
803}

805/// OpenCL C v2.0, s6.13.17.2 - Checks that the block parameters are all local
806/// void*, which is a requirement of device side enqueue.
807static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg) {
const BlockPointerType *BPT =
    cast<BlockPointerType>(BlockArg->getType().getCanonicalType());
ArrayRef<QualType> Params =
    BPT->getPointeeType()->castAs<FunctionProtoType>()->getParamTypes();
unsigned ArgCounter = 0;
bool IllegalParams = false;
// Iterate through the block parameters until either one is found that is not
// a local void*, or the block is valid.
for (ArrayRef<QualType>::iterator I = Params.begin(), E = Params.end();
     I != E; ++I, ++ArgCounter) {
  if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
      (*I)->getPointeeType().getQualifiers().getAddressSpace() !=
          LangAS::opencl_local) {
    // Get the location of the error. If a block literal has been passed
    // (BlockExpr) then we can point straight to the offending argument,
    // else we just point to the variable reference.
    SourceLocation ErrorLoc;
    if (isa<BlockExpr>(BlockArg)) {
      BlockDecl *BD = cast<BlockExpr>(BlockArg)->getBlockDecl();
      ErrorLoc = BD->getParamDecl(ArgCounter)->getBeginLoc();
    } else if (isa<DeclRefExpr>(BlockArg)) {
      ErrorLoc = cast<DeclRefExpr>(BlockArg)->getBeginLoc();
    }
    S.Diag(ErrorLoc,
           diag::err_opencl_enqueue_kernel_blocks_non_local_void_args);
    IllegalParams = true;
  }
}

return IllegalParams;
838}

840static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call) {
if (!S.getOpenCLOptions().isSupported("cl_khr_subgroups", S.getLangOpts())) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
      << 1 << Call->getDirectCallee() << "cl_khr_subgroups";
  return true;
}
return false;
847}

849static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall) {
if (checkArgCount(S, TheCall, 2))
  return true;

if (checkOpenCLSubgroupExt(S, TheCall))
  return true;

// First argument is an ndrange_t type.
Expr *NDRangeArg = TheCall->getArg(0);
if (NDRangeArg->getType().getUnqualifiedType().getAsString() != "ndrange_t") {
  S.Diag(NDRangeArg->getBeginLoc(), diag::err_opencl_builtin_expected_type)
      << TheCall->getDirectCallee() << "'ndrange_t'";
  return true;
}

Expr *BlockArg = TheCall->getArg(1);
if (!isBlockPointer(BlockArg)) {
  S.Diag(BlockArg->getBeginLoc(), diag::err_opencl_builtin_expected_type)
      << TheCall->getDirectCallee() << "block";
  return true;
}
return checkOpenCLBlockArgs(S, BlockArg);
871}

873/// OpenCL C v2.0, s6.13.17.6 - Check the argument to the
874/// get_kernel_work_group_size
875/// and get_kernel_preferred_work_group_size_multiple builtin functions.
876static bool SemaOpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall) {
if (checkArgCount(S, TheCall, 1))
  return true;

Expr *BlockArg = TheCall->getArg(0);
if (!isBlockPointer(BlockArg)) {
  S.Diag(BlockArg->getBeginLoc(), diag::err_opencl_builtin_expected_type)
      << TheCall->getDirectCallee() << "block";
  return true;
}
return checkOpenCLBlockArgs(S, BlockArg);
887}

889/// Diagnose integer type and any valid implicit conversion to it.
890static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E,
                                    const QualType &IntType);

893static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall,
                                          unsigned Start, unsigned End) {
bool IllegalParams = false;
for (unsigned I = Start; I <= End; ++I)
  IllegalParams |= checkOpenCLEnqueueIntType(S, TheCall->getArg(I),
                                            S.Context.getSizeType());
return IllegalParams;
900}

902/// OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all
903/// 'local void*' parameter of passed block.
904static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall,
                                         Expr *BlockArg,
                                         unsigned NumNonVarArgs) {
const BlockPointerType *BPT =
    cast<BlockPointerType>(BlockArg->getType().getCanonicalType());
unsigned NumBlockParams =
    BPT->getPointeeType()->castAs<FunctionProtoType>()->getNumParams();
unsigned TotalNumArgs = TheCall->getNumArgs();

// For each argument passed to the block, a corresponding uint needs to
// be passed to describe the size of the local memory.
if (TotalNumArgs != NumBlockParams + NumNonVarArgs) {
  S.Diag(TheCall->getBeginLoc(),
         diag::err_opencl_enqueue_kernel_local_size_args);
  return true;
}

// Check that the sizes of the local memory are specified by integers.
return checkOpenCLEnqueueLocalSizeArgs(S, TheCall, NumNonVarArgs,
                                       TotalNumArgs - 1);
924}

926/// OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different
927/// overload formats specified in Table 6.13.17.1.
928/// int enqueue_kernel(queue_t queue,
929///                    kernel_enqueue_flags_t flags,
930///                    const ndrange_t ndrange,
931///                    void (^block)(void))
932/// int enqueue_kernel(queue_t queue,
933///                    kernel_enqueue_flags_t flags,
934///                    const ndrange_t ndrange,
935///                    uint num_events_in_wait_list,
936///                    clk_event_t *event_wait_list,
937///                    clk_event_t *event_ret,
938///                    void (^block)(void))
939/// int enqueue_kernel(queue_t queue,
940///                    kernel_enqueue_flags_t flags,
941///                    const ndrange_t ndrange,
942///                    void (^block)(local void*, ...),
943///                    uint size0, ...)
944/// int enqueue_kernel(queue_t queue,
945///                    kernel_enqueue_flags_t flags,
946///                    const ndrange_t ndrange,
947///                    uint num_events_in_wait_list,
948///                    clk_event_t *event_wait_list,
949///                    clk_event_t *event_ret,
950///                    void (^block)(local void*, ...),
951///                    uint size0, ...)
952static bool SemaOpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall) {
unsigned NumArgs = TheCall->getNumArgs();

if (NumArgs < 4) {
  S.Diag(TheCall->getBeginLoc(),
         diag::err_typecheck_call_too_few_args_at_least)
      << 0 << 4 << NumArgs;
  return true;
}

Expr *Arg0 = TheCall->getArg(0);
Expr *Arg1 = TheCall->getArg(1);
Expr *Arg2 = TheCall->getArg(2);
Expr *Arg3 = TheCall->getArg(3);

// First argument always needs to be a queue_t type.
if (!Arg0->getType()->isQueueT()) {
  S.Diag(TheCall->getArg(0)->getBeginLoc(),
         diag::err_opencl_builtin_expected_type)
      << TheCall->getDirectCallee() << S.Context.OCLQueueTy;
  return true;
}

// Second argument always needs to be a kernel_enqueue_flags_t enum value.
if (!Arg1->getType()->isIntegerType()) {
  S.Diag(TheCall->getArg(1)->getBeginLoc(),
         diag::err_opencl_builtin_expected_type)
      << TheCall->getDirectCallee() << "'kernel_enqueue_flags_t' (i.e. uint)";
  return true;
}

// Third argument is always an ndrange_t type.
if (Arg2->getType().getUnqualifiedType().getAsString() != "ndrange_t") {
  S.Diag(TheCall->getArg(2)->getBeginLoc(),
         diag::err_opencl_builtin_expected_type)
      << TheCall->getDirectCallee() << "'ndrange_t'";
  return true;
}

// With four arguments, there is only one form that the function could be
// called in: no events and no variable arguments.
if (NumArgs == 4) {
  // check that the last argument is the right block type.
  if (!isBlockPointer(Arg3)) {
    S.Diag(Arg3->getBeginLoc(), diag::err_opencl_builtin_expected_type)
        << TheCall->getDirectCallee() << "block";
    return true;
  }
  // we have a block type, check the prototype
  const BlockPointerType *BPT =
      cast<BlockPointerType>(Arg3->getType().getCanonicalType());
  if (BPT->getPointeeType()->castAs<FunctionProtoType>()->getNumParams() > 0) {
    S.Diag(Arg3->getBeginLoc(),
           diag::err_opencl_enqueue_kernel_blocks_no_args);
    return true;
  }
  return false;
}
// we can have block + varargs.
if (isBlockPointer(Arg3))
  return (checkOpenCLBlockArgs(S, Arg3) ||
          checkOpenCLEnqueueVariadicArgs(S, TheCall, Arg3, 4));
// last two cases with either exactly 7 args or 7 args and varargs.
if (NumArgs >= 7) {
  // check common block argument.
  Expr *Arg6 = TheCall->getArg(6);
  if (!isBlockPointer(Arg6)) {
    S.Diag(Arg6->getBeginLoc(), diag::err_opencl_builtin_expected_type)
        << TheCall->getDirectCallee() << "block";
    return true;
  }
  if (checkOpenCLBlockArgs(S, Arg6))
    return true;

  // Forth argument has to be any integer type.
  if (!Arg3->getType()->isIntegerType()) {
    S.Diag(TheCall->getArg(3)->getBeginLoc(),
           diag::err_opencl_builtin_expected_type)
        << TheCall->getDirectCallee() << "integer";
    return true;
  }
  // check remaining common arguments.
  Expr *Arg4 = TheCall->getArg(4);
  Expr *Arg5 = TheCall->getArg(5);

  // Fifth argument is always passed as a pointer to clk_event_t.
  if (!Arg4->isNullPointerConstant(S.Context,
                                   Expr::NPC_ValueDependentIsNotNull) &&
      !Arg4->getType()->getPointeeOrArrayElementType()->isClkEventT()) {
    S.Diag(TheCall->getArg(4)->getBeginLoc(),
           diag::err_opencl_builtin_expected_type)
        << TheCall->getDirectCallee()
        << S.Context.getPointerType(S.Context.OCLClkEventTy);
    return true;
  }

  // Sixth argument is always passed as a pointer to clk_event_t.
  if (!Arg5->isNullPointerConstant(S.Context,
                                   Expr::NPC_ValueDependentIsNotNull) &&
      !(Arg5->getType()->isPointerType() &&
        Arg5->getType()->getPointeeType()->isClkEventT())) {
    S.Diag(TheCall->getArg(5)->getBeginLoc(),
           diag::err_opencl_builtin_expected_type)
        << TheCall->getDirectCallee()
        << S.Context.getPointerType(S.Context.OCLClkEventTy);
    return true;
  }

  if (NumArgs == 7)
    return false;

  return checkOpenCLEnqueueVariadicArgs(S, TheCall, Arg6, 7);
}

// None of the specific case has been detected, give generic error
S.Diag(TheCall->getBeginLoc(),
       diag::err_opencl_enqueue_kernel_incorrect_args);
return true;
1070}

1072/// Returns OpenCL access qual.
1073static OpenCLAccessAttr *getOpenCLArgAccess(const Decl *D) {
  return D->getAttr<OpenCLAccessAttr>();
1075}

1077/// Returns true if pipe element type is different from the pointer.
1078static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call) {
const Expr *Arg0 = Call->getArg(0);
// First argument type should always be pipe.
if (!Arg0->getType()->isPipeType()) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
      << Call->getDirectCallee() << Arg0->getSourceRange();
  return true;
}
OpenCLAccessAttr *AccessQual =
    getOpenCLArgAccess(cast<DeclRefExpr>(Arg0)->getDecl());
// Validates the access qualifier is compatible with the call.
// OpenCL v2.0 s6.13.16 - The access qualifiers for pipe should only be
// read_only and write_only, and assumed to be read_only if no qualifier is
// specified.
switch (Call->getDirectCallee()->getBuiltinID()) {
case Builtin::BIread_pipe:
case Builtin::BIreserve_read_pipe:
case Builtin::BIcommit_read_pipe:
case Builtin::BIwork_group_reserve_read_pipe:
case Builtin::BIsub_group_reserve_read_pipe:
case Builtin::BIwork_group_commit_read_pipe:
case Builtin::BIsub_group_commit_read_pipe:
  if (!(!AccessQual || AccessQual->isReadOnly())) {
    S.Diag(Arg0->getBeginLoc(),
           diag::err_opencl_builtin_pipe_invalid_access_modifier)
        << "read_only" << Arg0->getSourceRange();
    return true;
  }
  break;
case Builtin::BIwrite_pipe:
case Builtin::BIreserve_write_pipe:
case Builtin::BIcommit_write_pipe:
case Builtin::BIwork_group_reserve_write_pipe:
case Builtin::BIsub_group_reserve_write_pipe:
case Builtin::BIwork_group_commit_write_pipe:
case Builtin::BIsub_group_commit_write_pipe:
  if (!(AccessQual && AccessQual->isWriteOnly())) {
    S.Diag(Arg0->getBeginLoc(),
           diag::err_opencl_builtin_pipe_invalid_access_modifier)
        << "write_only" << Arg0->getSourceRange();
    return true;
  }
  break;
default:
  break;
}
return false;
1125}

1127/// Returns true if pipe element type is different from the pointer.
1128static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx) {
const Expr *Arg0 = Call->getArg(0);
const Expr *ArgIdx = Call->getArg(Idx);
const PipeType *PipeTy = cast<PipeType>(Arg0->getType());
const QualType EltTy = PipeTy->getElementType();
const PointerType *ArgTy = ArgIdx->getType()->getAs<PointerType>();
// The Idx argument should be a pointer and the type of the pointer and
// the type of pipe element should also be the same.
if (!ArgTy ||
    !S.Context.hasSameType(
        EltTy, ArgTy->getPointeeType()->getCanonicalTypeInternal())) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
      << Call->getDirectCallee() << S.Context.getPointerType(EltTy)
      << ArgIdx->getType() << ArgIdx->getSourceRange();
  return true;
}
return false;
1145}

1147// Performs semantic analysis for the read/write_pipe call.
1148// \param S Reference to the semantic analyzer.
1149// \param Call A pointer to the builtin call.
1150// \return True if a semantic error has been found, false otherwise.
1151static bool SemaBuiltinRWPipe(Sema &S, CallExpr *Call) {
// OpenCL v2.0 s6.13.16.2 - The built-in read/write
// functions have two forms.
switch (Call->getNumArgs()) {
case 2:
  if (checkOpenCLPipeArg(S, Call))
    return true;
  // The call with 2 arguments should be
  // read/write_pipe(pipe T, T*).
  // Check packet type T.
  if (checkOpenCLPipePacketType(S, Call, 1))
    return true;
  break;

case 4: {
  if (checkOpenCLPipeArg(S, Call))
    return true;
  // The call with 4 arguments should be
  // read/write_pipe(pipe T, reserve_id_t, uint, T*).
  // Check reserve_id_t.
  if (!Call->getArg(1)->getType()->isReserveIDT()) {
    S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
        << Call->getDirectCallee() << S.Context.OCLReserveIDTy
        << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
    return true;
  }

  // Check the index.
  const Expr *Arg2 = Call->getArg(2);
  if (!Arg2->getType()->isIntegerType() &&
      !Arg2->getType()->isUnsignedIntegerType()) {
    S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
        << Call->getDirectCallee() << S.Context.UnsignedIntTy
        << Arg2->getType() << Arg2->getSourceRange();
    return true;
  }

  // Check packet type T.
  if (checkOpenCLPipePacketType(S, Call, 3))
    return true;
} break;
default:
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_arg_num)
      << Call->getDirectCallee() << Call->getSourceRange();
  return true;
}

return false;
1199}

1201// Performs a semantic analysis on the {work_group_/sub_group_
1202//        /_}reserve_{read/write}_pipe
1203// \param S Reference to the semantic analyzer.
1204// \param Call The call to the builtin function to be analyzed.
1205// \return True if a semantic error was found, false otherwise.
1206static bool SemaBuiltinReserveRWPipe(Sema &S, CallExpr *Call) {
if (checkArgCount(S, Call, 2))
  return true;

if (checkOpenCLPipeArg(S, Call))
  return true;

// Check the reserve size.
if (!Call->getArg(1)->getType()->isIntegerType() &&
    !Call->getArg(1)->getType()->isUnsignedIntegerType()) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
      << Call->getDirectCallee() << S.Context.UnsignedIntTy
      << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
  return true;
}

// Since return type of reserve_read/write_pipe built-in function is
// reserve_id_t, which is not defined in the builtin def file , we used int
// as return type and need to override the return type of these functions.
Call->setType(S.Context.OCLReserveIDTy);

return false;
1228}

1230// Performs a semantic analysis on {work_group_/sub_group_
1231//        /_}commit_{read/write}_pipe
1232// \param S Reference to the semantic analyzer.
1233// \param Call The call to the builtin function to be analyzed.
1234// \return True if a semantic error was found, false otherwise.
1235static bool SemaBuiltinCommitRWPipe(Sema &S, CallExpr *Call) {
if (checkArgCount(S, Call, 2))
  return true;

if (checkOpenCLPipeArg(S, Call))
  return true;

// Check reserve_id_t.
if (!Call->getArg(1)->getType()->isReserveIDT()) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
      << Call->getDirectCallee() << S.Context.OCLReserveIDTy
      << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
  return true;
}

return false;
1251}

1253// Performs a semantic analysis on the call to built-in Pipe
1254//        Query Functions.
1255// \param S Reference to the semantic analyzer.
1256// \param Call The call to the builtin function to be analyzed.
1257// \return True if a semantic error was found, false otherwise.
1258static bool SemaBuiltinPipePackets(Sema &S, CallExpr *Call) {
if (checkArgCount(S, Call, 1))
  return true;

if (!Call->getArg(0)->getType()->isPipeType()) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
      << Call->getDirectCallee() << Call->getArg(0)->getSourceRange();
  return true;
}

return false;
1269}

1271// OpenCL v2.0 s6.13.9 - Address space qualifier functions.
1272// Performs semantic analysis for the to_global/local/private call.
1273// \param S Reference to the semantic analyzer.
1274// \param BuiltinID ID of the builtin function.
1275// \param Call A pointer to the builtin call.
1276// \return True if a semantic error has been found, false otherwise.
1277static bool SemaOpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID,
                                  CallExpr *Call) {
if (checkArgCount(S, Call, 1))
  return true;

auto RT = Call->getArg(0)->getType();
if (!RT->isPointerType() || RT->getPointeeType()
    .getAddressSpace() == LangAS::opencl_constant) {
  S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_to_addr_invalid_arg)
      << Call->getArg(0) << Call->getDirectCallee() << Call->getSourceRange();
  return true;
}

if (RT->getPointeeType().getAddressSpace() != LangAS::opencl_generic) {
  S.Diag(Call->getArg(0)->getBeginLoc(),
         diag::warn_opencl_generic_address_space_arg)
      << Call->getDirectCallee()->getNameInfo().getAsString()
      << Call->getArg(0)->getSourceRange();
}

RT = RT->getPointeeType();
auto Qual = RT.getQualifiers();
switch (BuiltinID) {
case Builtin::BIto_global:
  Qual.setAddressSpace(LangAS::opencl_global);
  break;
case Builtin::BIto_local:
  Qual.setAddressSpace(LangAS::opencl_local);
  break;
case Builtin::BIto_private:
  Qual.setAddressSpace(LangAS::opencl_private);
  break;
default:
  llvm_unreachable("Invalid builtin function")__builtin_unreachable();
}
Call->setType(S.Context.getPointerType(S.Context.getQualifiedType(
    RT.getUnqualifiedType(), Qual)));

return false;
1316}

1318static ExprResult SemaBuiltinLaunder(Sema &S, CallExpr *TheCall) {
if (checkArgCount(S, TheCall, 1))
  return ExprError();

// Compute __builtin_launder's parameter type from the argument.
// The parameter type is:
//  * The type of the argument if it's not an array or function type,
//  Otherwise,
//  * The decayed argument type.
QualType ParamTy = [&]() {
  QualType ArgTy = TheCall->getArg(0)->getType();
  if (const ArrayType *Ty = ArgTy->getAsArrayTypeUnsafe())
    return S.Context.getPointerType(Ty->getElementType());
  if (ArgTy->isFunctionType()) {
    return S.Context.getPointerType(ArgTy);
  }
  return ArgTy;
}();

TheCall->setType(ParamTy);

auto DiagSelect = [&]() -> llvm::Optional<unsigned> {
  if (!ParamTy->isPointerType())
    return 0;
  if (ParamTy->isFunctionPointerType())
    return 1;
  if (ParamTy->isVoidPointerType())
    return 2;
  return llvm::Optional<unsigned>{};
}();
if (DiagSelect.hasValue()) {
  S.Diag(TheCall->getBeginLoc(), diag::err_builtin_launder_invalid_arg)
      << DiagSelect.getValue() << TheCall->getSourceRange();
  return ExprError();
}

// We either have an incomplete class type, or we have a class template
// whose instantiation has not been forced. Example:
//
//   template <class T> struct Foo { T value; };
//   Foo<int> *p = nullptr;
//   auto *d = __builtin_launder(p);
if (S.RequireCompleteType(TheCall->getBeginLoc(), ParamTy->getPointeeType(),
                          diag::err_incomplete_type))
  return ExprError();

assert(ParamTy->getPointeeType()->isObjectType() &&((void)0)
       "Unhandled non-object pointer case")((void)0);

InitializedEntity Entity =
    InitializedEntity::InitializeParameter(S.Context, ParamTy, false);
ExprResult Arg =
    S.PerformCopyInitialization(Entity, SourceLocation(), TheCall->getArg(0));
if (Arg.isInvalid())
  return ExprError();
TheCall->setArg(0, Arg.get());

return TheCall;
1376}

1378// Emit an error and return true if the current architecture is not in the list
1379// of supported architectures.
1380static bool
1381CheckBuiltinTargetSupport(Sema &S, unsigned BuiltinID, CallExpr *TheCall,
                        ArrayRef<llvm::Triple::ArchType> SupportedArchs) {
llvm::Triple::ArchType CurArch =
    S.getASTContext().getTargetInfo().getTriple().getArch();
if (llvm::is_contained(SupportedArchs, CurArch))
  return false;
S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
    << TheCall->getSourceRange();
return true;
1390}

1392static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr,
                               SourceLocation CallSiteLoc);

1395bool 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.
  return false;
case llvm::Triple::arm:
case llvm::Triple::armeb:
case llvm::Triple::thumb:
case llvm::Triple::thumbeb:
  return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
case llvm::Triple::aarch64:
case llvm::Triple::aarch64_32:
case llvm::Triple::aarch64_be:
  return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
case llvm::Triple::bpfeb:
case llvm::Triple::bpfel:
  return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
case llvm::Triple::hexagon:
  return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
case llvm::Triple::mips:
case llvm::Triple::mipsel:
case llvm::Triple::mips64:
case llvm::Triple::mips64el:
  return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
case llvm::Triple::systemz:
  return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
case llvm::Triple::x86:
case llvm::Triple::x86_64:
  return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
case llvm::Triple::ppc:
case llvm::Triple::ppcle:
case llvm::Triple::ppc64:
case llvm::Triple::ppc64le:
  return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
case llvm::Triple::amdgcn:
  return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
case llvm::Triple::riscv32:
case llvm::Triple::riscv64:
  return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
}
1437}

1439ExprResult
1440Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
                             CallExpr *TheCall) {
ExprResult TheCallResult(TheCall);

// Find out if any arguments are required to be integer constant expressions.
unsigned ICEArguments = 0;
ASTContext::GetBuiltinTypeError Error;
Context.GetBuiltinType(BuiltinID, Error, &ICEArguments);
if (Error != ASTContext::GE_None)
  ICEArguments = 0;  // Don't diagnose previously diagnosed errors.

// If any arguments are required to be ICE's, check and diagnose.
for (unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
  // Skip arguments not required to be ICE's.
  if ((ICEArguments & (1 << ArgNo)) == 0) continue;

  llvm::APSInt Result;
  if (SemaBuiltinConstantArg(TheCall, ArgNo, Result))
    return true;
  ICEArguments &= ~(1 << ArgNo);
}

switch (BuiltinID) {
case Builtin::BI__builtin___CFStringMakeConstantString:
  assert(TheCall->getNumArgs() == 1 &&((void)0)
         "Wrong # arguments to builtin CFStringMakeConstantString")((void)0);
  if (CheckObjCString(TheCall->getArg(0)))
    return ExprError();
  break;
case Builtin::BI__builtin_ms_va_start:
case Builtin::BI__builtin_stdarg_start:
case Builtin::BI__builtin_va_start:
  if (SemaBuiltinVAStart(BuiltinID, TheCall))
    return ExprError();
  break;
case Builtin::BI__va_start: {
  switch (Context.getTargetInfo().getTriple().getArch()) {
  case llvm::Triple::aarch64:
  case llvm::Triple::arm:
  case llvm::Triple::thumb:
    if (SemaBuiltinVAStartARMMicrosoft(TheCall))
      return ExprError();
    break;
  default:
    if (SemaBuiltinVAStart(BuiltinID, TheCall))
      return ExprError();
    break;
  }
  break;
}

// The acquire, release, and no fence variants are ARM and AArch64 only.
case Builtin::BI_interlockedbittestandset_acq:
case Builtin::BI_interlockedbittestandset_rel:
case Builtin::BI_interlockedbittestandset_nf:
case Builtin::BI_interlockedbittestandreset_acq:
case Builtin::BI_interlockedbittestandreset_rel:
case Builtin::BI_interlockedbittestandreset_nf:
  if (CheckBuiltinTargetSupport(
          *this, BuiltinID, TheCall,
          {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
    return ExprError();
  break;

// The 64-bit bittest variants are x64, ARM, and AArch64 only.
case Builtin::BI_bittest64:
case Builtin::BI_bittestandcomplement64:
case Builtin::BI_bittestandreset64:
case Builtin::BI_bittestandset64:
case Builtin::BI_interlockedbittestandreset64:
case Builtin::BI_interlockedbittestandset64:
  if (CheckBuiltinTargetSupport(*this, BuiltinID, TheCall,
                                {llvm::Triple::x86_64, llvm::Triple::arm,
                                 llvm::Triple::thumb, llvm::Triple::aarch64}))
    return ExprError();
  break;

case Builtin::BI__builtin_isgreater:
case Builtin::BI__builtin_isgreaterequal:
case Builtin::BI__builtin_isless:
case Builtin::BI__builtin_islessequal:
case Builtin::BI__builtin_islessgreater:
case Builtin::BI__builtin_isunordered:
  if (SemaBuiltinUnorderedCompare(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_fpclassify:
  if (SemaBuiltinFPClassification(TheCall, 6))
    return ExprError();
  break;
case Builtin::BI__builtin_isfinite:
case Builtin::BI__builtin_isinf:
case Builtin::BI__builtin_isinf_sign:
case Builtin::BI__builtin_isnan:
case Builtin::BI__builtin_isnormal:
case Builtin::BI__builtin_signbit:
case Builtin::BI__builtin_signbitf:
case Builtin::BI__builtin_signbitl:
  if (SemaBuiltinFPClassification(TheCall, 1))
    return ExprError();
  break;
case Builtin::BI__builtin_shufflevector:
  return SemaBuiltinShuffleVector(TheCall);
  // TheCall will be freed by the smart pointer here, but that's fine, since
  // SemaBuiltinShuffleVector guts it, but then doesn't release it.
case Builtin::BI__builtin_prefetch:
  if (SemaBuiltinPrefetch(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_alloca_with_align:
  if (SemaBuiltinAllocaWithAlign(TheCall))
    return ExprError();
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case Builtin::BI__builtin_alloca:
  Diag(TheCall->getBeginLoc(), diag::warn_alloca)
      << TheCall->getDirectCallee();
  break;
case Builtin::BI__arithmetic_fence:
  if (SemaBuiltinArithmeticFence(TheCall))
    return ExprError();
  break;
case Builtin::BI__assume:
case Builtin::BI__builtin_assume:
  if (SemaBuiltinAssume(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_assume_aligned:
  if (SemaBuiltinAssumeAligned(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_dynamic_object_size:
case Builtin::BI__builtin_object_size:
  if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
    return ExprError();
  break;
case Builtin::BI__builtin_longjmp:
  if (SemaBuiltinLongjmp(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_setjmp:
  if (SemaBuiltinSetjmp(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_classify_type:
  if (checkArgCount(*this, TheCall, 1)) return true;
  TheCall->setType(Context.IntTy);
  break;
case Builtin::BI__builtin_complex:
  if (SemaBuiltinComplex(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_constant_p: {
  if (checkArgCount(*this, TheCall, 1)) return true;
  ExprResult Arg = DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
  if (Arg.isInvalid()) return true;
  TheCall->setArg(0, Arg.get());
  TheCall->setType(Context.IntTy);
  break;
}
case Builtin::BI__builtin_launder:
  return SemaBuiltinLaunder(*this, TheCall);
case Builtin::BI__sync_fetch_and_add:
case Builtin::BI__sync_fetch_and_add_1:
case Builtin::BI__sync_fetch_and_add_2:
case Builtin::BI__sync_fetch_and_add_4:
case Builtin::BI__sync_fetch_and_add_8:
case Builtin::BI__sync_fetch_and_add_16:
case Builtin::BI__sync_fetch_and_sub:
case Builtin::BI__sync_fetch_and_sub_1:
case Builtin::BI__sync_fetch_and_sub_2:
case Builtin::BI__sync_fetch_and_sub_4:
case Builtin::BI__sync_fetch_and_sub_8:
case Builtin::BI__sync_fetch_and_sub_16:
case Builtin::BI__sync_fetch_and_or:
case Builtin::BI__sync_fetch_and_or_1:
case Builtin::BI__sync_fetch_and_or_2:
case Builtin::BI__sync_fetch_and_or_4:
case Builtin::BI__sync_fetch_and_or_8:
case Builtin::BI__sync_fetch_and_or_16:
case Builtin::BI__sync_fetch_and_and:
case Builtin::BI__sync_fetch_and_and_1:
case Builtin::BI__sync_fetch_and_and_2:
case Builtin::BI__sync_fetch_and_and_4:
case Builtin::BI__sync_fetch_and_and_8:
case Builtin::BI__sync_fetch_and_and_16:
case Builtin::BI__sync_fetch_and_xor:
case Builtin::BI__sync_fetch_and_xor_1:
case Builtin::BI__sync_fetch_and_xor_2:
case Builtin::BI__sync_fetch_and_xor_4:
case Builtin::BI__sync_fetch_and_xor_8:
case Builtin::BI__sync_fetch_and_xor_16:
case Builtin::BI__sync_fetch_and_nand:
case Builtin::BI__sync_fetch_and_nand_1:
case Builtin::BI__sync_fetch_and_nand_2:
case Builtin::BI__sync_fetch_and_nand_4:
case Builtin::BI__sync_fetch_and_nand_8:
case Builtin::BI__sync_fetch_and_nand_16:
case Builtin::BI__sync_add_and_fetch:
case Builtin::BI__sync_add_and_fetch_1:
case Builtin::BI__sync_add_and_fetch_2:
case Builtin::BI__sync_add_and_fetch_4:
case Builtin::BI__sync_add_and_fetch_8:
case Builtin::BI__sync_add_and_fetch_16:
case Builtin::BI__sync_sub_and_fetch:
case Builtin::BI__sync_sub_and_fetch_1:
case Builtin::BI__sync_sub_and_fetch_2:
case Builtin::BI__sync_sub_and_fetch_4:
case Builtin::BI__sync_sub_and_fetch_8:
case Builtin::BI__sync_sub_and_fetch_16:
case Builtin::BI__sync_and_and_fetch:
case Builtin::BI__sync_and_and_fetch_1:
case Builtin::BI__sync_and_and_fetch_2:
case Builtin::BI__sync_and_and_fetch_4:
case Builtin::BI__sync_and_and_fetch_8:
case Builtin::BI__sync_and_and_fetch_16:
case Builtin::BI__sync_or_and_fetch:
case Builtin::BI__sync_or_and_fetch_1:
case Builtin::BI__sync_or_and_fetch_2:
case Builtin::BI__sync_or_and_fetch_4:
case Builtin::BI__sync_or_and_fetch_8:
case Builtin::BI__sync_or_and_fetch_16:
case Builtin::BI__sync_xor_and_fetch:
case Builtin::BI__sync_xor_and_fetch_1:
case Builtin::BI__sync_xor_and_fetch_2:
case Builtin::BI__sync_xor_and_fetch_4:
case Builtin::BI__sync_xor_and_fetch_8:
case Builtin::BI__sync_xor_and_fetch_16:
case Builtin::BI__sync_nand_and_fetch:
case Builtin::BI__sync_nand_and_fetch_1:
case Builtin::BI__sync_nand_and_fetch_2:
case Builtin::BI__sync_nand_and_fetch_4:
case Builtin::BI__sync_nand_and_fetch_8:
case Builtin::BI__sync_nand_and_fetch_16:
case Builtin::BI__sync_val_compare_and_swap:
case Builtin::BI__sync_val_compare_and_swap_1:
case Builtin::BI__sync_val_compare_and_swap_2:
case Builtin::BI__sync_val_compare_and_swap_4:
case Builtin::BI__sync_val_compare_and_swap_8:
case Builtin::BI__sync_val_compare_and_swap_16:
case Builtin::BI__sync_bool_compare_and_swap:
case Builtin::BI__sync_bool_compare_and_swap_1:
case Builtin::BI__sync_bool_compare_and_swap_2:
case Builtin::BI__sync_bool_compare_and_swap_4:
case Builtin::BI__sync_bool_compare_and_swap_8:
case Builtin::BI__sync_bool_compare_and_swap_16:
case Builtin::BI__sync_lock_test_and_set:
case Builtin::BI__sync_lock_test_and_set_1:
case Builtin::BI__sync_lock_test_and_set_2:
case Builtin::BI__sync_lock_test_and_set_4:
case Builtin::BI__sync_lock_test_and_set_8:
case Builtin::BI__sync_lock_test_and_set_16:
case Builtin::BI__sync_lock_release:
case Builtin::BI__sync_lock_release_1:
case Builtin::BI__sync_lock_release_2:
case Builtin::BI__sync_lock_release_4:
case Builtin::BI__sync_lock_release_8:
case Builtin::BI__sync_lock_release_16:
case Builtin::BI__sync_swap:
case Builtin::BI__sync_swap_1:
case Builtin::BI__sync_swap_2:
case Builtin::BI__sync_swap_4:
case Builtin::BI__sync_swap_8:
case Builtin::BI__sync_swap_16:
  return SemaBuiltinAtomicOverloaded(TheCallResult);
case Builtin::BI__sync_synchronize:
  Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst)
      << TheCall->getCallee()->getSourceRange();
  break;
case Builtin::BI__builtin_nontemporal_load:
case Builtin::BI__builtin_nontemporal_store:
  return SemaBuiltinNontemporalOverloaded(TheCallResult);
case Builtin::BI__builtin_memcpy_inline: {
  clang::Expr *SizeOp = TheCall->getArg(2);
  // We warn about copying to or from `nullptr` pointers when `size` is
  // greater than 0. When `size` is value dependent we cannot evaluate its
  // value so we bail out.
  if (SizeOp->isValueDependent())
    break;
  if (!SizeOp->EvaluateKnownConstInt(Context).isNullValue()) {
    CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
    CheckNonNullArgument(*this, TheCall->getArg(1), TheCall->getExprLoc());
  }
  break;
}
1724#define BUILTIN(ID, TYPE, ATTRS)
1725#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
case Builtin::BI##ID: \
  return SemaAtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
1728#include "clang/Basic/Builtins.def"
case Builtin::BI__annotation:
  if (SemaBuiltinMSVCAnnotation(*this, TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_annotation:
  if (SemaBuiltinAnnotation(*this, TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_addressof:
  if (SemaBuiltinAddressof(*this, TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_is_aligned:
case Builtin::BI__builtin_align_up:
case Builtin::BI__builtin_align_down:
  if (SemaBuiltinAlignment(*this, TheCall, BuiltinID))
    return ExprError();
  break;
case Builtin::BI__builtin_add_overflow:
case Builtin::BI__builtin_sub_overflow:
case Builtin::BI__builtin_mul_overflow:
  if (SemaBuiltinOverflow(*this, TheCall, BuiltinID))
    return ExprError();
  break;
case Builtin::BI__builtin_operator_new:
case Builtin::BI__builtin_operator_delete: {
  bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
  ExprResult Res =
      SemaBuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
  if (Res.isInvalid())
    CorrectDelayedTyposInExpr(TheCallResult.get());
  return Res;
}
case Builtin::BI__builtin_dump_struct: {
  // We first want to ensure we are called with 2 arguments
  if (checkArgCount(*this, TheCall, 2))
    return ExprError();
  // Ensure that the first argument is of type 'struct XX *'
  const Expr *PtrArg = TheCall->getArg(0)->IgnoreParenImpCasts();
  const QualType PtrArgType = PtrArg->getType();
  if (!PtrArgType->isPointerType() ||
      !PtrArgType->getPointeeType()->isRecordType()) {
    Diag(PtrArg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
        << PtrArgType << "structure pointer" << 1 << 0 << 3 << 1 << PtrArgType
        << "structure pointer";
    return ExprError();
  }

  // Ensure that the second argument is of type 'FunctionType'
  const Expr *FnPtrArg = TheCall->getArg(1)->IgnoreImpCasts();
  const QualType FnPtrArgType = FnPtrArg->getType();
  if (!FnPtrArgType->isPointerType()) {
    Diag(FnPtrArg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
        << FnPtrArgType << "'int (*)(const char *, ...)'" << 1 << 0 << 3 << 2
        << FnPtrArgType << "'int (*)(const char *, ...)'";
    return ExprError();
  }

  const auto *FuncType =
      FnPtrArgType->getPointeeType()->getAs<FunctionType>();

  if (!FuncType) {
    Diag(FnPtrArg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
        << FnPtrArgType << "'int (*)(const char *, ...)'" << 1 << 0 << 3 << 2
        << FnPtrArgType << "'int (*)(const char *, ...)'";
    return ExprError();
  }

  if (const auto *FT = dyn_cast<FunctionProtoType>(FuncType)) {
    if (!FT->getNumParams()) {
      Diag(FnPtrArg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
          << FnPtrArgType << "'int (*)(const char *, ...)'" << 1 << 0 << 3
          << 2 << FnPtrArgType << "'int (*)(const char *, ...)'";
      return ExprError();
    }
    QualType PT = FT->getParamType(0);
    if (!FT->isVariadic() || FT->getReturnType() != Context.IntTy ||
        !PT->isPointerType() || !PT->getPointeeType()->isCharType() ||
        !PT->getPointeeType().isConstQualified()) {
      Diag(FnPtrArg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
          << FnPtrArgType << "'int (*)(const char *, ...)'" << 1 << 0 << 3
          << 2 << FnPtrArgType << "'int (*)(const char *, ...)'";
      return ExprError();
    }
  }

  TheCall->setType(Context.IntTy);
  break;
}
case Builtin::BI__builtin_expect_with_probability: {
  // We first want to ensure we are called with 3 arguments
  if (checkArgCount(*this, TheCall, 3))
    return ExprError();
  // then check probability is constant float in range [0.0, 1.0]
  const Expr *ProbArg = TheCall->getArg(2);
  SmallVector<PartialDiagnosticAt, 8> Notes;
  Expr::EvalResult Eval;
  Eval.Diag = &Notes;
  if ((!ProbArg->EvaluateAsConstantExpr(Eval, Context)) ||
      !Eval.Val.isFloat()) {
    Diag(ProbArg->getBeginLoc(), diag::err_probability_not_constant_float)
        << ProbArg->getSourceRange();
    for (const PartialDiagnosticAt &PDiag : Notes)
      Diag(PDiag.first, PDiag.second);
    return ExprError();
  }
  llvm::APFloat Probability = Eval.Val.getFloat();
  bool LoseInfo = false;
  Probability.convert(llvm::APFloat::IEEEdouble(),
                      llvm::RoundingMode::Dynamic, &LoseInfo);
  if (!(Probability >= llvm::APFloat(0.0) &&
        Probability <= llvm::APFloat(1.0))) {
    Diag(ProbArg->getBeginLoc(), diag::err_probability_out_of_range)
        << ProbArg->getSourceRange();
    return ExprError();
  }
  break;
}
case Builtin::BI__builtin_preserve_access_index:
  if (SemaBuiltinPreserveAI(*this, TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_call_with_static_chain:
  if (SemaBuiltinCallWithStaticChain(*this, TheCall))
    return ExprError();
  break;
case Builtin::BI__exception_code:
case Builtin::BI_exception_code:
  if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHExceptScope,
                               diag::err_seh___except_block))
    return ExprError();
  break;
case Builtin::BI__exception_info:
case Builtin::BI_exception_info:
  if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHFilterScope,
                               diag::err_seh___except_filter))
    return ExprError();
  break;
case Builtin::BI__GetExceptionInfo:
  if (checkArgCount(*this, TheCall, 1))
    return ExprError();

  if (CheckCXXThrowOperand(
          TheCall->getBeginLoc(),
          Context.getExceptionObjectType(FDecl->getParamDecl(0)->getType()),
          TheCall))
    return ExprError();

  TheCall->setType(Context.VoidPtrTy);
  break;
// OpenCL v2.0, s6.13.16 - Pipe functions
case Builtin::BIread_pipe:
case Builtin::BIwrite_pipe:
  // Since those two functions are declared with var args, we need a semantic
  // check for the argument.
  if (SemaBuiltinRWPipe(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIreserve_read_pipe:
case Builtin::BIreserve_write_pipe:
case Builtin::BIwork_group_reserve_read_pipe:
case Builtin::BIwork_group_reserve_write_pipe:
  if (SemaBuiltinReserveRWPipe(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIsub_group_reserve_read_pipe:
case Builtin::BIsub_group_reserve_write_pipe:
  if (checkOpenCLSubgroupExt(*this, TheCall) ||
      SemaBuiltinReserveRWPipe(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIcommit_read_pipe:
case Builtin::BIcommit_write_pipe:
case Builtin::BIwork_group_commit_read_pipe:
case Builtin::BIwork_group_commit_write_pipe:
  if (SemaBuiltinCommitRWPipe(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIsub_group_commit_read_pipe:
case Builtin::BIsub_group_commit_write_pipe:
  if (checkOpenCLSubgroupExt(*this, TheCall) ||
      SemaBuiltinCommitRWPipe(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIget_pipe_num_packets:
case Builtin::BIget_pipe_max_packets:
  if (SemaBuiltinPipePackets(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIto_global:
case Builtin::BIto_local:
case Builtin::BIto_private:
  if (SemaOpenCLBuiltinToAddr(*this, BuiltinID, TheCall))
    return ExprError();
  break;
// OpenCL v2.0, s6.13.17 - Enqueue kernel functions.
case Builtin::BIenqueue_kernel:
  if (SemaOpenCLBuiltinEnqueueKernel(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIget_kernel_work_group_size:
case Builtin::BIget_kernel_preferred_work_group_size_multiple:
  if (SemaOpenCLBuiltinKernelWorkGroupSize(*this, TheCall))
    return ExprError();
  break;
case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
case Builtin::BIget_kernel_sub_group_count_for_ndrange:
  if (SemaOpenCLBuiltinNDRangeAndBlock(*this, TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_os_log_format:
  Cleanup.setExprNeedsCleanups(true);
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case Builtin::BI__builtin_os_log_format_buffer_size:
  if (SemaBuiltinOSLogFormat(TheCall))
    return ExprError();
  break;
case Builtin::BI__builtin_frame_address:
case Builtin::BI__builtin_return_address: {
  if (SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
    return ExprError();

  // -Wframe-address warning if non-zero passed to builtin
  // return/frame address.
  Expr::EvalResult Result;
  if (!TheCall->getArg(0)->isValueDependent() &&
      TheCall->getArg(0)->EvaluateAsInt(Result, getASTContext()) &&
      Result.Val.getInt() != 0)
    Diag(TheCall->getBeginLoc(), diag::warn_frame_address)
        << ((BuiltinID == Builtin::BI__builtin_return_address)
                ? "__builtin_return_address"
                : "__builtin_frame_address")
        << TheCall->getSourceRange();
  break;
}

case Builtin::BI__builtin_matrix_transpose:
  return SemaBuiltinMatrixTranspose(TheCall, TheCallResult);

case Builtin::BI__builtin_matrix_column_major_load:
  return SemaBuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);

case Builtin::BI__builtin_matrix_column_major_store:
  return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult);

case Builtin::BI__builtin_get_device_side_mangled_name: {
  auto Check = [](CallExpr *TheCall) {
    if (TheCall->getNumArgs() != 1)
      return false;
    auto *DRE = dyn_cast<DeclRefExpr>(TheCall->getArg(0)->IgnoreImpCasts());
    if (!DRE)
      return false;
    auto *D = DRE->getDecl();
    if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
      return false;
    return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
           D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
  };
  if (!Check(TheCall)) {
    Diag(TheCall->getBeginLoc(),
         diag::err_hip_invalid_args_builtin_mangled_name);
    return ExprError();
  }
}
}

// Since the target specific builtins for each arch overlap, only check those
// of the arch we are compiling for.
if (Context.BuiltinInfo.isTSBuiltin(BuiltinID)) {
  if (Context.BuiltinInfo.isAuxBuiltinID(BuiltinID)) {
    assert(Context.getAuxTargetInfo() &&((void)0)
           "Aux Target Builtin, but not an aux target?")((void)0);

    if (CheckTSBuiltinFunctionCall(
            *Context.getAuxTargetInfo(),
            Context.BuiltinInfo.getAuxBuiltinID(BuiltinID), TheCall))
      return ExprError();
  } else {
    if (CheckTSBuiltinFunctionCall(Context.getTargetInfo(), BuiltinID,
                                   TheCall))
      return ExprError();
  }
}

return TheCallResult;
2014}

2016// Get the valid immediate range for the specified NEON type code.
2017static unsigned RFT(unsigned t, bool shift = false, bool ForceQuad = false) {
NeonTypeFlags Type(t);
int IsQuad = ForceQuad ? true : Type.isQuad();
switch (Type.getEltType()) {
case NeonTypeFlags::Int8:
case NeonTypeFlags::Poly8:
  return shift ? 7 : (8 << IsQuad) - 1;
case NeonTypeFlags::Int16:
case NeonTypeFlags::Poly16:
  return shift ? 15 : (4 << IsQuad) - 1;
case NeonTypeFlags::Int32:
  return shift ? 31 : (2 << IsQuad) - 1;
case NeonTypeFlags::Int64:
case NeonTypeFlags::Poly64:
  return shift ? 63 : (1 << IsQuad) - 1;
case NeonTypeFlags::Poly128:
  return shift ? 127 : (1 << IsQuad) - 1;
case NeonTypeFlags::Float16:
  assert(!shift && "cannot shift float types!")((void)0);
  return (4 << IsQuad) - 1;
case NeonTypeFlags::Float32:
  assert(!shift && "cannot shift float types!")((void)0);
  return (2 << IsQuad) - 1;
case NeonTypeFlags::Float64:
  assert(!shift && "cannot shift float types!")((void)0);
  return (1 << IsQuad) - 1;
case NeonTypeFlags::BFloat16:
  assert(!shift && "cannot shift float types!")((void)0);
  return (4 << IsQuad) - 1;
}
llvm_unreachable("Invalid NeonTypeFlag!")__builtin_unreachable();
2048}

2050/// getNeonEltType - Return the QualType corresponding to the elements of
2051/// the vector type specified by the NeonTypeFlags.  This is used to check
2052/// the pointer arguments for Neon load/store intrinsics.
2053static QualType getNeonEltType(NeonTypeFlags Flags, ASTContext &Context,
                             bool IsPolyUnsigned, bool IsInt64Long) {
switch (Flags.getEltType()) {
case NeonTypeFlags::Int8:
  return Flags.isUnsigned() ? Context.UnsignedCharTy : Context.SignedCharTy;
case NeonTypeFlags::Int16:
  return Flags.isUnsigned() ? Context.UnsignedShortTy : Context.ShortTy;
case NeonTypeFlags::Int32:
  return Flags.isUnsigned() ? Context.UnsignedIntTy : Context.IntTy;
case NeonTypeFlags::Int64:
  if (IsInt64Long)
    return Flags.isUnsigned() ? Context.UnsignedLongTy : Context.LongTy;
  else
    return Flags.isUnsigned() ? Context.UnsignedLongLongTy
                              : Context.LongLongTy;
case NeonTypeFlags::Poly8:
  return IsPolyUnsigned ? Context.UnsignedCharTy : Context.SignedCharTy;
case NeonTypeFlags::Poly16:
  return IsPolyUnsigned ? Context.UnsignedShortTy : Context.ShortTy;
case NeonTypeFlags::Poly64:
  if (IsInt64Long)
    return Context.UnsignedLongTy;
  else
    return Context.UnsignedLongLongTy;
case NeonTypeFlags::Poly128:
  break;
case NeonTypeFlags::Float16:
  return Context.HalfTy;
case NeonTypeFlags::Float32:
  return Context.FloatTy;
case NeonTypeFlags::Float64:
  return Context.DoubleTy;
case NeonTypeFlags::BFloat16:
  return Context.BFloat16Ty;
}
llvm_unreachable("Invalid NeonTypeFlag!")__builtin_unreachable();
2089}

2091bool Sema::CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
// Range check SVE intrinsics that take immediate values.
SmallVector<std::tuple<int,int,int>, 3> ImmChecks;

switch (BuiltinID) {
default:
  return false;
2098#define GET_SVE_IMMEDIATE_CHECK
2099#include "clang/Basic/arm_sve_sema_rangechecks.inc"
2100#undef GET_SVE_IMMEDIATE_CHECK
}

// Perform all the immediate checks for this builtin call.
bool HasError = false;
for (auto &I : ImmChecks) {
  int ArgNum, CheckTy, ElementSizeInBits;
  std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;

  typedef bool(*OptionSetCheckFnTy)(int64_t Value);

  // Function that checks whether the operand (ArgNum) is an immediate
  // that is one of the predefined values.
  auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
                                 int ErrDiag) -> bool {
    // We can't check the value of a dependent argument.
    Expr *Arg = TheCall->getArg(ArgNum);
    if (Arg->isTypeDependent() || Arg->isValueDependent())
      return false;

    // Check constant-ness first.
    llvm::APSInt Imm;
    if (SemaBuiltinConstantArg(TheCall, ArgNum, Imm))
      return true;

    if (!CheckImm(Imm.getSExtValue()))
      return Diag(TheCall->getBeginLoc(), ErrDiag) << Arg->getSourceRange();
    return false;
  };

  switch ((SVETypeFlags::ImmCheckType)CheckTy) {
  case SVETypeFlags::ImmCheck0_31:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheck0_13:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheck1_16:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheck0_7:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckExtract:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
                                    (2048 / ElementSizeInBits) - 1))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckShiftRight:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckShiftRightNarrow:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1,
                                    ElementSizeInBits / 2))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckShiftLeft:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
                                    ElementSizeInBits - 1))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckLaneIndex:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
                                    (128 / (1 * ElementSizeInBits)) - 1))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckLaneIndexCompRotate:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
                                    (128 / (2 * ElementSizeInBits)) - 1))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckLaneIndexDot:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
                                    (128 / (4 * ElementSizeInBits)) - 1))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckComplexRot90_270:
    if (CheckImmediateInSet([](int64_t V) { return V == 90 || V == 270; },
                            diag::err_rotation_argument_to_cadd))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheckComplexRotAll90:
    if (CheckImmediateInSet(
            [](int64_t V) {
              return V == 0 || V == 90 || V == 180 || V == 270;
            },
            diag::err_rotation_argument_to_cmla))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheck0_1:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheck0_2:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
      HasError = true;
    break;
  case SVETypeFlags::ImmCheck0_3:
    if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
      HasError = true;
    break;
  }
}

return HasError;
2210}

2212bool Sema::CheckNeonBuiltinFunctionCall(const TargetInfo &TI,
                                      unsigned BuiltinID, CallExpr *TheCall) {
llvm::APSInt Result;
uint64_t mask = 0;
unsigned TV = 0;
int PtrArgNum = -1;
bool HasConstPtr = false;
switch (BuiltinID) {
2220#define GET_NEON_OVERLOAD_CHECK
2221#include "clang/Basic/arm_neon.inc"
2222#include "clang/Basic/arm_fp16.inc"
2223#undef GET_NEON_OVERLOAD_CHECK
}

// For NEON intrinsics which are overloaded on vector element type, validate
// the immediate which specifies which variant to emit.
unsigned ImmArg = TheCall->getNumArgs()-1;
if (mask) {
  if (SemaBuiltinConstantArg(TheCall, ImmArg, Result))
    return true;

  TV = Result.getLimitedValue(64);
  if ((TV > 63) || (mask & (1ULL << TV)) == 0)
    return Diag(TheCall->getBeginLoc(), diag::err_invalid_neon_type_code)
           << TheCall->getArg(ImmArg)->getSourceRange();
}

if (PtrArgNum >= 0) {
  // Check that pointer arguments have the specified type.
  Expr *Arg = TheCall->getArg(PtrArgNum);
  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg))
    Arg = ICE->getSubExpr();
  ExprResult RHS = DefaultFunctionArrayLvalueConversion(Arg);
  QualType RHSTy = RHS.get()->getType();

  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 = TI.getInt64Type() == TargetInfo::SignedLong;
  QualType EltTy =
      getNeonEltType(NeonTypeFlags(TV), Context, IsPolyUnsigned, IsInt64Long);
  if (HasConstPtr)
    EltTy = EltTy.withConst();
  QualType LHSTy = Context.getPointerType(EltTy);
  AssignConvertType ConvTy;
  ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
  if (RHS.isInvalid())
    return true;
  if (DiagnoseAssignmentResult(ConvTy, Arg->getBeginLoc(), LHSTy, RHSTy,
                               RHS.get(), AA_Assigning))
    return true;
}

// For NEON intrinsics which take an immediate value as part of the
// instruction, range check them here.
unsigned i = 0, l = 0, u = 0;
switch (BuiltinID) {
default:
  return false;
#define GET_NEON_IMMEDIATE_CHECK
#include "clang/Basic/arm_neon.inc"
#include "clang/Basic/arm_fp16.inc"
#undef GET_NEON_IMMEDIATE_CHECK
}

return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
2279}

2281bool Sema::CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
switch (BuiltinID) {
default:
  return false;
#include "clang/Basic/arm_mve_builtin_sema.inc"
}
2287}

2289bool Sema::CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                     CallExpr *TheCall) {
bool Err = false;
switch (BuiltinID) {
default:
  return false;
2295#include "clang/Basic/arm_cde_builtin_sema.inc"
}

if (Err)
  return true;

return CheckARMCoprocessorImmediate(TI, TheCall->getArg(0), /*WantCDE*/ true);
2302}

2304bool Sema::CheckARMCoprocessorImmediate(const TargetInfo &TI,
                                      const Expr *CoprocArg, bool WantCDE) {
if (isConstantEvaluated())
  return false;

// We can't check the value of a dependent argument.
if (CoprocArg->isTypeDependent() || CoprocArg->isValueDependent())
  return false;

llvm::APSInt CoprocNoAP = *CoprocArg->getIntegerConstantExpr(Context);
int64_t CoprocNo = CoprocNoAP.getExtValue();
assert(CoprocNo >= 0 && "Coprocessor immediate must be non-negative")((void)0);

uint32_t CDECoprocMask = TI.getARMCDECoprocMask();
bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));

if (IsCDECoproc != WantCDE)
  return Diag(CoprocArg->getBeginLoc(), diag::err_arm_invalid_coproc)
         << (int)CoprocNo << (int)WantCDE << CoprocArg->getSourceRange();

return false;
2325}

2327bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
                                      unsigned MaxWidth) {
assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||((void)0)
        BuiltinID == ARM::BI__builtin_arm_ldaex ||((void)0)
        BuiltinID == ARM::BI__builtin_arm_strex ||((void)0)
        BuiltinID == ARM::BI__builtin_arm_stlex ||((void)0)
        BuiltinID == AArch64::BI__builtin_arm_ldrex ||((void)0)
        BuiltinID == AArch64::BI__builtin_arm_ldaex ||((void)0)
        BuiltinID == AArch64::BI__builtin_arm_strex ||((void)0)
        BuiltinID == AArch64::BI__builtin_arm_stlex) &&((void)0)
       "unexpected ARM builtin")((void)0);
bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
               BuiltinID == ARM::BI__builtin_arm_ldaex ||
               BuiltinID == AArch64::BI__builtin_arm_ldrex ||
               BuiltinID == AArch64::BI__builtin_arm_ldaex;

DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());

// Ensure that we have the proper number of arguments.
if (checkArgCount(*this, TheCall, IsLdrex ? 1 : 2))
  return true;

// Inspect the pointer argument of the atomic builtin.  This should always be
// a pointer type, whose element is an integral scalar or pointer type.
// Because it is a pointer type, we don't have to worry about any implicit
// casts here.
Expr *PointerArg = TheCall->getArg(IsLdrex ? 0 : 1);
ExprResult PointerArgRes = DefaultFunctionArrayLvalueConversion(PointerArg);
if (PointerArgRes.isInvalid())
  return true;
PointerArg = PointerArgRes.get();

const PointerType *pointerType = PointerArg->getType()->getAs<PointerType>();
if (!pointerType) {
  Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_must_be_pointer)
      << PointerArg->getType() << PointerArg->getSourceRange();
  return true;
}

// ldrex takes a "const volatile T*" and strex takes a "volatile T*". Our next
// task is to insert the appropriate casts into the AST. First work out just
// what the appropriate type is.
QualType ValType = pointerType->getPointeeType();
QualType AddrType = ValType.getUnqualifiedType().withVolatile();
if (IsLdrex)
  AddrType.addConst();

// Issue a warning if the cast is dodgy.
CastKind CastNeeded = CK_NoOp;
if (!AddrType.isAtLeastAsQualifiedAs(ValType)) {
  CastNeeded = CK_BitCast;
  Diag(DRE->getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
      << PointerArg->getType() << Context.getPointerType(AddrType)
      << AA_Passing << PointerArg->getSourceRange();
}

// Finally, do the cast and replace the argument with the corrected version.
AddrType = Context.getPointerType(AddrType);
PointerArgRes = ImpCastExprToType(PointerArg, AddrType, CastNeeded);
if (PointerArgRes.isInvalid())
  return true;
PointerArg = PointerArgRes.get();

TheCall->setArg(IsLdrex ? 0 : 1, PointerArg);

// In general, we allow ints, floats and pointers to be loaded and stored.
if (!ValType->isIntegerType() && !ValType->isAnyPointerType() &&
    !ValType->isBlockPointerType() && !ValType->isFloatingType()) {
  Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
      << PointerArg->getType() << PointerArg->getSourceRange();
  return true;
}

// But ARM doesn't have instructions to deal with 128-bit versions.
if (Context.getTypeSize(ValType) > MaxWidth) {
  assert(MaxWidth == 64 && "Diagnostic unexpectedly inaccurate")((void)0);
  Diag(DRE->getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
      << PointerArg->getType() << PointerArg->getSourceRange();
  return true;
}

switch (ValType.getObjCLifetime()) {
case Qualifiers::OCL_None:
case Qualifiers::OCL_ExplicitNone:
  // okay
  break;

case Qualifiers::OCL_Weak:
case Qualifiers::OCL_Strong:
case Qualifiers::OCL_Autoreleasing:
  Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership)
      << ValType << PointerArg->getSourceRange();
  return true;
}

if (IsLdrex) {
  TheCall->setType(ValType);
  return false;
}

// Initialize the argument to be stored.
ExprResult ValArg = TheCall->getArg(0);
InitializedEntity Entity = InitializedEntity::InitializeParameter(
    Context, ValType, /*consume*/ false);
ValArg = PerformCopyInitialization(Entity, SourceLocation(), ValArg);
if (ValArg.isInvalid())
  return true;
TheCall->setArg(0, ValArg.get());

// __builtin_arm_strex always returns an int. It's marked as such in the .def,
// but the custom checker bypasses all default analysis.
TheCall->setType(Context.IntTy);
return false;
2440}

2442bool 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 ||
    BuiltinID == ARM::BI__builtin_arm_stlex) {
  return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
}

if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
    SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
}

if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
    BuiltinID == ARM::BI__builtin_arm_wsr64)
  return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3, false);

if (BuiltinID == ARM::BI__builtin_arm_rsr ||
    BuiltinID == ARM::BI__builtin_arm_rsrp ||
    BuiltinID == ARM::BI__builtin_arm_wsr ||
    BuiltinID == ARM::BI__builtin_arm_wsrp)
  return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);

if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
  return true;
if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
  return true;
if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
  return true;

// For intrinsics which take an immediate value as part of the instruction,
// range check them here.
// FIXME: VFP Intrinsics should error if VFP not present.
switch (BuiltinID) {
default: return false;
case ARM::BI__builtin_arm_ssat:
  return SemaBuiltinConstantArgRange(TheCall, 1, 1, 32);
case ARM::BI__builtin_arm_usat:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
case ARM::BI__builtin_arm_ssat16:
  return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
case ARM::BI__builtin_arm_usat16:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
case ARM::BI__builtin_arm_vcvtr_f:
case ARM::BI__builtin_arm_vcvtr_d:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
case ARM::BI__builtin_arm_dmb:
case ARM::BI__builtin_arm_dsb:
case ARM::BI__builtin_arm_isb:
case ARM::BI__builtin_arm_dbg:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15);
case ARM::BI__builtin_arm_cdp:
case ARM::BI__builtin_arm_cdp2:
case ARM::BI__builtin_arm_mcr:
case ARM::BI__builtin_arm_mcr2:
case ARM::BI__builtin_arm_mrc:
case ARM::BI__builtin_arm_mrc2:
case ARM::BI__builtin_arm_mcrr:
case ARM::BI__builtin_arm_mcrr2:
case ARM::BI__builtin_arm_mrrc:
case ARM::BI__builtin_arm_mrrc2:
case ARM::BI__builtin_arm_ldc:
case ARM::BI__builtin_arm_ldcl:
case ARM::BI__builtin_arm_ldc2:
case ARM::BI__builtin_arm_ldc2l:
case ARM::BI__builtin_arm_stc:
case ARM::BI__builtin_arm_stcl:
case ARM::BI__builtin_arm_stc2:
case ARM::BI__builtin_arm_stc2l:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15) ||
         CheckARMCoprocessorImmediate(TI, TheCall->getArg(0),
                                      /*WantCDE*/ false);
}
2516}

2518bool 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 ||
    BuiltinID == AArch64::BI__builtin_arm_stlex) {
  return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
}

if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
    SemaBuiltinConstantArgRange(TheCall, 2, 0, 2) ||
    SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
    SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
}

if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
    BuiltinID == AArch64::BI__builtin_arm_wsr64)
  return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);

// Memory Tagging Extensions (MTE) Intrinsics
if (BuiltinID == AArch64::BI__builtin_arm_irg ||
    BuiltinID == AArch64::BI__builtin_arm_addg ||
    BuiltinID == AArch64::BI__builtin_arm_gmi ||
    BuiltinID == AArch64::BI__builtin_arm_ldg ||
    BuiltinID == AArch64::BI__builtin_arm_stg ||
    BuiltinID == AArch64::BI__builtin_arm_subp) {
  return SemaBuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
}

if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
    BuiltinID == AArch64::BI__builtin_arm_rsrp ||
    BuiltinID == AArch64::BI__builtin_arm_wsr ||
    BuiltinID == AArch64::BI__builtin_arm_wsrp)
  return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);

// Only check the valid encoding range. Any constant in this range would be
// converted to a register of the form S1_2_C3_C4_5. Let the hardware throw
// an exception for incorrect registers. This matches MSVC behavior.
if (BuiltinID == AArch64::BI_ReadStatusReg ||
    BuiltinID == AArch64::BI_WriteStatusReg)
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);

if (BuiltinID == AArch64::BI__getReg)
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);

if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
  return true;

if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
  return true;

// For intrinsics which take an immediate value as part of the instruction,
// range check them here.
unsigned i = 0, l = 0, u = 0;
switch (BuiltinID) {
default: return false;
case AArch64::BI__builtin_arm_dmb:
case AArch64::BI__builtin_arm_dsb:
case AArch64::BI__builtin_arm_isb: l = 0; u = 15; break;
case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535; break;
}

return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
2583}

2585static bool isValidBPFPreserveFieldInfoArg(Expr *Arg) {
if (Arg->getType()->getAsPlaceholderType())
  return false;

// The first argument needs to be a record field access.
// If it is an array element access, we delay decision
// to BPF backend to check whether the access is a
// field access or not.
return (Arg->IgnoreParens()->getObjectKind() == OK_BitField ||
        dyn_cast<MemberExpr>(Arg->IgnoreParens()) ||
        dyn_cast<ArraySubscriptExpr>(Arg->IgnoreParens()));
2596}

2598static bool isEltOfVectorTy(ASTContext &Context, CallExpr *Call, Sema &S,
                          QualType VectorTy, QualType EltTy) {
QualType VectorEltTy = VectorTy->castAs<VectorType>()->getElementType();
if (!Context.hasSameType(VectorEltTy, EltTy)) {
  S.Diag(Call->getBeginLoc(), diag::err_typecheck_call_different_arg_types)
      << Call->getSourceRange() << VectorEltTy << EltTy;
  return false;
}
return true;
2607}

2609static bool isValidBPFPreserveTypeInfoArg(Expr *Arg) {
QualType ArgType = Arg->getType();
if (ArgType->getAsPlaceholderType())
  return false;

// for TYPE_EXISTENCE/TYPE_SIZEOF reloc type
// format:
//   1. __builtin_preserve_type_info(*(<type> *)0, flag);
//   2. <type> var;
//      __builtin_preserve_type_info(var, flag);
if (!dyn_cast<DeclRefExpr>(Arg->IgnoreParens()) &&
    !dyn_cast<UnaryOperator>(Arg->IgnoreParens()))
  return false;

// Typedef type.
if (ArgType->getAs<TypedefType>())
  return true;

// Record type or Enum type.
const Type *Ty = ArgType->getUnqualifiedDesugaredType();
if (const auto *RT = Ty->getAs<RecordType>()) {
  if (!RT->getDecl()->getDeclName().isEmpty())
    return true;
} else if (const auto *ET = Ty->getAs<EnumType>()) {
  if (!ET->getDecl()->getDeclName().isEmpty())
    return true;
}

return false;
2638}

2640static bool isValidBPFPreserveEnumValueArg(Expr *Arg) {
QualType ArgType = Arg->getType();
if (ArgType->getAsPlaceholderType())
  return false;

// for ENUM_VALUE_EXISTENCE/ENUM_VALUE reloc type
// format:
//   __builtin_preserve_enum_value(*(<enum_type> *)<enum_value>,
//                                 flag);
const auto *UO = dyn_cast<UnaryOperator>(Arg->IgnoreParens());
if (!UO)
  return false;

const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
if (!CE)
  return false;
if (CE->getCastKind() != CK_IntegralToPointer &&
    CE->getCastKind() != CK_NullToPointer)
  return false;

// The integer must be from an EnumConstantDecl.
const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
if (!DR)
  return false;

const EnumConstantDecl *Enumerator =
    dyn_cast<EnumConstantDecl>(DR->getDecl());
if (!Enumerator)
  return false;

// The type must be EnumType.
const Type *Ty = ArgType->getUnqualifiedDesugaredType();
const auto *ET = Ty->getAs<EnumType>();
if (!ET)
  return false;

// The enum value must be supported.
for (auto *EDI : ET->getDecl()->enumerators()) {
  if (EDI == Enumerator)
    return true;
}

return false;
2683}

2685bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID,
                                     CallExpr *TheCall) {
assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||((void)0)
        BuiltinID == BPF::BI__builtin_btf_type_id ||((void)0)
        BuiltinID == BPF::BI__builtin_preserve_type_info ||((void)0)
        BuiltinID == BPF::BI__builtin_preserve_enum_value) &&((void)0)
       "unexpected BPF builtin")((void)0);

if (checkArgCount(*this, TheCall, 2))
  return true;

// The second argument needs to be a constant int
Expr *Arg = TheCall->getArg(1);
Optional<llvm::APSInt> Value = Arg->getIntegerConstantExpr(Context);
diag::kind kind;
if (!Value) {
  if (BuiltinID == BPF::BI__builtin_preserve_field_info)
    kind = diag::err_preserve_field_info_not_const;
  else if (BuiltinID == BPF::BI__builtin_btf_type_id)
    kind = diag::err_btf_type_id_not_const;
  else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
    kind = diag::err_preserve_type_info_not_const;
  else
    kind = diag::err_preserve_enum_value_not_const;
  Diag(Arg->getBeginLoc(), kind) << 2 << Arg->getSourceRange();
  return true;
}

// The first argument
Arg = TheCall->getArg(0);
bool InvalidArg = false;
bool ReturnUnsignedInt = true;
if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
  if (!isValidBPFPreserveFieldInfoArg(Arg)) {
    InvalidArg = true;
    kind = diag::err_preserve_field_info_not_field;
  }
} else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
  if (!isValidBPFPreserveTypeInfoArg(Arg)) {
    InvalidArg = true;
    kind = diag::err_preserve_type_info_invalid;
  }
} else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
  if (!isValidBPFPreserveEnumValueArg(Arg)) {
    InvalidArg = true;
    kind = diag::err_preserve_enum_value_invalid;
  }
  ReturnUnsignedInt = false;
} else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
  ReturnUnsignedInt = false;
}

if (InvalidArg) {
  Diag(Arg->getBeginLoc(), kind) << 1 << Arg->getSourceRange();
  return true;
}

if (ReturnUnsignedInt)
  TheCall->setType(Context.UnsignedIntTy);
else
  TheCall->setType(Context.UnsignedLongTy);
return false;
2747}

2749bool Sema::CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
struct ArgInfo {
  uint8_t OpNum;
  bool IsSigned;
  uint8_t BitWidth;
  uint8_t Align;
};
struct BuiltinInfo {
  unsigned BuiltinID;
  ArgInfo Infos[2];
};

static BuiltinInfo Infos[] = {
  { Hexagon::BI__builtin_circ_ldd,                  {{ 3, true,  4,  3 }} },
  { Hexagon::BI__builtin_circ_ldw,                  {{ 3, true,  4,  2 }} },
  { Hexagon::BI__builtin_circ_ldh,                  {{ 3, true,  4,  1 }} },
  { Hexagon::BI__builtin_circ_lduh,                 {{ 3, true,  4,  1 }} },
  { Hexagon::BI__builtin_circ_ldb,                  {{ 3, true,  4,  0 }} },
  { Hexagon::BI__builtin_circ_ldub,                 {{ 3, true,  4,  0 }} },
  { Hexagon::BI__builtin_circ_std,                  {{ 3, true,  4,  3 }} },
  { Hexagon::BI__builtin_circ_stw,                  {{ 3, true,  4,  2 }} },
  { Hexagon::BI__builtin_circ_sth,                  {{ 3, true,  4,  1 }} },
  { Hexagon::BI__builtin_circ_sthhi,                {{ 3, true,  4,  1 }} },
  { Hexagon::BI__builtin_circ_stb,                  {{ 3, true,  4,  0 }} },

  { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci,    {{ 1, true,  4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci,     {{ 1, true,  4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci,    {{ 1, true,  4,  1 }} },
  { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci,     {{ 1, true,  4,  1 }} },
  { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci,     {{ 1, true,  4,  2 }} },
  { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci,     {{ 1, true,  4,  3 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci,    {{ 1, true,  4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci,    {{ 1, true,  4,  1 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci,    {{ 1, true,  4,  1 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci,    {{ 1, true,  4,  2 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci,    {{ 1, true,  4,  3 }} },

  { Hexagon::BI__builtin_HEXAGON_A2_combineii,      {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A2_tfrih,          {{ 1, false, 16, 0 }} },
  { Hexagon::BI__builtin_HEXAGON_A2_tfril,          {{ 1, false, 16, 0 }} },
  { Hexagon::BI__builtin_HEXAGON_A2_tfrpi,          {{ 0, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_bitspliti,      {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi,        {{ 1, false, 8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti,        {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_cround_ri,      {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_round_ri,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat,   {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi,       {{ 1, false, 8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti,       {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui,      {{ 1, false, 7,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi,       {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti,       {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui,      {{ 1, false, 7,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi,       {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti,       {{ 1, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui,      {{ 1, false, 7,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_C2_bitsclri,       {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_C2_muxii,          {{ 2, true,  8,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri,      {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_F2_dfclass,        {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n,        {{ 0, false, 10, 0 }} },
  { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p,        {{ 0, false, 10, 0 }} },
  { Hexagon::BI__builtin_HEXAGON_F2_sfclass,        {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n,        {{ 0, false, 10, 0 }} },
  { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p,        {{ 0, false, 10, 0 }} },
  { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi,     {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2,  {{ 1, false, 6,  2 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri,    {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p,        {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or,     {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc,   {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r,        {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or,     {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat,    {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc,   {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh,       {{ 1, false, 4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p,        {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or,     {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
                                                    {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd,    {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r,        {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or,     {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
                                                    {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd,    {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh,       {{ 1, false, 4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_extractu,       {{ 1, false, 5,  0 },
                                                     { 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_extractup,      {{ 1, false, 6,  0 },
                                                     { 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_insert,         {{ 2, false, 5,  0 },
                                                     { 3, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_insertp,        {{ 2, false, 6,  0 },
                                                     { 3, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p,        {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or,     {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc,   {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r,        {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or,     {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc,   {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh,       {{ 1, false, 4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_setbit_i,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
                                                    {{ 2, false, 4,  0 },
                                                     { 3, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
                                                    {{ 2, false, 4,  0 },
                                                     { 3, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
                                                    {{ 2, false, 4,  0 },
                                                     { 3, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
                                                    {{ 2, false, 4,  0 },
                                                     { 3, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i,    {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i,       {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_valignib,       {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S2_vspliceib,      {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_clbaddi,        {{ 1, true , 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi,       {{ 1, true,  6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_extract,        {{ 1, false, 5,  0 },
                                                     { 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_extractp,       {{ 1, false, 6,  0 },
                                                     { 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_lsli,           {{ 0, true,  6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i,      {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri,     {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri,     {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc,  {{ 3, false, 2,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate,      {{ 2, false, 2,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
                                                    {{ 1, false, 4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat,     {{ 1, false, 4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
                                                    {{ 1, false, 4,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p,        {{ 1, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac,    {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or,     {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc,   {{ 2, false, 6,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r,        {{ 1, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac,    {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or,     {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc,   {{ 2, false, 5,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_valignbi,       {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B,  {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi,      {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2, false, 3,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi,      {{ 2, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc,  {{ 3, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
                                                    {{ 3, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi,       {{ 2, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B,  {{ 2, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc,   {{ 3, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
                                                    {{ 3, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi,       {{ 2, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B,  {{ 2, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc,   {{ 3, false, 1,  0 }} },
  { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
                                                    {{ 3, false, 1,  0 }} },
};

// Use a dynamically initialized static to sort the table exactly once on
// first run.
static const bool SortOnce =
    (llvm::sort(Infos,
               [](const BuiltinInfo &LHS, const BuiltinInfo &RHS) {
                 return LHS.BuiltinID < RHS.BuiltinID;
               }),
     true);
(void)SortOnce;

const BuiltinInfo *F = llvm::partition_point(
    Infos, [=](const BuiltinInfo &BI) { return BI.BuiltinID < BuiltinID; });
if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
  return false;

bool Error = false;

for (const ArgInfo &A : F->Infos) {
  // Ignore empty ArgInfo elements.
  if (A.BitWidth == 0)
    continue;

  int32_t Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
  int32_t Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
  if (!A.Align) {
    Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
  } else {
    unsigned M = 1 << A.Align;
    Min *= M;
    Max *= M;
    Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max) |
             SemaBuiltinConstantArgMultiple(TheCall, A.OpNum, M);
  }
}
return Error;
2982}

2984bool Sema::CheckHexagonBuiltinFunctionCall(unsigned BuiltinID,
                                         CallExpr *TheCall) {
return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
2987}

2989bool Sema::CheckMipsBuiltinFunctionCall(const TargetInfo &TI,
                                      unsigned BuiltinID, CallExpr *TheCall) {
return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
       CheckMipsBuiltinArgument(BuiltinID, TheCall);
2993}

2995bool Sema::CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,
                             CallExpr *TheCall) {

if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
    BuiltinID <= Mips::BI__builtin_mips_lwx) {
  if (!TI.hasFeature("dsp"))
    return Diag(TheCall->getBeginLoc(), diag::err_mips_builtin_requires_dsp);
}

if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
    BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
  if (!TI.hasFeature("dspr2"))
    return Diag(TheCall->getBeginLoc(),
                diag::err_mips_builtin_requires_dspr2);
}

if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
    BuiltinID <= Mips::BI__builtin_msa_xori_b) {
  if (!TI.hasFeature("msa"))
    return Diag(TheCall->getBeginLoc(), diag::err_mips_builtin_requires_msa);
}

return false;
3018}

3020// CheckMipsBuiltinArgument - Checks the constant value passed to the
3021// intrinsic is correct. The switch statement is ordered by DSP, MSA. The
3022// ordering for DSP is unspecified. MSA is ordered by the data format used
3023// by the underlying instruction i.e., df/m, df/n and then by size.
3024//
3025// FIXME: The size tests here should instead be tablegen'd along with the
3026//        definitions from include/clang/Basic/BuiltinsMips.def.
3027// FIXME: GCC is strict on signedness for some of these intrinsics, we should
3028//        be too.
3029bool Sema::CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
unsigned i = 0, l = 0, u = 0, m = 0;
switch (BuiltinID) {
default: return false;
case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63; break;
case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63; break;
case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31; break;
case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3; break;
case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31; break;
case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31; break;
case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31; break;
// MSA intrinsics. Instructions (which the intrinsics maps to) which use the
// df/m field.
// These intrinsics take an unsigned 3 bit immediate.
case Mips::BI__builtin_msa_bclri_b:
case Mips::BI__builtin_msa_bnegi_b:
case Mips::BI__builtin_msa_bseti_b:
case Mips::BI__builtin_msa_sat_s_b:
case Mips::BI__builtin_msa_sat_u_b:
case Mips::BI__builtin_msa_slli_b:
case Mips::BI__builtin_msa_srai_b:
case Mips::BI__builtin_msa_srari_b:
case Mips::BI__builtin_msa_srli_b:
case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7; break;
case Mips::BI__builtin_msa_binsli_b:
case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7; break;
// These intrinsics take an unsigned 4 bit immediate.
case Mips::BI__builtin_msa_bclri_h:
case Mips::BI__builtin_msa_bnegi_h:
case Mips::BI__builtin_msa_bseti_h:
case Mips::BI__builtin_msa_sat_s_h:
case Mips::BI__builtin_msa_sat_u_h:
case Mips::BI__builtin_msa_slli_h:
case Mips::BI__builtin_msa_srai_h:
case Mips::BI__builtin_msa_srari_h:
case Mips::BI__builtin_msa_srli_h:
case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15; break;
case Mips::BI__builtin_msa_binsli_h:
case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15; break;
// These intrinsics take an unsigned 5 bit immediate.
// The first block of intrinsics actually have an unsigned 5 bit field,
// not a df/n field.
case Mips::BI__builtin_msa_cfcmsa:
case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31; break;
case Mips::BI__builtin_msa_clei_u_b:
case Mips::BI__builtin_msa_clei_u_h:
case Mips::BI__builtin_msa_clei_u_w:
case Mips::BI__builtin_msa_clei_u_d:
case Mips::BI__builtin_msa_clti_u_b:
case Mips::BI__builtin_msa_clti_u_h:
case Mips::BI__builtin_msa_clti_u_w:
case Mips::BI__builtin_msa_clti_u_d:
case Mips::BI__builtin_msa_maxi_u_b:
case Mips::BI__builtin_msa_maxi_u_h:
case Mips::BI__builtin_msa_maxi_u_w:
case Mips::BI__builtin_msa_maxi_u_d:
case Mips::BI__builtin_msa_mini_u_b:
case Mips::BI__builtin_msa_mini_u_h:
case Mips::BI__builtin_msa_mini_u_w:
case Mips::BI__builtin_msa_mini_u_d:
case Mips::BI__builtin_msa_addvi_b:
case Mips::BI__builtin_msa_addvi_h:
case Mips::BI__builtin_msa_addvi_w:
case Mips::BI__builtin_msa_addvi_d:
case Mips::BI__builtin_msa_bclri_w:
case Mips::BI__builtin_msa_bnegi_w:
case Mips::BI__builtin_msa_bseti_w:
case Mips::BI__builtin_msa_sat_s_w:
case Mips::BI__builtin_msa_sat_u_w:
case Mips::BI__builtin_msa_slli_w:
case Mips::BI__builtin_msa_srai_w:
case Mips::BI__builtin_msa_srari_w:
case Mips::BI__builtin_msa_srli_w:
case Mips::BI__builtin_msa_srlri_w:
case Mips::BI__builtin_msa_subvi_b:
case Mips::BI__builtin_msa_subvi_h:
case Mips::BI__builtin_msa_subvi_w:
case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31; break;
case Mips::BI__builtin_msa_binsli_w:
case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31; break;
// These intrinsics take an unsigned 6 bit immediate.
case Mips::BI__builtin_msa_bclri_d:
case Mips::BI__builtin_msa_bnegi_d:
case Mips::BI__builtin_msa_bseti_d:
case Mips::BI__builtin_msa_sat_s_d:
case Mips::BI__builtin_msa_sat_u_d:
case Mips::BI__builtin_msa_slli_d:
case Mips::BI__builtin_msa_srai_d:
case Mips::BI__builtin_msa_srari_d:
case Mips::BI__builtin_msa_srli_d:
case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63; break;
case Mips::BI__builtin_msa_binsli_d:
case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63; break;
// These intrinsics take a signed 5 bit immediate.
case Mips::BI__builtin_msa_ceqi_b:
case Mips::BI__builtin_msa_ceqi_h:
case Mips::BI__builtin_msa_ceqi_w:
case Mips::BI__builtin_msa_ceqi_d:
case Mips::BI__builtin_msa_clti_s_b:
case Mips::BI__builtin_msa_clti_s_h:
case Mips::BI__builtin_msa_clti_s_w:
case Mips::BI__builtin_msa_clti_s_d:
case Mips::BI__builtin_msa_clei_s_b:
case Mips::BI__builtin_msa_clei_s_h:
case Mips::BI__builtin_msa_clei_s_w:
case Mips::BI__builtin_msa_clei_s_d:
case Mips::BI__builtin_msa_maxi_s_b:
case Mips::BI__builtin_msa_maxi_s_h:
case Mips::BI__builtin_msa_maxi_s_w:
case Mips::BI__builtin_msa_maxi_s_d:
case Mips::BI__builtin_msa_mini_s_b:
case Mips::BI__builtin_msa_mini_s_h:
case Mips::BI__builtin_msa_mini_s_w:
case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15; break;
// These intrinsics take an unsigned 8 bit immediate.
case Mips::BI__builtin_msa_andi_b:
case Mips::BI__builtin_msa_nori_b:
case Mips::BI__builtin_msa_ori_b:
case Mips::BI__builtin_msa_shf_b:
case Mips::BI__builtin_msa_shf_h:
case Mips::BI__builtin_msa_shf_w:
case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255; break;
case Mips::BI__builtin_msa_bseli_b:
case Mips::BI__builtin_msa_bmnzi_b:
case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255; break;
// df/n format
// These intrinsics take an unsigned 4 bit immediate.
case Mips::BI__builtin_msa_copy_s_b:
case Mips::BI__builtin_msa_copy_u_b:
case Mips::BI__builtin_msa_insve_b:
case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15; break;
case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15; break;
// These intrinsics take an unsigned 3 bit immediate.
case Mips::BI__builtin_msa_copy_s_h:
case Mips::BI__builtin_msa_copy_u_h:
case Mips::BI__builtin_msa_insve_h:
case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7; break;
case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7; break;
// These intrinsics take an unsigned 2 bit immediate.
case Mips::BI__builtin_msa_copy_s_w:
case Mips::BI__builtin_msa_copy_u_w:
case Mips::BI__builtin_msa_insve_w:
case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3; break;
case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3; break;
// These intrinsics take an unsigned 1 bit immediate.
case Mips::BI__builtin_msa_copy_s_d:
case Mips::BI__builtin_msa_copy_u_d:
case Mips::BI__builtin_msa_insve_d:
case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1; break;
case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1; break;
// Memory offsets and immediate loads.
// These intrinsics take a signed 10 bit immediate.
case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255; break;
case Mips::BI__builtin_msa_ldi_h:
case Mips::BI__builtin_msa_ldi_w:
case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511; break;
case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1; break;
case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2; break;
case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4; break;
case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8; break;
case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8; break;
case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4; break;
case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1; break;
case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2; break;
case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4; break;
case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8; break;
case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8; break;
case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4; break;
}

if (!m)
  return SemaBuiltinConstantArgRange(TheCall, i, l, u);

return SemaBuiltinConstantArgRange(TheCall, i, l, u) ||
       SemaBuiltinConstantArgMultiple(TheCall, i, m);
3204}

3206/// DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str,
3207/// advancing the pointer over the consumed characters. The decoded type is
3208/// returned. If the decoded type represents a constant integer with a
3209/// constraint on its value then Mask is set to that value. The type descriptors
3210/// used in Str are specific to PPC MMA builtins and are documented in the file
3211/// defining the PPC builtins.
3212static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str,
                                      unsigned &Mask) {
bool RequireICE = false;
ASTContext::GetBuiltinTypeError Error = ASTContext::GE_None;
switch (*Str++) {
case 'V':
  return Context.getVectorType(Context.UnsignedCharTy, 16,
                               VectorType::VectorKind::AltiVecVector);
case 'i': {
  char *End;
  unsigned size = strtoul(Str, &End, 10);
  assert(End != Str && "Missing constant parameter constraint")((void)0);
  Str = End;
  Mask = size;
  return Context.IntTy;
}
case 'W': {
  char *End;
  unsigned size = strtoul(Str, &End, 10);
  assert(End != Str && "Missing PowerPC MMA type size")((void)0);
  Str = End;
  QualType Type;
  switch (size) {
#define PPC_VECTOR_TYPE(typeName, Id, size) \
  case size: Type = Context.Id##Ty; break;
#include "clang/Basic/PPCTypes.def"
  default: llvm_unreachable("Invalid PowerPC MMA vector type")__builtin_unreachable();
  }
  bool CheckVectorArgs = false;
  while (!CheckVectorArgs) {
    switch (*Str++) {
    case '*':
      Type = Context.getPointerType(Type);
      break;
    case 'C':
      Type = Type.withConst();
      break;
    default:
      CheckVectorArgs = true;
      --Str;
      break;
    }
  }
  return Type;
}
default:
  return Context.DecodeTypeStr(--Str, Context, Error, RequireICE, true);
}
3260}

3262static bool isPPC_64Builtin(unsigned BuiltinID) {
// These builtins only work on PPC 64bit targets.
switch (BuiltinID) {
case PPC::BI__builtin_divde:
case PPC::BI__builtin_divdeu:
case PPC::BI__builtin_bpermd:
case PPC::BI__builtin_ppc_ldarx:
case PPC::BI__builtin_ppc_stdcx:
case PPC::BI__builtin_ppc_tdw:
case PPC::BI__builtin_ppc_trapd:
case PPC::BI__builtin_ppc_cmpeqb:
case PPC::BI__builtin_ppc_setb:
case PPC::BI__builtin_ppc_mulhd:
case PPC::BI__builtin_ppc_mulhdu:
case PPC::BI__builtin_ppc_maddhd:
case PPC::BI__builtin_ppc_maddhdu:
case PPC::BI__builtin_ppc_maddld:
case PPC::BI__builtin_ppc_load8r:
case PPC::BI__builtin_ppc_store8r:
case PPC::BI__builtin_ppc_insert_exp:
case PPC::BI__builtin_ppc_extract_sig:
  return true;
}
return false;
3286}

3288static bool SemaFeatureCheck(Sema &S, CallExpr *TheCall,
                           StringRef FeatureToCheck, unsigned DiagID,
                           StringRef DiagArg = "") {
if (S.Context.getTargetInfo().hasFeature(FeatureToCheck))
  return false;

if (DiagArg.empty())
  S.Diag(TheCall->getBeginLoc(), DiagID) << TheCall->getSourceRange();
else
  S.Diag(TheCall->getBeginLoc(), DiagID)
      << DiagArg << TheCall->getSourceRange();

return true;
3301}

3303/// Returns true if the argument consists of one contiguous run of 1s with any
3304/// number of 0s on either side. The 1s are allowed to wrap from LSB to MSB, so
3305/// 0x000FFF0, 0x0000FFFF, 0xFF0000FF, 0x0 are all runs. 0x0F0F0000 is not,
3306/// since all 1s are not contiguous.
3307bool Sema::SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum) {
llvm::APSInt Result;
// We can't check the value of a dependent argument.
Expr *Arg = TheCall->getArg(ArgNum);
if (Arg->isTypeDependent() || Arg->isValueDependent())
  return false;

// Check constant-ness first.
if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
  return true;

// Check contiguous run of 1s, 0xFF0000FF is also a run of 1s.
if (Result.isShiftedMask() || (~Result).isShiftedMask())
  return false;

return Diag(TheCall->getBeginLoc(),
            diag::err_argument_not_contiguous_bit_field)
       << ArgNum << Arg->getSourceRange();
3325}

3327bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                     CallExpr *TheCall) {
unsigned i = 0, l = 0, u = 0;
bool IsTarget64Bit = TI.getTypeWidth(TI.getIntPtrType()) == 64;
llvm::APSInt Result;

if (isPPC_64Builtin(BuiltinID) && !IsTarget64Bit)
  return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
         << TheCall->getSourceRange();

switch (BuiltinID) {
default: return false;
case PPC::BI__builtin_altivec_crypto_vshasigmaw:
case PPC::BI__builtin_altivec_crypto_vshasigmad:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
         SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
case PPC::BI__builtin_altivec_dss:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
case PPC::BI__builtin_tbegin:
case PPC::BI__builtin_tend: i = 0; l = 0; u = 1; break;
case PPC::BI__builtin_tsr: i = 0; l = 0; u = 7; break;
case PPC::BI__builtin_tabortwc:
case PPC::BI__builtin_tabortdc: i = 0; l = 0; u = 31; break;
case PPC::BI__builtin_tabortwci:
case PPC::BI__builtin_tabortdci:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
         SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
case PPC::BI__builtin_altivec_dst:
case PPC::BI__builtin_altivec_dstt:
case PPC::BI__builtin_altivec_dstst:
case PPC::BI__builtin_altivec_dststt:
  return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
case PPC::BI__builtin_vsx_xxpermdi:
case PPC::BI__builtin_vsx_xxsldwi:
  return SemaBuiltinVSX(TheCall);
case PPC::BI__builtin_divwe:
case PPC::BI__builtin_divweu:
case PPC::BI__builtin_divde:
case PPC::BI__builtin_divdeu:
  return SemaFeatureCheck(*this, TheCall, "extdiv",
                          diag::err_ppc_builtin_only_on_arch, "7");
case PPC::BI__builtin_bpermd:
  return SemaFeatureCheck(*this, TheCall, "bpermd",
                          diag::err_ppc_builtin_only_on_arch, "7");
case PPC::BI__builtin_unpack_vector_int128:
  return SemaFeatureCheck(*this, TheCall, "vsx",
                          diag::err_ppc_builtin_only_on_arch, "7") ||
         SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
case PPC::BI__builtin_pack_vector_int128:
  return SemaFeatureCheck(*this, TheCall, "vsx",
                          diag::err_ppc_builtin_only_on_arch, "7");
case PPC::BI__builtin_altivec_vgnb:
   return SemaBuiltinConstantArgRange(TheCall, 1, 2, 7);
case PPC::BI__builtin_altivec_vec_replace_elt:
case PPC::BI__builtin_altivec_vec_replace_unaligned: {
  QualType VecTy = TheCall->getArg(0)->getType();
  QualType EltTy = TheCall->getArg(1)->getType();
  unsigned Width = Context.getIntWidth(EltTy);
  return SemaBuiltinConstantArgRange(TheCall, 2, 0, Width == 32 ? 12 : 8) ||
         !isEltOfVectorTy(Context, TheCall, *this, VecTy, EltTy);
}
case PPC::BI__builtin_vsx_xxeval:
   return SemaBuiltinConstantArgRange(TheCall, 3, 0, 255);
case PPC::BI__builtin_altivec_vsldbi:
   return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
case PPC::BI__builtin_altivec_vsrdbi:
   return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
case PPC::BI__builtin_vsx_xxpermx:
   return SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
case PPC::BI__builtin_ppc_tw:
case PPC::BI__builtin_ppc_tdw:
  return SemaBuiltinConstantArgRange(TheCall, 2, 1, 31);
case PPC::BI__builtin_ppc_cmpeqb:
case PPC::BI__builtin_ppc_setb:
case PPC::BI__builtin_ppc_maddhd:
case PPC::BI__builtin_ppc_maddhdu:
case PPC::BI__builtin_ppc_maddld:
  return SemaFeatureCheck(*this, TheCall, "isa-v30-instructions",
                          diag::err_ppc_builtin_only_on_arch, "9");
case PPC::BI__builtin_ppc_cmprb:
  return SemaFeatureCheck(*this, TheCall, "isa-v30-instructions",
                          diag::err_ppc_builtin_only_on_arch, "9") ||
         SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
// For __rlwnm, __rlwimi and __rldimi, the last parameter mask must
// be a constant that represents a contiguous bit field.
case PPC::BI__builtin_ppc_rlwnm:
  return SemaBuiltinConstantArg(TheCall, 1, Result) ||
         SemaValueIsRunOfOnes(TheCall, 2);
case PPC::BI__builtin_ppc_rlwimi:
case PPC::BI__builtin_ppc_rldimi:
  return SemaBuiltinConstantArg(TheCall, 2, Result) ||
         SemaValueIsRunOfOnes(TheCall, 3);
case PPC::BI__builtin_ppc_extract_exp:
case PPC::BI__builtin_ppc_extract_sig:
case PPC::BI__builtin_ppc_insert_exp:
  return SemaFeatureCheck(*this, TheCall, "power9-vector",
                          diag::err_ppc_builtin_only_on_arch, "9");
case PPC::BI__builtin_ppc_mtfsb0:
case PPC::BI__builtin_ppc_mtfsb1:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
case PPC::BI__builtin_ppc_mtfsf:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 255);
case PPC::BI__builtin_ppc_mtfsfi:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7) ||
         SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
case PPC::BI__builtin_ppc_alignx:
  return SemaBuiltinConstantArgPower2(TheCall, 0);
case PPC::BI__builtin_ppc_rdlam:
  return SemaValueIsRunOfOnes(TheCall, 2);
case PPC::BI__builtin_ppc_icbt:
case PPC::BI__builtin_ppc_sthcx:
case PPC::BI__builtin_ppc_stbcx:
case PPC::BI__builtin_ppc_lharx:
case PPC::BI__builtin_ppc_lbarx:
  return SemaFeatureCheck(*this, TheCall, "isa-v207-instructions",
                          diag::err_ppc_builtin_only_on_arch, "8");
case PPC::BI__builtin_vsx_ldrmb:
case PPC::BI__builtin_vsx_strmb:
  return SemaFeatureCheck(*this, TheCall, "isa-v207-instructions",
                          diag::err_ppc_builtin_only_on_arch, "8") ||
         SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
3448#define CUSTOM_BUILTIN(Name, Intr, Types, Acc) \
case PPC::BI__builtin_##Name: \
  return SemaBuiltinPPCMMACall(TheCall, Types);
3451#include "clang/Basic/BuiltinsPPC.def"
}
return SemaBuiltinConstantArgRange(TheCall, i, l, u);
3454}

3456// Check if the given type is a non-pointer PPC MMA type. This function is used
3457// in Sema to prevent invalid uses of restricted PPC MMA types.
3458bool Sema::CheckPPCMMAType(QualType Type, SourceLocation TypeLoc) {
if (Type->isPointerType() || Type->isArrayType())
  return false;

QualType CoreType = Type.getCanonicalType().getUnqualifiedType();
3463#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
if (false
3465#include "clang/Basic/PPCTypes.def"
   ) {
  Diag(TypeLoc, diag::err_ppc_invalid_use_mma_type);
  return true;
}
return false;
3471}

3473bool Sema::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID,
                                        CallExpr *TheCall) {
// position of memory order and scope arguments in the builtin
unsigned OrderIndex, ScopeIndex;
switch (BuiltinID) {
case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
  OrderIndex = 2;
  ScopeIndex = 3;
  break;
case AMDGPU::BI__builtin_amdgcn_fence:
  OrderIndex = 0;
  ScopeIndex = 1;
  break;
default:
  return false;
}

ExprResult Arg = TheCall->getArg(OrderIndex);
auto ArgExpr = Arg.get();
Expr::EvalResult ArgResult;

if (!ArgExpr->EvaluateAsInt(ArgResult, Context))
  return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
         << ArgExpr->getType();
auto Ord = ArgResult.Val.getInt().getZExtValue();

// Check valididty of memory ordering as per C11 / C++11's memody model.
// Only fence needs check. Atomic dec/inc allow all memory orders.
if (!llvm::isValidAtomicOrderingCABI(Ord))
  return Diag(ArgExpr->getBeginLoc(),
              diag::warn_atomic_op_has_invalid_memory_order)
         << ArgExpr->getSourceRange();
switch (static_cast<llvm::AtomicOrderingCABI>(Ord)) {
case llvm::AtomicOrderingCABI::relaxed:
case llvm::AtomicOrderingCABI::consume:
  if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
    return Diag(ArgExpr->getBeginLoc(),
                diag::warn_atomic_op_has_invalid_memory_order)
           << ArgExpr->getSourceRange();
  break;
case llvm::AtomicOrderingCABI::acquire:
case llvm::AtomicOrderingCABI::release:
case llvm::AtomicOrderingCABI::acq_rel:
case llvm::AtomicOrderingCABI::seq_cst:
  break;
}

Arg = TheCall->getArg(ScopeIndex);
ArgExpr = Arg.get();
Expr::EvalResult ArgResult1;
// Check that sync scope is a constant literal
if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1, Context))
  return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
         << ArgExpr->getType();

return false;
3532}

3534bool Sema::CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum) {
llvm::APSInt Result;

// We can't check the value of a dependent argument.
Expr *Arg = TheCall->getArg(ArgNum);
if (Arg->isTypeDependent() || Arg->isValueDependent())
  return false;

// Check constant-ness first.
if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
  return true;

int64_t Val = Result.getSExtValue();
if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
  return false;

return Diag(TheCall->getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
       << Arg->getSourceRange();
3552}

3554bool Sema::CheckRISCVBuiltinFunctionCall(const TargetInfo &TI,
                                       unsigned BuiltinID,
                                       CallExpr *TheCall) {
// CodeGenFunction can also detect this, but this gives a better error
// message.
bool FeatureMissing = false;
SmallVector<StringRef> ReqFeatures;
StringRef Features = Context.BuiltinInfo.getRequiredFeatures(BuiltinID);
Features.split(ReqFeatures, ',');

// Check if each required feature is included
for (StringRef F : ReqFeatures) {
  if (TI.hasFeature(F))
    continue;

  // If the feature is 64bit, alter the string so it will print better in
  // the diagnostic.
  if (F == "64bit")
    F = "RV64";

  // Convert features like "zbr" and "experimental-zbr" to "Zbr".
  F.consume_front("experimental-");
  std::string FeatureStr = F.str();
  FeatureStr[0] = std::toupper(FeatureStr[0]);

  // Error message
  FeatureMissing = true;
  Diag(TheCall->getBeginLoc(), diag::err_riscv_builtin_requires_extension)
      << TheCall->getSourceRange() << StringRef(FeatureStr);
}

if (FeatureMissing)
  return true;

switch (BuiltinID) {
case RISCV::BI__builtin_rvv_vsetvli:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3) ||
         CheckRISCVLMUL(TheCall, 2);
case RISCV::BI__builtin_rvv_vsetvlimax:
  return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
         CheckRISCVLMUL(TheCall, 1);
case RISCV::BI__builtin_rvv_vget_v_i8m2_i8m1:
case RISCV::BI__builtin_rvv_vget_v_i16m2_i16m1:
case RISCV::BI__builtin_rvv_vget_v_i32m2_i32m1:
case RISCV::BI__builtin_rvv_vget_v_i64m2_i64m1:
case RISCV::BI__builtin_rvv_vget_v_f32m2_f32m1:
case RISCV::BI__builtin_rvv_vget_v_f64m2_f64m1:
case RISCV::BI__builtin_rvv_vget_v_u8m2_u8m1:
case RISCV::BI__builtin_rvv_vget_v_u16m2_u16m1:
case RISCV::BI__builtin_rvv_vget_v_u32m2_u32m1:
case RISCV::BI__builtin_rvv_vget_v_u64m2_u64m1:
case RISCV::BI__builtin_rvv_vget_v_i8m4_i8m2:
case RISCV::BI__builtin_rvv_vget_v_i16m4_i16m2:
case RISCV::BI__builtin_rvv_vget_v_i32m4_i32m2:
case RISCV::BI__builtin_rvv_vget_v_i64m4_i64m2:
case RISCV::BI__builtin_rvv_vget_v_f32m4_f32m2:
case RISCV::BI__builtin_rvv_vget_v_f64m4_f64m2:
case RISCV::BI__builtin_rvv_vget_v_u8m4_u8m2:
case RISCV::BI__builtin_rvv_vget_v_u16m4_u16m2:
case RISCV::BI__builtin_rvv_vget_v_u32m4_u32m2:
case RISCV::BI__builtin_rvv_vget_v_u64m4_u64m2:
case RISCV::BI__builtin_rvv_vget_v_i8m8_i8m4:
case RISCV::BI__builtin_rvv_vget_v_i16m8_i16m4:
case RISCV::BI__builtin_rvv_vget_v_i32m8_i32m4:
case RISCV::BI__builtin_rvv_vget_v_i64m8_i64m4:
case RISCV::BI__builtin_rvv_vget_v_f32m8_f32m4:
case RISCV::BI__builtin_rvv_vget_v_f64m8_f64m4:
case RISCV::BI__builtin_rvv_vget_v_u8m8_u8m4:
case RISCV::BI__builtin_rvv_vget_v_u16m8_u16m4:
case RISCV::BI__builtin_rvv_vget_v_u32m8_u32m4:
case RISCV::BI__builtin_rvv_vget_v_u64m8_u64m4:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
case RISCV::BI__builtin_rvv_vget_v_i8m4_i8m1:
case RISCV::BI__builtin_rvv_vget_v_i16m4_i16m1:
case RISCV::BI__builtin_rvv_vget_v_i32m4_i32m1:
case RISCV::BI__builtin_rvv_vget_v_i64m4_i64m1:
case RISCV::BI__builtin_rvv_vget_v_f32m4_f32m1:
case RISCV::BI__builtin_rvv_vget_v_f64m4_f64m1:
case RISCV::BI__builtin_rvv_vget_v_u8m4_u8m1:
case RISCV::BI__builtin_rvv_vget_v_u16m4_u16m1:
case RISCV::BI__builtin_rvv_vget_v_u32m4_u32m1:
case RISCV::BI__builtin_rvv_vget_v_u64m4_u64m1:
case RISCV::BI__builtin_rvv_vget_v_i8m8_i8m2:
case RISCV::BI__builtin_rvv_vget_v_i16m8_i16m2:
case RISCV::BI__builtin_rvv_vget_v_i32m8_i32m2:
case RISCV::BI__builtin_rvv_vget_v_i64m8_i64m2:
case RISCV::BI__builtin_rvv_vget_v_f32m8_f32m2:
case RISCV::BI__builtin_rvv_vget_v_f64m8_f64m2:
case RISCV::BI__builtin_rvv_vget_v_u8m8_u8m2:
case RISCV::BI__builtin_rvv_vget_v_u16m8_u16m2:
case RISCV::BI__builtin_rvv_vget_v_u32m8_u32m2:
case RISCV::BI__builtin_rvv_vget_v_u64m8_u64m2:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
case RISCV::BI__builtin_rvv_vget_v_i8m8_i8m1:
case RISCV::BI__builtin_rvv_vget_v_i16m8_i16m1:
case RISCV::BI__builtin_rvv_vget_v_i32m8_i32m1:
case RISCV::BI__builtin_rvv_vget_v_i64m8_i64m1:
case RISCV::BI__builtin_rvv_vget_v_f32m8_f32m1:
case RISCV::BI__builtin_rvv_vget_v_f64m8_f64m1:
case RISCV::BI__builtin_rvv_vget_v_u8m8_u8m1:
case RISCV::BI__builtin_rvv_vget_v_u16m8_u16m1:
case RISCV::BI__builtin_rvv_vget_v_u32m8_u32m1:
case RISCV::BI__builtin_rvv_vget_v_u64m8_u64m1:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 7);
case RISCV::BI__builtin_rvv_vset_v_i8m1_i8m2:
case RISCV::BI__builtin_rvv_vset_v_i16m1_i16m2:
case RISCV::BI__builtin_rvv_vset_v_i32m1_i32m2:
case RISCV::BI__builtin_rvv_vset_v_i64m1_i64m2:
case RISCV::BI__builtin_rvv_vset_v_f32m1_f32m2:
case RISCV::BI__builtin_rvv_vset_v_f64m1_f64m2:
case RISCV::BI__builtin_rvv_vset_v_u8m1_u8m2:
case RISCV::BI__builtin_rvv_vset_v_u16m1_u16m2:
case RISCV::BI__builtin_rvv_vset_v_u32m1_u32m2:
case RISCV::BI__builtin_rvv_vset_v_u64m1_u64m2:
case RISCV::BI__builtin_rvv_vset_v_i8m2_i8m4:
case RISCV::BI__builtin_rvv_vset_v_i16m2_i16m4:
case RISCV::BI__builtin_rvv_vset_v_i32m2_i32m4:
case RISCV::BI__builtin_rvv_vset_v_i64m2_i64m4:
case RISCV::BI__builtin_rvv_vset_v_f32m2_f32m4:
case RISCV::BI__builtin_rvv_vset_v_f64m2_f64m4:
case RISCV::BI__builtin_rvv_vset_v_u8m2_u8m4:
case RISCV::BI__builtin_rvv_vset_v_u16m2_u16m4:
case RISCV::BI__builtin_rvv_vset_v_u32m2_u32m4:
case RISCV::BI__builtin_rvv_vset_v_u64m2_u64m4:
case RISCV::BI__builtin_rvv_vset_v_i8m4_i8m8:
case RISCV::BI__builtin_rvv_vset_v_i16m4_i16m8:
case RISCV::BI__builtin_rvv_vset_v_i32m4_i32m8:
case RISCV::BI__builtin_rvv_vset_v_i64m4_i64m8:
case RISCV::BI__builtin_rvv_vset_v_f32m4_f32m8:
case RISCV::BI__builtin_rvv_vset_v_f64m4_f64m8:
case RISCV::BI__builtin_rvv_vset_v_u8m4_u8m8:
case RISCV::BI__builtin_rvv_vset_v_u16m4_u16m8:
case RISCV::BI__builtin_rvv_vset_v_u32m4_u32m8:
case RISCV::BI__builtin_rvv_vset_v_u64m4_u64m8:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
case RISCV::BI__builtin_rvv_vset_v_i8m1_i8m4:
case RISCV::BI__builtin_rvv_vset_v_i16m1_i16m4:
case RISCV::BI__builtin_rvv_vset_v_i32m1_i32m4:
case RISCV::BI__builtin_rvv_vset_v_i64m1_i64m4:
case RISCV::BI__builtin_rvv_vset_v_f32m1_f32m4:
case RISCV::BI__builtin_rvv_vset_v_f64m1_f64m4:
case RISCV::BI__builtin_rvv_vset_v_u8m1_u8m4:
case RISCV::BI__builtin_rvv_vset_v_u16m1_u16m4:
case RISCV::BI__builtin_rvv_vset_v_u32m1_u32m4:
case RISCV::BI__builtin_rvv_vset_v_u64m1_u64m4:
case RISCV::BI__builtin_rvv_vset_v_i8m2_i8m8:
case RISCV::BI__builtin_rvv_vset_v_i16m2_i16m8:
case RISCV::BI__builtin_rvv_vset_v_i32m2_i32m8:
case RISCV::BI__builtin_rvv_vset_v_i64m2_i64m8:
case RISCV::BI__builtin_rvv_vset_v_f32m2_f32m8:
case RISCV::BI__builtin_rvv_vset_v_f64m2_f64m8:
case RISCV::BI__builtin_rvv_vset_v_u8m2_u8m8:
case RISCV::BI__builtin_rvv_vset_v_u16m2_u16m8:
case RISCV::BI__builtin_rvv_vset_v_u32m2_u32m8:
case RISCV::BI__builtin_rvv_vset_v_u64m2_u64m8:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
case RISCV::BI__builtin_rvv_vset_v_i8m1_i8m8:
case RISCV::BI__builtin_rvv_vset_v_i16m1_i16m8:
case RISCV::BI__builtin_rvv_vset_v_i32m1_i32m8:
case RISCV::BI__builtin_rvv_vset_v_i64m1_i64m8:
case RISCV::BI__builtin_rvv_vset_v_f32m1_f32m8:
case RISCV::BI__builtin_rvv_vset_v_f64m1_f64m8:
case RISCV::BI__builtin_rvv_vset_v_u8m1_u8m8:
case RISCV::BI__builtin_rvv_vset_v_u16m1_u16m8:
case RISCV::BI__builtin_rvv_vset_v_u32m1_u32m8:
case RISCV::BI__builtin_rvv_vset_v_u64m1_u64m8:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 7);
}

return false;
3724}

3726bool Sema::CheckSystemZBuiltinFunctionCall(unsigned BuiltinID,
                                         CallExpr *TheCall) {
if (BuiltinID == SystemZ::BI__builtin_tabort) {
  Expr *Arg = TheCall->getArg(0);
  if (Optional<llvm::APSInt> AbortCode = Arg->getIntegerConstantExpr(Context))
    if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
      return Diag(Arg->getBeginLoc(), diag::err_systemz_invalid_tabort_code)
             << Arg->getSourceRange();
}

// For intrinsics which take an immediate value as part of the instruction,
// range check them here.
unsigned i = 0, l = 0, u = 0;
switch (BuiltinID) {
default: return false;
case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_verimb:
case SystemZ::BI__builtin_s390_verimh:
case SystemZ::BI__builtin_s390_verimf:
case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255; break;
case SystemZ::BI__builtin_s390_vfaeb:
case SystemZ::BI__builtin_s390_vfaeh:
case SystemZ::BI__builtin_s390_vfaef:
case SystemZ::BI__builtin_s390_vfaebs:
case SystemZ::BI__builtin_s390_vfaehs:
case SystemZ::BI__builtin_s390_vfaefs:
case SystemZ::BI__builtin_s390_vfaezb:
case SystemZ::BI__builtin_s390_vfaezh:
case SystemZ::BI__builtin_s390_vfaezf:
case SystemZ::BI__builtin_s390_vfaezbs:
case SystemZ::BI__builtin_s390_vfaezhs:
case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vfisb:
case SystemZ::BI__builtin_s390_vfidb:
  return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15) ||
         SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
case SystemZ::BI__builtin_s390_vftcisb:
case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095; break;
case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vstrcb:
case SystemZ::BI__builtin_s390_vstrch:
case SystemZ::BI__builtin_s390_vstrcf:
case SystemZ::BI__builtin_s390_vstrczb:
case SystemZ::BI__builtin_s390_vstrczh:
case SystemZ::BI__builtin_s390_vstrczf:
case SystemZ::BI__builtin_s390_vstrcbs:
case SystemZ::BI__builtin_s390_vstrchs:
case SystemZ::BI__builtin_s390_vstrcfs:
case SystemZ::BI__builtin_s390_vstrczbs:
case SystemZ::BI__builtin_s390_vstrczhs:
case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vfminsb:
case SystemZ::BI__builtin_s390_vfmaxsb:
case SystemZ::BI__builtin_s390_vfmindb:
case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7; break;
case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7; break;
case SystemZ::BI__builtin_s390_vclfnhs:
case SystemZ::BI__builtin_s390_vclfnls:
case SystemZ::BI__builtin_s390_vcfn:
case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15; break;
case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15; break;
}
return SemaBuiltinConstantArgRange(TheCall, i, l, u);
3793}

3795/// SemaBuiltinCpuSupports - Handle __builtin_cpu_supports(char *).
3796/// This checks that the target supports __builtin_cpu_supports and
3797/// that the string argument is constant and valid.
3798static bool SemaBuiltinCpuSupports(Sema &S, const TargetInfo &TI,
                                 CallExpr *TheCall) {
Expr *Arg = TheCall->getArg(0);

// Check if the argument is a string literal.
if (!isa<StringLiteral>(Arg->IgnoreParenImpCasts()))
  return S.Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
         << Arg->getSourceRange();

// Check the contents of the string.
StringRef Feature =
    cast<StringLiteral>(Arg->IgnoreParenImpCasts())->getString();
if (!TI.validateCpuSupports(Feature))
  return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_supports)
         << Arg->getSourceRange();
return false;
3814}

3816/// SemaBuiltinCpuIs - Handle __builtin_cpu_is(char *).
3817/// This checks that the target supports __builtin_cpu_is and
3818/// that the string argument is constant and valid.
3819static bool SemaBuiltinCpuIs(Sema &S, const TargetInfo &TI, CallExpr *TheCall) {
Expr *Arg = TheCall->getArg(0);

// Check if the argument is a string literal.
if (!isa<StringLiteral>(Arg->IgnoreParenImpCasts()))
  return S.Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
         << Arg->getSourceRange();

// Check the contents of the string.
StringRef Feature =
    cast<StringLiteral>(Arg->IgnoreParenImpCasts())->getString();
if (!TI.validateCpuIs(Feature))
  return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_is)
         << Arg->getSourceRange();
return false;
3834}

3836// Check if the rounding mode is legal.
3837bool Sema::CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall) {
// Indicates if this instruction has rounding control or just SAE.
bool HasRC = false;

unsigned ArgNum = 0;
switch (BuiltinID) {
default:
  return false;
case X86::BI__builtin_ia32_vcvttsd2si32:
case X86::BI__builtin_ia32_vcvttsd2si64:
case X86::BI__builtin_ia32_vcvttsd2usi32:
case X86::BI__builtin_ia32_vcvttsd2usi64:
case X86::BI__builtin_ia32_vcvttss2si32:
case X86::BI__builtin_ia32_vcvttss2si64:
case X86::BI__builtin_ia32_vcvttss2usi32:
case X86::BI__builtin_ia32_vcvttss2usi64:
  ArgNum = 1;
  break;
case X86::BI__builtin_ia32_maxpd512:
case X86::BI__builtin_ia32_maxps512:
case X86::BI__builtin_ia32_minpd512:
case X86::BI__builtin_ia32_minps512:
  ArgNum = 2;
  break;
case X86::BI__builtin_ia32_cvtps2pd512_mask:
case X86::BI__builtin_ia32_cvttpd2dq512_mask:
case X86::BI__builtin_ia32_cvttpd2qq512_mask:
case X86::BI__builtin_ia32_cvttpd2udq512_mask:
case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
case X86::BI__builtin_ia32_cvttps2dq512_mask:
case X86::BI__builtin_ia32_cvttps2qq512_mask:
case X86::BI__builtin_ia32_cvttps2udq512_mask:
case X86::BI__builtin_ia32_cvttps2uqq512_mask:
case X86::BI__builtin_ia32_exp2pd_mask:
case X86::BI__builtin_ia32_exp2ps_mask:
case X86::BI__builtin_ia32_getexppd512_mask:
case X86::BI__builtin_ia32_getexpps512_mask:
case X86::BI__builtin_ia32_rcp28pd_mask:
case X86::BI__builtin_ia32_rcp28ps_mask:
case X86::BI__builtin_ia32_rsqrt28pd_mask:
case X86::BI__builtin_ia32_rsqrt28ps_mask:
case X86::BI__builtin_ia32_vcomisd:
case X86::BI__builtin_ia32_vcomiss:
case X86::BI__builtin_ia32_vcvtph2ps512_mask:
  ArgNum = 3;
  break;
case X86::BI__builtin_ia32_cmppd512_mask:
case X86::BI__builtin_ia32_cmpps512_mask:
case X86::BI__builtin_ia32_cmpsd_mask:
case X86::BI__builtin_ia32_cmpss_mask:
case X86::BI__builtin_ia32_cvtss2sd_round_mask:
case X86::BI__builtin_ia32_getexpsd128_round_mask:
case X86::BI__builtin_ia32_getexpss128_round_mask:
case X86::BI__builtin_ia32_getmantpd512_mask:
case X86::BI__builtin_ia32_getmantps512_mask:
case X86::BI__builtin_ia32_maxsd_round_mask:
case X86::BI__builtin_ia32_maxss_round_mask:
case X86::BI__builtin_ia32_minsd_round_mask:
case X86::BI__builtin_ia32_minss_round_mask:
case X86::BI__builtin_ia32_rcp28sd_round_mask:
case X86::BI__builtin_ia32_rcp28ss_round_mask:
case X86::BI__builtin_ia32_reducepd512_mask:
case X86::BI__builtin_ia32_reduceps512_mask:
case X86::BI__builtin_ia32_rndscalepd_mask:
case X86::BI__builtin_ia32_rndscaleps_mask:
case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
  ArgNum = 4;
  break;
case X86::BI__builtin_ia32_fixupimmpd512_mask:
case X86::BI__builtin_ia32_fixupimmpd512_maskz:
case X86::BI__builtin_ia32_fixupimmps512_mask:
case X86::BI__builtin_ia32_fixupimmps512_maskz:
case X86::BI__builtin_ia32_fixupimmsd_mask:
case X86::BI__builtin_ia32_fixupimmsd_maskz:
case X86::BI__builtin_ia32_fixupimmss_mask:
case X86::BI__builtin_ia32_fixupimmss_maskz:
case X86::BI__builtin_ia32_getmantsd_round_mask:
case X86::BI__builtin_ia32_getmantss_round_mask:
case X86::BI__builtin_ia32_rangepd512_mask:
case X86::BI__builtin_ia32_rangeps512_mask:
case X86::BI__builtin_ia32_rangesd128_round_mask:
case X86::BI__builtin_ia32_rangess128_round_mask:
case X86::BI__builtin_ia32_reducesd_mask:
case X86::BI__builtin_ia32_reducess_mask:
case X86::BI__builtin_ia32_rndscalesd_round_mask:
case X86::BI__builtin_ia32_rndscaless_round_mask:
  ArgNum = 5;
  break;
case X86::BI__builtin_ia32_vcvtsd2si64:
case X86::BI__builtin_ia32_vcvtsd2si32:
case X86::BI__builtin_ia32_vcvtsd2usi32:
case X86::BI__builtin_ia32_vcvtsd2usi64:
case X86::BI__builtin_ia32_vcvtss2si32:
case X86::BI__builtin_ia32_vcvtss2si64:
case X86::BI__builtin_ia32_vcvtss2usi32:
case X86::BI__builtin_ia32_vcvtss2usi64:
case X86::BI__builtin_ia32_sqrtpd512:
case X86::BI__builtin_ia32_sqrtps512:
  ArgNum = 1;
  HasRC = true;
  break;
case X86::BI__builtin_ia32_addpd512:
case X86::BI__builtin_ia32_addps512:
case X86::BI__builtin_ia32_divpd512:
case X86::BI__builtin_ia32_divps512:
case X86::BI__builtin_ia32_mulpd512:
case X86::BI__builtin_ia32_mulps512:
case X86::BI__builtin_ia32_subpd512:
case X86::BI__builtin_ia32_subps512:
case X86::BI__builtin_ia32_cvtsi2sd64:
case X86::BI__builtin_ia32_cvtsi2ss32:
case X86::BI__builtin_ia32_cvtsi2ss64:
case X86::BI__builtin_ia32_cvtusi2sd64:
case X86::BI__builtin_ia32_cvtusi2ss32:
case X86::BI__builtin_ia32_cvtusi2ss64:
  ArgNum = 2;
  HasRC = true;
  break;
case X86::BI__builtin_ia32_cvtdq2ps512_mask:
case X86::BI__builtin_ia32_cvtudq2ps512_mask:
case X86::BI__builtin_ia32_cvtpd2ps512_mask:
case X86::BI__builtin_ia32_cvtpd2dq512_mask:
case X86::BI__builtin_ia32_cvtpd2qq512_mask:
case X86::BI__builtin_ia32_cvtpd2udq512_mask:
case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
case X86::BI__builtin_ia32_cvtps2dq512_mask:
case X86::BI__builtin_ia32_cvtps2qq512_mask:
case X86::BI__builtin_ia32_cvtps2udq512_mask:
case X86::BI__builtin_ia32_cvtps2uqq512_mask:
case X86::BI__builtin_ia32_cvtqq2pd512_mask:
case X86::BI__builtin_ia32_cvtqq2ps512_mask:
case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
  ArgNum = 3;
  HasRC = true;
  break;
case X86::BI__builtin_ia32_addss_round_mask:
case X86::BI__builtin_ia32_addsd_round_mask:
case X86::BI__builtin_ia32_divss_round_mask:
case X86::BI__builtin_ia32_divsd_round_mask:
case X86::BI__builtin_ia32_mulss_round_mask:
case X86::BI__builtin_ia32_mulsd_round_mask:
case X86::BI__builtin_ia32_subss_round_mask:
case X86::BI__builtin_ia32_subsd_round_mask:
case X86::BI__builtin_ia32_scalefpd512_mask:
case X86::BI__builtin_ia32_scalefps512_mask:
case X86::BI__builtin_ia32_scalefsd_round_mask:
case X86::BI__builtin_ia32_scalefss_round_mask:
case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
case X86::BI__builtin_ia32_sqrtsd_round_mask:
case X86::BI__builtin_ia32_sqrtss_round_mask:
case X86::BI__builtin_ia32_vfmaddsd3_mask:
case X86::BI__builtin_ia32_vfmaddsd3_maskz:
case X86::BI__builtin_ia32_vfmaddsd3_mask3:
case X86::BI__builtin_ia32_vfmaddss3_mask:
case X86::BI__builtin_ia32_vfmaddss3_maskz:
case X86::BI__builtin_ia32_vfmaddss3_mask3:
case X86::BI__builtin_ia32_vfmaddpd512_mask:
case X86::BI__builtin_ia32_vfmaddpd512_maskz:
case X86::BI__builtin_ia32_vfmaddpd512_mask3:
case X86::BI__builtin_ia32_vfmsubpd512_mask3:
case X86::BI__builtin_ia32_vfmaddps512_mask:
case X86::BI__builtin_ia32_vfmaddps512_maskz:
case X86::BI__builtin_ia32_vfmaddps512_mask3:
case X86::BI__builtin_ia32_vfmsubps512_mask3:
case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
case X86::BI__builtin_ia32_vfmaddsubps512_mask:
case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
  ArgNum = 4;
  HasRC = true;
  break;
}

llvm::APSInt Result;

// We can't check the value of a dependent argument.
Expr *Arg = TheCall->getArg(ArgNum);
if (Arg->isTypeDependent() || Arg->isValueDependent())
  return false;

// Check constant-ness first.
if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
  return true;

// Make sure rounding mode is either ROUND_CUR_DIRECTION or ROUND_NO_EXC bit
// is set. If the intrinsic has rounding control(bits 1:0), make sure its only
// combined with ROUND_NO_EXC. If the intrinsic does not have rounding
// control, allow ROUND_NO_EXC and ROUND_CUR_DIRECTION together.
if (Result == 4/*ROUND_CUR_DIRECTION*/ ||
    Result == 8/*ROUND_NO_EXC*/ ||
    (!HasRC && Result == 12/*ROUND_CUR_DIRECTION|ROUND_NO_EXC*/) ||
    (HasRC && Result.getZExtValue() >= 8 && Result.getZExtValue() <= 11))
  return false;

return Diag(TheCall->getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
       << Arg->getSourceRange();
4039}

4041// Check if the gather/scatter scale is legal.
4042bool Sema::CheckX86BuiltinGatherScatterScale(unsigned BuiltinID,
                                           CallExpr *TheCall) {
unsigned ArgNum = 0;
switch (BuiltinID) {
default:
  return false;
case X86::BI__builtin_ia32_gatherpfdpd:
case X86::BI__builtin_ia32_gatherpfdps:
case X86::BI__builtin_ia32_gatherpfqpd:
case X86::BI__builtin_ia32_gatherpfqps:
case X86::BI__builtin_ia32_scatterpfdpd:
case X86::BI__builtin_ia32_scatterpfdps:
case X86::BI__builtin_ia32_scatterpfqpd:
case X86::BI__builtin_ia32_scatterpfqps:
  ArgNum = 3;
  break;
case X86::BI__builtin_ia32_gatherd_pd:
case X86::BI__builtin_ia32_gatherd_pd256:
case X86::BI__builtin_ia32_gatherq_pd:
case X86::BI__builtin_ia32_gatherq_pd256:
case X86::BI__builtin_ia32_gatherd_ps:
case X86::BI__builtin_ia32_gatherd_ps256:
case X86::BI__builtin_ia32_gatherq_ps:
case X86::BI__builtin_ia32_gatherq_ps256:
case X86::BI__builtin_ia32_gatherd_q:
case X86::BI__builtin_ia32_gatherd_q256:
case X86::BI__builtin_ia32_gatherq_q:
case X86::BI__builtin_ia32_gatherq_q256:
case X86::BI__builtin_ia32_gatherd_d:
case X86::BI__builtin_ia32_gatherd_d256:
case X86::BI__builtin_ia32_gatherq_d:
case X86::BI__builtin_ia32_gatherq_d256:
case X86::BI__builtin_ia32_gather3div2df:
case X86::BI__builtin_ia32_gather3div2di:
case X86::BI__builtin_ia32_gather3div4df:
case X86::BI__builtin_ia32_gather3div4di:
case X86::BI__builtin_ia32_gather3div4sf:
case X86::BI__builtin_ia32_gather3div4si:
case X86::BI__builtin_ia32_gather3div8sf:
case X86::BI__builtin_ia32_gather3div8si:
case X86::BI__builtin_ia32_gather3siv2df:
case X86::BI__builtin_ia32_gather3siv2di:
case X86::BI__builtin_ia32_gather3siv4df:
case X86::BI__builtin_ia32_gather3siv4di:
case X86::BI__builtin_ia32_gather3siv4sf:
case X86::BI__builtin_ia32_gather3siv4si:
case X86::BI__builtin_ia32_gather3siv8sf:
case X86::BI__builtin_ia32_gather3siv8si:
case X86::BI__builtin_ia32_gathersiv8df:
case X86::BI__builtin_ia32_gathersiv16sf:
case X86::BI__builtin_ia32_gatherdiv8df:
case X86::BI__builtin_ia32_gatherdiv16sf:
case X86::BI__builtin_ia32_gathersiv8di:
case X86::BI__builtin_ia32_gathersiv16si:
case X86::BI__builtin_ia32_gatherdiv8di:
case X86::BI__builtin_ia32_gatherdiv16si:
case X86::BI__builtin_ia32_scatterdiv2df:
case X86::BI__builtin_ia32_scatterdiv2di:
case X86::BI__builtin_ia32_scatterdiv4df:
case X86::BI__builtin_ia32_scatterdiv4di:
case X86::BI__builtin_ia32_scatterdiv4sf:
case X86::BI__builtin_ia32_scatterdiv4si:
case X86::BI__builtin_ia32_scatterdiv8sf:
case X86::BI__builtin_ia32_scatterdiv8si:
case X86::BI__builtin_ia32_scattersiv2df:
case X86::BI__builtin_ia32_scattersiv2di:
case X86::BI__builtin_ia32_scattersiv4df:
case X86::BI__builtin_ia32_scattersiv4di:
case X86::BI__builtin_ia32_scattersiv4sf:
case X86::BI__builtin_ia32_scattersiv4si:
case X86::BI__builtin_ia32_scattersiv8sf:
case X86::BI__builtin_ia32_scattersiv8si:
case X86::BI__builtin_ia32_scattersiv8df:
case X86::BI__builtin_ia32_scattersiv16sf:
case X86::BI__builtin_ia32_scatterdiv8df:
case X86::BI__builtin_ia32_scatterdiv16sf:
case X86::BI__builtin_ia32_scattersiv8di:
case X86::BI__builtin_ia32_scattersiv16si:
case X86::BI__builtin_ia32_scatterdiv8di:
case X86::BI__builtin_ia32_scatterdiv16si:
  ArgNum = 4;
  break;
}

llvm::APSInt Result;

// We can't check the value of a dependent argument.
Expr *Arg = TheCall->getArg(ArgNum);
if (Arg->isTypeDependent() || Arg->isValueDependent())
  return false;

// Check constant-ness first.
if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
  return true;

if (Result == 1 || Result == 2 || Result == 4 || Result == 8)
  return false;

return Diag(TheCall->getBeginLoc(), diag::err_x86_builtin_invalid_scale)
       << Arg->getSourceRange();
4142}

4144enum { TileRegLow = 0, TileRegHigh = 7 };

4146bool Sema::CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,
                                           ArrayRef<int> ArgNums) {
for (int ArgNum : ArgNums) {
  if (SemaBuiltinConstantArgRange(TheCall, ArgNum, TileRegLow, TileRegHigh))
    return true;
}
return false;
4153}

4155bool Sema::CheckX86BuiltinTileDuplicate(CallExpr *TheCall,
                                      ArrayRef<int> ArgNums) {
// Because the max number of tile register is TileRegHigh + 1, so here we use
// each bit to represent the usage of them in bitset.
std::bitset<TileRegHigh + 1> ArgValues;
for (int ArgNum : ArgNums) {
  Expr *Arg = TheCall->getArg(ArgNum);
  if (Arg->isTypeDependent() || Arg->isValueDependent())
    continue;

  llvm::APSInt Result;
  if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
    return true;
  int ArgExtValue = Result.getExtValue();
  assert((ArgExtValue >= TileRegLow || ArgExtValue <= TileRegHigh) &&((void)0)
         "Incorrect tile register num.")((void)0);
  if (ArgValues.test(ArgExtValue))
    return Diag(TheCall->getBeginLoc(),
                diag::err_x86_builtin_tile_arg_duplicate)
           << TheCall->getArg(ArgNum)->getSourceRange();
  ArgValues.set(ArgExtValue);
}
return false;
4178}

4180bool Sema::CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,
                                              ArrayRef<int> ArgNums) {
return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
       CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
4184}

4186bool Sema::CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall) {
switch (BuiltinID) {
default:
  return false;
case X86::BI__builtin_ia32_tileloadd64:
case X86::BI__builtin_ia32_tileloaddt164:
case X86::BI__builtin_ia32_tilestored64:
case X86::BI__builtin_ia32_tilezero:
  return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
case X86::BI__builtin_ia32_tdpbssd:
case X86::BI__builtin_ia32_tdpbsud:
case X86::BI__builtin_ia32_tdpbusd:
case X86::BI__builtin_ia32_tdpbuud:
case X86::BI__builtin_ia32_tdpbf16ps:
  return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
}
4202}
4203static bool isX86_32Builtin(unsigned BuiltinID) {
// These builtins only work on x86-32 targets.
switch (BuiltinID) {
case X86::BI__builtin_ia32_readeflags_u32:
case X86::BI__builtin_ia32_writeeflags_u32:
  return true;
}

return false;
4212}

4214bool Sema::CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                     CallExpr *TheCall) {
if (BuiltinID == X86::BI__builtin_cpu_supports)
  return SemaBuiltinCpuSupports(*this, TI, TheCall);

if (BuiltinID == X86::BI__builtin_cpu_is)
  return SemaBuiltinCpuIs(*this, TI, TheCall);

// Check for 32-bit only builtins on a 64-bit target.
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);

// If the intrinsic has rounding or SAE make sure its valid.
if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
  return true;

// If the intrinsic has a gather/scatter scale immediate make sure its valid.
if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
  return true;

// If the intrinsic has a tile arguments, make sure they are valid.
if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
  return true;

// For intrinsics which take an immediate value as part of the instruction,
// range check them here.
int i = 0, l = 0, u = 0;
switch (BuiltinID) {
default:
  return false;
case X86::BI__builtin_ia32_vec_ext_v2si:
case X86::BI__builtin_ia32_vec_ext_v2di:
case X86::BI__builtin_ia32_vextractf128_pd256:
case X86::BI__builtin_ia32_vextractf128_ps256:
case X86::BI__builtin_ia32_vextractf128_si256:
case X86::BI__builtin_ia32_extract128i256:
case X86::BI__builtin_ia32_extractf64x4_mask:
case X86::BI__builtin_ia32_extracti64x4_mask:
case X86::BI__builtin_ia32_extractf32x8_mask:
case X86::BI__builtin_ia32_extracti32x8_mask:
case X86::BI__builtin_ia32_extractf64x2_256_mask:
case X86::BI__builtin_ia32_extracti64x2_256_mask:
case X86::BI__builtin_ia32_extractf32x4_256_mask:
case X86::BI__builtin_ia32_extracti32x4_256_mask:
  i = 1; l = 0; u = 1;
  break;
case X86::BI__builtin_ia32_vec_set_v2di:
case X86::BI__builtin_ia32_vinsertf128_pd256:
case X86::BI__builtin_ia32_vinsertf128_ps256:
case X86::BI__builtin_ia32_vinsertf128_si256:
case X86::BI__builtin_ia32_insert128i256:
case X86::BI__builtin_ia32_insertf32x8:
case X86::BI__builtin_ia32_inserti32x8:
case X86::BI__builtin_ia32_insertf64x4:
case X86::BI__builtin_ia32_inserti64x4:
case X86::BI__builtin_ia32_insertf64x2_256:
case X86::BI__builtin_ia32_inserti64x2_256:
case X86::BI__builtin_ia32_insertf32x4_256:
case X86::BI__builtin_ia32_inserti32x4_256:
  i = 2; l = 0; u = 1;
  break;
case X86::BI__builtin_ia32_vpermilpd:
case X86::BI__builtin_ia32_vec_ext_v4hi:
case X86::BI__builtin_ia32_vec_ext_v4si:
case X86::BI__builtin_ia32_vec_ext_v4sf:
case X86::BI__builtin_ia32_vec_ext_v4di:
case X86::BI__builtin_ia32_extractf32x4_mask:
case X86::BI__builtin_ia32_extracti32x4_mask:
case X86::BI__builtin_ia32_extractf64x2_512_mask:
case X86::BI__builtin_ia32_extracti64x2_512_mask:
  i = 1; l = 0; u = 3;
  break;
case X86::BI_mm_prefetch:
case X86::BI__builtin_ia32_vec_ext_v8hi:
case X86::BI__builtin_ia32_vec_ext_v8si:
  i = 1; l = 0; u = 7;
  break;
case X86::BI__builtin_ia32_sha1rnds4:
case X86::BI__builtin_ia32_blendpd:
case X86::BI__builtin_ia32_shufpd:
case X86::BI__builtin_ia32_vec_set_v4hi:
case X86::BI__builtin_ia32_vec_set_v4si:
case X86::BI__builtin_ia32_vec_set_v4di:
case X86::BI__builtin_ia32_shuf_f32x4_256:
case X86::BI__builtin_ia32_shuf_f64x2_256:
case X86::BI__builtin_ia32_shuf_i32x4_256:
case X86::BI__builtin_ia32_shuf_i64x2_256:
case X86::BI__builtin_ia32_insertf64x2_512:
case X86::BI__builtin_ia32_inserti64x2_512:
case X86::BI__builtin_ia32_insertf32x4:
case X86::BI__builtin_ia32_inserti32x4:
  i = 2; l = 0; u = 3;
  break;
case X86::BI__builtin_ia32_vpermil2pd:
case X86::BI__builtin_ia32_vpermil2pd256:
case X86::BI__builtin_ia32_vpermil2ps:
case X86::BI__builtin_ia32_vpermil2ps256:
  i = 3; l = 0; u = 3;
  break;
case X86::BI__builtin_ia32_cmpb128_mask:
case X86::BI__builtin_ia32_cmpw128_mask:
case X86::BI__builtin_ia32_cmpd128_mask:
case X86::BI__builtin_ia32_cmpq128_mask:
case X86::BI__builtin_ia32_cmpb256_mask:
case X86::BI__builtin_ia32_cmpw256_mask:
case X86::BI__builtin_ia32_cmpd256_mask:
case X86::BI__builtin_ia32_cmpq256_mask:
case X86::BI__builtin_ia32_cmpb512_mask:
case X86::BI__builtin_ia32_cmpw512_mask:
case X86::BI__builtin_ia32_cmpd512_mask:
case X86::BI__builtin_ia32_cmpq512_mask:
case X86::BI__builtin_ia32_ucmpb128_mask:
case X86::BI__builtin_ia32_ucmpw128_mask:
case X86::BI__builtin_ia32_ucmpd128_mask:
case X86::BI__builtin_ia32_ucmpq128_mask:
case X86::BI__builtin_ia32_ucmpb256_mask:
case X86::BI__builtin_ia32_ucmpw256_mask:
case X86::BI__builtin_ia32_ucmpd256_mask:
case X86::BI__builtin_ia32_ucmpq256_mask:
case X86::BI__builtin_ia32_ucmpb512_mask:
case X86::BI__builtin_ia32_ucmpw512_mask:
case X86::BI__builtin_ia32_ucmpd512_mask:
case X86::BI__builtin_ia32_ucmpq512_mask:
case X86::BI__builtin_ia32_vpcomub:
case X86::BI__builtin_ia32_vpcomuw:
case X86::BI__builtin_ia32_vpcomud:
case X86::BI__builtin_ia32_vpcomuq:
case X86::BI__builtin_ia32_vpcomb:
case X86::BI__builtin_ia32_vpcomw:
case X86::BI__builtin_ia32_vpcomd:
case X86::BI__builtin_ia32_vpcomq:
case X86::BI__builtin_ia32_vec_set_v8hi:
case X86::BI__builtin_ia32_vec_set_v8si:
  i = 2; l = 0; u = 7;
  break;
case X86::BI__builtin_ia32_vpermilpd256:
case X86::BI__builtin_ia32_roundps:
case X86::BI__builtin_ia32_roundpd:
case X86::BI__builtin_ia32_roundps256:
case X86::BI__builtin_ia32_roundpd256:
case X86::BI__builtin_ia32_getmantpd128_mask:
case X86::BI__builtin_ia32_getmantpd256_mask:
case X86::BI__builtin_ia32_getmantps128_mask:
case X86::BI__builtin_ia32_getmantps256_mask:
case X86::BI__builtin_ia32_getmantpd512_mask:
case X86::BI__builtin_ia32_getmantps512_mask:
case X86::BI__builtin_ia32_vec_ext_v16qi:
case X86::BI__builtin_ia32_vec_ext_v16hi:
  i = 1; l = 0; u = 15;
  break;
case X86::BI__builtin_ia32_pblendd128:
case X86::BI__builtin_ia32_blendps:
case X86::BI__builtin_ia32_blendpd256:
case X86::BI__builtin_ia32_shufpd256:
case X86::BI__builtin_ia32_roundss:
case X86::BI__builtin_ia32_roundsd:
case X86::BI__builtin_ia32_rangepd128_mask:
case X86::BI__builtin_ia32_rangepd256_mask:
case X86::BI__builtin_ia32_rangepd512_mask:
case X86::BI__builtin_ia32_rangeps128_mask:
case X86::BI__builtin_ia32_rangeps256_mask:
case X86::BI__builtin_ia32_rangeps512_mask:
case X86::BI__builtin_ia32_getmantsd_round_mask:
case X86::BI__builtin_ia32_getmantss_round_mask:
case X86::BI__builtin_ia32_vec_set_v16qi:
case X86::BI__builtin_ia32_vec_set_v16hi:
  i = 2; l = 0; u = 15;
  break;
case X86::BI__builtin_ia32_vec_ext_v32qi:
  i = 1; l = 0; u = 31;
  break;
case X86::BI__builtin_ia32_cmpps:
case X86::BI__builtin_ia32_cmpss:
case X86::BI__builtin_ia32_cmppd:
case X86::BI__builtin_ia32_cmpsd:
case X86::BI__builtin_ia32_cmpps256:
case X86::BI__builtin_ia32_cmppd256:
case X86::BI__builtin_ia32_cmpps128_mask:
case X86::BI__builtin_ia32_cmppd128_mask:
case X86::BI__builtin_ia32_cmpps256_mask:
case X86::BI__builtin_ia32_cmppd256_mask:
case X86::BI__builtin_ia32_cmpps512_mask:
case X86::BI__builtin_ia32_cmppd512_mask:
case X86::BI__builtin_ia32_cmpsd_mask:
case X86::BI__builtin_ia32_cmpss_mask:
case X86::BI__builtin_ia32_vec_set_v32qi:
  i = 2; l = 0; u = 31;
  break;
case X86::BI__builtin_ia32_permdf256:
case X86::BI__builtin_ia32_permdi256:
case X86::BI__builtin_ia32_permdf512:
case X86::BI__builtin_ia32_permdi512:
case X86::BI__builtin_ia32_vpermilps:
case X86::BI__builtin_ia32_vpermilps256:
case X86::BI__builtin_ia32_vpermilpd512:
case X86::BI__builtin_ia32_vpermilps512:
case X86::BI__builtin_ia32_pshufd:
case X86::BI__builtin_ia32_pshufd256:
case X86::BI__builtin_ia32_pshufd512:
case X86::BI__builtin_ia32_pshufhw:
case X86::BI__builtin_ia32_pshufhw256:
case X86::BI__builtin_ia32_pshufhw512:
case X86::BI__builtin_ia32_pshuflw:
case X86::BI__builtin_ia32_pshuflw256:
case X86::BI__builtin_ia32_pshuflw512:
case X86::BI__builtin_ia32_vcvtps2ph:
case X86::BI__builtin_ia32_vcvtps2ph_mask:
case X86::BI__builtin_ia32_vcvtps2ph256:
case X86::BI__builtin_ia32_vcvtps2ph256_mask:
case X86::BI__builtin_ia32_vcvtps2ph512_mask:
case X86::BI__builtin_ia32_rndscaleps_128_mask:
case X86::BI__builtin_ia32_rndscalepd_128_mask:
case X86::BI__builtin_ia32_rndscaleps_256_mask:
case X86::BI__builtin_ia32_rndscalepd_256_mask:
case X86::BI__builtin_ia32_rndscaleps_mask:
case X86::BI__builtin_ia32_rndscalepd_mask:
case X86::BI__builtin_ia32_reducepd128_mask:
case X86::BI__builtin_ia32_reducepd256_mask:
case X86::BI__builtin_ia32_reducepd512_mask:
case X86::BI__builtin_ia32_reduceps128_mask:
case X86::BI__builtin_ia32_reduceps256_mask:
case X86::BI__builtin_ia32_reduceps512_mask:
case X86::BI__builtin_ia32_prold512:
case X86::BI__builtin_ia32_prolq512:
case X86::BI__builtin_ia32_prold128:
case X86::BI__builtin_ia32_prold256:
case X86::BI__builtin_ia32_prolq128:
case X86::BI__builtin_ia32_prolq256:
case X86::BI__builtin_ia32_prord512:
case X86::BI__builtin_ia32_prorq512:
case X86::BI__builtin_ia32_prord128:
case X86::BI__builtin_ia32_prord256:
case X86::BI__builtin_ia32_prorq128:
case X86::BI__builtin_ia32_prorq256:
case X86::BI__builtin_ia32_fpclasspd128_mask:
case X86::BI__builtin_ia32_fpclasspd256_mask:
case X86::BI__builtin_ia32_fpclassps128_mask:
case X86::BI__builtin_ia32_fpclassps256_mask:
case X86::BI__builtin_ia32_fpclassps512_mask:
case X86::BI__builtin_ia32_fpclasspd512_mask:
case X86::BI__builtin_ia32_fpclasssd_mask:
case X86::BI__builtin_ia32_fpclassss_mask:
case X86::BI__builtin_ia32_pslldqi128_byteshift:
case X86::BI__builtin_ia32_pslldqi256_byteshift:
case X86::BI__builtin_ia32_pslldqi512_byteshift:
case X86::BI__builtin_ia32_psrldqi128_byteshift:
case X86::BI__builtin_ia32_psrldqi256_byteshift:
case X86::BI__builtin_ia32_psrldqi512_byteshift:
case X86::BI__builtin_ia32_kshiftliqi:
case X86::BI__builtin_ia32_kshiftlihi:
case X86::BI__builtin_ia32_kshiftlisi:
case X86::BI__builtin_ia32_kshiftlidi:
case X86::BI__builtin_ia32_kshiftriqi:
case X86::BI__builtin_ia32_kshiftrihi:
case X86::BI__builtin_ia32_kshiftrisi:
case X86::BI__builtin_ia32_kshiftridi:
  i = 1; l = 0; u = 255;
  break;
case X86::BI__builtin_ia32_vperm2f128_pd256:
case X86::BI__builtin_ia32_vperm2f128_ps256:
case X86::BI__builtin_ia32_vperm2f128_si256:
case X86::BI__builtin_ia32_permti256:
case X86::BI__builtin_ia32_pblendw128:
case X86::BI__builtin_ia32_pblendw256:
case X86::BI__builtin_ia32_blendps256:
case X86::BI__builtin_ia32_pblendd256:
case X86::BI__builtin_ia32_palignr128:
case X86::BI__builtin_ia32_palignr256:
case X86::BI__builtin_ia32_palignr512:
case X86::BI__builtin_ia32_alignq512:
case X86::BI__builtin_ia32_alignd512:
case X86::BI__builtin_ia32_alignd128:
case X86::BI__builtin_ia32_alignd256:
case X86::BI__builtin_ia32_alignq128:
case X86::BI__builtin_ia32_alignq256:
case X86::BI__builtin_ia32_vcomisd:
case X86::BI__builtin_ia32_vcomiss:
case X86::BI__builtin_ia32_shuf_f32x4:
case X86::BI__builtin_ia32_shuf_f64x2:
case X86::BI__builtin_ia32_shuf_i32x4:
case X86::BI__builtin_ia32_shuf_i64x2:
case X86::BI__builtin_ia32_shufpd512:
case X86::BI__builtin_ia32_shufps:
case X86::BI__builtin_ia32_shufps256:
case X86::BI__builtin_ia32_shufps512:
case X86::BI__builtin_ia32_dbpsadbw128:
case X86::BI__builtin_ia32_dbpsadbw256:
case X86::BI__builtin_ia32_dbpsadbw512:
case X86::BI__builtin_ia32_vpshldd128:
case X86::BI__builtin_ia32_vpshldd256:
case X86::BI__builtin_ia32_vpshldd512:
case X86::BI__builtin_ia32_vpshldq128:
case X86::BI__builtin_ia32_vpshldq256:
case X86::BI__builtin_ia32_vpshldq512:
case X86::BI__builtin_ia32_vpshldw128:
case X86::BI__builtin_ia32_vpshldw256:
case X86::BI__builtin_ia32_vpshldw512:
case X86::BI__builtin_ia32_vpshrdd128:
case X86::BI__builtin_ia32_vpshrdd256:
case X86::BI__builtin_ia32_vpshrdd512:
case X86::BI__builtin_ia32_vpshrdq128:
case X86::BI__builtin_ia32_vpshrdq256:
case X86::BI__builtin_ia32_vpshrdq512:
case X86::BI__builtin_ia32_vpshrdw128:
case X86::BI__builtin_ia32_vpshrdw256:
case X86::BI__builtin_ia32_vpshrdw512:
  i = 2; l = 0; u = 255;
  break;
case X86::BI__builtin_ia32_fixupimmpd512_mask:
case X86::BI__builtin_ia32_fixupimmpd512_maskz:
case X86::BI__builtin_ia32_fixupimmps512_mask:
case X86::BI__builtin_ia32_fixupimmps512_maskz:
case X86::BI__builtin_ia32_fixupimmsd_mask:
case X86::BI__builtin_ia32_fixupimmsd_maskz:
case X86::BI__builtin_ia32_fixupimmss_mask:
case X86::BI__builtin_ia32_fixupimmss_maskz:
case X86::BI__builtin_ia32_fixupimmpd128_mask:
case X86::BI__builtin_ia32_fixupimmpd128_maskz:
case X86::BI__builtin_ia32_fixupimmpd256_mask:
case X86::BI__builtin_ia32_fixupimmpd256_maskz:
case X86::BI__builtin_ia32_fixupimmps128_mask:
case X86::BI__builtin_ia32_fixupimmps128_maskz:
case X86::BI__builtin_ia32_fixupimmps256_mask:
case X86::BI__builtin_ia32_fixupimmps256_maskz:
case X86::BI__builtin_ia32_pternlogd512_mask:
case X86::BI__builtin_ia32_pternlogd512_maskz:
case X86::BI__builtin_ia32_pternlogq512_mask:
case X86::BI__builtin_ia32_pternlogq512_maskz:
case X86::BI__builtin_ia32_pternlogd128_mask:
case X86::BI__builtin_ia32_pternlogd128_maskz:
case X86::BI__builtin_ia32_pternlogd256_mask:
case X86::BI__builtin_ia32_pternlogd256_maskz:
case X86::BI__builtin_ia32_pternlogq128_mask:
case X86::BI__builtin_ia32_pternlogq128_maskz:
case X86::BI__builtin_ia32_pternlogq256_mask:
case X86::BI__builtin_ia32_pternlogq256_maskz:
  i = 3; l = 0; u = 255;
  break;
case X86::BI__builtin_ia32_gatherpfdpd:
case X86::BI__builtin_ia32_gatherpfdps:
case X86::BI__builtin_ia32_gatherpfqpd:
case X86::BI__builtin_ia32_gatherpfqps:
case X86::BI__builtin_ia32_scatterpfdpd:
case X86::BI__builtin_ia32_scatterpfdps:
case X86::BI__builtin_ia32_scatterpfqpd:
case X86::BI__builtin_ia32_scatterpfqps:
  i = 4; l = 2; u = 3;
  break;
case X86::BI__builtin_ia32_reducesd_mask:
case X86::BI__builtin_ia32_reducess_mask:
case X86::BI__builtin_ia32_rndscalesd_round_mask:
case X86::BI__builtin_ia32_rndscaless_round_mask:
  i = 4; l = 0; u = 255;
  break;
}

// Note that we don't force a hard error on the range check here, allowing
// template-generated or macro-generated dead code to potentially have out-of-
// range values. These need to code generate, but don't need to necessarily
// make any sense. We use a warning that defaults to an error.
return SemaBuiltinConstantArgRange(TheCall, i, l, u, /*RangeIsError*/ false);
4577}

4579/// Given a FunctionDecl's FormatAttr, attempts to populate the FomatStringInfo
4580/// parameter with the FormatAttr's correct format_idx and firstDataArg.
4581/// Returns true when the format fits the function and the FormatStringInfo has
4582/// been populated.
4583bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
                             FormatStringInfo *FSI) {
FSI->HasVAListArg = Format->getFirstArg() == 0;
FSI->FormatIdx = Format->getFormatIdx() - 1;
FSI->FirstDataArg = FSI->HasVAListArg ? 0 : Format->getFirstArg() - 1;

// The way the format attribute works in GCC, the implicit this argument
// of member functions is counted. However, it doesn't appear in our own
// lists, so decrement format_idx in that case.
if (IsCXXMember) {
  if(FSI->FormatIdx == 0)
    return false;
  --FSI->FormatIdx;
  if (FSI->FirstDataArg != 0)
    --FSI->FirstDataArg;
}
return true;
4600}

4602/// Checks if a the given expression evaluates to null.
4603///
4604/// Returns true if the value evaluates to null.
4605static bool CheckNonNullExpr(Sema &S, const Expr *Expr) {
// If the expression has non-null type, it doesn't evaluate to null.
if (auto nullability
      = Expr->IgnoreImplicit()->getType()->getNullability(S.Context)) {
  if (*nullability == NullabilityKind::NonNull)
    return false;
}

// As a special case, transparent unions initialized with zero are
// considered null for the purposes of the nonnull attribute.
if (const RecordType *UT = Expr->getType()->getAsUnionType()) {
  if (UT->getDecl()->hasAttr<TransparentUnionAttr>())
    if (const CompoundLiteralExpr *CLE =
        dyn_cast<CompoundLiteralExpr>(Expr))
      if (const InitListExpr *ILE =
          dyn_cast<InitListExpr>(CLE->getInitializer()))
        Expr = ILE->getInit(0);
}

bool Result;
return (!Expr->isValueDependent() &&
        Expr->EvaluateAsBooleanCondition(Result, S.Context) &&
        !Result);
4628}

4630static void CheckNonNullArgument(Sema &S,
                               const Expr *ArgExpr,
                               SourceLocation CallSiteLoc) {
if (CheckNonNullExpr(S, ArgExpr))
  S.DiagRuntimeBehavior(CallSiteLoc, ArgExpr,
                        S.PDiag(diag::warn_null_arg)
                            << ArgExpr->getSourceRange());
4637}

4639bool Sema::GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx) {
FormatStringInfo FSI;
if ((GetFormatStringType(Format) == FST_NSString) &&
    getFormatStringInfo(Format, false, &FSI)) {
  Idx = FSI.FormatIdx;
  return true;
}
return false;
4647}

4649/// Diagnose use of %s directive in an NSString which is being passed
4650/// as formatting string to formatting method.
4651static void
4652DiagnoseCStringFormatDirectiveInCFAPI(Sema &S,
                                      const NamedDecl *FDecl,
                                      Expr **Args,
                                      unsigned NumArgs) {
unsigned Idx = 0;
bool Format = false;
ObjCStringFormatFamily SFFamily = FDecl->getObjCFStringFormattingFamily();
if (SFFamily == ObjCStringFormatFamily::SFF_CFString) {
  Idx = 2;
  Format = true;
}
else
  for (const auto *I : FDecl->specific_attrs<FormatAttr>()) {
    if (S.GetFormatNSStringIdx(I, Idx)) {
      Format = true;
      break;
    }
  }
if (!Format || NumArgs <= Idx)
  return;
const Expr *FormatExpr = Args[Idx];
if (const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
  FormatExpr = CSCE->getSubExpr();
const StringLiteral *FormatString;
if (const ObjCStringLiteral *OSL =
    dyn_cast<ObjCStringLiteral>(FormatExpr->IgnoreParenImpCasts()))
  FormatString = OSL->getString();
else
  FormatString = dyn_cast<StringLiteral>(FormatExpr->IgnoreParenImpCasts());
if (!FormatString)
  return;
if (S.FormatStringHasSArg(FormatString)) {
  S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string)
    << "%s" << 1 << 1;
  S.Diag(FDecl->getLocation(), diag::note_entity_declared_at)
    << FDecl->getDeclName();
}
4689}

4691/// Determine whether the given type has a non-null nullability annotation.
4692static bool isNonNullType(ASTContext &ctx, QualType type) {
if (auto nullability = type->getNullability(ctx))
  return *nullability == NullabilityKind::NonNull;

return false;
4697}

4699static void CheckNonNullArguments(Sema &S,
                                const NamedDecl *FDecl,
                                const FunctionProtoType *Proto,
                                ArrayRef<const Expr *> Args,
                                SourceLocation CallSiteLoc) {
assert((FDecl || Proto) && "Need a function declaration or prototype")((void)0);

// Already checked by by constant evaluator.
if (S.isConstantEvaluated())
  return;
// Check the attributes attached to the method/function itself.
llvm::SmallBitVector NonNullArgs;
if (FDecl) {
  // Handle the nonnull attribute on the function/method declaration itself.
  for (const auto *NonNull : FDecl->specific_attrs<NonNullAttr>()) {
    if (!NonNull->args_size()) {
      // Easy case: all pointer arguments are nonnull.
      for (const auto *Arg : Args)
        if (S.isValidPointerAttrType(Arg->getType()))
          CheckNonNullArgument(S, Arg, CallSiteLoc);
      return;
    }

    for (const ParamIdx &Idx : NonNull->args()) {
      unsigned IdxAST = Idx.getASTIndex();
      if (IdxAST >= Args.size())
        continue;
      if (NonNullArgs.empty())
        NonNullArgs.resize(Args.size());
      NonNullArgs.set(IdxAST);
    }
  }
}

if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
  // Handle the nonnull attribute on the parameters of the
  // function/method.
  ArrayRef<ParmVarDecl*> parms;
  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
    parms = FD->parameters();
  else
    parms = cast<ObjCMethodDecl>(FDecl)->parameters();

  unsigned ParamIndex = 0;
  for (ArrayRef<ParmVarDecl*>::iterator I = parms.begin(), E = parms.end();
       I != E; ++I, ++ParamIndex) {
    const ParmVarDecl *PVD = *I;
    if (PVD->hasAttr<NonNullAttr>() ||
        isNonNullType(S.Context, PVD->getType())) {
      if (NonNullArgs.empty())
        NonNullArgs.resize(Args.size());

      NonNullArgs.set(ParamIndex);
    }
  }
} else {
  // If we have a non-function, non-method declaration but no
  // function prototype, try to dig out the function prototype.
  if (!Proto) {
    if (const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
      QualType type = VD->getType().getNonReferenceType();
      if (auto pointerType = type->getAs<PointerType>())
        type = pointerType->getPointeeType();
      else if (auto blockType = type->getAs<BlockPointerType>())
        type = blockType->getPointeeType();
      // FIXME: data member pointers?

      // Dig out the function prototype, if there is one.
      Proto = type->getAs<FunctionProtoType>();
    }
  }

  // Fill in non-null argument information from the nullability
  // information on the parameter types (if we have them).
  if (Proto) {
    unsigned Index = 0;
    for (auto paramType : Proto->getParamTypes()) {
      if (isNonNullType(S.Context, paramType)) {
        if (NonNullArgs.empty())
          NonNullArgs.resize(Args.size());

        NonNullArgs.set(Index);
      }

      ++Index;
    }
  }
}

// Check for non-null arguments.
for (unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
     ArgIndex != ArgIndexEnd; ++ArgIndex) {
  if (NonNullArgs[ArgIndex])
    CheckNonNullArgument(S, Args[ArgIndex], CallSiteLoc);
}
4794}

4796/// Warn if a pointer or reference argument passed to a function points to an
4797/// object that is less aligned than the parameter. This can happen when
4798/// creating a typedef with a lower alignment than the original type and then
4799/// calling functions defined in terms of the original type.
4800void Sema::CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,
                           StringRef ParamName, QualType ArgTy,
                           QualType ParamTy) {

// If a function accepts a pointer or reference type
if (!ParamTy->isPointerType() && !ParamTy->isReferenceType())
  return;

// If the parameter is a pointer type, get the pointee type for the
// argument too. If the parameter is a reference type, don't try to get
// the pointee type for the argument.
if (ParamTy->isPointerType())
  ArgTy = ArgTy->getPointeeType();

// Remove reference or pointer
ParamTy = ParamTy->getPointeeType();

// Find expected alignment, and the actual alignment of the passed object.
// getTypeAlignInChars requires complete types
if (ArgTy.isNull() || ParamTy->isIncompleteType() ||
    ArgTy->isIncompleteType() || ParamTy->isUndeducedType() ||
    ArgTy->isUndeducedType())
  return;

CharUnits ParamAlign = Context.getTypeAlignInChars(ParamTy);
CharUnits ArgAlign = Context.getTypeAlignInChars(ArgTy);

// If the argument is less aligned than the parameter, there is a
// potential alignment issue.
if (ArgAlign < ParamAlign)
  Diag(Loc, diag::warn_param_mismatched_alignment)
      << (int)ArgAlign.getQuantity() << (int)ParamAlign.getQuantity()
      << ParamName << FDecl;
4833}

4835/// Handles the checks for format strings, non-POD arguments to vararg
4836/// functions, NULL arguments passed to non-NULL parameters, and diagnose_if
4837/// attributes.
4838void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
                   const Expr *ThisArg, ArrayRef<const Expr *> Args,
                   bool IsMemberFunction, SourceLocation Loc,
                   SourceRange Range, VariadicCallType CallType) {
// FIXME: We should check as much as we can in the template definition.
if (CurContext->isDependentContext())
  return;

// Printf and scanf checking.
llvm::SmallBitVector CheckedVarArgs;
if (FDecl) {
  for (const auto *I : FDecl->specific_attrs<FormatAttr>()) {
    // Only create vector if there are format attributes.
    CheckedVarArgs.resize(Args.size());

    CheckFormatArguments(I, Args, IsMemberFunction, CallType, Loc, Range,
                         CheckedVarArgs);
  }
}

// Refuse POD arguments that weren't caught by the format string
// checks above.
auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
if (CallType != VariadicDoesNotApply &&
    (!FD || FD->getBuiltinID() != Builtin::BI__noop)) {
  unsigned NumParams = Proto ? Proto->getNumParams()
                     : FDecl && isa<FunctionDecl>(FDecl)
                         ? cast<FunctionDecl>(FDecl)->getNumParams()
                     : FDecl && isa<ObjCMethodDecl>(FDecl)
                         ? cast<ObjCMethodDecl>(FDecl)->param_size()
                     : 0;

  for (unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
    // Args[ArgIdx] can be null in malformed code.
    if (const Expr *Arg = Args[ArgIdx]) {
      if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
        checkVariadicArgument(Arg, CallType);
    }
  }
}

if (FDecl || Proto) {
  CheckNonNullArguments(*this, FDecl, Proto, Args, Loc);

  // Type safety checking.
  if (FDecl) {
    for (const auto *I : FDecl->specific_attrs<ArgumentWithTypeTagAttr>())
      CheckArgumentWithTypeTag(I, Args, Loc);
  }
}

// Check that passed arguments match the alignment of original arguments.
// Try to get the missing prototype from the declaration.
if (!Proto && FDecl) {
  const auto *FT = FDecl->getFunctionType();
  if (isa_and_nonnull<FunctionProtoType>(FT))
    Proto = cast<FunctionProtoType>(FDecl->getFunctionType());
}
if (Proto) {
  // For variadic functions, we may have more args than parameters.
  // For some K&R functions, we may have less args than parameters.
  const auto N = std::min<unsigned>(Proto->getNumParams(), Args.size());
  for (unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
    // Args[ArgIdx] can be null in malformed code.
    if (const Expr *Arg = Args[ArgIdx]) {
      if (Arg->containsErrors())
        continue;

      QualType ParamTy = Proto->getParamType(ArgIdx);
      QualType ArgTy = Arg->getType();
      CheckArgAlignment(Arg->getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
                        ArgTy, ParamTy);
    }
  }
}

if (FDecl && FDecl->hasAttr<AllocAlignAttr>()) {
  auto *AA = FDecl->getAttr<AllocAlignAttr>();
  const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
  if (!Arg->isValueDependent()) {
    Expr::EvalResult Align;
    if (Arg->EvaluateAsInt(Align, Context)) {
      const llvm::APSInt &I = Align.Val.getInt();
      if (!I.isPowerOf2())
        Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
            << Arg->getSourceRange();

      if (I > Sema::MaximumAlignment)
        Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
            << Arg->getSourceRange() << Sema::MaximumAlignment;
    }
  }
}

if (FD)
  diagnoseArgDependentDiagnoseIfAttrs(FD, ThisArg, Args, Loc);
4934}

4936/// CheckConstructorCall - Check a constructor call for correctness and safety
4937/// properties not enforced by the C type system.
4938void Sema::CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
                              ArrayRef<const Expr *> Args,
                              const FunctionProtoType *Proto,
                              SourceLocation Loc) {
VariadicCallType CallType =
    Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;

auto *Ctor = cast<CXXConstructorDecl>(FDecl);
CheckArgAlignment(Loc, FDecl, "'this'", Context.getPointerType(ThisType),
                  Context.getPointerType(Ctor->getThisObjectType()));

checkCall(FDecl, Proto, /*ThisArg=*/nullptr, Args, /*IsMemberFunction=*/true,
          Loc, SourceRange(), CallType);
4951}

4953/// CheckFunctionCall - Check a direct function call for various correctness
4954/// and safety properties not strictly enforced by the C type system.
4955bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
                           const FunctionProtoType *Proto) {
bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
1
Assuming 'TheCall' is not a 'CXXOperatorCallExpr'→
                            isa<CXXMethodDecl>(FDecl);
bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
2
←
Assuming 'TheCall' is not a 'CXXMemberCallExpr'→
                        IsMemberOperatorCall;
VariadicCallType CallType = getVariadicCallType(FDecl, Proto,
                                                TheCall->getCallee());
Expr** Args = TheCall->getArgs();
unsigned NumArgs = TheCall->getNumArgs();

Expr *ImplicitThis = nullptr;
if (IsMemberOperatorCall2.1
'IsMemberOperatorCall' is false
) {
3
←
Taking false branch→
  // If this is a call to a member operator, hide the first argument
  // from checkCall.
  // FIXME: Our choice of AST representation here is less than ideal.
  ImplicitThis = Args[0];
  ++Args;
  --NumArgs;
} else if (IsMemberFunction3.1
'IsMemberFunction' is false
)
4
←
Taking false branch→
  ImplicitThis =
      cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();

if (ImplicitThis4.1
'ImplicitThis' is null
) {
5
←
Taking false branch→
  // ImplicitThis may or may not be a pointer, depending on whether . or -> is
  // used.
  QualType ThisType = ImplicitThis->getType();
  if (!ThisType->isPointerType()) {
    assert(!ThisType->isReferenceType())((void)0);
    ThisType = Context.getPointerType(ThisType);
  }

  QualType ThisTypeFromDecl =
      Context.getPointerType(cast<CXXMethodDecl>(FDecl)->getThisObjectType());

  CheckArgAlignment(TheCall->getRParenLoc(), FDecl, "'this'", ThisType,
                    ThisTypeFromDecl);
}

checkCall(FDecl, Proto, ImplicitThis, llvm::makeArrayRef(Args, NumArgs),
          IsMemberFunction, TheCall->getRParenLoc(),
          TheCall->getCallee()->getSourceRange(), CallType);

IdentifierInfo *FnInfo = FDecl->getIdentifier();
// None of the checks below are needed for functions that don't have
// simple names (e.g., C++ conversion functions).
if (!FnInfo)
6
←
Assuming 'FnInfo' is non-null→
7
←
Taking false branch→
  return false;

CheckTCBEnforcement(TheCall, FDecl);

CheckAbsoluteValueFunction(TheCall, FDecl);
CheckMaxUnsignedZero(TheCall, FDecl);

if (getLangOpts().ObjC)
8
←
Assuming field 'ObjC' is 0→
9
←
Taking false branch→
  DiagnoseCStringFormatDirectiveInCFAPI(*this, FDecl, Args, NumArgs);

unsigned CMId = FDecl->getMemoryFunctionKind();

// Handle memory setting and copying functions.
switch (CMId) {
10
←
Control jumps to 'case BIfree:'  at line 5025→
case 0:
  return false;
case Builtin::BIstrlcpy: // fallthrough
case Builtin::BIstrlcat:
  CheckStrlcpycatArguments(TheCall, FnInfo);
  break;
case Builtin::BIstrncat:
  CheckStrncatArguments(TheCall, FnInfo);
  break;
case Builtin::BIfree:
  CheckFreeArguments(TheCall);
11
←
Calling 'Sema::CheckFreeArguments'→
  break;
default:
  CheckMemaccessArguments(TheCall, CMId, FnInfo);
}

return false;
5033}

5035bool Sema::CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation lbrac,
                             ArrayRef<const Expr *> Args) {
VariadicCallType CallType =
    Method->isVariadic() ? VariadicMethod : VariadicDoesNotApply;

checkCall(Method, nullptr, /*ThisArg=*/nullptr, Args,
          /*IsMemberFunction=*/false, lbrac, Method->getSourceRange(),
          CallType);

return false;
5045}

5047bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
                          const FunctionProtoType *Proto) {
QualType Ty;
if (const auto *V = dyn_cast<VarDecl>(NDecl))
  Ty = V->getType().getNonReferenceType();
else if (const auto *F = dyn_cast<FieldDecl>(NDecl))
  Ty = F->getType().getNonReferenceType();
else
  return false;

if (!Ty->isBlockPointerType() && !Ty->isFunctionPointerType() &&
    !Ty->isFunctionProtoType())
  return false;

VariadicCallType CallType;
if (!Proto || !Proto->isVariadic()) {
  CallType = VariadicDoesNotApply;
} else if (Ty->isBlockPointerType()) {
  CallType = VariadicBlock;
} else { // Ty->isFunctionPointerType()
  CallType = VariadicFunction;
}

checkCall(NDecl, Proto, /*ThisArg=*/nullptr,
          llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
          /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
          TheCall->getCallee()->getSourceRange(), CallType);

return false;
5076}

5078/// Checks function calls when a FunctionDecl or a NamedDecl is not available,
5079/// such as function pointers returned from functions.
5080bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
VariadicCallType CallType = getVariadicCallType(/*FDecl=*/nullptr, Proto,
                                                TheCall->getCallee());
checkCall(/*FDecl=*/nullptr, Proto, /*ThisArg=*/nullptr,
          llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
          /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
          TheCall->getCallee()->getSourceRange(), CallType);

return false;
5089}

5091static bool isValidOrderingForOp(int64_t Ordering, AtomicExpr::AtomicOp Op) {
if (!llvm::isValidAtomicOrderingCABI(Ordering))
  return false;

auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
switch (Op) {
case AtomicExpr::AO__c11_atomic_init:
case AtomicExpr::AO__opencl_atomic_init:
  llvm_unreachable("There is no ordering argument for an init")__builtin_unreachable();

case AtomicExpr::AO__c11_atomic_load:
case AtomicExpr::AO__opencl_atomic_load:
case AtomicExpr::AO__atomic_load_n:
case AtomicExpr::AO__atomic_load:
  return OrderingCABI != llvm::AtomicOrderingCABI::release &&
         OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;

case AtomicExpr::AO__c11_atomic_store:
case AtomicExpr::AO__opencl_atomic_store:
case AtomicExpr::AO__atomic_store:
case AtomicExpr::AO__atomic_store_n:
  return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
         OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
         OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;

default:
  return true;
}
5119}

5121ExprResult Sema::SemaAtomicOpsOverloaded(ExprResult TheCallResult,
                                       AtomicExpr::AtomicOp Op) {
CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
MultiExprArg Args{TheCall->getArgs(), TheCall->getNumArgs()};
return BuildAtomicExpr({TheCall->getBeginLoc(), TheCall->getEndLoc()},
                       DRE->getSourceRange(), TheCall->getRParenLoc(), Args,
                       Op);
5129}

5131ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
                               SourceLocation RParenLoc, MultiExprArg Args,
                               AtomicExpr::AtomicOp Op,
                               AtomicArgumentOrder ArgOrder) {
// All the non-OpenCL operations take one of the following forms.
// The OpenCL operations take the __c11 forms with one extra argument for
// synchronization scope.
enum {
  // C    __c11_atomic_init(A *, C)
  Init,

  // C    __c11_atomic_load(A *, int)
  Load,

  // void __atomic_load(A *, CP, int)
  LoadCopy,

  // void __atomic_store(A *, CP, int)
  Copy,

  // C    __c11_atomic_add(A *, M, int)
  Arithmetic,

  // C    __atomic_exchange_n(A *, CP, int)
  Xchg,

  // void __atomic_exchange(A *, C *, CP, int)
  GNUXchg,

  // bool __c11_atomic_compare_exchange_strong(A *, C *, CP, int, int)
  C11CmpXchg,

  // bool __atomic_compare_exchange(A *, C *, CP, bool, int, int)
  GNUCmpXchg
} Form = Init;

const unsigned NumForm = GNUCmpXchg + 1;
const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
// where:
//   C is an appropriate type,
//   A is volatile _Atomic(C) for __c11 builtins and is C for GNU builtins,
//   CP is C for __c11 builtins and GNU _n builtins and is C * otherwise,
//   M is C if C is an integer, and ptrdiff_t if C is a pointer, and
//   the int parameters are for orderings.

static_assert(sizeof(NumArgs)/sizeof(NumArgs[0]) == NumForm
    && sizeof(NumVals)/sizeof(NumVals[0]) == NumForm,
    "need to update code for modified forms");
static_assert(AtomicExpr::AO__c11_atomic_init == 0 &&
                  AtomicExpr::AO__c11_atomic_fetch_min + 1 ==
                      AtomicExpr::AO__atomic_load,
              "need to update code for modified C11 atomics");
bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_init &&
                Op <= AtomicExpr::AO__opencl_atomic_fetch_max;
bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_init &&
             Op <= AtomicExpr::AO__c11_atomic_fetch_min) ||
             IsOpenCL;
bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
           Op == AtomicExpr::AO__atomic_store_n ||
           Op == AtomicExpr::AO__atomic_exchange_n ||
           Op == AtomicExpr::AO__atomic_compare_exchange_n;
bool IsAddSub = false;

switch (Op) {
case AtomicExpr::AO__c11_atomic_init:
case AtomicExpr::AO__opencl_atomic_init:
  Form = Init;
  break;

case AtomicExpr::AO__c11_atomic_load:
case AtomicExpr::AO__opencl_atomic_load:
case AtomicExpr::AO__atomic_load_n:
  Form = Load;
  break;

case AtomicExpr::AO__atomic_load:
  Form = LoadCopy;
  break;

case AtomicExpr::AO__c11_atomic_store:
case AtomicExpr::AO__opencl_atomic_store:
case AtomicExpr::AO__atomic_store:
case AtomicExpr::AO__atomic_store_n:
  Form = Copy;
  break;

case AtomicExpr::AO__c11_atomic_fetch_add:
case AtomicExpr::AO__c11_atomic_fetch_sub:
case AtomicExpr::AO__opencl_atomic_fetch_add:
case AtomicExpr::AO__opencl_atomic_fetch_sub:
case AtomicExpr::AO__atomic_fetch_add:
case AtomicExpr::AO__atomic_fetch_sub:
case AtomicExpr::AO__atomic_add_fetch:
case AtomicExpr::AO__atomic_sub_fetch:
  IsAddSub = true;
  Form = Arithmetic;
  break;
case AtomicExpr::AO__c11_atomic_fetch_and:
case AtomicExpr::AO__c11_atomic_fetch_or:
case AtomicExpr::AO__c11_atomic_fetch_xor:
case AtomicExpr::AO__opencl_atomic_fetch_and:
case AtomicExpr::AO__opencl_atomic_fetch_or:
case AtomicExpr::AO__opencl_atomic_fetch_xor:
case AtomicExpr::AO__atomic_fetch_and:
case AtomicExpr::AO__atomic_fetch_or:
case AtomicExpr::AO__atomic_fetch_xor:
case AtomicExpr::AO__atomic_fetch_nand:
case AtomicExpr::AO__atomic_and_fetch:
case AtomicExpr::AO__atomic_or_fetch:
case AtomicExpr::AO__atomic_xor_fetch:
case AtomicExpr::AO__atomic_nand_fetch:
  Form = Arithmetic;
  break;
case AtomicExpr::AO__c11_atomic_fetch_min:
case AtomicExpr::AO__c11_atomic_fetch_max:
case AtomicExpr::AO__opencl_atomic_fetch_min:
case AtomicExpr::AO__opencl_atomic_fetch_max:
case AtomicExpr::AO__atomic_min_fetch:
case AtomicExpr::AO__atomic_max_fetch:
case AtomicExpr::AO__atomic_fetch_min:
case AtomicExpr::AO__atomic_fetch_max:
  Form = Arithmetic;
  break;

case AtomicExpr::AO__c11_atomic_exchange:
case AtomicExpr::AO__opencl_atomic_exchange:
case AtomicExpr::AO__atomic_exchange_n:
  Form = Xchg;
  break;

case AtomicExpr::AO__atomic_exchange:
  Form = GNUXchg;
  break;

case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
  Form = C11CmpXchg;
  break;

case AtomicExpr::AO__atomic_compare_exchange:
case AtomicExpr::AO__atomic_compare_exchange_n:
  Form = GNUCmpXchg;
  break;
}

unsigned AdjustedNumArgs = NumArgs[Form];
if (IsOpenCL && Op != AtomicExpr::AO__opencl_atomic_init)
  ++AdjustedNumArgs;
// Check we have the right number of arguments.
if (Args.size() < AdjustedNumArgs) {
  Diag(CallRange.getEnd(), diag::err_typecheck_call_too_few_args)
      << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
      << ExprRange;
  return ExprError();
} else if (Args.size() > AdjustedNumArgs) {
  Diag(Args[AdjustedNumArgs]->getBeginLoc(),
       diag::err_typecheck_call_too_many_args)
      << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
      << ExprRange;
  return ExprError();
}

// Inspect the first argument of the atomic operation.
Expr *Ptr = Args[0];
ExprResult ConvertedPtr = DefaultFunctionArrayLvalueConversion(Ptr);
if (ConvertedPtr.isInvalid())
  return ExprError();

Ptr = ConvertedPtr.get();
const PointerType *pointerType = Ptr->getType()->getAs<PointerType>();
if (!pointerType) {
  Diag(ExprRange.getBegin(), diag::err_atomic_builtin_must_be_pointer)
      << Ptr->getType() << Ptr->getSourceRange();
  return ExprError();
}

// For a __c11 builtin, this should be a pointer to an _Atomic type.
QualType AtomTy = pointerType->getPointeeType(); // 'A'
QualType ValType = AtomTy; // 'C'
if (IsC11) {
  if (!AtomTy->isAtomicType()) {
    Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_atomic)
        << Ptr->getType() << Ptr->getSourceRange();
    return ExprError();
  }
  if ((Form != Load && Form != LoadCopy && AtomTy.isConstQualified()) ||
      AtomTy.getAddressSpace() == LangAS::opencl_constant) {
    Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_non_const_atomic)
        << (AtomTy.isConstQualified() ? 0 : 1) << Ptr->getType()
        << Ptr->getSourceRange();
    return ExprError();
  }
  ValType = AtomTy->castAs<AtomicType>()->getValueType();
} else if (Form != Load && Form != LoadCopy) {
  if (ValType.isConstQualified()) {
    Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_non_const_pointer)
        << Ptr->getType() << Ptr->getSourceRange();
    return ExprError();
  }
}

// For an arithmetic operation, the implied arithmetic must be well-formed.
if (Form == Arithmetic) {
  // gcc does not enforce these rules for GNU atomics, but we do so for
  // sanity.
  auto IsAllowedValueType = [&](QualType ValType) {
    if (ValType->isIntegerType())
      return true;
    if (ValType->isPointerType())
      return true;
    if (!ValType->isFloatingType())
      return false;
    // LLVM Parser does not allow atomicrmw with x86_fp80 type.
    if (ValType->isSpecificBuiltinType(BuiltinType::LongDouble) &&
        &Context.getTargetInfo().getLongDoubleFormat() ==
            &llvm::APFloat::x87DoubleExtended())
      return false;
    return true;
  };
  if (IsAddSub && !IsAllowedValueType(ValType)) {
    Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_atomic_int_ptr_or_fp)
        << IsC11 << Ptr->getType() << Ptr->getSourceRange();
    return ExprError();
  }
  if (!IsAddSub && !ValType->isIntegerType()) {
    Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_atomic_int)
        << IsC11 << Ptr->getType() << Ptr->getSourceRange();
    return ExprError();
  }
  if (IsC11 && ValType->isPointerType() &&
      RequireCompleteType(Ptr->getBeginLoc(), ValType->getPointeeType(),
                          diag::err_incomplete_type)) {
    return ExprError();
  }
} else if (IsN && !ValType->isIntegerType() && !ValType->isPointerType()) {
  // For __atomic_*_n operations, the value type must be a scalar integral or
  // pointer type which is 1, 2, 4, 8 or 16 bytes in length.
  Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
      << IsC11 << Ptr->getType() << Ptr->getSourceRange();
  return ExprError();
}

if (!IsC11 && !AtomTy.isTriviallyCopyableType(Context) &&
    !AtomTy->isScalarType()) {
  // For GNU atomics, require a trivially-copyable type. This is not part of
  // the GNU atomics specification, but we enforce it for sanity.
  Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_trivial_copy)
      << Ptr->getType() << Ptr->getSourceRange();
  return ExprError();
}

switch (ValType.getObjCLifetime()) {
case Qualifiers::OCL_None:
case Qualifiers::OCL_ExplicitNone:
  // okay
  break;

case Qualifiers::OCL_Weak:
case Qualifiers::OCL_Strong:
case Qualifiers::OCL_Autoreleasing:
  // FIXME: Can this happen? By this point, ValType should be known
  // to be trivially copyable.
  Diag(ExprRange.getBegin(), diag::err_arc_atomic_ownership)
      << ValType << Ptr->getSourceRange();
  return ExprError();
}

// All atomic operations have an overload which takes a pointer to a volatile
// 'A'.  We shouldn't let the volatile-ness of the pointee-type inject itself
// into the result or the other operands. Similarly atomic_load takes a
// pointer to a const 'A'.
ValType.removeLocalVolatile();
ValType.removeLocalConst();
QualType ResultType = ValType;
if (Form == Copy || Form == LoadCopy || Form == GNUXchg ||
    Form == Init)
  ResultType = Context.VoidTy;
else if (Form == C11CmpXchg || Form == GNUCmpXchg)
  ResultType = Context.BoolTy;

// The type of a parameter passed 'by value'. In the GNU atomics, such
// arguments are actually passed as pointers.
QualType ByValType = ValType; // 'CP'
bool IsPassedByAddress = false;
if (!IsC11 && !IsN) {
  ByValType = Ptr->getType();
  IsPassedByAddress = true;
}

SmallVector<Expr *, 5> APIOrderedArgs;
if (ArgOrder == Sema::AtomicArgumentOrder::AST) {
  APIOrderedArgs.push_back(Args[0]);
  switch (Form) {
  case Init:
  case Load:
    APIOrderedArgs.push_back(Args[1]); // Val1/Order
    break;
  case LoadCopy:
  case Copy:
  case Arithmetic:
  case Xchg:
    APIOrderedArgs.push_back(Args[2]); // Val1
    APIOrderedArgs.push_back(Args[1]); // Order
    break;
  case GNUXchg:
    APIOrderedArgs.push_back(Args[2]); // Val1
    APIOrderedArgs.push_back(Args[3]); // Val2
    APIOrderedArgs.push_back(Args[1]); // Order
    break;
  case C11CmpXchg:
    APIOrderedArgs.push_back(Args[2]); // Val1
    APIOrderedArgs.push_back(Args[4]); // Val2
    APIOrderedArgs.push_back(Args[1]); // Order
    APIOrderedArgs.push_back(Args[3]); // OrderFail
    break;
  case GNUCmpXchg:
    APIOrderedArgs.push_back(Args[2]); // Val1
    APIOrderedArgs.push_back(Args[4]); // Val2
    APIOrderedArgs.push_back(Args[5]); // Weak
    APIOrderedArgs.push_back(Args[1]); // Order
    APIOrderedArgs.push_back(Args[3]); // OrderFail
    break;
  }
} else
  APIOrderedArgs.append(Args.begin(), Args.end());

// The first argument's non-CV pointer type is used to deduce the type of
// subsequent arguments, except for:
//  - weak flag (always converted to bool)
//  - memory order (always converted to int)
//  - scope  (always converted to int)
for (unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
  QualType Ty;
  if (i < NumVals[Form] + 1) {
    switch (i) {
    case 0:
      // The first argument is always a pointer. It has a fixed type.
      // It is always dereferenced, a nullptr is undefined.
      CheckNonNullArgument(*this, APIOrderedArgs[i], ExprRange.getBegin());
      // Nothing else to do: we already know all we want about this pointer.
      continue;
    case 1:
      // The second argument is the non-atomic operand. For arithmetic, this
      // is always passed by value, and for a compare_exchange it is always
      // passed by address. For the rest, GNU uses by-address and C11 uses
      // by-value.
      assert(Form != Load)((void)0);
      if (Form == Arithmetic && ValType->isPointerType())
        Ty = Context.getPointerDiffType();
      else if (Form == Init || Form == Arithmetic)
        Ty = ValType;
      else if (Form == Copy || Form == Xchg) {
        if (IsPassedByAddress) {
          // The value pointer is always dereferenced, a nullptr is undefined.
          CheckNonNullArgument(*this, APIOrderedArgs[i],
                               ExprRange.getBegin());
        }
        Ty = ByValType;
      } else {
        Expr *ValArg = APIOrderedArgs[i];
        // The value pointer is always dereferenced, a nullptr is undefined.
        CheckNonNullArgument(*this, ValArg, ExprRange.getBegin());
        LangAS AS = LangAS::Default;
        // Keep address space of non-atomic pointer type.
        if (const PointerType *PtrTy =
                ValArg->getType()->getAs<PointerType>()) {
          AS = PtrTy->getPointeeType().getAddressSpace();
        }
        Ty = Context.getPointerType(
            Context.getAddrSpaceQualType(ValType.getUnqualifiedType(), AS));
      }
      break;
    case 2:
      // The third argument to compare_exchange / GNU exchange is the desired
      // value, either by-value (for the C11 and *_n variant) or as a pointer.
      if (IsPassedByAddress)
        CheckNonNullArgument(*this, APIOrderedArgs[i], ExprRange.getBegin());
      Ty = ByValType;
      break;
    case 3:
      // The fourth argument to GNU compare_exchange is a 'weak' flag.
      Ty = Context.BoolTy;
      break;
    }
  } else {
    // The order(s) and scope are always converted to int.
    Ty = Context.IntTy;
  }

  InitializedEntity Entity =
      InitializedEntity::InitializeParameter(Context, Ty, false);
  ExprResult Arg = APIOrderedArgs[i];
  Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
  if (Arg.isInvalid())
    return true;
  APIOrderedArgs[i] = Arg.get();
}

// Permute the arguments into a 'consistent' order.
SmallVector<Expr*, 5> SubExprs;
SubExprs.push_back(Ptr);
switch (Form) {
case Init:
  // Note, AtomicExpr::getVal1() has a special case for this atomic.
  SubExprs.push_back(APIOrderedArgs[1]); // Val1
  break;
case Load:
  SubExprs.push_back(APIOrderedArgs[1]); // Order
  break;
case LoadCopy:
case Copy:
case Arithmetic:
case Xchg:
  SubExprs.push_back(APIOrderedArgs[2]); // Order
  SubExprs.push_back(APIOrderedArgs[1]); // Val1
  break;
case GNUXchg:
  // Note, AtomicExpr::getVal2() has a special case for this atomic.
  SubExprs.push_back(APIOrderedArgs[3]); // Order
  SubExprs.push_back(APIOrderedArgs[1]); // Val1
  SubExprs.push_back(APIOrderedArgs[2]); // Val2
  break;
case C11CmpXchg:
  SubExprs.push_back(APIOrderedArgs[3]); // Order
  SubExprs.push_back(APIOrderedArgs[1]); // Val1
  SubExprs.push_back(APIOrderedArgs[4]); // OrderFail
  SubExprs.push_back(APIOrderedArgs[2]); // Val2
  break;
case GNUCmpXchg:
  SubExprs.push_back(APIOrderedArgs[4]); // Order
  SubExprs.push_back(APIOrderedArgs[1]); // Val1
  SubExprs.push_back(APIOrderedArgs[5]); // OrderFail
  SubExprs.push_back(APIOrderedArgs[2]); // Val2
  SubExprs.push_back(APIOrderedArgs[3]); // Weak
  break;
}

if (SubExprs.size() >= 2 && Form != Init) {
  if (Optional<llvm::APSInt> Result =
          SubExprs[1]->getIntegerConstantExpr(Context))
    if (!isValidOrderingForOp(Result->getSExtValue(), Op))
      Diag(SubExprs[1]->getBeginLoc(),
           diag::warn_atomic_op_has_invalid_memory_order)
          << SubExprs[1]->getSourceRange();
}

if (auto ScopeModel = AtomicExpr::getScopeModel(Op)) {
  auto *Scope = Args[Args.size() - 1];
  if (Optional<llvm::APSInt> Result =
          Scope->getIntegerConstantExpr(Context)) {
    if (!ScopeModel->isValid(Result->getZExtValue()))
      Diag(Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
          << Scope->getSourceRange();
  }
  SubExprs.push_back(Scope);
}

AtomicExpr *AE = new (Context)
    AtomicExpr(ExprRange.getBegin(), SubExprs, ResultType, Op, RParenLoc);

if ((Op == AtomicExpr::AO__c11_atomic_load ||
     Op == AtomicExpr::AO__c11_atomic_store ||
     Op == AtomicExpr::AO__opencl_atomic_load ||
     Op == AtomicExpr::AO__opencl_atomic_store ) &&
    Context.AtomicUsesUnsupportedLibcall(AE))
  Diag(AE->getBeginLoc(), diag::err_atomic_load_store_uses_lib)
      << ((Op == AtomicExpr::AO__c11_atomic_load ||
           Op == AtomicExpr::AO__opencl_atomic_load)
              ? 0
              : 1);

if (ValType->isExtIntType()) {
  Diag(Ptr->getExprLoc(), diag::err_atomic_builtin_ext_int_prohibit);
  return ExprError();
}

return AE;
5611}

5613/// checkBuiltinArgument - Given a call to a builtin function, perform
5614/// normal type-checking on the given argument, updating the call in
5615/// place.  This is useful when a builtin function requires custom
5616/// type-checking for some of its arguments but not necessarily all of
5617/// them.
5618///
5619/// Returns true on error.
5620static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex) {
FunctionDecl *Fn = E->getDirectCallee();
assert(Fn && "builtin call without direct callee!")((void)0);

ParmVarDecl *Param = Fn->getParamDecl(ArgIndex);
InitializedEntity Entity =
  InitializedEntity::InitializeParameter(S.Context, Param);

ExprResult Arg = E->getArg(0);
Arg = S.PerformCopyInitialization(Entity, SourceLocation(), Arg);
if (Arg.isInvalid())
  return true;

E->setArg(ArgIndex, Arg.get());
return false;
5635}

5637/// We have a call to a function like __sync_fetch_and_add, which is an
5638/// overloaded function based on the pointer type of its first argument.
5639/// The main BuildCallExpr routines have already promoted the types of
5640/// arguments because all of these calls are prototyped as void(...).
5641///
5642/// This function goes through and does final semantic checking for these
5643/// builtins, as well as generating any warnings.
5644ExprResult
5645Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) {
CallExpr *TheCall = static_cast<CallExpr *>(TheCallResult.get());
Expr *Callee = TheCall->getCallee();
DeclRefExpr *DRE = cast<DeclRefExpr>(Callee->IgnoreParenCasts());
FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());

// Ensure that we have at least one argument to do type inference from.
if (TheCall->getNumArgs() < 1) {
  Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
      << 0 << 1 << TheCall->getNumArgs() << Callee->getSourceRange();
  return ExprError();
}

// Inspect the first argument of the atomic builtin.  This should always be
// a pointer type, whose element is an integral scalar or pointer type.
// Because it is a pointer type, we don't have to worry about any implicit
// casts here.
// FIXME: We don't allow floating point scalars as input.
Expr *FirstArg = TheCall->getArg(0);
ExprResult FirstArgResult = DefaultFunctionArrayLvalueConversion(FirstArg);
if (FirstArgResult.isInvalid())
  return ExprError();
FirstArg = FirstArgResult.get();
TheCall->setArg(0, FirstArg);

const PointerType *pointerType = FirstArg->getType()->getAs<PointerType>();
if (!pointerType) {
  Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_must_be_pointer)
      << FirstArg->getType() << FirstArg->getSourceRange();
  return ExprError();
}

QualType ValType = pointerType->getPointeeType();
if (!ValType->isIntegerType() && !ValType->isAnyPointerType() &&
    !ValType->isBlockPointerType()) {
  Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
      << FirstArg->getType() << FirstArg->getSourceRange();
  return ExprError();
}

if (ValType.isConstQualified()) {
  Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_cannot_be_const)
      << FirstArg->getType() << FirstArg->getSourceRange();
  return ExprError();
}

switch (ValType.getObjCLifetime()) {
case Qualifiers::OCL_None:
case Qualifiers::OCL_ExplicitNone:
  // okay
  break;

case Qualifiers::OCL_Weak:
case Qualifiers::OCL_Strong:
case Qualifiers::OCL_Autoreleasing:
  Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership)
      << ValType << FirstArg->getSourceRange();
  return ExprError();
}

// Strip any qualifiers off ValType.
ValType = ValType.getUnqualifiedType();

// The majority of builtins return a value, but a few have special return
// types, so allow them to override appropriately below.
QualType ResultType = ValType;

// We need to figure out which concrete builtin this maps onto.  For example,
// __sync_fetch_and_add with a 2 byte object turns into
// __sync_fetch_and_add_2.
5715#define BUILTIN_ROW(x) \
{ Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
  Builtin::BI##x##_8, Builtin::BI##x##_16 }

static const unsigned BuiltinIndices[][5] = {
  BUILTIN_ROW(__sync_fetch_and_add),
  BUILTIN_ROW(__sync_fetch_and_sub),
  BUILTIN_ROW(__sync_fetch_and_or),
  BUILTIN_ROW(__sync_fetch_and_and),
  BUILTIN_ROW(__sync_fetch_and_xor),
  BUILTIN_ROW(__sync_fetch_and_nand),

  BUILTIN_ROW(__sync_add_and_fetch),
  BUILTIN_ROW(__sync_sub_and_fetch),
  BUILTIN_ROW(__sync_and_and_fetch),
  BUILTIN_ROW(__sync_or_and_fetch),
  BUILTIN_ROW(__sync_xor_and_fetch),
  BUILTIN_ROW(__sync_nand_and_fetch),

  BUILTIN_ROW(__sync_val_compare_and_swap),
  BUILTIN_ROW(__sync_bool_compare_and_swap),
  BUILTIN_ROW(__sync_lock_test_and_set),
  BUILTIN_ROW(__sync_lock_release),
  BUILTIN_ROW(__sync_swap)
};
5740#undef BUILTIN_ROW

// Determine the index of the size.
unsigned SizeIndex;
switch (Context.getTypeSizeInChars(ValType).getQuantity()) {
case 1: SizeIndex = 0; break;
case 2: SizeIndex = 1; break;
case 4: SizeIndex = 2; break;
case 8: SizeIndex = 3; break;
case 16: SizeIndex = 4; break;
default:
  Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_pointer_size)
      << FirstArg->getType() << FirstArg->getSourceRange();
  return ExprError();
}

// Each of these builtins has one pointer argument, followed by some number of
// values (0, 1 or 2) followed by a potentially empty varags list of stuff
// that we ignore.  Find out which row of BuiltinIndices to read from as well
// as the number of fixed args.
unsigned BuiltinID = FDecl->getBuiltinID();
unsigned BuiltinIndex, NumFixed = 1;
bool WarnAboutSemanticsChange = false;
switch (BuiltinID) {
default: llvm_unreachable("Unknown overloaded atomic builtin!")__builtin_unreachable();
case Builtin::BI__sync_fetch_and_add:
case Builtin::BI__sync_fetch_and_add_1:
case Builtin::BI__sync_fetch_and_add_2:
case Builtin::BI__sync_fetch_and_add_4:
case Builtin::BI__sync_fetch_and_add_8:
case Builtin::BI__sync_fetch_and_add_16:
  BuiltinIndex = 0;
  break;

case Builtin::BI__sync_fetch_and_sub:
case Builtin::BI__sync_fetch_and_sub_1:
case Builtin::BI__sync_fetch_and_sub_2:
case Builtin::BI__sync_fetch_and_sub_4:
case Builtin::BI__sync_fetch_and_sub_8:
case Builtin::BI__sync_fetch_and_sub_16:
  BuiltinIndex = 1;
  break;

case Builtin::BI__sync_fetch_and_or:
case Builtin::BI__sync_fetch_and_or_1:
case Builtin::BI__sync_fetch_and_or_2:
case Builtin::BI__sync_fetch_and_or_4:
case Builtin::BI__sync_fetch_and_or_8:
case Builtin::BI__sync_fetch_and_or_16:
  BuiltinIndex = 2;
  break;

case Builtin::BI__sync_fetch_and_and:
case Builtin::BI__sync_fetch_and_and_1:
case Builtin::BI__sync_fetch_and_and_2:
case Builtin::BI__sync_fetch_and_and_4:
case Builtin::BI__sync_fetch_and_and_8:
case Builtin::BI__sync_fetch_and_and_16:
  BuiltinIndex = 3;
  break;

case Builtin::BI__sync_fetch_and_xor:
case Builtin::BI__sync_fetch_and_xor_1:
case Builtin::BI__sync_fetch_and_xor_2:
case Builtin::BI__sync_fetch_and_xor_4:
case Builtin::BI__sync_fetch_and_xor_8:
case Builtin::BI__sync_fetch_and_xor_16:
  BuiltinIndex = 4;
  break;

case Builtin::BI__sync_fetch_and_nand:
case Builtin::BI__sync_fetch_and_nand_1:
case Builtin::BI__sync_fetch_and_nand_2:
case Builtin::BI__sync_fetch_and_nand_4:
case Builtin::BI__sync_fetch_and_nand_8:
case Builtin::BI__sync_fetch_and_nand_16:
  BuiltinIndex = 5;
  WarnAboutSemanticsChange = true;
  break;

case Builtin::BI__sync_add_and_fetch:
case Builtin::BI__sync_add_and_fetch_1:
case Builtin::BI__sync_add_and_fetch_2:
case Builtin::BI__sync_add_and_fetch_4:
case Builtin::BI__sync_add_and_fetch_8:
case Builtin::BI__sync_add_and_fetch_16:
  BuiltinIndex = 6;
  break;

case Builtin::BI__sync_sub_and_fetch:
case Builtin::BI__sync_sub_and_fetch_1:
case Builtin::BI__sync_sub_and_fetch_2:
case Builtin::BI__sync_sub_and_fetch_4:
case Builtin::BI__sync_sub_and_fetch_8:
case Builtin::BI__sync_sub_and_fetch_16:
  BuiltinIndex = 7;
  break;

case Builtin::BI__sync_and_and_fetch:
case Builtin::BI__sync_and_and_fetch_1:
case Builtin::BI__sync_and_and_fetch_2:
case Builtin::BI__sync_and_and_fetch_4:
case Builtin::BI__sync_and_and_fetch_8:
case Builtin::BI__sync_and_and_fetch_16:
  BuiltinIndex = 8;
  break;

case Builtin::BI__sync_or_and_fetch:
case Builtin::BI__sync_or_and_fetch_1:
case Builtin::BI__sync_or_and_fetch_2:
case Builtin::BI__sync_or_and_fetch_4:
case Builtin::BI__sync_or_and_fetch_8:
case Builtin::BI__sync_or_and_fetch_16:
  BuiltinIndex = 9;
  break;

case Builtin::BI__sync_xor_and_fetch:
case Builtin::BI__sync_xor_and_fetch_1:
case Builtin::BI__sync_xor_and_fetch_2:
case Builtin::BI__sync_xor_and_fetch_4:
case Builtin::BI__sync_xor_and_fetch_8:
case Builtin::BI__sync_xor_and_fetch_16:
  BuiltinIndex = 10;
  break;

case Builtin::BI__sync_nand_and_fetch:
case Builtin::BI__sync_nand_and_fetch_1:
case Builtin::BI__sync_nand_and_fetch_2:
case Builtin::BI__sync_nand_and_fetch_4:
case Builtin::BI__sync_nand_and_fetch_8:
case Builtin::BI__sync_nand_and_fetch_16:
  BuiltinIndex = 11;
  WarnAboutSemanticsChange = true;
  break;

case Builtin::BI__sync_val_compare_and_swap:
case Builtin::BI__sync_val_compare_and_swap_1:
case Builtin::BI__sync_val_compare_and_swap_2:
case Builtin::BI__sync_val_compare_and_swap_4:
case Builtin::BI__sync_val_compare_and_swap_8:
case Builtin::BI__sync_val_compare_and_swap_16:
  BuiltinIndex = 12;
  NumFixed = 2;
  break;

case Builtin::BI__sync_bool_compare_and_swap:
case Builtin::BI__sync_bool_compare_and_swap_1:
case Builtin::BI__sync_bool_compare_and_swap_2:
case Builtin::BI__sync_bool_compare_and_swap_4:
case Builtin::BI__sync_bool_compare_and_swap_8:
case Builtin::BI__sync_bool_compare_and_swap_16:
  BuiltinIndex = 13;
  NumFixed = 2;
  ResultType = Context.BoolTy;
  break;

case Builtin::BI__sync_lock_test_and_set:
case Builtin::BI__sync_lock_test_and_set_1:
case Builtin::BI__sync_lock_test_and_set_2:
case Builtin::BI__sync_lock_test_and_set_4:
case Builtin::BI__sync_lock_test_and_set_8:
case Builtin::BI__sync_lock_test_and_set_16:
  BuiltinIndex = 14;
  break;

case Builtin::BI__sync_lock_release:
case Builtin::BI__sync_lock_release_1:
case Builtin::BI__sync_lock_release_2:
case Builtin::BI__sync_lock_release_4:
case Builtin::BI__sync_lock_release_8:
case Builtin::BI__sync_lock_release_16:
  BuiltinIndex = 15;
  NumFixed = 0;
  ResultType = Context.VoidTy;
  break;

case Builtin::BI__sync_swap:
case Builtin::BI__sync_swap_1:
case Builtin::BI__sync_swap_2:
case Builtin::BI__sync_swap_4:
case Builtin::BI__sync_swap_8:
case Builtin::BI__sync_swap_16:
  BuiltinIndex = 16;
  break;
}

// Now that we know how many fixed arguments we expect, first check that we
// have at least that many.
if (TheCall->getNumArgs() < 1+NumFixed) {
  Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
      << 0 << 1 + NumFixed << TheCall->getNumArgs()
      << Callee->getSourceRange();
  return ExprError();
}

Diag(TheCall->getEndLoc(), diag::warn_atomic_implicit_seq_cst)
    << Callee->getSourceRange();

if (WarnAboutSemanticsChange) {
  Diag(TheCall->getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
      << Callee->getSourceRange();
}

// Get the decl for the concrete builtin from this, we can tell what the
// concrete integer type we should convert to is.
unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
const char *NewBuiltinName = Context.BuiltinInfo.getName(NewBuiltinID);
FunctionDecl *NewBuiltinDecl;
if (NewBuiltinID == BuiltinID)
  NewBuiltinDecl = FDecl;
else {
  // Perform builtin lookup to avoid redeclaring it.
  DeclarationName DN(&Context.Idents.get(NewBuiltinName));
  LookupResult Res(*this, DN, DRE->getBeginLoc(), LookupOrdinaryName);
  LookupName(Res, TUScope, /*AllowBuiltinCreation=*/true);
  assert(Res.getFoundDecl())((void)0);
  NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
  if (!NewBuiltinDecl)
    return ExprError();
}

// The first argument --- the pointer --- has a fixed type; we
// deduce the types of the rest of the arguments accordingly.  Walk
// the remaining arguments, converting them to the deduced value type.
for (unsigned i = 0; i != NumFixed; ++i) {
  ExprResult Arg = TheCall->getArg(i+1);

  // GCC does an implicit conversion to the pointer or integer ValType.  This
  // can fail in some cases (1i -> int**), check for this error case now.
  // Initialize the argument.
  InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
                                                 ValType, /*consume*/ false);
  Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
  if (Arg.isInvalid())
    return ExprError();

  // Okay, we have something that *can* be converted to the right type.  Check
  // to see if there is a potentially weird extension going on here.  This can
  // happen when you do an atomic operation on something like an char* and
  // pass in 42.  The 42 gets converted to char.  This is even more strange
  // for things like 45.123 -> char, etc.
  // FIXME: Do this check.
  TheCall->setArg(i+1, Arg.get());
}

// Create a new DeclRefExpr to refer to the new decl.
DeclRefExpr *NewDRE = DeclRefExpr::Create(
    Context, DRE->getQualifierLoc(), SourceLocation(), NewBuiltinDecl,
    /*enclosing*/ false, DRE->getLocation(), Context.BuiltinFnTy,
    DRE->getValueKind(), nullptr, nullptr, DRE->isNonOdrUse());

// Set the callee in the CallExpr.
// FIXME: This loses syntactic information.
QualType CalleePtrTy = Context.getPointerType(NewBuiltinDecl->getType());
ExprResult PromotedCall = ImpCastExprToType(NewDRE, CalleePtrTy,
                                            CK_BuiltinFnToFnPtr);
TheCall->setCallee(PromotedCall.get());

// Change the result type of the call to match the original value type. This
// is arbitrary, but the codegen for these builtins ins design to handle it
// gracefully.
TheCall->setType(ResultType);

// Pro