/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp

Bug Summary

File:	clang/lib/CodeGen/CGExprScalar.cpp
Warning:	line 3838, column 39 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGExprScalar.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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-11-115256-23437-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp

/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp

→

1//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//
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 contains code to emit Expr nodes with scalar LLVM types as LLVM code.
10//
11//===----------------------------------------------------------------------===//

13#include "CGCXXABI.h"
14#include "CGCleanup.h"
15#include "CGDebugInfo.h"
16#include "CGObjCRuntime.h"
17#include "CGOpenMPRuntime.h"
18#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
20#include "ConstantEmitter.h"
21#include "TargetInfo.h"
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/Attr.h"
24#include "clang/AST/DeclObjC.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/RecordLayout.h"
27#include "clang/AST/StmtVisitor.h"
28#include "clang/Basic/CodeGenOptions.h"
29#include "clang/Basic/FixedPoint.h"
30#include "clang/Basic/TargetInfo.h"
31#include "llvm/ADT/Optional.h"
32#include "llvm/IR/CFG.h"
33#include "llvm/IR/Constants.h"
34#include "llvm/IR/DataLayout.h"
35#include "llvm/IR/Function.h"
36#include "llvm/IR/GetElementPtrTypeIterator.h"
37#include "llvm/IR/GlobalVariable.h"
38#include "llvm/IR/Intrinsics.h"
39#include "llvm/IR/IntrinsicsPowerPC.h"
40#include "llvm/IR/Module.h"
41#include <cstdarg>

43using namespace clang;
44using namespace CodeGen;
45using llvm::Value;

47//===----------------------------------------------------------------------===//
48//                         Scalar Expression Emitter
49//===----------------------------------------------------------------------===//

51namespace {

53/// Determine whether the given binary operation may overflow.
54/// Sets \p Result to the value of the operation for BO_Add, BO_Sub, BO_Mul,
55/// and signed BO_{Div,Rem}. For these opcodes, and for unsigned BO_{Div,Rem},
56/// the returned overflow check is precise. The returned value is 'true' for
57/// all other opcodes, to be conservative.
58bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
                           BinaryOperator::Opcode Opcode, bool Signed,
                           llvm::APInt &Result) {
// Assume overflow is possible, unless we can prove otherwise.
bool Overflow = true;
const auto &LHSAP = LHS->getValue();
const auto &RHSAP = RHS->getValue();
if (Opcode == BO_Add) {
  if (Signed)
    Result = LHSAP.sadd_ov(RHSAP, Overflow);
  else
    Result = LHSAP.uadd_ov(RHSAP, Overflow);
} else if (Opcode == BO_Sub) {
  if (Signed)
    Result = LHSAP.ssub_ov(RHSAP, Overflow);
  else
    Result = LHSAP.usub_ov(RHSAP, Overflow);
} else if (Opcode == BO_Mul) {
  if (Signed)
    Result = LHSAP.smul_ov(RHSAP, Overflow);
  else
    Result = LHSAP.umul_ov(RHSAP, Overflow);
} else if (Opcode == BO_Div || Opcode == BO_Rem) {
  if (Signed && !RHS->isZero())
    Result = LHSAP.sdiv_ov(RHSAP, Overflow);
  else
    return false;
}
return Overflow;
87}

89struct BinOpInfo {
Value *LHS;
Value *RHS;
QualType Ty;  // Computation Type.
BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform
FPOptions FPFeatures;
const Expr *E;      // Entire expr, for error unsupported.  May not be binop.

/// Check if the binop can result in integer overflow.
bool mayHaveIntegerOverflow() const {
  // Without constant input, we can't rule out overflow.
  auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
  auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
  if (!LHSCI || !RHSCI)
    return true;

  llvm::APInt Result;
  return ::mayHaveIntegerOverflow(
      LHSCI, RHSCI, Opcode, Ty->hasSignedIntegerRepresentation(), Result);
}

/// Check if the binop computes a division or a remainder.
bool isDivremOp() const {
  return Opcode == BO_Div || Opcode == BO_Rem || Opcode == BO_DivAssign ||
         Opcode == BO_RemAssign;
}

/// Check if the binop can result in an integer division by zero.
bool mayHaveIntegerDivisionByZero() const {
  if (isDivremOp())
    if (auto *CI = dyn_cast<llvm::ConstantInt>(RHS))
      return CI->isZero();
  return true;
}

/// Check if the binop can result in a float division by zero.
bool mayHaveFloatDivisionByZero() const {
  if (isDivremOp())
    if (auto *CFP = dyn_cast<llvm::ConstantFP>(RHS))
      return CFP->isZero();
  return true;
}

/// Check if either operand is a fixed point type or integer type, with at
/// least one being a fixed point type. In any case, this
/// operation did not follow usual arithmetic conversion and both operands may
/// not be the same.
bool isFixedPointBinOp() const {
  // We cannot simply check the result type since comparison operations return
  // an int.
  if (const auto *BinOp = dyn_cast<BinaryOperator>(E)) {
    QualType LHSType = BinOp->getLHS()->getType();
    QualType RHSType = BinOp->getRHS()->getType();
    return LHSType->isFixedPointType() || RHSType->isFixedPointType();
  }
  return false;
}
146};

148static bool MustVisitNullValue(const Expr *E) {
// If a null pointer expression's type is the C++0x nullptr_t, then
// it's not necessarily a simple constant and it must be evaluated
// for its potential side effects.
return E->getType()->isNullPtrType();
153}

155/// If \p E is a widened promoted integer, get its base (unpromoted) type.
156static llvm::Optional<QualType> getUnwidenedIntegerType(const ASTContext &Ctx,
                                                      const Expr *E) {
const Expr *Base = E->IgnoreImpCasts();
if (E == Base)
  return llvm::None;

QualType BaseTy = Base->getType();
if (!BaseTy->isPromotableIntegerType() ||
    Ctx.getTypeSize(BaseTy) >= Ctx.getTypeSize(E->getType()))
  return llvm::None;

return BaseTy;
168}

170/// Check if \p E is a widened promoted integer.
171static bool IsWidenedIntegerOp(const ASTContext &Ctx, const Expr *E) {
return getUnwidenedIntegerType(Ctx, E).hasValue();
173}

175/// Check if we can skip the overflow check for \p Op.
176static bool CanElideOverflowCheck(const ASTContext &Ctx, const BinOpInfo &Op) {
assert((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) &&(((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>
(Op.E)) && "Expected a unary or binary operator") ? static_cast
<void> (0) : __assert_fail ("(isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) && \"Expected a unary or binary operator\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 178, __PRETTY_FUNCTION__))
       "Expected a unary or binary operator")(((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>
(Op.E)) && "Expected a unary or binary operator") ? static_cast
<void> (0) : __assert_fail ("(isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) && \"Expected a unary or binary operator\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 178, __PRETTY_FUNCTION__));

// If the binop has constant inputs and we can prove there is no overflow,
// we can elide the overflow check.
if (!Op.mayHaveIntegerOverflow())
  return true;

// If a unary op has a widened operand, the op cannot overflow.
if (const auto *UO = dyn_cast<UnaryOperator>(Op.E))
  return !UO->canOverflow();

// We usually don't need overflow checks for binops with widened operands.
// Multiplication with promoted unsigned operands is a special case.
const auto *BO = cast<BinaryOperator>(Op.E);
auto OptionalLHSTy = getUnwidenedIntegerType(Ctx, BO->getLHS());
if (!OptionalLHSTy)
  return false;

auto OptionalRHSTy = getUnwidenedIntegerType(Ctx, BO->getRHS());
if (!OptionalRHSTy)
  return false;

QualType LHSTy = *OptionalLHSTy;
QualType RHSTy = *OptionalRHSTy;

// This is the simple case: binops without unsigned multiplication, and with
// widened operands. No overflow check is needed here.
if ((Op.Opcode != BO_Mul && Op.Opcode != BO_MulAssign) ||
    !LHSTy->isUnsignedIntegerType() || !RHSTy->isUnsignedIntegerType())
  return true;

// For unsigned multiplication the overflow check can be elided if either one
// of the unpromoted types are less than half the size of the promoted type.
unsigned PromotedSize = Ctx.getTypeSize(Op.E->getType());
return (2 * Ctx.getTypeSize(LHSTy)) < PromotedSize ||
       (2 * Ctx.getTypeSize(RHSTy)) < PromotedSize;
214}

216/// Update the FastMathFlags of LLVM IR from the FPOptions in LangOptions.
217static void updateFastMathFlags(llvm::FastMathFlags &FMF,
                              FPOptions FPFeatures) {
FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());
220}

222/// Propagate fast-math flags from \p Op to the instruction in \p V.
223static Value *propagateFMFlags(Value *V, const BinOpInfo &Op) {
if (auto *I = dyn_cast<llvm::Instruction>(V)) {
  llvm::FastMathFlags FMF = I->getFastMathFlags();
  updateFastMathFlags(FMF, Op.FPFeatures);
  I->setFastMathFlags(FMF);
}
return V;
230}

232class ScalarExprEmitter
: public StmtVisitor<ScalarExprEmitter, Value*> {
CodeGenFunction &CGF;
CGBuilderTy &Builder;
bool IgnoreResultAssign;
llvm::LLVMContext &VMContext;
238public:

ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
  : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
    VMContext(cgf.getLLVMContext()) {
}

//===--------------------------------------------------------------------===//
//                               Utilities
//===--------------------------------------------------------------------===//

bool TestAndClearIgnoreResultAssign() {
  bool I = IgnoreResultAssign;
  IgnoreResultAssign = false;
  return I;
}

llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
LValue EmitCheckedLValue(const Expr *E, CodeGenFunction::TypeCheckKind TCK) {
  return CGF.EmitCheckedLValue(E, TCK);
}

void EmitBinOpCheck(ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
                    const BinOpInfo &Info);

Value *EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
  return CGF.EmitLoadOfLValue(LV, Loc).getScalarVal();
}

void EmitLValueAlignmentAssumption(const Expr *E, Value *V) {
  const AlignValueAttr *AVAttr = nullptr;
  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
    const ValueDecl *VD = DRE->getDecl();

    if (VD->getType()->isReferenceType()) {
      if (const auto *TTy =
          dyn_cast<TypedefType>(VD->getType().getNonReferenceType()))
        AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
    } else {
      // Assumptions for function parameters are emitted at the start of the
      // function, so there is no need to repeat that here,
      // unless the alignment-assumption sanitizer is enabled,
      // then we prefer the assumption over alignment attribute
      // on IR function param.
      if (isa<ParmVarDecl>(VD) && !CGF.SanOpts.has(SanitizerKind::Alignment))
        return;

      AVAttr = VD->getAttr<AlignValueAttr>();
    }
  }

  if (!AVAttr)
    if (const auto *TTy =
        dyn_cast<TypedefType>(E->getType()))
      AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();

  if (!AVAttr)
    return;

  Value *AlignmentValue = CGF.EmitScalarExpr(AVAttr->getAlignment());
  llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
  CGF.EmitAlignmentAssumption(V, E, AVAttr->getLocation(), AlignmentCI);
}

/// EmitLoadOfLValue - Given an expression with complex type that represents a
/// value l-value, this method emits the address of the l-value, then loads
/// and returns the result.
Value *EmitLoadOfLValue(const Expr *E) {
  Value *V = EmitLoadOfLValue(EmitCheckedLValue(E, CodeGenFunction::TCK_Load),
                              E->getExprLoc());

  EmitLValueAlignmentAssumption(E, V);
  return V;
}

/// EmitConversionToBool - Convert the specified expression value to a
/// boolean (i1) truth value.  This is equivalent to "Val != 0".
Value *EmitConversionToBool(Value *Src, QualType DstTy);

/// Emit a check that a conversion from a floating-point type does not
/// overflow.
void EmitFloatConversionCheck(Value *OrigSrc, QualType OrigSrcType,
                              Value *Src, QualType SrcType, QualType DstType,
                              llvm::Type *DstTy, SourceLocation Loc);

/// Known implicit conversion check kinds.
/// Keep in sync with the enum of the same name in ubsan_handlers.h
enum ImplicitConversionCheckKind : unsigned char {
  ICCK_IntegerTruncation = 0, // Legacy, was only used by clang 7.
  ICCK_UnsignedIntegerTruncation = 1,
  ICCK_SignedIntegerTruncation = 2,
  ICCK_IntegerSignChange = 3,
  ICCK_SignedIntegerTruncationOrSignChange = 4,
};

/// Emit a check that an [implicit] truncation of an integer  does not
/// discard any bits. It is not UB, so we use the value after truncation.
void EmitIntegerTruncationCheck(Value *Src, QualType SrcType, Value *Dst,
                                QualType DstType, SourceLocation Loc);

/// Emit a check that an [implicit] conversion of an integer does not change
/// the sign of the value. It is not UB, so we use the value after conversion.
/// NOTE: Src and Dst may be the exact same value! (point to the same thing)
void EmitIntegerSignChangeCheck(Value *Src, QualType SrcType, Value *Dst,
                                QualType DstType, SourceLocation Loc);

/// Emit a conversion from the specified type to the specified destination
/// type, both of which are LLVM scalar types.
struct ScalarConversionOpts {
  bool TreatBooleanAsSigned;
  bool EmitImplicitIntegerTruncationChecks;
  bool EmitImplicitIntegerSignChangeChecks;

  ScalarConversionOpts()
      : TreatBooleanAsSigned(false),
        EmitImplicitIntegerTruncationChecks(false),
        EmitImplicitIntegerSignChangeChecks(false) {}

  ScalarConversionOpts(clang::SanitizerSet SanOpts)
      : TreatBooleanAsSigned(false),
        EmitImplicitIntegerTruncationChecks(
            SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation)),
        EmitImplicitIntegerSignChangeChecks(
            SanOpts.has(SanitizerKind::ImplicitIntegerSignChange)) {}
};
Value *
EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy,
                     SourceLocation Loc,
                     ScalarConversionOpts Opts = ScalarConversionOpts());

/// Convert between either a fixed point and other fixed point or fixed point
/// and an integer.
Value *EmitFixedPointConversion(Value *Src, QualType SrcTy, QualType DstTy,
                                SourceLocation Loc);
Value *EmitFixedPointConversion(Value *Src, FixedPointSemantics &SrcFixedSema,
                                FixedPointSemantics &DstFixedSema,
                                SourceLocation Loc,
                                bool DstIsInteger = false);

/// Emit a conversion from the specified complex type to the specified
/// destination type, where the destination type is an LLVM scalar type.
Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
                                     QualType SrcTy, QualType DstTy,
                                     SourceLocation Loc);

/// EmitNullValue - Emit a value that corresponds to null for the given type.
Value *EmitNullValue(QualType Ty);

/// EmitFloatToBoolConversion - Perform an FP to boolean conversion.
Value *EmitFloatToBoolConversion(Value *V) {
  // Compare against 0.0 for fp scalars.
  llvm::Value *Zero = llvm::Constant::getNullValue(V->getType());
  return Builder.CreateFCmpUNE(V, Zero, "tobool");
}

/// EmitPointerToBoolConversion - Perform a pointer to boolean conversion.
Value *EmitPointerToBoolConversion(Value *V, QualType QT) {
  Value *Zero = CGF.CGM.getNullPointer(cast<llvm::PointerType>(V->getType()), QT);

  return Builder.CreateICmpNE(V, Zero, "tobool");
}

Value *EmitIntToBoolConversion(Value *V) {
  // Because of the type rules of C, we often end up computing a
  // logical value, then zero extending it to int, then wanting it
  // as a logical value again.  Optimize this common case.
  if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) {
    if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
      Value *Result = ZI->getOperand(0);
      // If there aren't any more uses, zap the instruction to save space.
      // Note that there can be more uses, for example if this
      // is the result of an assignment.
      if (ZI->use_empty())
        ZI->eraseFromParent();
      return Result;
    }
  }

  return Builder.CreateIsNotNull(V, "tobool");
}

//===--------------------------------------------------------------------===//
//                            Visitor Methods
//===--------------------------------------------------------------------===//

Value *Visit(Expr *E) {
  ApplyDebugLocation DL(CGF, E);
  return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E);
}

Value *VisitStmt(Stmt *S) {
  S->dump(CGF.getContext().getSourceManager());
  llvm_unreachable("Stmt can't have complex result type!")::llvm::llvm_unreachable_internal("Stmt can't have complex result type!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 431);
}
Value *VisitExpr(Expr *S);

Value *VisitConstantExpr(ConstantExpr *E) {
  return Visit(E->getSubExpr());
}
Value *VisitParenExpr(ParenExpr *PE) {
  return Visit(PE->getSubExpr());
}
Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
  return Visit(E->getReplacement());
}
Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
  return Visit(GE->getResultExpr());
}
Value *VisitCoawaitExpr(CoawaitExpr *S) {
  return CGF.EmitCoawaitExpr(*S).getScalarVal();
}
Value *VisitCoyieldExpr(CoyieldExpr *S) {
  return CGF.EmitCoyieldExpr(*S).getScalarVal();
}
Value *VisitUnaryCoawait(const UnaryOperator *E) {
  return Visit(E->getSubExpr());
}

// Leaves.
Value *VisitIntegerLiteral(const IntegerLiteral *E) {
  return Builder.getInt(E->getValue());
}
Value *VisitFixedPointLiteral(const FixedPointLiteral *E) {
  return Builder.getInt(E->getValue());
}
Value *VisitFloatingLiteral(const FloatingLiteral *E) {
  return llvm::ConstantFP::get(VMContext, E->getValue());
}
Value *VisitCharacterLiteral(const CharacterLiteral *E) {
  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
}
Value *VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
}
Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
}
Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
  return EmitNullValue(E->getType());
}
Value *VisitGNUNullExpr(const GNUNullExpr *E) {
  return EmitNullValue(E->getType());
}
Value *VisitOffsetOfExpr(OffsetOfExpr *E);
Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
  llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
  return Builder.CreateBitCast(V, ConvertType(E->getType()));
}

Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) {
  return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength());
}

Value *VisitPseudoObjectExpr(PseudoObjectExpr *E) {
  return CGF.EmitPseudoObjectRValue(E).getScalarVal();
}

Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) {
  if (E->isGLValue())
    return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
                            E->getExprLoc());

  // Otherwise, assume the mapping is the scalar directly.
  return CGF.getOrCreateOpaqueRValueMapping(E).getScalarVal();
}

// l-values.
Value *VisitDeclRefExpr(DeclRefExpr *E) {
  if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
    return CGF.emitScalarConstant(Constant, E);
  return EmitLoadOfLValue(E);
}

Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
  return CGF.EmitObjCSelectorExpr(E);
}
Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
  return CGF.EmitObjCProtocolExpr(E);
}
Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
  return EmitLoadOfLValue(E);
}
Value *VisitObjCMessageExpr(ObjCMessageExpr *E) {
  if (E->getMethodDecl() &&
      E->getMethodDecl()->getReturnType()->isReferenceType())
    return EmitLoadOfLValue(E);
  return CGF.EmitObjCMessageExpr(E).getScalarVal();
}

Value *VisitObjCIsaExpr(ObjCIsaExpr *E) {
  LValue LV = CGF.EmitObjCIsaExpr(E);
  Value *V = CGF.EmitLoadOfLValue(LV, E->getExprLoc()).getScalarVal();
  return V;
}

Value *VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
  VersionTuple Version = E->getVersion();

  // If we're checking for a platform older than our minimum deployment
  // target, we can fold the check away.
  if (Version <= CGF.CGM.getTarget().getPlatformMinVersion())
    return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);

  Optional<unsigned> Min = Version.getMinor(), SMin = Version.getSubminor();
  llvm::Value *Args[] = {
      llvm::ConstantInt::get(CGF.CGM.Int32Ty, Version.getMajor()),
      llvm::ConstantInt::get(CGF.CGM.Int32Ty, Min ? *Min : 0),
      llvm::ConstantInt::get(CGF.CGM.Int32Ty, SMin ? *SMin : 0),
  };

  return CGF.EmitBuiltinAvailable(Args);
}

Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E);
Value *VisitConvertVectorExpr(ConvertVectorExpr *E);
Value *VisitMemberExpr(MemberExpr *E);
Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
  return EmitLoadOfLValue(E);
}

Value *VisitInitListExpr(InitListExpr *E);

Value *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
  assert(CGF.getArrayInitIndex() &&((CGF.getArrayInitIndex() && "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?"
) ? static_cast<void> (0) : __assert_fail ("CGF.getArrayInitIndex() && \"ArrayInitIndexExpr not inside an ArrayInitLoopExpr?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 566, __PRETTY_FUNCTION__))
         "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?")((CGF.getArrayInitIndex() && "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?"
) ? static_cast<void> (0) : __assert_fail ("CGF.getArrayInitIndex() && \"ArrayInitIndexExpr not inside an ArrayInitLoopExpr?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 566, __PRETTY_FUNCTION__));
  return CGF.getArrayInitIndex();
}

Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
  return EmitNullValue(E->getType());
}
Value *VisitExplicitCastExpr(ExplicitCastExpr *E) {
  CGF.CGM.EmitExplicitCastExprType(E, &CGF);
  return VisitCastExpr(E);
}
Value *VisitCastExpr(CastExpr *E);

Value *VisitCallExpr(const CallExpr *E) {
  if (E->getCallReturnType(CGF.getContext())->isReferenceType())
    return EmitLoadOfLValue(E);

  Value *V = CGF.EmitCallExpr(E).getScalarVal();

  EmitLValueAlignmentAssumption(E, V);
  return V;
}

Value *VisitStmtExpr(const StmtExpr *E);

// Unary Operators.
Value *VisitUnaryPostDec(const UnaryOperator *E) {
  LValue LV = EmitLValue(E->getSubExpr());
  return EmitScalarPrePostIncDec(E, LV, false, false);
}
Value *VisitUnaryPostInc(const UnaryOperator *E) {
  LValue LV = EmitLValue(E->getSubExpr());
  return EmitScalarPrePostIncDec(E, LV, true, false);
}
Value *VisitUnaryPreDec(const UnaryOperator *E) {
  LValue LV = EmitLValue(E->getSubExpr());
  return EmitScalarPrePostIncDec(E, LV, false, true);
}
Value *VisitUnaryPreInc(const UnaryOperator *E) {
  LValue LV = EmitLValue(E->getSubExpr());
  return EmitScalarPrePostIncDec(E, LV, true, true);
}

llvm::Value *EmitIncDecConsiderOverflowBehavior(const UnaryOperator *E,
                                                llvm::Value *InVal,
                                                bool IsInc);

llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
                                     bool isInc, bool isPre);


Value *VisitUnaryAddrOf(const UnaryOperator *E) {
  if (isa<MemberPointerType>(E->getType())) // never sugared
    return CGF.CGM.getMemberPointerConstant(E);

  return EmitLValue(E->getSubExpr()).getPointer(CGF);
}
Value *VisitUnaryDeref(const UnaryOperator *E) {
  if (E->getType()->isVoidType())
    return Visit(E->getSubExpr()); // the actual value should be unused
  return EmitLoadOfLValue(E);
}
Value *VisitUnaryPlus(const UnaryOperator *E) {
  // This differs from gcc, though, most likely due to a bug in gcc.
  TestAndClearIgnoreResultAssign();
  return Visit(E->getSubExpr());
}
Value *VisitUnaryMinus    (const UnaryOperator *E);
Value *VisitUnaryNot      (const UnaryOperator *E);
Value *VisitUnaryLNot     (const UnaryOperator *E);
Value *VisitUnaryReal     (const UnaryOperator *E);
Value *VisitUnaryImag     (const UnaryOperator *E);
Value *VisitUnaryExtension(const UnaryOperator *E) {
  return Visit(E->getSubExpr());
}

// C++
Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) {
  return EmitLoadOfLValue(E);
}
Value *VisitSourceLocExpr(SourceLocExpr *SLE) {
  auto &Ctx = CGF.getContext();
  APValue Evaluated =
      SLE->EvaluateInContext(Ctx, CGF.CurSourceLocExprScope.getDefaultExpr());
  return ConstantEmitter(CGF).emitAbstract(SLE->getLocation(), Evaluated,
                                           SLE->getType());
}

Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
  CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
  return Visit(DAE->getExpr());
}
Value *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
  CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
  return Visit(DIE->getExpr());
}
Value *VisitCXXThisExpr(CXXThisExpr *TE) {
  return CGF.LoadCXXThis();
}

Value *VisitExprWithCleanups(ExprWithCleanups *E);
Value *VisitCXXNewExpr(const CXXNewExpr *E) {
  return CGF.EmitCXXNewExpr(E);
}
Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
  CGF.EmitCXXDeleteExpr(E);
  return nullptr;
}

Value *VisitTypeTraitExpr(const TypeTraitExpr *E) {
  return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
}

Value *VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
  return Builder.getInt1(E->isSatisfied());
}

Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
  return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
}

Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
  return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
}

Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) {
  // C++ [expr.pseudo]p1:
  //   The result shall only be used as the operand for the function call
  //   operator (), and the result of such a call has type void. The only
  //   effect is the evaluation of the postfix-expression before the dot or
  //   arrow.
  CGF.EmitScalarExpr(E->getBase());
  return nullptr;
}

Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
  return EmitNullValue(E->getType());
}

Value *VisitCXXThrowExpr(const CXXThrowExpr *E) {
  CGF.EmitCXXThrowExpr(E);
  return nullptr;
}

Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
  return Builder.getInt1(E->getValue());
}

// Binary Operators.
Value *EmitMul(const BinOpInfo &Ops) {
  if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
    switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
    case LangOptions::SOB_Defined:
      return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
    case LangOptions::SOB_Undefined:
      if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
        return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
      LLVM_FALLTHROUGH[[gnu::fallthrough]];
    case LangOptions::SOB_Trapping:
      if (CanElideOverflowCheck(CGF.getContext(), Ops))
        return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
      return EmitOverflowCheckedBinOp(Ops);
    }
  }

  if (Ops.Ty->isUnsignedIntegerType() &&
      CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
      !CanElideOverflowCheck(CGF.getContext(), Ops))
    return EmitOverflowCheckedBinOp(Ops);

  if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
    Value *V = Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
    return propagateFMFlags(V, Ops);
  }
  return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
}
/// Create a binary op that checks for overflow.
/// Currently only supports +, - and *.
Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops);

// Check for undefined division and modulus behaviors.
void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops,
                                                llvm::Value *Zero,bool isDiv);
// Common helper for getting how wide LHS of shift is.
static Value *GetWidthMinusOneValue(Value* LHS,Value* RHS);
Value *EmitDiv(const BinOpInfo &Ops);
Value *EmitRem(const BinOpInfo &Ops);
Value *EmitAdd(const BinOpInfo &Ops);
Value *EmitSub(const BinOpInfo &Ops);
Value *EmitShl(const BinOpInfo &Ops);
Value *EmitShr(const BinOpInfo &Ops);
Value *EmitAnd(const BinOpInfo &Ops) {
  return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
}
Value *EmitXor(const BinOpInfo &Ops) {
  return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
}
Value *EmitOr (const BinOpInfo &Ops) {
  return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
}

// Helper functions for fixed point binary operations.
Value *EmitFixedPointBinOp(const BinOpInfo &Ops);

BinOpInfo EmitBinOps(const BinaryOperator *E);
LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
                          Value *(ScalarExprEmitter::*F)(const BinOpInfo &),
                                Value *&Result);

Value *EmitCompoundAssign(const CompoundAssignOperator *E,
                          Value *(ScalarExprEmitter::*F)(const BinOpInfo &));

// Binary operators and binary compound assignment operators.
779#define HANDLEBINOP(OP) \
Value *VisitBin ## OP(const BinaryOperator *E) {                         \
  return Emit ## OP(EmitBinOps(E));                                      \
}                                                                        \
Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) {       \
  return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP);          \
}
HANDLEBINOP(Mul)
HANDLEBINOP(Div)
HANDLEBINOP(Rem)
HANDLEBINOP(Add)
HANDLEBINOP(Sub)
HANDLEBINOP(Shl)
HANDLEBINOP(Shr)
HANDLEBINOP(And)
HANDLEBINOP(Xor)
HANDLEBINOP(Or)
796#undef HANDLEBINOP

// Comparisons.
Value *EmitCompare(const BinaryOperator *E, llvm::CmpInst::Predicate UICmpOpc,
                   llvm::CmpInst::Predicate SICmpOpc,
                   llvm::CmpInst::Predicate FCmpOpc);
802#define VISITCOMP(CODE, UI, SI, FP) \
  Value *VisitBin##CODE(const BinaryOperator *E) { \
    return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
                       llvm::FCmpInst::FP); }
VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT)
VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT)
VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE)
VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE)
VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ)
VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE)
1
Calling 'ScalarExprEmitter::EmitCompare'→
812#undef VISITCOMP

Value *VisitBinAssign     (const BinaryOperator *E);

Value *VisitBinLAnd       (const BinaryOperator *E);
Value *VisitBinLOr        (const BinaryOperator *E);
Value *VisitBinComma      (const BinaryOperator *E);

Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); }
Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); }

Value *VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
  return Visit(E->getSemanticForm());
}

// Other Operators.
Value *VisitBlockExpr(const BlockExpr *BE);
Value *VisitAbstractConditionalOperator(const AbstractConditionalOperator *);
Value *VisitChooseExpr(ChooseExpr *CE);
Value *VisitVAArgExpr(VAArgExpr *VE);
Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
  return CGF.EmitObjCStringLiteral(E);
}
Value *VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
  return CGF.EmitObjCBoxedExpr(E);
}
Value *VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
  return CGF.EmitObjCArrayLiteral(E);
}
Value *VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
  return CGF.EmitObjCDictionaryLiteral(E);
}
Value *VisitAsTypeExpr(AsTypeExpr *CE);
Value *VisitAtomicExpr(AtomicExpr *AE);
846};
847}  // end anonymous namespace.

849//===----------------------------------------------------------------------===//
850//                                Utilities
851//===----------------------------------------------------------------------===//

853/// EmitConversionToBool - Convert the specified expression value to a
854/// boolean (i1) truth value.  This is equivalent to "Val != 0".
855Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs")((SrcType.isCanonical() && "EmitScalarConversion strips typedefs"
) ? static_cast<void> (0) : __assert_fail ("SrcType.isCanonical() && \"EmitScalarConversion strips typedefs\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 856, __PRETTY_FUNCTION__));

if (SrcType->isRealFloatingType())
  return EmitFloatToBoolConversion(Src);

if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType))
  return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);

assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&(((SrcType->isIntegerType() || isa<llvm::PointerType>
(Src->getType())) && "Unknown scalar type to convert"
) ? static_cast<void> (0) : __assert_fail ("(SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && \"Unknown scalar type to convert\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 865, __PRETTY_FUNCTION__))
       "Unknown scalar type to convert")(((SrcType->isIntegerType() || isa<llvm::PointerType>
(Src->getType())) && "Unknown scalar type to convert"
) ? static_cast<void> (0) : __assert_fail ("(SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && \"Unknown scalar type to convert\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 865, __PRETTY_FUNCTION__));

if (isa<llvm::IntegerType>(Src->getType()))
  return EmitIntToBoolConversion(Src);

assert(isa<llvm::PointerType>(Src->getType()))((isa<llvm::PointerType>(Src->getType())) ? static_cast
<void> (0) : __assert_fail ("isa<llvm::PointerType>(Src->getType())"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 870, __PRETTY_FUNCTION__));
return EmitPointerToBoolConversion(Src, SrcType);
872}

874void ScalarExprEmitter::EmitFloatConversionCheck(
  Value *OrigSrc, QualType OrigSrcType, Value *Src, QualType SrcType,
  QualType DstType, llvm::Type *DstTy, SourceLocation Loc) {
assert(SrcType->isFloatingType() && "not a conversion from floating point")((SrcType->isFloatingType() && "not a conversion from floating point"
) ? static_cast<void> (0) : __assert_fail ("SrcType->isFloatingType() && \"not a conversion from floating point\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 877, __PRETTY_FUNCTION__));
if (!isa<llvm::IntegerType>(DstTy))
  return;

CodeGenFunction::SanitizerScope SanScope(&CGF);
using llvm::APFloat;
using llvm::APSInt;

llvm::Value *Check = nullptr;
const llvm::fltSemantics &SrcSema =
  CGF.getContext().getFloatTypeSemantics(OrigSrcType);

// Floating-point to integer. This has undefined behavior if the source is
// +-Inf, NaN, or doesn't fit into the destination type (after truncation
// to an integer).
unsigned Width = CGF.getContext().getIntWidth(DstType);
bool Unsigned = DstType->isUnsignedIntegerOrEnumerationType();

APSInt Min = APSInt::getMinValue(Width, Unsigned);
APFloat MinSrc(SrcSema, APFloat::uninitialized);
if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
    APFloat::opOverflow)
  // Don't need an overflow check for lower bound. Just check for
  // -Inf/NaN.
  MinSrc = APFloat::getInf(SrcSema, true);
else
  // Find the largest value which is too small to represent (before
  // truncation toward zero).
  MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);

APSInt Max = APSInt::getMaxValue(Width, Unsigned);
APFloat MaxSrc(SrcSema, APFloat::uninitialized);
if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
    APFloat::opOverflow)
  // Don't need an overflow check for upper bound. Just check for
  // +Inf/NaN.
  MaxSrc = APFloat::getInf(SrcSema, false);
else
  // Find the smallest value which is too large to represent (before
  // truncation toward zero).
  MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);

// If we're converting from __half, convert the range to float to match
// the type of src.
if (OrigSrcType->isHalfType()) {
  const llvm::fltSemantics &Sema =
    CGF.getContext().getFloatTypeSemantics(SrcType);
  bool IsInexact;
  MinSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
  MaxSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
}

llvm::Value *GE =
  Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
llvm::Value *LE =
  Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
Check = Builder.CreateAnd(GE, LE);

llvm::Constant *StaticArgs[] = {CGF.EmitCheckSourceLocation(Loc),
                                CGF.EmitCheckTypeDescriptor(OrigSrcType),
                                CGF.EmitCheckTypeDescriptor(DstType)};
CGF.EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
              SanitizerHandler::FloatCastOverflow, StaticArgs, OrigSrc);
940}

942// Should be called within CodeGenFunction::SanitizerScope RAII scope.
943// Returns 'i1 false' when the truncation Src -> Dst was lossy.
944static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
               std::pair<llvm::Value *, SanitizerMask>>
946EmitIntegerTruncationCheckHelper(Value *Src, QualType SrcType, Value *Dst,
                               QualType DstType, CGBuilderTy &Builder) {
llvm::Type *SrcTy = Src->getType();
llvm::Type *DstTy = Dst->getType();
(void)DstTy; // Only used in assert()

// This should be truncation of integral types.
assert(Src != Dst)((Src != Dst) ? static_cast<void> (0) : __assert_fail (
"Src != Dst", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 953, __PRETTY_FUNCTION__));
assert(SrcTy->getScalarSizeInBits() > Dst->getType()->getScalarSizeInBits())((SrcTy->getScalarSizeInBits() > Dst->getType()->
getScalarSizeInBits()) ? static_cast<void> (0) : __assert_fail
 ("SrcTy->getScalarSizeInBits() > Dst->getType()->getScalarSizeInBits()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 954, __PRETTY_FUNCTION__));
assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&((isa<llvm::IntegerType>(SrcTy) && isa<llvm::
IntegerType>(DstTy) && "non-integer llvm type") ? static_cast
<void> (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 956, __PRETTY_FUNCTION__))
       "non-integer llvm type")((isa<llvm::IntegerType>(SrcTy) && isa<llvm::
IntegerType>(DstTy) && "non-integer llvm type") ? static_cast
<void> (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 956, __PRETTY_FUNCTION__));

bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
bool DstSigned = DstType->isSignedIntegerOrEnumerationType();

// If both (src and dst) types are unsigned, then it's an unsigned truncation.
// Else, it is a signed truncation.
ScalarExprEmitter::ImplicitConversionCheckKind Kind;
SanitizerMask Mask;
if (!SrcSigned && !DstSigned) {
  Kind = ScalarExprEmitter::ICCK_UnsignedIntegerTruncation;
  Mask = SanitizerKind::ImplicitUnsignedIntegerTruncation;
} else {
  Kind = ScalarExprEmitter::ICCK_SignedIntegerTruncation;
  Mask = SanitizerKind::ImplicitSignedIntegerTruncation;
}

llvm::Value *Check = nullptr;
// 1. Extend the truncated value back to the same width as the Src.
Check = Builder.CreateIntCast(Dst, SrcTy, DstSigned, "anyext");
// 2. Equality-compare with the original source value
Check = Builder.CreateICmpEQ(Check, Src, "truncheck");
// If the comparison result is 'i1 false', then the truncation was lossy.
return std::make_pair(Kind, std::make_pair(Check, Mask));
980}

982static bool PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(
  QualType SrcType, QualType DstType) {
return SrcType->isIntegerType() && DstType->isIntegerType();
985}

987void ScalarExprEmitter::EmitIntegerTruncationCheck(Value *Src, QualType SrcType,
                                                 Value *Dst, QualType DstType,
                                                 SourceLocation Loc) {
if (!CGF.SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation))
  return;

// We only care about int->int conversions here.
// We ignore conversions to/from pointer and/or bool.
if (!PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(SrcType,
                                                                     DstType))
  return;

unsigned SrcBits = Src->getType()->getScalarSizeInBits();
unsigned DstBits = Dst->getType()->getScalarSizeInBits();
// This must be truncation. Else we do not care.
if (SrcBits <= DstBits)
  return;

assert(!DstType->isBooleanType() && "we should not get here with booleans.")((!DstType->isBooleanType() && "we should not get here with booleans."
) ? static_cast<void> (0) : __assert_fail ("!DstType->isBooleanType() && \"we should not get here with booleans.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1005, __PRETTY_FUNCTION__));

// If the integer sign change sanitizer is enabled,
// and we are truncating from larger unsigned type to smaller signed type,
// let that next sanitizer deal with it.
bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
if (CGF.SanOpts.has(SanitizerKind::ImplicitIntegerSignChange) &&
    (!SrcSigned && DstSigned))
  return;

CodeGenFunction::SanitizerScope SanScope(&CGF);

std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
          std::pair<llvm::Value *, SanitizerMask>>
    Check =
        EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
// If the comparison result is 'i1 false', then the truncation was lossy.

// Do we care about this type of truncation?
if (!CGF.SanOpts.has(Check.second.second))
  return;

llvm::Constant *StaticArgs[] = {
    CGF.EmitCheckSourceLocation(Loc), CGF.EmitCheckTypeDescriptor(SrcType),
    CGF.EmitCheckTypeDescriptor(DstType),
    llvm::ConstantInt::get(Builder.getInt8Ty(), Check.first)};
CGF.EmitCheck(Check.second, SanitizerHandler::ImplicitConversion, StaticArgs,
              {Src, Dst});
1034}

1036// Should be called within CodeGenFunction::SanitizerScope RAII scope.
1037// Returns 'i1 false' when the conversion Src -> Dst changed the sign.
1038static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
               std::pair<llvm::Value *, SanitizerMask>>
1040EmitIntegerSignChangeCheckHelper(Value *Src, QualType SrcType, Value *Dst,
                               QualType DstType, CGBuilderTy &Builder) {
llvm::Type *SrcTy = Src->getType();
llvm::Type *DstTy = Dst->getType();

assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&((isa<llvm::IntegerType>(SrcTy) && isa<llvm::
IntegerType>(DstTy) && "non-integer llvm type") ? static_cast
<void> (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1046, __PRETTY_FUNCTION__))
       "non-integer llvm type")((isa<llvm::IntegerType>(SrcTy) && isa<llvm::
IntegerType>(DstTy) && "non-integer llvm type") ? static_cast
<void> (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1046, __PRETTY_FUNCTION__));

bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
(void)SrcSigned; // Only used in assert()
(void)DstSigned; // Only used in assert()
unsigned SrcBits = SrcTy->getScalarSizeInBits();
unsigned DstBits = DstTy->getScalarSizeInBits();
(void)SrcBits; // Only used in assert()
(void)DstBits; // Only used in assert()

assert(((SrcBits != DstBits) || (SrcSigned != DstSigned)) &&((((SrcBits != DstBits) || (SrcSigned != DstSigned)) &&
 "either the widths should be different, or the signednesses."
) ? static_cast<void> (0) : __assert_fail ("((SrcBits != DstBits) || (SrcSigned != DstSigned)) && \"either the widths should be different, or the signednesses.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1058, __PRETTY_FUNCTION__))
       "either the widths should be different, or the signednesses.")((((SrcBits != DstBits) || (SrcSigned != DstSigned)) &&
 "either the widths should be different, or the signednesses."
) ? static_cast<void> (0) : __assert_fail ("((SrcBits != DstBits) || (SrcSigned != DstSigned)) && \"either the widths should be different, or the signednesses.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1058, __PRETTY_FUNCTION__));

// NOTE: zero value is considered to be non-negative.
auto EmitIsNegativeTest = [&Builder](Value *V, QualType VType,
                                     const char *Name) -> Value * {
  // Is this value a signed type?
  bool VSigned = VType->isSignedIntegerOrEnumerationType();
  llvm::Type *VTy = V->getType();
  if (!VSigned) {
    // If the value is unsigned, then it is never negative.
    // FIXME: can we encounter non-scalar VTy here?
    return llvm::ConstantInt::getFalse(VTy->getContext());
  }
  // Get the zero of the same type with which we will be comparing.
  llvm::Constant *Zero = llvm::ConstantInt::get(VTy, 0);
  // %V.isnegative = icmp slt %V, 0
  // I.e is %V *strictly* less than zero, does it have negative value?
  return Builder.CreateICmp(llvm::ICmpInst::ICMP_SLT, V, Zero,
                            llvm::Twine(Name) + "." + V->getName() +
                                ".negativitycheck");
};

// 1. Was the old Value negative?
llvm::Value *SrcIsNegative = EmitIsNegativeTest(Src, SrcType, "src");
// 2. Is the new Value negative?
llvm::Value *DstIsNegative = EmitIsNegativeTest(Dst, DstType, "dst");
// 3. Now, was the 'negativity status' preserved during the conversion?
//    NOTE: conversion from negative to zero is considered to change the sign.
//    (We want to get 'false' when the conversion changed the sign)
//    So we should just equality-compare the negativity statuses.
llvm::Value *Check = nullptr;
Check = Builder.CreateICmpEQ(SrcIsNegative, DstIsNegative, "signchangecheck");
// If the comparison result is 'false', then the conversion changed the sign.
return std::make_pair(
    ScalarExprEmitter::ICCK_IntegerSignChange,
    std::make_pair(Check, SanitizerKind::ImplicitIntegerSignChange));
1094}

1096void ScalarExprEmitter::EmitIntegerSignChangeCheck(Value *Src, QualType SrcType,
                                                 Value *Dst, QualType DstType,
                                                 SourceLocation Loc) {
if (!CGF.SanOpts.has(SanitizerKind::ImplicitIntegerSignChange))
  return;

llvm::Type *SrcTy = Src->getType();
llvm::Type *DstTy = Dst->getType();

// We only care about int->int conversions here.
// We ignore conversions to/from pointer and/or bool.
if (!PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(SrcType,
                                                                     DstType))
  return;

bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
unsigned SrcBits = SrcTy->getScalarSizeInBits();
unsigned DstBits = DstTy->getScalarSizeInBits();

// Now, we do not need to emit the check in *all* of the cases.
// We can avoid emitting it in some obvious cases where it would have been
// dropped by the opt passes (instcombine) always anyways.
// If it's a cast between effectively the same type, no check.
// NOTE: this is *not* equivalent to checking the canonical types.
if (SrcSigned == DstSigned && SrcBits == DstBits)
  return;
// At least one of the values needs to have signed type.
// If both are unsigned, then obviously, neither of them can be negative.
if (!SrcSigned && !DstSigned)
  return;
// If the conversion is to *larger* *signed* type, then no check is needed.
// Because either sign-extension happens (so the sign will remain),
// or zero-extension will happen (the sign bit will be zero.)
if ((DstBits > SrcBits) && DstSigned)
  return;
if (CGF.SanOpts.has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
    (SrcBits > DstBits) && SrcSigned) {
  // If the signed integer truncation sanitizer is enabled,
  // and this is a truncation from signed type, then no check is needed.
  // Because here sign change check is interchangeable with truncation check.
  return;
}
// That's it. We can't rule out any more cases with the data we have.

CodeGenFunction::SanitizerScope SanScope(&CGF);

std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
          std::pair<llvm::Value *, SanitizerMask>>
    Check;

// Each of these checks needs to return 'false' when an issue was detected.
ImplicitConversionCheckKind CheckKind;
llvm::SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks;
// So we can 'and' all the checks together, and still get 'false',
// if at least one of the checks detected an issue.

Check = EmitIntegerSignChangeCheckHelper(Src, SrcType, Dst, DstType, Builder);
CheckKind = Check.first;
Checks.emplace_back(Check.second);

if (CGF.SanOpts.has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
    (SrcBits > DstBits) && !SrcSigned && DstSigned) {
  // If the signed integer truncation sanitizer was enabled,
  // and we are truncating from larger unsigned type to smaller signed type,
  // let's handle the case we skipped in that check.
  Check =
      EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
  CheckKind = ICCK_SignedIntegerTruncationOrSignChange;
  Checks.emplace_back(Check.second);
  // If the comparison result is 'i1 false', then the truncation was lossy.
}

llvm::Constant *StaticArgs[] = {
    CGF.EmitCheckSourceLocation(Loc), CGF.EmitCheckTypeDescriptor(SrcType),
    CGF.EmitCheckTypeDescriptor(DstType),
    llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
// EmitCheck() will 'and' all the checks together.
CGF.EmitCheck(Checks, SanitizerHandler::ImplicitConversion, StaticArgs,
              {Src, Dst});
1176}

1178/// Emit a conversion from the specified type to the specified destination type,
1179/// both of which are LLVM scalar types.
1180Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
                                             QualType DstType,
                                             SourceLocation Loc,
                                             ScalarConversionOpts Opts) {
// All conversions involving fixed point types should be handled by the
// EmitFixedPoint family functions. This is done to prevent bloating up this
// function more, and although fixed point numbers are represented by
// integers, we do not want to follow any logic that assumes they should be
// treated as integers.
// TODO(leonardchan): When necessary, add another if statement checking for
// conversions to fixed point types from other types.
if (SrcType->isFixedPointType()) {
  if (DstType->isBooleanType())
    // It is important that we check this before checking if the dest type is
    // an integer because booleans are technically integer types.
    // We do not need to check the padding bit on unsigned types if unsigned
    // padding is enabled because overflow into this bit is undefined
    // behavior.
    return Builder.CreateIsNotNull(Src, "tobool");
  if (DstType->isFixedPointType() || DstType->isIntegerType())
    return EmitFixedPointConversion(Src, SrcType, DstType, Loc);

  llvm_unreachable(::llvm::llvm_unreachable_internal("Unhandled scalar conversion from a fixed point type to another type."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1203)
      "Unhandled scalar conversion from a fixed point type to another type.")::llvm::llvm_unreachable_internal("Unhandled scalar conversion from a fixed point type to another type."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1203);
} else if (DstType->isFixedPointType()) {
  if (SrcType->isIntegerType())
    // This also includes converting booleans and enums to fixed point types.
    return EmitFixedPointConversion(Src, SrcType, DstType, Loc);

  llvm_unreachable(::llvm::llvm_unreachable_internal("Unhandled scalar conversion to a fixed point type from another type."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1210)
      "Unhandled scalar conversion to a fixed point type from another type.")::llvm::llvm_unreachable_internal("Unhandled scalar conversion to a fixed point type from another type."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1210);
}

QualType NoncanonicalSrcType = SrcType;
QualType NoncanonicalDstType = DstType;

SrcType = CGF.getContext().getCanonicalType(SrcType);
DstType = CGF.getContext().getCanonicalType(DstType);
if (SrcType == DstType) return Src;

if (DstType->isVoidType()) return nullptr;

llvm::Value *OrigSrc = Src;
QualType OrigSrcType = SrcType;
llvm::Type *SrcTy = Src->getType();

// Handle conversions to bool first, they are special: comparisons against 0.
if (DstType->isBooleanType())
  return EmitConversionToBool(Src, SrcType);

llvm::Type *DstTy = ConvertType(DstType);

// Cast from half through float if half isn't a native type.
if (SrcType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
  // Cast to FP using the intrinsic if the half type itself isn't supported.
  if (DstTy->isFloatingPointTy()) {
    if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics())
      return Builder.CreateCall(
          CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy),
          Src);
  } else {
    // Cast to other types through float, using either the intrinsic or FPExt,
    // depending on whether the half type itself is supported
    // (as opposed to operations on half, available with NativeHalfType).
    if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
      Src = Builder.CreateCall(
          CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
                               CGF.CGM.FloatTy),
          Src);
    } else {
      Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
    }
    SrcType = CGF.getContext().FloatTy;
    SrcTy = CGF.FloatTy;
  }
}

// Ignore conversions like int -> uint.
if (SrcTy == DstTy) {
  if (Opts.EmitImplicitIntegerSignChangeChecks)
    EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Src,
                               NoncanonicalDstType, Loc);

  return Src;
}

// Handle pointer conversions next: pointers can only be converted to/from
// other pointers and integers. Check for pointer types in terms of LLVM, as
// some native types (like Obj-C id) may map to a pointer type.
if (auto DstPT = dyn_cast<llvm::PointerType>(DstTy)) {
  // The source value may be an integer, or a pointer.
  if (isa<llvm::PointerType>(SrcTy))
    return Builder.CreateBitCast(Src, DstTy, "conv");

  assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?")((SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"
) ? static_cast<void> (0) : __assert_fail ("SrcType->isIntegerType() && \"Not ptr->ptr or int->ptr conversion?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1274, __PRETTY_FUNCTION__));
  // First, convert to the correct width so that we control the kind of
  // extension.
  llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DstPT);
  bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
  llvm::Value* IntResult =
      Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
  // Then, cast to pointer.
  return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
}

if (isa<llvm::PointerType>(SrcTy)) {
  // Must be an ptr to int cast.
  assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?")((isa<llvm::IntegerType>(DstTy) && "not ptr->int?"
) ? static_cast<void> (0) : __assert_fail ("isa<llvm::IntegerType>(DstTy) && \"not ptr->int?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1287, __PRETTY_FUNCTION__));
  return Builder.CreatePtrToInt(Src, DstTy, "conv");
}

// A scalar can be splatted to an extended vector of the same element type
if (DstType->isExtVectorType() && !SrcType->isVectorType()) {
  // Sema should add casts to make sure that the source expression's type is
  // the same as the vector's element type (sans qualifiers)
  assert(DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() ==((DstType->castAs<ExtVectorType>()->getElementType
().getTypePtr() == SrcType.getTypePtr() && "Splatted expr doesn't match with vector element type?"
) ? static_cast<void> (0) : __assert_fail ("DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() == SrcType.getTypePtr() && \"Splatted expr doesn't match with vector element type?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1297, __PRETTY_FUNCTION__))
             SrcType.getTypePtr() &&((DstType->castAs<ExtVectorType>()->getElementType
().getTypePtr() == SrcType.getTypePtr() && "Splatted expr doesn't match with vector element type?"
) ? static_cast<void> (0) : __assert_fail ("DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() == SrcType.getTypePtr() && \"Splatted expr doesn't match with vector element type?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1297, __PRETTY_FUNCTION__))
         "Splatted expr doesn't match with vector element type?")((DstType->castAs<ExtVectorType>()->getElementType
().getTypePtr() == SrcType.getTypePtr() && "Splatted expr doesn't match with vector element type?"
) ? static_cast<void> (0) : __assert_fail ("DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() == SrcType.getTypePtr() && \"Splatted expr doesn't match with vector element type?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1297, __PRETTY_FUNCTION__));

  // Splat the element across to all elements
  unsigned NumElements = DstTy->getVectorNumElements();
  return Builder.CreateVectorSplat(NumElements, Src, "splat");
}

if (isa<llvm::VectorType>(SrcTy) || isa<llvm::VectorType>(DstTy)) {
  // Allow bitcast from vector to integer/fp of the same size.
  unsigned SrcSize = SrcTy->getPrimitiveSizeInBits();
  unsigned DstSize = DstTy->getPrimitiveSizeInBits();
  if (SrcSize == DstSize)
    return Builder.CreateBitCast(Src, DstTy, "conv");

  // Conversions between vectors of different sizes are not allowed except
  // when vectors of half are involved. Operations on storage-only half
  // vectors require promoting half vector operands to float vectors and
  // truncating the result, which is either an int or float vector, to a
  // short or half vector.

  // Source and destination are both expected to be vectors.
  llvm::Type *SrcElementTy = SrcTy->getVectorElementType();
  llvm::Type *DstElementTy = DstTy->getVectorElementType();
  (void)DstElementTy;

  assert(((SrcElementTy->isIntegerTy() &&((((SrcElementTy->isIntegerTy() && DstElementTy->
isIntegerTy()) || (SrcElementTy->isFloatingPointTy() &&
 DstElementTy->isFloatingPointTy())) && "unexpected conversion between a floating-point vector and an "
 "integer vector") ? static_cast<void> (0) : __assert_fail
 ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1327, __PRETTY_FUNCTION__))
           DstElementTy->isIntegerTy()) ||((((SrcElementTy->isIntegerTy() && DstElementTy->
isIntegerTy()) || (SrcElementTy->isFloatingPointTy() &&
 DstElementTy->isFloatingPointTy())) && "unexpected conversion between a floating-point vector and an "
 "integer vector") ? static_cast<void> (0) : __assert_fail
 ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1327, __PRETTY_FUNCTION__))
          (SrcElementTy->isFloatingPointTy() &&((((SrcElementTy->isIntegerTy() && DstElementTy->
isIntegerTy()) || (SrcElementTy->isFloatingPointTy() &&
 DstElementTy->isFloatingPointTy())) && "unexpected conversion between a floating-point vector and an "
 "integer vector") ? static_cast<void> (0) : __assert_fail
 ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1327, __PRETTY_FUNCTION__))
           DstElementTy->isFloatingPointTy())) &&((((SrcElementTy->isIntegerTy() && DstElementTy->
isIntegerTy()) || (SrcElementTy->isFloatingPointTy() &&
 DstElementTy->isFloatingPointTy())) && "unexpected conversion between a floating-point vector and an "
 "integer vector") ? static_cast<void> (0) : __assert_fail
 ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1327, __PRETTY_FUNCTION__))
         "unexpected conversion between a floating-point vector and an "((((SrcElementTy->isIntegerTy() && DstElementTy->
isIntegerTy()) || (SrcElementTy->isFloatingPointTy() &&
 DstElementTy->isFloatingPointTy())) && "unexpected conversion between a floating-point vector and an "
 "integer vector") ? static_cast<void> (0) : __assert_fail
 ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1327, __PRETTY_FUNCTION__))
         "integer vector")((((SrcElementTy->isIntegerTy() && DstElementTy->
isIntegerTy()) || (SrcElementTy->isFloatingPointTy() &&
 DstElementTy->isFloatingPointTy())) && "unexpected conversion between a floating-point vector and an "
 "integer vector") ? static_cast<void> (0) : __assert_fail
 ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1327, __PRETTY_FUNCTION__));

  // Truncate an i32 vector to an i16 vector.
  if (SrcElementTy->isIntegerTy())
    return Builder.CreateIntCast(Src, DstTy, false, "conv");

  // Truncate a float vector to a half vector.
  if (SrcSize > DstSize)
    return Builder.CreateFPTrunc(Src, DstTy, "conv");

  // Promote a half vector to a float vector.
  return Builder.CreateFPExt(Src, DstTy, "conv");
}

// Finally, we have the arithmetic types: real int/float.
Value *Res = nullptr;
llvm::Type *ResTy = DstTy;

// An overflowing conversion has undefined behavior if either the source type
// or the destination type is a floating-point type. However, we consider the
// range of representable values for all floating-point types to be
// [-inf,+inf], so no overflow can ever happen when the destination type is a
// floating-point type.
if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
    OrigSrcType->isFloatingType())
  EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType, DstTy,
                           Loc);

// Cast to half through float if half isn't a native type.
if (DstType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
  // Make sure we cast in a single step if from another FP type.
  if (SrcTy->isFloatingPointTy()) {
    // Use the intrinsic if the half type itself isn't supported
    // (as opposed to operations on half, available with NativeHalfType).
    if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics())
      return Builder.CreateCall(
          CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
    // If the half type is supported, just use an fptrunc.
    return Builder.CreateFPTrunc(Src, DstTy);
  }
  DstTy = CGF.FloatTy;
}

if (isa<llvm::IntegerType>(SrcTy)) {
  bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
  if (SrcType->isBooleanType() && Opts.TreatBooleanAsSigned) {
    InputSigned = true;
  }
  if (isa<llvm::IntegerType>(DstTy))
    Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
  else if (InputSigned)
    Res = Builder.CreateSIToFP(Src, DstTy, "conv");
  else
    Res = Builder.CreateUIToFP(Src, DstTy, "conv");
} else if (isa<llvm::IntegerType>(DstTy)) {
  assert(SrcTy->isFloatingPointTy() && "Unknown real conversion")((SrcTy->isFloatingPointTy() && "Unknown real conversion"
) ? static_cast<void> (0) : __assert_fail ("SrcTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1382, __PRETTY_FUNCTION__));
  if (DstType->isSignedIntegerOrEnumerationType())
    Res = Builder.CreateFPToSI(Src, DstTy, "conv");
  else
    Res = Builder.CreateFPToUI(Src, DstTy, "conv");
} else {
  assert(SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() &&((SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy
() && "Unknown real conversion") ? static_cast<void
> (0) : __assert_fail ("SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1389, __PRETTY_FUNCTION__))
         "Unknown real conversion")((SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy
() && "Unknown real conversion") ? static_cast<void
> (0) : __assert_fail ("SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1389, __PRETTY_FUNCTION__));
  if (DstTy->getTypeID() < SrcTy->getTypeID())
    Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
  else
    Res = Builder.CreateFPExt(Src, DstTy, "conv");
}

if (DstTy != ResTy) {
  if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
    assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion")((ResTy->isIntegerTy(16) && "Only half FP requires extra conversion"
) ? static_cast<void> (0) : __assert_fail ("ResTy->isIntegerTy(16) && \"Only half FP requires extra conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1398, __PRETTY_FUNCTION__));
    Res = Builder.CreateCall(
      CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
      Res);
  } else {
    Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
  }
}

if (Opts.EmitImplicitIntegerTruncationChecks)
  EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,
                             NoncanonicalDstType, Loc);

if (Opts.EmitImplicitIntegerSignChangeChecks)
  EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Res,
                             NoncanonicalDstType, Loc);

return Res;
1416}

1418Value *ScalarExprEmitter::EmitFixedPointConversion(Value *Src, QualType SrcTy,
                                                 QualType DstTy,
                                                 SourceLocation Loc) {
FixedPointSemantics SrcFPSema =
    CGF.getContext().getFixedPointSemantics(SrcTy);
FixedPointSemantics DstFPSema =
    CGF.getContext().getFixedPointSemantics(DstTy);
return EmitFixedPointConversion(Src, SrcFPSema, DstFPSema, Loc,
                                DstTy->isIntegerType());
1427}

1429Value *ScalarExprEmitter::EmitFixedPointConversion(
  Value *Src, FixedPointSemantics &SrcFPSema, FixedPointSemantics &DstFPSema,
  SourceLocation Loc, bool DstIsInteger) {
using llvm::APInt;
using llvm::ConstantInt;
using llvm::Value;

unsigned SrcWidth = SrcFPSema.getWidth();
unsigned DstWidth = DstFPSema.getWidth();
unsigned SrcScale = SrcFPSema.getScale();
unsigned DstScale = DstFPSema.getScale();
bool SrcIsSigned = SrcFPSema.isSigned();
bool DstIsSigned = DstFPSema.isSigned();

llvm::Type *DstIntTy = Builder.getIntNTy(DstWidth);

Value *Result = Src;
unsigned ResultWidth = SrcWidth;

// Downscale.
if (DstScale < SrcScale) {
  // When converting to integers, we round towards zero. For negative numbers,
  // right shifting rounds towards negative infinity. In this case, we can
  // just round up before shifting.
  if (DstIsInteger && SrcIsSigned) {
    Value *Zero = llvm::Constant::getNullValue(Result->getType());
    Value *IsNegative = Builder.CreateICmpSLT(Result, Zero);
    Value *LowBits = ConstantInt::get(
        CGF.getLLVMContext(), APInt::getLowBitsSet(ResultWidth, SrcScale));
    Value *Rounded = Builder.CreateAdd(Result, LowBits);
    Result = Builder.CreateSelect(IsNegative, Rounded, Result);
  }

  Result = SrcIsSigned
               ? Builder.CreateAShr(Result, SrcScale - DstScale, "downscale")
               : Builder.CreateLShr(Result, SrcScale - DstScale, "downscale");
}

if (!DstFPSema.isSaturated()) {
  // Resize.
  Result = Builder.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");

  // Upscale.
  if (DstScale > SrcScale)
    Result = Builder.CreateShl(Result, DstScale - SrcScale, "upscale");
} else {
  // Adjust the number of fractional bits.
  if (DstScale > SrcScale) {
    // Compare to DstWidth to prevent resizing twice.
    ResultWidth = std::max(SrcWidth + DstScale - SrcScale, DstWidth);
    llvm::Type *UpscaledTy = Builder.getIntNTy(ResultWidth);
    Result = Builder.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize");
    Result = Builder.CreateShl(Result, DstScale - SrcScale, "upscale");
  }

  // Handle saturation.
  bool LessIntBits = DstFPSema.getIntegralBits() < SrcFPSema.getIntegralBits();
  if (LessIntBits) {
    Value *Max = ConstantInt::get(
        CGF.getLLVMContext(),
        APFixedPoint::getMax(DstFPSema).getValue().extOrTrunc(ResultWidth));
    Value *TooHigh = SrcIsSigned ? Builder.CreateICmpSGT(Result, Max)
                                 : Builder.CreateICmpUGT(Result, Max);
    Result = Builder.CreateSelect(TooHigh, Max, Result, "satmax");
  }
  // Cannot overflow min to dest type if src is unsigned since all fixed
  // point types can cover the unsigned min of 0.
  if (SrcIsSigned && (LessIntBits || !DstIsSigned)) {
    Value *Min = ConstantInt::get(
        CGF.getLLVMContext(),
        APFixedPoint::getMin(DstFPSema).getValue().extOrTrunc(ResultWidth));
    Value *TooLow = Builder.CreateICmpSLT(Result, Min);
    Result = Builder.CreateSelect(TooLow, Min, Result, "satmin");
  }

  // Resize the integer part to get the final destination size.
  if (ResultWidth != DstWidth)
    Result = Builder.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
}
return Result;
1509}

1511/// Emit a conversion from the specified complex type to the specified
1512/// destination type, where the destination type is an LLVM scalar type.
1513Value *ScalarExprEmitter::EmitComplexToScalarConversion(
  CodeGenFunction::ComplexPairTy Src, QualType SrcTy, QualType DstTy,
  SourceLocation Loc) {
// Get the source element type.
SrcTy = SrcTy->castAs<ComplexType>()->getElementType();

// Handle conversions to bool first, they are special: comparisons against 0.
if (DstTy->isBooleanType()) {
  //  Complex != 0  -> (Real != 0) | (Imag != 0)
  Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
  Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy, Loc);
  return Builder.CreateOr(Src.first, Src.second, "tobool");
}

// C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
// the imaginary part of the complex value is discarded and the value of the
// real part is converted according to the conversion rules for the
// corresponding real type.
return EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1532}

1534Value *ScalarExprEmitter::EmitNullValue(QualType Ty) {
return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
1536}

1538/// Emit a sanitization check for the given "binary" operation (which
1539/// might actually be a unary increment which has been lowered to a binary
1540/// operation). The check passes if all values in \p Checks (which are \c i1),
1541/// are \c true.
1542void ScalarExprEmitter::EmitBinOpCheck(
  ArrayRef<std::pair<Value *, SanitizerMask>> Checks, const BinOpInfo &Info) {
assert(CGF.IsSanitizerScope)((CGF.IsSanitizerScope) ? static_cast<void> (0) : __assert_fail
 ("CGF.IsSanitizerScope", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1544, __PRETTY_FUNCTION__));
SanitizerHandler Check;
SmallVector<llvm::Constant *, 4> StaticData;
SmallVector<llvm::Value *, 2> DynamicData;

BinaryOperatorKind Opcode = Info.Opcode;
if (BinaryOperator::isCompoundAssignmentOp(Opcode))
  Opcode = BinaryOperator::getOpForCompoundAssignment(Opcode);

StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
const UnaryOperator *UO = dyn_cast<UnaryOperator>(Info.E);
if (UO && UO->getOpcode() == UO_Minus) {
  Check = SanitizerHandler::NegateOverflow;
  StaticData.push_back(CGF.EmitCheckTypeDescriptor(UO->getType()));
  DynamicData.push_back(Info.RHS);
} else {
  if (BinaryOperator::isShiftOp(Opcode)) {
    // Shift LHS negative or too large, or RHS out of bounds.
    Check = SanitizerHandler::ShiftOutOfBounds;
    const BinaryOperator *BO = cast<BinaryOperator>(Info.E);
    StaticData.push_back(
      CGF.EmitCheckTypeDescriptor(BO->getLHS()->getType()));
    StaticData.push_back(
      CGF.EmitCheckTypeDescriptor(BO->getRHS()->getType()));
  } else if (Opcode == BO_Div || Opcode == BO_Rem) {
    // Divide or modulo by zero, or signed overflow (eg INT_MAX / -1).
    Check = SanitizerHandler::DivremOverflow;
    StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
  } else {
    // Arithmetic overflow (+, -, *).
    switch (Opcode) {
    case BO_Add: Check = SanitizerHandler::AddOverflow; break;
    case BO_Sub: Check = SanitizerHandler::SubOverflow; break;
    case BO_Mul: Check = SanitizerHandler::MulOverflow; break;
    default: llvm_unreachable("unexpected opcode for bin op check")::llvm::llvm_unreachable_internal("unexpected opcode for bin op check"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1578);
    }
    StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
  }
  DynamicData.push_back(Info.LHS);
  DynamicData.push_back(Info.RHS);
}

CGF.EmitCheck(Checks, Check, StaticData, DynamicData);
1587}

1589//===----------------------------------------------------------------------===//
1590//                            Visitor Methods
1591//===----------------------------------------------------------------------===//

1593Value *ScalarExprEmitter::VisitExpr(Expr *E) {
CGF.ErrorUnsupported(E, "scalar expression");
if (E->getType()->isVoidType())
  return nullptr;
return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1598}

1600Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
// Vector Mask Case
if (E->getNumSubExprs() == 2) {
  Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
  Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
  Value *Mask;

  llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType());
  unsigned LHSElts = LTy->getNumElements();

  Mask = RHS;

  llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType());

  // Mask off the high bits of each shuffle index.
  Value *MaskBits =
      llvm::ConstantInt::get(MTy, llvm::NextPowerOf2(LHSElts - 1) - 1);
  Mask = Builder.CreateAnd(Mask, MaskBits, "mask");

  // newv = undef
  // mask = mask & maskbits
  // for each elt
  //   n = extract mask i
  //   x = extract val n
  //   newv = insert newv, x, i
  llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(),
                                                MTy->getNumElements());
  Value* NewV = llvm::UndefValue::get(RTy);
  for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) {
    Value *IIndx = llvm::ConstantInt::get(CGF.SizeTy, i);
    Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");

    Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
    NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
  }
  return NewV;
}

Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));

SmallVector<llvm::Constant*, 32> indices;
for (unsigned i = 2; i < E->getNumSubExprs(); ++i) {
  llvm::APSInt Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
  // Check for -1 and output it as undef in the IR.
  if (Idx.isSigned() && Idx.isAllOnesValue())
    indices.push_back(llvm::UndefValue::get(CGF.Int32Ty));
  else
    indices.push_back(Builder.getInt32(Idx.getZExtValue()));
}

Value *SV = llvm::ConstantVector::get(indices);
return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
1653}

1655Value *ScalarExprEmitter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
QualType SrcType = E->getSrcExpr()->getType(),
         DstType = E->getType();

Value *Src  = CGF.EmitScalarExpr(E->getSrcExpr());

SrcType = CGF.getContext().getCanonicalType(SrcType);
DstType = CGF.getContext().getCanonicalType(DstType);
if (SrcType == DstType) return Src;

assert(SrcType->isVectorType() &&((SrcType->isVectorType() && "ConvertVector source type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("SrcType->isVectorType() && \"ConvertVector source type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1666, __PRETTY_FUNCTION__))
       "ConvertVector source type must be a vector")((SrcType->isVectorType() && "ConvertVector source type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("SrcType->isVectorType() && \"ConvertVector source type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1666, __PRETTY_FUNCTION__));
assert(DstType->isVectorType() &&((DstType->isVectorType() && "ConvertVector destination type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("DstType->isVectorType() && \"ConvertVector destination type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1668, __PRETTY_FUNCTION__))
       "ConvertVector destination type must be a vector")((DstType->isVectorType() && "ConvertVector destination type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("DstType->isVectorType() && \"ConvertVector destination type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1668, __PRETTY_FUNCTION__));

llvm::Type *SrcTy = Src->getType();
llvm::Type *DstTy = ConvertType(DstType);

// Ignore conversions like int -> uint.
if (SrcTy == DstTy)
  return Src;

QualType SrcEltType = SrcType->castAs<VectorType>()->getElementType(),
         DstEltType = DstType->castAs<VectorType>()->getElementType();

assert(SrcTy->isVectorTy() &&((SrcTy->isVectorTy() && "ConvertVector source IR type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("SrcTy->isVectorTy() && \"ConvertVector source IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1681, __PRETTY_FUNCTION__))
       "ConvertVector source IR type must be a vector")((SrcTy->isVectorTy() && "ConvertVector source IR type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("SrcTy->isVectorTy() && \"ConvertVector source IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1681, __PRETTY_FUNCTION__));
assert(DstTy->isVectorTy() &&((DstTy->isVectorTy() && "ConvertVector destination IR type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("DstTy->isVectorTy() && \"ConvertVector destination IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1683, __PRETTY_FUNCTION__))
       "ConvertVector destination IR type must be a vector")((DstTy->isVectorTy() && "ConvertVector destination IR type must be a vector"
) ? static_cast<void> (0) : __assert_fail ("DstTy->isVectorTy() && \"ConvertVector destination IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1683, __PRETTY_FUNCTION__));

llvm::Type *SrcEltTy = SrcTy->getVectorElementType(),
           *DstEltTy = DstTy->getVectorElementType();

if (DstEltType->isBooleanType()) {
  assert((SrcEltTy->isFloatingPointTy() ||(((SrcEltTy->isFloatingPointTy() || isa<llvm::IntegerType
>(SrcEltTy)) && "Unknown boolean conversion") ? static_cast
<void> (0) : __assert_fail ("(SrcEltTy->isFloatingPointTy() || isa<llvm::IntegerType>(SrcEltTy)) && \"Unknown boolean conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1690, __PRETTY_FUNCTION__))
          isa<llvm::IntegerType>(SrcEltTy)) && "Unknown boolean conversion")(((SrcEltTy->isFloatingPointTy() || isa<llvm::IntegerType
>(SrcEltTy)) && "Unknown boolean conversion") ? static_cast
<void> (0) : __assert_fail ("(SrcEltTy->isFloatingPointTy() || isa<llvm::IntegerType>(SrcEltTy)) && \"Unknown boolean conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1690, __PRETTY_FUNCTION__));

  llvm::Value *Zero = llvm::Constant::getNullValue(SrcTy);
  if (SrcEltTy->isFloatingPointTy()) {
    return Builder.CreateFCmpUNE(Src, Zero, "tobool");
  } else {
    return Builder.CreateICmpNE(Src, Zero, "tobool");
  }
}

// We have the arithmetic types: real int/float.
Value *Res = nullptr;

if (isa<llvm::IntegerType>(SrcEltTy)) {
  bool InputSigned = SrcEltType->isSignedIntegerOrEnumerationType();
  if (isa<llvm::IntegerType>(DstEltTy))
    Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
  else if (InputSigned)
    Res = Builder.CreateSIToFP(Src, DstTy, "conv");
  else
    Res = Builder.CreateUIToFP(Src, DstTy, "conv");
} else if (isa<llvm::IntegerType>(DstEltTy)) {
  assert(SrcEltTy->isFloatingPointTy() && "Unknown real conversion")((SrcEltTy->isFloatingPointTy() && "Unknown real conversion"
) ? static_cast<void> (0) : __assert_fail ("SrcEltTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1712, __PRETTY_FUNCTION__));
  if (DstEltType->isSignedIntegerOrEnumerationType())
    Res = Builder.CreateFPToSI(Src, DstTy, "conv");
  else
    Res = Builder.CreateFPToUI(Src, DstTy, "conv");
} else {
  assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&((SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy
() && "Unknown real conversion") ? static_cast<void
> (0) : __assert_fail ("SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1719, __PRETTY_FUNCTION__))
         "Unknown real conversion")((SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy
() && "Unknown real conversion") ? static_cast<void
> (0) : __assert_fail ("SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1719, __PRETTY_FUNCTION__));
  if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
    Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
  else
    Res = Builder.CreateFPExt(Src, DstTy, "conv");
}

return Res;
1727}

1729Value *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) {
if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) {
  CGF.EmitIgnoredExpr(E->getBase());
  return CGF.emitScalarConstant(Constant, E);
} else {
  Expr::EvalResult Result;
  if (E->EvaluateAsInt(Result, CGF.getContext(), Expr::SE_AllowSideEffects)) {
    llvm::APSInt Value = Result.Val.getInt();
    CGF.EmitIgnoredExpr(E->getBase());
    return Builder.getInt(Value);
  }
}

return EmitLoadOfLValue(E);
1743}

1745Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
TestAndClearIgnoreResultAssign();

// Emit subscript expressions in rvalue context's.  For most cases, this just
// loads the lvalue formed by the subscript expr.  However, we have to be
// careful, because the base of a vector subscript is occasionally an rvalue,
// so we can't get it as an lvalue.
if (!E->getBase()->getType()->isVectorType())
  return EmitLoadOfLValue(E);

// Handle the vector case.  The base must be a vector, the index must be an
// integer value.
Value *Base = Visit(E->getBase());
Value *Idx  = Visit(E->getIdx());
QualType IdxTy = E->getIdx()->getType();

if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
  CGF.EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, /*Accessed*/true);

return Builder.CreateExtractElement(Base, Idx, "vecext");
1765}

1767static llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx,
                                unsigned Off, llvm::Type *I32Ty) {
int MV = SVI->getMaskValue(Idx);
if (MV == -1)
  return llvm::UndefValue::get(I32Ty);
return llvm::ConstantInt::get(I32Ty, Off+MV);
1773}

1775static llvm::Constant *getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty) {
if (C->getBitWidth() != 32) {
    assert(llvm::ConstantInt::isValueValidForType(I32Ty,((llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue
()) && "Index operand too large for shufflevector mask!"
) ? static_cast<void> (0) : __assert_fail ("llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) && \"Index operand too large for shufflevector mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1779, __PRETTY_FUNCTION__))
                                                  C->getZExtValue()) &&((llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue
()) && "Index operand too large for shufflevector mask!"
) ? static_cast<void> (0) : __assert_fail ("llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) && \"Index operand too large for shufflevector mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1779, __PRETTY_FUNCTION__))
           "Index operand too large for shufflevector mask!")((llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue
()) && "Index operand too large for shufflevector mask!"
) ? static_cast<void> (0) : __assert_fail ("llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) && \"Index operand too large for shufflevector mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1779, __PRETTY_FUNCTION__));
    return llvm::ConstantInt::get(I32Ty, C->getZExtValue());
}
return C;
1783}

1785Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
bool Ignore = TestAndClearIgnoreResultAssign();
(void)Ignore;
assert (Ignore == false && "init list ignored")((Ignore == false && "init list ignored") ? static_cast
<void> (0) : __assert_fail ("Ignore == false && \"init list ignored\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1788, __PRETTY_FUNCTION__));
unsigned NumInitElements = E->getNumInits();

if (E->hadArrayRangeDesignator())
  CGF.ErrorUnsupported(E, "GNU array range designator extension");

llvm::VectorType *VType =
  dyn_cast<llvm::VectorType>(ConvertType(E->getType()));

if (!VType) {
  if (NumInitElements == 0) {
    // C++11 value-initialization for the scalar.
    return EmitNullValue(E->getType());
  }
  // We have a scalar in braces. Just use the first element.
  return Visit(E->getInit(0));
}

unsigned ResElts = VType->getNumElements();

// Loop over initializers collecting the Value for each, and remembering
// whether the source was swizzle (ExtVectorElementExpr).  This will allow
// us to fold the shuffle for the swizzle into the shuffle for the vector
// initializer, since LLVM optimizers generally do not want to touch
// shuffles.
unsigned CurIdx = 0;
bool VIsUndefShuffle = false;
llvm::Value *V = llvm::UndefValue::get(VType);
for (unsigned i = 0; i != NumInitElements; ++i) {
  Expr *IE = E->getInit(i);
  Value *Init = Visit(IE);
  SmallVector<llvm::Constant*, 16> Args;

  llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType());

  // Handle scalar elements.  If the scalar initializer is actually one
  // element of a different vector of the same width, use shuffle instead of
  // extract+insert.
  if (!VVT) {
    if (isa<ExtVectorElementExpr>(IE)) {
      llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);

      if (EI->getVectorOperandType()->getNumElements() == ResElts) {
        llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand());
        Value *LHS = nullptr, *RHS = nullptr;
        if (CurIdx == 0) {
          // insert into undef -> shuffle (src, undef)
          // shufflemask must use an i32
          Args.push_back(getAsInt32(C, CGF.Int32Ty));
          Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));

          LHS = EI->getVectorOperand();
          RHS = V;
          VIsUndefShuffle = true;
        } else if (VIsUndefShuffle) {
          // insert into undefshuffle && size match -> shuffle (v, src)
          llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
          for (unsigned j = 0; j != CurIdx; ++j)
            Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty));
          Args.push_back(Builder.getInt32(ResElts + C->getZExtValue()));
          Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));

          LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
          RHS = EI->getVectorOperand();
          VIsUndefShuffle = false;
        }
        if (!Args.empty()) {
          llvm::Constant *Mask = llvm::ConstantVector::get(Args);
          V = Builder.CreateShuffleVector(LHS, RHS, Mask);
          ++CurIdx;
          continue;
        }
      }
    }
    V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
                                    "vecinit");
    VIsUndefShuffle = false;
    ++CurIdx;
    continue;
  }

  unsigned InitElts = VVT->getNumElements();

  // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's
  // input is the same width as the vector being constructed, generate an
  // optimized shuffle of the swizzle input into the result.
  unsigned Offset = (CurIdx == 0) ? 0 : ResElts;
  if (isa<ExtVectorElementExpr>(IE)) {
    llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
    Value *SVOp = SVI->getOperand(0);
    llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType());

    if (OpTy->getNumElements() == ResElts) {
      for (unsigned j = 0; j != CurIdx; ++j) {
        // If the current vector initializer is a shuffle with undef, merge
        // this shuffle directly into it.
        if (VIsUndefShuffle) {
          Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0,
                                    CGF.Int32Ty));
        } else {
          Args.push_back(Builder.getInt32(j));
        }
      }
      for (unsigned j = 0, je = InitElts; j != je; ++j)
        Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty));
      Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));

      if (VIsUndefShuffle)
        V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);

      Init = SVOp;
    }
  }

  // Extend init to result vector length, and then shuffle its contribution
  // to the vector initializer into V.
  if (Args.empty()) {
    for (unsigned j = 0; j != InitElts; ++j)
      Args.push_back(Builder.getInt32(j));
    Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
    llvm::Constant *Mask = llvm::ConstantVector::get(Args);
    Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
                                       Mask, "vext");

    Args.clear();
    for (unsigned j = 0; j != CurIdx; ++j)
      Args.push_back(Builder.getInt32(j));
    for (unsigned j = 0; j != InitElts; ++j)
      Args.push_back(Builder.getInt32(j+Offset));
    Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
  }

  // If V is undef, make sure it ends up on the RHS of the shuffle to aid
  // merging subsequent shuffles into this one.
  if (CurIdx == 0)
    std::swap(V, Init);
  llvm::Constant *Mask = llvm::ConstantVector::get(Args);
  V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit");
  VIsUndefShuffle = isa<llvm::UndefValue>(Init);
  CurIdx += InitElts;
}

// FIXME: evaluate codegen vs. shuffling against constant null vector.
// Emit remaining default initializers.
llvm::Type *EltTy = VType->getElementType();

// Emit remaining default initializers
for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) {
  Value *Idx = Builder.getInt32(CurIdx);
  llvm::Value *Init = llvm::Constant::getNullValue(EltTy);
  V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
}
return V;
1941}

1943bool CodeGenFunction::ShouldNullCheckClassCastValue(const CastExpr *CE) {
const Expr *E = CE->getSubExpr();

if (CE->getCastKind() == CK_UncheckedDerivedToBase)
  return false;

if (isa<CXXThisExpr>(E->IgnoreParens())) {
  // We always assume that 'this' is never null.
  return false;
}

if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
  // And that glvalue casts are never null.
  if (ICE->getValueKind() != VK_RValue)
    return false;
}

return true;
1961}

1963// VisitCastExpr - Emit code for an explicit or implicit cast.  Implicit casts
1964// have to handle a more broad range of conversions than explicit casts, as they
1965// handle things like function to ptr-to-function decay etc.
1966Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
Expr *E = CE->getSubExpr();
QualType DestTy = CE->getType();
CastKind Kind = CE->getCastKind();

// These cases are generally not written to ignore the result of
// evaluating their sub-expressions, so we clear this now.
bool Ignored = TestAndClearIgnoreResultAssign();

// Since almost all cast kinds apply to scalars, this switch doesn't have
// a default case, so the compiler will warn on a missing case.  The cases
// are in the same order as in the CastKind enum.
switch (Kind) {
case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!")::llvm::llvm_unreachable_internal("dependent cast kind in IR gen!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1979);
case CK_BuiltinFnToFnPtr:
  llvm_unreachable("builtin functions are handled elsewhere")::llvm::llvm_unreachable_internal("builtin functions are handled elsewhere"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 1981);

case CK_LValueBitCast:
case CK_ObjCObjectLValueCast: {
  Address Addr = EmitLValue(E).getAddress(CGF);
  Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
  LValue LV = CGF.MakeAddrLValue(Addr, DestTy);
  return EmitLoadOfLValue(LV, CE->getExprLoc());
}

case CK_LValueToRValueBitCast: {
  LValue SourceLVal = CGF.EmitLValue(E);
  Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(CGF),
                                              CGF.ConvertTypeForMem(DestTy));
  LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
  DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
  return EmitLoadOfLValue(DestLV, CE->getExprLoc());
}

case CK_CPointerToObjCPointerCast:
case CK_BlockPointerToObjCPointerCast:
case CK_AnyPointerToBlockPointerCast:
case CK_BitCast: {
  Value *Src = Visit(const_cast<Expr*>(E));
  llvm::Type *SrcTy = Src->getType();
  llvm::Type *DstTy = ConvertType(DestTy);
  if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
      SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
    llvm_unreachable("wrong cast for pointers in different address spaces"::llvm::llvm_unreachable_internal("wrong cast for pointers in different address spaces"
 "(must be an address space cast)!", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2010)
                     "(must be an address space cast)!")::llvm::llvm_unreachable_internal("wrong cast for pointers in different address spaces"
 "(must be an address space cast)!", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2010);
  }

  if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
    if (auto PT = DestTy->getAs<PointerType>())
      CGF.EmitVTablePtrCheckForCast(PT->getPointeeType(), Src,
                                    /*MayBeNull=*/true,
                                    CodeGenFunction::CFITCK_UnrelatedCast,
                                    CE->getBeginLoc());
  }

  if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
    const QualType SrcType = E->getType();

    if (SrcType.mayBeNotDynamicClass() && DestTy.mayBeDynamicClass()) {
      // Casting to pointer that could carry dynamic information (provided by
      // invariant.group) requires launder.
      Src = Builder.CreateLaunderInvariantGroup(Src);
    } else if (SrcType.mayBeDynamicClass() && DestTy.mayBeNotDynamicClass()) {
      // Casting to pointer that does not carry dynamic information (provided
      // by invariant.group) requires stripping it.  Note that we don't do it
      // if the source could not be dynamic type and destination could be
      // dynamic because dynamic information is already laundered.  It is
      // because launder(strip(src)) == launder(src), so there is no need to
      // add extra strip before launder.
      Src = Builder.CreateStripInvariantGroup(Src);
    }
  }

  // Update heapallocsite metadata when there is an explicit cast.
  if (llvm::CallInst *CI = dyn_cast<llvm::CallInst>(Src))
    if (CI->getMetadata("heapallocsite") && isa<ExplicitCastExpr>(CE))
        CGF.getDebugInfo()->
            addHeapAllocSiteMetadata(CI, CE->getType(), CE->getExprLoc());

  return Builder.CreateBitCast(Src, DstTy);
}
case CK_AddressSpaceConversion: {
  Expr::EvalResult Result;
  if (E->EvaluateAsRValue(Result, CGF.getContext()) &&
      Result.Val.isNullPointer()) {
    // If E has side effect, it is emitted even if its final result is a
    // null pointer. In that case, a DCE pass should be able to
    // eliminate the useless instructions emitted during translating E.
    if (Result.HasSideEffects)
      Visit(E);
    return CGF.CGM.getNullPointer(cast<llvm::PointerType>(
        ConvertType(DestTy)), DestTy);
  }
  // Since target may map different address spaces in AST to the same address
  // space, an address space conversion may end up as a bitcast.
  return CGF.CGM.getTargetCodeGenInfo().performAddrSpaceCast(
      CGF, Visit(E), E->getType()->getPointeeType().getAddressSpace(),
      DestTy->getPointeeType().getAddressSpace(), ConvertType(DestTy));
}
case CK_AtomicToNonAtomic:
case CK_NonAtomicToAtomic:
case CK_NoOp:
case CK_UserDefinedConversion:
  return Visit(const_cast<Expr*>(E));

case CK_BaseToDerived: {
  const CXXRecordDecl *DerivedClassDecl = DestTy->getPointeeCXXRecordDecl();
  assert(DerivedClassDecl && "BaseToDerived arg isn't a C++ object pointer!")((DerivedClassDecl && "BaseToDerived arg isn't a C++ object pointer!"
) ? static_cast<void> (0) : __assert_fail ("DerivedClassDecl && \"BaseToDerived arg isn't a C++ object pointer!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2073, __PRETTY_FUNCTION__));

  Address Base = CGF.EmitPointerWithAlignment(E);
  Address Derived =
    CGF.GetAddressOfDerivedClass(Base, DerivedClassDecl,
                                 CE->path_begin(), CE->path_end(),
                                 CGF.ShouldNullCheckClassCastValue(CE));

  // C++11 [expr.static.cast]p11: Behavior is undefined if a downcast is
  // performed and the object is not of the derived type.
  if (CGF.sanitizePerformTypeCheck())
    CGF.EmitTypeCheck(CodeGenFunction::TCK_DowncastPointer, CE->getExprLoc(),
                      Derived.getPointer(), DestTy->getPointeeType());

  if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
    CGF.EmitVTablePtrCheckForCast(
        DestTy->getPointeeType(), Derived.getPointer(),
        /*MayBeNull=*/true, CodeGenFunction::CFITCK_DerivedCast,
        CE->getBeginLoc());

  return Derived.getPointer();
}
case CK_UncheckedDerivedToBase:
case CK_DerivedToBase: {
  // The EmitPointerWithAlignment path does this fine; just discard
  // the alignment.
  return CGF.EmitPointerWithAlignment(CE).getPointer();
}

case CK_Dynamic: {
  Address V = CGF.EmitPointerWithAlignment(E);
  const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE);
  return CGF.EmitDynamicCast(V, DCE);
}

case CK_ArrayToPointerDecay:
  return CGF.EmitArrayToPointerDecay(E).getPointer();
case CK_FunctionToPointerDecay:
  return EmitLValue(E).getPointer(CGF);

case CK_NullToPointer:
  if (MustVisitNullValue(E))
    CGF.EmitIgnoredExpr(E);

  return CGF.CGM.getNullPointer(cast<llvm::PointerType>(ConvertType(DestTy)),
                            DestTy);

case CK_NullToMemberPointer: {
  if (MustVisitNullValue(E))
    CGF.EmitIgnoredExpr(E);

  const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>();
  return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
}

case CK_ReinterpretMemberPointer:
case CK_BaseToDerivedMemberPointer:
case CK_DerivedToBaseMemberPointer: {
  Value *Src = Visit(E);

  // Note that the AST doesn't distinguish between checked and
  // unchecked member pointer conversions, so we always have to
  // implement checked conversions here.  This is inefficient when
  // actual control flow may be required in order to perform the
  // check, which it is for data member pointers (but not member
  // function pointers on Itanium and ARM).
  return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
}

case CK_ARCProduceObject:
  return CGF.EmitARCRetainScalarExpr(E);
case CK_ARCConsumeObject:
  return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
case CK_ARCReclaimReturnedObject:
  return CGF.EmitARCReclaimReturnedObject(E, /*allowUnsafe*/ Ignored);
case CK_ARCExtendBlockObject:
  return CGF.EmitARCExtendBlockObject(E);

case CK_CopyAndAutoreleaseBlockObject:
  return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());

case CK_FloatingRealToComplex:
case CK_FloatingComplexCast:
case CK_IntegralRealToComplex:
case CK_IntegralComplexCast:
case CK_IntegralComplexToFloatingComplex:
case CK_FloatingComplexToIntegralComplex:
case CK_ConstructorConversion:
case CK_ToUnion:
  llvm_unreachable("scalar cast to non-scalar value")::llvm::llvm_unreachable_internal("scalar cast to non-scalar value"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2162);

case CK_LValueToRValue:
  assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy))((CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy
)) ? static_cast<void> (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2165, __PRETTY_FUNCTION__));
  assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!")((E->isGLValue() && "lvalue-to-rvalue applied to r-value!"
) ? static_cast<void> (0) : __assert_fail ("E->isGLValue() && \"lvalue-to-rvalue applied to r-value!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2166, __PRETTY_FUNCTION__));
  return Visit(const_cast<Expr*>(E));

case CK_IntegralToPointer: {
  Value *Src = Visit(const_cast<Expr*>(E));

  // First, convert to the correct width so that we control the kind of
  // extension.
  auto DestLLVMTy = ConvertType(DestTy);
  llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DestLLVMTy);
  bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType();
  llvm::Value* IntResult =
    Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");

  auto *IntToPtr = Builder.CreateIntToPtr(IntResult, DestLLVMTy);

  if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
    // Going from integer to pointer that could be dynamic requires reloading
    // dynamic information from invariant.group.
    if (DestTy.mayBeDynamicClass())
      IntToPtr = Builder.CreateLaunderInvariantGroup(IntToPtr);
  }
  return IntToPtr;
}
case CK_PointerToIntegral: {
  assert(!DestTy->isBooleanType() && "bool should use PointerToBool")((!DestTy->isBooleanType() && "bool should use PointerToBool"
) ? static_cast<void> (0) : __assert_fail ("!DestTy->isBooleanType() && \"bool should use PointerToBool\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2191, __PRETTY_FUNCTION__));
  auto *PtrExpr = Visit(E);

  if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
    const QualType SrcType = E->getType();

    // Casting to integer requires stripping dynamic information as it does
    // not carries it.
    if (SrcType.mayBeDynamicClass())
      PtrExpr = Builder.CreateStripInvariantGroup(PtrExpr);
  }

  return Builder.CreatePtrToInt(PtrExpr, ConvertType(DestTy));
}
case CK_ToVoid: {
  CGF.EmitIgnoredExpr(E);
  return nullptr;
}
case CK_VectorSplat: {
  llvm::Type *DstTy = ConvertType(DestTy);
  Value *Elt = Visit(const_cast<Expr*>(E));
  // Splat the element across to all elements
  unsigned NumElements = DstTy->getVectorNumElements();
  return Builder.CreateVectorSplat(NumElements, Elt, "splat");
}

case CK_FixedPointCast:
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());

case CK_FixedPointToBoolean:
  assert(E->getType()->isFixedPointType() &&((E->getType()->isFixedPointType() && "Expected src type to be fixed point type"
) ? static_cast<void> (0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2223, __PRETTY_FUNCTION__))
         "Expected src type to be fixed point type")((E->getType()->isFixedPointType() && "Expected src type to be fixed point type"
) ? static_cast<void> (0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2223, __PRETTY_FUNCTION__));
  assert(DestTy->isBooleanType() && "Expected dest type to be boolean type")((DestTy->isBooleanType() && "Expected dest type to be boolean type"
) ? static_cast<void> (0) : __assert_fail ("DestTy->isBooleanType() && \"Expected dest type to be boolean type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2224, __PRETTY_FUNCTION__));
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());

case CK_FixedPointToIntegral:
  assert(E->getType()->isFixedPointType() &&((E->getType()->isFixedPointType() && "Expected src type to be fixed point type"
) ? static_cast<void> (0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2230, __PRETTY_FUNCTION__))
         "Expected src type to be fixed point type")((E->getType()->isFixedPointType() && "Expected src type to be fixed point type"
) ? static_cast<void> (0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2230, __PRETTY_FUNCTION__));
  assert(DestTy->isIntegerType() && "Expected dest type to be an integer")((DestTy->isIntegerType() && "Expected dest type to be an integer"
) ? static_cast<void> (0) : __assert_fail ("DestTy->isIntegerType() && \"Expected dest type to be an integer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2231, __PRETTY_FUNCTION__));
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());

case CK_IntegralToFixedPoint:
  assert(E->getType()->isIntegerType() &&((E->getType()->isIntegerType() && "Expected src type to be an integer"
) ? static_cast<void> (0) : __assert_fail ("E->getType()->isIntegerType() && \"Expected src type to be an integer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2237, __PRETTY_FUNCTION__))
         "Expected src type to be an integer")((E->getType()->isIntegerType() && "Expected src type to be an integer"
) ? static_cast<void> (0) : __assert_fail ("E->getType()->isIntegerType() && \"Expected src type to be an integer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2237, __PRETTY_FUNCTION__));
  assert(DestTy->isFixedPointType() &&((DestTy->isFixedPointType() && "Expected dest type to be fixed point type"
) ? static_cast<void> (0) : __assert_fail ("DestTy->isFixedPointType() && \"Expected dest type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2239, __PRETTY_FUNCTION__))
         "Expected dest type to be fixed point type")((DestTy->isFixedPointType() && "Expected dest type to be fixed point type"
) ? static_cast<void> (0) : __assert_fail ("DestTy->isFixedPointType() && \"Expected dest type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2239, __PRETTY_FUNCTION__));
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());

case CK_IntegralCast: {
  ScalarConversionOpts Opts;
  if (auto *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
    if (!ICE->isPartOfExplicitCast())
      Opts = ScalarConversionOpts(CGF.SanOpts);
  }
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc(), Opts);
}
case CK_IntegralToFloating:
case CK_FloatingToIntegral:
case CK_FloatingCast:
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());
case CK_BooleanToSignedIntegral: {
  ScalarConversionOpts Opts;
  Opts.TreatBooleanAsSigned = true;
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc(), Opts);
}
case CK_IntegralToBoolean:
  return EmitIntToBoolConversion(Visit(E));
case CK_PointerToBoolean:
  return EmitPointerToBoolConversion(Visit(E), E->getType());
case CK_FloatingToBoolean:
  return EmitFloatToBoolConversion(Visit(E));
case CK_MemberPointerToBoolean: {
  llvm::Value *MemPtr = Visit(E);
  const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
  return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
}

case CK_FloatingComplexToReal:
case CK_IntegralComplexToReal:
  return CGF.EmitComplexExpr(E, false, true).first;

case CK_FloatingComplexToBoolean:
case CK_IntegralComplexToBoolean: {
  CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E);

  // TODO: kill this function off, inline appropriate case here
  return EmitComplexToScalarConversion(V, E->getType(), DestTy,
                                       CE->getExprLoc());
}

case CK_ZeroToOCLOpaqueType: {
  assert((DestTy->isEventT() || DestTy->isQueueT() ||(((DestTy->isEventT() || DestTy->isQueueT() || DestTy->
isOCLIntelSubgroupAVCType()) && "CK_ZeroToOCLEvent cast on non-event type"
) ? static_cast<void> (0) : __assert_fail ("(DestTy->isEventT() || DestTy->isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) && \"CK_ZeroToOCLEvent cast on non-event type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2291, __PRETTY_FUNCTION__))
          DestTy->isOCLIntelSubgroupAVCType()) &&(((DestTy->isEventT() || DestTy->isQueueT() || DestTy->
isOCLIntelSubgroupAVCType()) && "CK_ZeroToOCLEvent cast on non-event type"
) ? static_cast<void> (0) : __assert_fail ("(DestTy->isEventT() || DestTy->isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) && \"CK_ZeroToOCLEvent cast on non-event type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2291, __PRETTY_FUNCTION__))
         "CK_ZeroToOCLEvent cast on non-event type")(((DestTy->isEventT() || DestTy->isQueueT() || DestTy->
isOCLIntelSubgroupAVCType()) && "CK_ZeroToOCLEvent cast on non-event type"
) ? static_cast<void> (0) : __assert_fail ("(DestTy->isEventT() || DestTy->isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) && \"CK_ZeroToOCLEvent cast on non-event type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2291, __PRETTY_FUNCTION__));
  return llvm::Constant::getNullValue(ConvertType(DestTy));
}

case CK_IntToOCLSampler:
  return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);

} // end of switch

llvm_unreachable("unknown scalar cast")::llvm::llvm_unreachable_internal("unknown scalar cast", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2300);
2301}

2303Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
CodeGenFunction::StmtExprEvaluation eval(CGF);
Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(),
                                         !E->getType()->isVoidType());
if (!RetAlloca.isValid())
  return nullptr;
return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->getType()),
                            E->getExprLoc());
2311}

2313Value *ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
CGF.enterFullExpression(E);
CodeGenFunction::RunCleanupsScope Scope(CGF);
Value *V = Visit(E->getSubExpr());
// Defend against dominance problems caused by jumps out of expression
// evaluation through the shared cleanup block.
Scope.ForceCleanup({&V});
return V;
2321}

2323//===----------------------------------------------------------------------===//
2324//                             Unary Operators
2325//===----------------------------------------------------------------------===//

2327static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E,
                                         llvm::Value *InVal, bool IsInc) {
BinOpInfo BinOp;
BinOp.LHS = InVal;
BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1, false);
BinOp.Ty = E->getType();
BinOp.Opcode = IsInc ? BO_Add : BO_Sub;
// FIXME: once UnaryOperator carries FPFeatures, copy it here.
BinOp.E = E;
return BinOp;
2337}

2339llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
  const UnaryOperator *E, llvm::Value *InVal, bool IsInc) {
llvm::Value *Amount =
    llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1, true);
StringRef Name = IsInc ? "inc" : "dec";
switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
case LangOptions::SOB_Defined:
  return Builder.CreateAdd(InVal, Amount, Name);
case LangOptions::SOB_Undefined:
  if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
    return Builder.CreateNSWAdd(InVal, Amount, Name);
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case LangOptions::SOB_Trapping:
  if (!E->canOverflow())
    return Builder.CreateNSWAdd(InVal, Amount, Name);
  return EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(E, InVal, IsInc));
}
llvm_unreachable("Unknown SignedOverflowBehaviorTy")::llvm::llvm_unreachable_internal("Unknown SignedOverflowBehaviorTy"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2356);
2357}

2359namespace {
2360/// Handles check and update for lastprivate conditional variables.
2361class OMPLastprivateConditionalUpdateRAII {
2362private:
CodeGenFunction &CGF;
const UnaryOperator *E;

2366public:
OMPLastprivateConditionalUpdateRAII(CodeGenFunction &CGF,
                                    const UnaryOperator *E)
    : CGF(CGF), E(E) {}
~OMPLastprivateConditionalUpdateRAII() {
  if (CGF.getLangOpts().OpenMP)
    CGF.CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(
        CGF, E->getSubExpr());
}
2375};
2376} // namespace

2378llvm::Value *
2379ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
                                         bool isInc, bool isPre) {
OMPLastprivateConditionalUpdateRAII OMPRegion(CGF, E);
QualType type = E->getSubExpr()->getType();
llvm::PHINode *atomicPHI = nullptr;
llvm::Value *value;
llvm::Value *input;

int amount = (isInc ? 1 : -1);
bool isSubtraction = !isInc;

if (const AtomicType *atomicTy = type->getAs<AtomicType>()) {
  type = atomicTy->getValueType();
  if (isInc && type->isBooleanType()) {
    llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
    if (isPre) {
      Builder.CreateStore(True, LV.getAddress(CGF), LV.isVolatileQualified())
          ->setAtomic(llvm::AtomicOrdering::SequentiallyConsistent);
      return Builder.getTrue();
    }
    // For atomic bool increment, we just store true and return it for
    // preincrement, do an atomic swap with true for postincrement
    return Builder.CreateAtomicRMW(
        llvm::AtomicRMWInst::Xchg, LV.getPointer(CGF), True,
        llvm::AtomicOrdering::SequentiallyConsistent);
  }
  // Special case for atomic increment / decrement on integers, emit
  // atomicrmw instructions.  We skip this if we want to be doing overflow
  // checking, and fall into the slow path with the atomic cmpxchg loop.
  if (!type->isBooleanType() && type->isIntegerType() &&
      !(type->isUnsignedIntegerType() &&
        CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
      CGF.getLangOpts().getSignedOverflowBehavior() !=
          LangOptions::SOB_Trapping) {
    llvm::AtomicRMWInst::BinOp aop = isInc ? llvm::AtomicRMWInst::Add :
      llvm::AtomicRMWInst::Sub;
    llvm::Instruction::BinaryOps op = isInc ? llvm::Instruction::Add :
      llvm::Instruction::Sub;
    llvm::Value *amt = CGF.EmitToMemory(
        llvm::ConstantInt::get(ConvertType(type), 1, true), type);
    llvm::Value *old =
        Builder.CreateAtomicRMW(aop, LV.getPointer(CGF), amt,
                                llvm::AtomicOrdering::SequentiallyConsistent);
    return isPre ? Builder.CreateBinOp(op, old, amt) : old;
  }
  value = EmitLoadOfLValue(LV, E->getExprLoc());
  input = value;
  // For every other atomic operation, we need to emit a load-op-cmpxchg loop
  llvm::BasicBlock *startBB = Builder.GetInsertBlock();
  llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
  value = CGF.EmitToMemory(value, type);
  Builder.CreateBr(opBB);
  Builder.SetInsertPoint(opBB);
  atomicPHI = Builder.CreatePHI(value->getType(), 2);
  atomicPHI->addIncoming(value, startBB);
  value = atomicPHI;
} else {
  value = EmitLoadOfLValue(LV, E->getExprLoc());
  input = value;
}

// Special case of integer increment that we have to check first: bool++.
// Due to promotion rules, we get:
//   bool++ -> bool = bool + 1
//          -> bool = (int)bool + 1
//          -> bool = ((int)bool + 1 != 0)
// An interesting aspect of this is that increment is always true.
// Decrement does not have this property.
if (isInc && type->isBooleanType()) {
  value = Builder.getTrue();

// Most common case by far: integer increment.
} else if (type->isIntegerType()) {
  QualType promotedType;
  bool canPerformLossyDemotionCheck = false;
  if (type->isPromotableIntegerType()) {
    promotedType = CGF.getContext().getPromotedIntegerType(type);
    assert(promotedType != type && "Shouldn't promote to the same type.")((promotedType != type && "Shouldn't promote to the same type."
) ? static_cast<void> (0) : __assert_fail ("promotedType != type && \"Shouldn't promote to the same type.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2456, __PRETTY_FUNCTION__));
    canPerformLossyDemotionCheck = true;
    canPerformLossyDemotionCheck &=
        CGF.getContext().getCanonicalType(type) !=
        CGF.getContext().getCanonicalType(promotedType);
    canPerformLossyDemotionCheck &=
        PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(
            type, promotedType);
    assert((!canPerformLossyDemotionCheck ||(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
            type->isSignedIntegerOrEnumerationType() ||(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
            promotedType->isSignedIntegerOrEnumerationType() ||(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
            ConvertType(type)->getScalarSizeInBits() ==(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
                ConvertType(promotedType)->getScalarSizeInBits()) &&(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
           "The following check expects that if we do promotion to different "(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
           "underlying canonical type, at least one of the types (either "(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__))
           "base or promoted) will be signed, or the bitwidths will match.")(((!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType
() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType
(type)->getScalarSizeInBits() == ConvertType(promotedType)
->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
 "underlying canonical type, at least one of the types (either "
 "base or promoted) will be signed, or the bitwidths will match."
) ? static_cast<void> (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2471, __PRETTY_FUNCTION__));
  }
  if (CGF.SanOpts.hasOneOf(
          SanitizerKind::ImplicitIntegerArithmeticValueChange) &&
      canPerformLossyDemotionCheck) {
    // While `x += 1` (for `x` with width less than int) is modeled as
    // promotion+arithmetics+demotion, and we can catch lossy demotion with
    // ease; inc/dec with width less than int can't overflow because of
    // promotion rules, so we omit promotion+demotion, which means that we can
    // not catch lossy "demotion". Because we still want to catch these cases
    // when the sanitizer is enabled, we perform the promotion, then perform
    // the increment/decrement in the wider type, and finally
    // perform the demotion. This will catch lossy demotions.

    value = EmitScalarConversion(value, type, promotedType, E->getExprLoc());
    Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
    value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
    // Do pass non-default ScalarConversionOpts so that sanitizer check is
    // emitted.
    value = EmitScalarConversion(value, promotedType, type, E->getExprLoc(),
                                 ScalarConversionOpts(CGF.SanOpts));

    // Note that signed integer inc/dec with width less than int can't
    // overflow because of promotion rules; we're just eliding a few steps
    // here.
  } else if (E->canOverflow() && type->isSignedIntegerOrEnumerationType()) {
    value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
  } else if (E->canOverflow() && type->isUnsignedIntegerType() &&
             CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) {
    value =
        EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(E, value, isInc));
  } else {
    llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
    value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
  }

// Next most common: pointer increment.
} else if (const PointerType *ptr = type->getAs<PointerType>()) {
  QualType type = ptr->getPointeeType();

  // VLA types don't have constant size.
  if (const VariableArrayType *vla
        = CGF.getContext().getAsVariableArrayType(type)) {
    llvm::Value *numElts = CGF.getVLASize(vla).NumElts;
    if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
    if (CGF.getLangOpts().isSignedOverflowDefined())
      value = Builder.CreateGEP(value, numElts, "vla.inc");
    else
      value = CGF.EmitCheckedInBoundsGEP(
          value, numElts, /*SignedIndices=*/false, isSubtraction,
          E->getExprLoc(), "vla.inc");

  // Arithmetic on function pointers (!) is just +-1.
  } else if (type->isFunctionType()) {
    llvm::Value *amt = Builder.getInt32(amount);

    value = CGF.EmitCastToVoidPtr(value);
    if (CGF.getLangOpts().isSignedOverflowDefined())
      value = Builder.CreateGEP(value, amt, "incdec.funcptr");
    else
      value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false,
                                         isSubtraction, E->getExprLoc(),
                                         "incdec.funcptr");
    value = Builder.CreateBitCast(value, input->getType());

  // For everything else, we can just do a simple increment.
  } else {
    llvm::Value *amt = Builder.getInt32(amount);
    if (CGF.getLangOpts().isSignedOverflowDefined())
      value = Builder.CreateGEP(value, amt, "incdec.ptr");
    else
      value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false,
                                         isSubtraction, E->getExprLoc(),
                                         "incdec.ptr");
  }

// Vector increment/decrement.
} else if (type->isVectorType()) {
  if (type->hasIntegerRepresentation()) {
    llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);

    value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
  } else {
    value = Builder.CreateFAdd(
                value,
                llvm::ConstantFP::get(value->getType(), amount),
                isInc ? "inc" : "dec");
  }

// Floating point.
} else if (type->isRealFloatingType()) {
  // Add the inc/dec to the real part.
  llvm::Value *amt;

  if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
    // Another special case: half FP increment should be done via float
    if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
      value = Builder.CreateCall(
          CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
                               CGF.CGM.FloatTy),
          input, "incdec.conv");
    } else {
      value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
    }
  }

  if (value->getType()->isFloatTy())
    amt = llvm::ConstantFP::get(VMContext,
                                llvm::APFloat(static_cast<float>(amount)));
  else if (value->getType()->isDoubleTy())
    amt = llvm::ConstantFP::get(VMContext,
                                llvm::APFloat(static_cast<double>(amount)));
  else {
    // Remaining types are Half, LongDouble or __float128. Convert from float.
    llvm::APFloat F(static_cast<float>(amount));
    bool ignored;
    const llvm::fltSemantics *FS;
    // Don't use getFloatTypeSemantics because Half isn't
    // necessarily represented using the "half" LLVM type.
    if (value->getType()->isFP128Ty())
      FS = &CGF.getTarget().getFloat128Format();
    else if (value->getType()->isHalfTy())
      FS = &CGF.getTarget().getHalfFormat();
    else
      FS = &CGF.getTarget().getLongDoubleFormat();
    F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
    amt = llvm::ConstantFP::get(VMContext, F);
  }
  value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");

  if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
    if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
      value = Builder.CreateCall(
          CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
                               CGF.CGM.FloatTy),
          value, "incdec.conv");
    } else {
      value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
    }
  }

// Objective-C pointer types.
} else {
  const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>();
  value = CGF.EmitCastToVoidPtr(value);

  CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
  if (!isInc) size = -size;
  llvm::Value *sizeValue =
    llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());

  if (CGF.getLangOpts().isSignedOverflowDefined())
    value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
  else
    value = CGF.EmitCheckedInBoundsGEP(value, sizeValue,
                                       /*SignedIndices=*/false, isSubtraction,
                                       E->getExprLoc(), "incdec.objptr");
  value = Builder.CreateBitCast(value, input->getType());
}

if (atomicPHI) {
  llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
  llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
  auto Pair = CGF.EmitAtomicCompareExchange(
      LV, RValue::get(atomicPHI), RValue::get(value), E->getExprLoc());
  llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), type);
  llvm::Value *success = Pair.second;
  atomicPHI->addIncoming(old, curBlock);
  Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
  Builder.SetInsertPoint(contBB);
  return isPre ? value : input;
}

// Store the updated result through the lvalue.
if (LV.isBitField())
  CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
else
  CGF.EmitStoreThroughLValue(RValue::get(value), LV);

// If this is a postinc, return the value read from memory, otherwise use the
// updated value.
return isPre ? value : input;
2653}



2657Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
TestAndClearIgnoreResultAssign();
Value *Op = Visit(E->getSubExpr());

// Generate a unary FNeg for FP ops.
if (Op->getType()->isFPOrFPVectorTy())
  return Builder.CreateFNeg(Op, "fneg");

// Emit unary minus with EmitSub so we handle overflow cases etc.
BinOpInfo BinOp;
BinOp.RHS = Op;
BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType());
BinOp.Ty = E->getType();
BinOp.Opcode = BO_Sub;
// FIXME: once UnaryOperator carries FPFeatures, copy it here.
BinOp.E = E;
return EmitSub(BinOp);
2674}

2676Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
TestAndClearIgnoreResultAssign();
Value *Op = Visit(E->getSubExpr());
return Builder.CreateNot(Op, "neg");
2680}

2682Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
// Perform vector logical not on comparison with zero vector.
if (E->getType()->isExtVectorType()) {
  Value *Oper = Visit(E->getSubExpr());
  Value *Zero = llvm::Constant::getNullValue(Oper->getType());
  Value *Result;
  if (Oper->getType()->isFPOrFPVectorTy())
    Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");
  else
    Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
  return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
}

// Compare operand to zero.
Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());

// Invert value.
// TODO: Could dynamically modify easy computations here.  For example, if
// the operand is an icmp ne, turn into icmp eq.
BoolVal = Builder.CreateNot(BoolVal, "lnot");

// ZExt result to the expr type.
return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
2705}

2707Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) {
// Try folding the offsetof to a constant.
Expr::EvalResult EVResult;
if (E->EvaluateAsInt(EVResult, CGF.getContext())) {
  llvm::APSInt Value = EVResult.Val.getInt();
  return Builder.getInt(Value);
}

// Loop over the components of the offsetof to compute the value.
unsigned n = E->getNumComponents();
llvm::Type* ResultType = ConvertType(E->getType());
llvm::Value* Result = llvm::Constant::getNullValue(ResultType);
QualType CurrentType = E->getTypeSourceInfo()->getType();
for (unsigned i = 0; i != n; ++i) {
  OffsetOfNode ON = E->getComponent(i);
  llvm::Value *Offset = nullptr;
  switch (ON.getKind()) {
  case OffsetOfNode::Array: {
    // Compute the index
    Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex());
    llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr);
    bool IdxSigned = IdxExpr->getType()->isSignedIntegerOrEnumerationType();
    Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");

    // Save the element type
    CurrentType =
        CGF.getContext().getAsArrayType(CurrentType)->getElementType();

    // Compute the element size
    llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
        CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());

    // Multiply out to compute the result
    Offset = Builder.CreateMul(Idx, ElemSize);
    break;
  }

  case OffsetOfNode::Field: {
    FieldDecl *MemberDecl = ON.getField();
    RecordDecl *RD = CurrentType->castAs<RecordType>()->getDecl();
    const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);

    // Compute the index of the field in its parent.
    unsigned i = 0;
    // FIXME: It would be nice if we didn't have to loop here!
    for (RecordDecl::field_iterator Field = RD->field_begin(),
                                    FieldEnd = RD->field_end();
         Field != FieldEnd; ++Field, ++i) {
      if (*Field == MemberDecl)
        break;
    }
    assert(i < RL.getFieldCount() && "offsetof field in wrong type")((i < RL.getFieldCount() && "offsetof field in wrong type"
) ? static_cast<void> (0) : __assert_fail ("i < RL.getFieldCount() && \"offsetof field in wrong type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2758, __PRETTY_FUNCTION__));

    // Compute the offset to the field
    int64_t OffsetInt = RL.getFieldOffset(i) /
                        CGF.getContext().getCharWidth();
    Offset = llvm::ConstantInt::get(ResultType, OffsetInt);

    // Save the element type.
    CurrentType = MemberDecl->getType();
    break;
  }

  case OffsetOfNode::Identifier:
    llvm_unreachable("dependent __builtin_offsetof")::llvm::llvm_unreachable_internal("dependent __builtin_offsetof"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2771);

  case OffsetOfNode::Base: {
    if (ON.getBase()->isVirtual()) {
      CGF.ErrorUnsupported(E, "virtual base in offsetof");
      continue;
    }

    RecordDecl *RD = CurrentType->castAs<RecordType>()->getDecl();
    const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);

    // Save the element type.
    CurrentType = ON.getBase()->getType();

    // Compute the offset to the base.
    const RecordType *BaseRT = CurrentType->getAs<RecordType>();
    CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
    CharUnits OffsetInt = RL.getBaseClassOffset(BaseRD);
    Offset = llvm::ConstantInt::get(ResultType, OffsetInt.getQuantity());
    break;
  }
  }
  Result = Builder.CreateAdd(Result, Offset);
}
return Result;
2796}

2798/// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of
2799/// argument of the sizeof expression as an integer.
2800Value *
2801ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
                            const UnaryExprOrTypeTraitExpr *E) {
QualType TypeToSize = E->getTypeOfArgument();
if (E->getKind() == UETT_SizeOf) {
  if (const VariableArrayType *VAT =
        CGF.getContext().getAsVariableArrayType(TypeToSize)) {
    if (E->isArgumentType()) {
      // sizeof(type) - make sure to emit the VLA size.
      CGF.EmitVariablyModifiedType(TypeToSize);
    } else {
      // C99 6.5.3.4p2: If the argument is an expression of type
      // VLA, it is evaluated.
      CGF.EmitIgnoredExpr(E->getArgumentExpr());
    }

    auto VlaSize = CGF.getVLASize(VAT);
    llvm::Value *size = VlaSize.NumElts;

    // Scale the number of non-VLA elements by the non-VLA element size.
    CharUnits eltSize = CGF.getContext().getTypeSizeInChars(VlaSize.Type);
    if (!eltSize.isOne())
      size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), size);

    return size;
  }
} else if (E->getKind() == UETT_OpenMPRequiredSimdAlign) {
  auto Alignment =
      CGF.getContext()
          .toCharUnitsFromBits(CGF.getContext().getOpenMPDefaultSimdAlign(
              E->getTypeOfArgument()->getPointeeType()))
          .getQuantity();
  return llvm::ConstantInt::get(CGF.SizeTy, Alignment);
}

// If this isn't sizeof(vla), the result must be constant; use the constant
// folding logic so we don't have to duplicate it here.
return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
2838}

2840Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {
Expr *Op = E->getSubExpr();
if (Op->getType()->isAnyComplexType()) {
  // If it's an l-value, load through the appropriate subobject l-value.
  // Note that we have to ask E because Op might be an l-value that
  // this won't work for, e.g. an Obj-C property.
  if (E->isGLValue())
    return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
                                E->getExprLoc()).getScalarVal();

  // Otherwise, calculate and project.
  return CGF.EmitComplexExpr(Op, false, true).first;
}

return Visit(Op);
2855}

2857Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
Expr *Op = E->getSubExpr();
if (Op->getType()->isAnyComplexType()) {
  // If it's an l-value, load through the appropriate subobject l-value.
  // Note that we have to ask E because Op might be an l-value that
  // this won't work for, e.g. an Obj-C property.
  if (Op->isGLValue())
    return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
                                E->getExprLoc()).getScalarVal();

  // Otherwise, calculate and project.
  return CGF.EmitComplexExpr(Op, true, false).second;
}

// __imag on a scalar returns zero.  Emit the subexpr to ensure side
// effects are evaluated, but not the actual value.
if (Op->isGLValue())
  CGF.EmitLValue(Op);
else
  CGF.EmitScalarExpr(Op, true);
return llvm::Constant::getNullValue(ConvertType(E->getType()));
2878}

2880//===----------------------------------------------------------------------===//
2881//                           Binary Operators
2882//===----------------------------------------------------------------------===//

2884BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
TestAndClearIgnoreResultAssign();
BinOpInfo Result;
Result.LHS = Visit(E->getLHS());
Result.RHS = Visit(E->getRHS());
Result.Ty  = E->getType();
Result.Opcode = E->getOpcode();
Result.FPFeatures = E->getFPFeatures();
Result.E = E;
return Result;
2894}

2896LValue ScalarExprEmitter::EmitCompoundAssignLValue(
                                            const CompoundAssignOperator *E,
                      Value *(ScalarExprEmitter::*Func)(const BinOpInfo &),
                                                 Value *&Result) {
QualType LHSTy = E->getLHS()->getType();
BinOpInfo OpInfo;

if (E->getComputationResultType()->isAnyComplexType())
  return CGF.EmitScalarCompoundAssignWithComplex(E, Result);

// Emit the RHS first.  __block variables need to have the rhs evaluated
// first, plus this should improve codegen a little.
OpInfo.RHS = Visit(E->getRHS());
OpInfo.Ty = E->getComputationResultType();
OpInfo.Opcode = E->getOpcode();
OpInfo.FPFeatures = E->getFPFeatures();
OpInfo.E = E;
// Load/convert the LHS.
LValue LHSLV = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);

llvm::PHINode *atomicPHI = nullptr;
if (const AtomicType *atomicTy = LHSTy->getAs<AtomicType>()) {
  QualType type = atomicTy->getValueType();
  if (!type->isBooleanType() && type->isIntegerType() &&
      !(type->isUnsignedIntegerType() &&
        CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
      CGF.getLangOpts().getSignedOverflowBehavior() !=
          LangOptions::SOB_Trapping) {
    llvm::AtomicRMWInst::BinOp AtomicOp = llvm::AtomicRMWInst::BAD_BINOP;
    llvm::Instruction::BinaryOps Op;
    switch (OpInfo.Opcode) {
      // We don't have atomicrmw operands for *, %, /, <<, >>
      case BO_MulAssign: case BO_DivAssign:
      case BO_RemAssign:
      case BO_ShlAssign:
      case BO_ShrAssign:
        break;
      case BO_AddAssign:
        AtomicOp = llvm::AtomicRMWInst::Add;
        Op = llvm::Instruction::Add;
        break;
      case BO_SubAssign:
        AtomicOp = llvm::AtomicRMWInst::Sub;
        Op = llvm::Instruction::Sub;
        break;
      case BO_AndAssign:
        AtomicOp = llvm::AtomicRMWInst::And;
        Op = llvm::Instruction::And;
        break;
      case BO_XorAssign:
        AtomicOp = llvm::AtomicRMWInst::Xor;
        Op = llvm::Instruction::Xor;
        break;
      case BO_OrAssign:
        AtomicOp = llvm::AtomicRMWInst::Or;
        Op = llvm::Instruction::Or;
        break;
      default:
        llvm_unreachable("Invalid compound assignment type")::llvm::llvm_unreachable_internal("Invalid compound assignment type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 2954);
    }
    if (AtomicOp != llvm::AtomicRMWInst::BAD_BINOP) {
      llvm::Value *Amt = CGF.EmitToMemory(
          EmitScalarConversion(OpInfo.RHS, E->getRHS()->getType(), LHSTy,
                               E->getExprLoc()),
          LHSTy);
      Value *OldVal = Builder.CreateAtomicRMW(
          AtomicOp, LHSLV.getPointer(CGF), Amt,
          llvm::AtomicOrdering::SequentiallyConsistent);

      // Since operation is atomic, the result type is guaranteed to be the
      // same as the input in LLVM terms.
      Result = Builder.CreateBinOp(Op, OldVal, Amt);
      return LHSLV;
    }
  }
  // FIXME: For floating point types, we should be saving and restoring the
  // floating point environment in the loop.
  llvm::BasicBlock *startBB = Builder.GetInsertBlock();
  llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
  OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
  OpInfo.LHS = CGF.EmitToMemory(OpInfo.LHS, type);
  Builder.CreateBr(opBB);
  Builder.SetInsertPoint(opBB);
  atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
  atomicPHI->addIncoming(OpInfo.LHS, startBB);
  OpInfo.LHS = atomicPHI;
}
else
  OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());

SourceLocation Loc = E->getExprLoc();
OpInfo.LHS =
    EmitScalarConversion(OpInfo.LHS, LHSTy, E->getComputationLHSType(), Loc);

// Expand the binary operator.
Result = (this->*Func)(OpInfo);

// Convert the result back to the LHS type,
// potentially with Implicit Conversion sanitizer check.
Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy,
                              Loc, ScalarConversionOpts(CGF.SanOpts));

if (atomicPHI) {
  llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
  llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
  auto Pair = CGF.EmitAtomicCompareExchange(
      LHSLV, RValue::get(atomicPHI), RValue::get(Result), E->getExprLoc());
  llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), LHSTy);
  llvm::Value *success = Pair.second;
  atomicPHI->addIncoming(old, curBlock);
  Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
  Builder.SetInsertPoint(contBB);
  return LHSLV;
}

// Store the result value into the LHS lvalue. Bit-fields are handled
// specially because the result is altered by the store, i.e., [C99 6.5.16p1]
// 'An assignment expression has the value of the left operand after the
// assignment...'.
if (LHSLV.isBitField())
  CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
else
  CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);

if (CGF.getLangOpts().OpenMP)
  CGF.CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(CGF,
                                                                E->getLHS());
return LHSLV;
3024}

3026Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
                    Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
bool Ignore = TestAndClearIgnoreResultAssign();
Value *RHS = nullptr;
LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);

// If the result is clearly ignored, return now.
if (Ignore)
  return nullptr;

// The result of an assignment in C is the assigned r-value.
if (!CGF.getLangOpts().CPlusPlus)
  return RHS;

// If the lvalue is non-volatile, return the computed value of the assignment.
if (!LHS.isVolatileQualified())
  return RHS;

// Otherwise, reload the value.
return EmitLoadOfLValue(LHS, E->getExprLoc());
3046}

3048void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck(
  const BinOpInfo &Ops, llvm::Value *Zero, bool isDiv) {
SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks;

if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
  Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS, Zero),
                                  SanitizerKind::IntegerDivideByZero));
}

const auto *BO = cast<BinaryOperator>(Ops.E);
if (CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow) &&
    Ops.Ty->hasSignedIntegerRepresentation() &&
    !IsWidenedIntegerOp(CGF.getContext(), BO->getLHS()) &&
    Ops.mayHaveIntegerOverflow()) {
  llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType());

  llvm::Value *IntMin =
    Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
  llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL);

  llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
  llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
  llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp, "or");
  Checks.push_back(
      std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
}

if (Checks.size() > 0)
  EmitBinOpCheck(Checks, Ops);
3077}

3079Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
{
  CodeGenFunction::SanitizerScope SanScope(&CGF);
  if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
       CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
      Ops.Ty->isIntegerType() &&
      (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
    llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
    EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true);
  } else if (CGF.SanOpts.has(SanitizerKind::FloatDivideByZero) &&
             Ops.Ty->isRealFloatingType() &&
             Ops.mayHaveFloatDivisionByZero()) {
    llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
    llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
    EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
                   Ops);
  }
}

if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
  llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
  if (CGF.getLangOpts().OpenCL &&
      !CGF.CGM.getCodeGenOpts().CorrectlyRoundedDivSqrt) {
    // OpenCL v1.1 s7.4: minimum accuracy of single precision / is 2.5ulp
    // OpenCL v1.2 s5.6.4.2: The -cl-fp32-correctly-rounded-divide-sqrt
    // build option allows an application to specify that single precision
    // floating-point divide (x/y and 1/x) and sqrt used in the program
    // source are correctly rounded.
    llvm::Type *ValTy = Val->getType();
    if (ValTy->isFloatTy() ||
        (isa<llvm::VectorType>(ValTy) &&
         cast<llvm::VectorType>(ValTy)->getElementType()->isFloatTy()))
      CGF.SetFPAccuracy(Val, 2.5);
  }
  return Val;
}
else if (Ops.Ty->hasUnsignedIntegerRepresentation())
  return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
else
  return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
3119}

3121Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
// Rem in C can't be a floating point type: C99 6.5.5p2.
if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
     CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
    Ops.Ty->isIntegerType() &&
    (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
  CodeGenFunction::SanitizerScope SanScope(&CGF);
  llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
  EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false);
}

if (Ops.Ty->hasUnsignedIntegerRepresentation())
  return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
else
  return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
3136}

3138Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) {
unsigned IID;
unsigned OpID = 0;

bool isSigned = Ops.Ty->isSignedIntegerOrEnumerationType();
switch (Ops.Opcode) {
case BO_Add:
case BO_AddAssign:
  OpID = 1;
  IID = isSigned ? llvm::Intrinsic::sadd_with_overflow :
                   llvm::Intrinsic::uadd_with_overflow;
  break;
case BO_Sub:
case BO_SubAssign:
  OpID = 2;
  IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
                   llvm::Intrinsic::usub_with_overflow;
  break;
case BO_Mul:
case BO_MulAssign:
  OpID = 3;
  IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
                   llvm::Intrinsic::umul_with_overflow;
  break;
default:
  llvm_unreachable("Unsupported operation for overflow detection")::llvm::llvm_unreachable_internal("Unsupported operation for overflow detection"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3163);
}
OpID <<= 1;
if (isSigned)
  OpID |= 1;

CodeGenFunction::SanitizerScope SanScope(&CGF);
llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);

llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);

Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);

// Handle overflow with llvm.trap if no custom handler has been specified.
const std::string *handlerName =
  &CGF.getLangOpts().OverflowHandler;
if (handlerName->empty()) {
  // If the signed-integer-overflow sanitizer is enabled, emit a call to its
  // runtime. Otherwise, this is a -ftrapv check, so just emit a trap.
  if (!isSigned || CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) {
    llvm::Value *NotOverflow = Builder.CreateNot(overflow);
    SanitizerMask Kind = isSigned ? SanitizerKind::SignedIntegerOverflow
                            : SanitizerKind::UnsignedIntegerOverflow;
    EmitBinOpCheck(std::make_pair(NotOverflow, Kind), Ops);
  } else
    CGF.EmitTrapCheck(Builder.CreateNot(overflow));
  return result;
}

// Branch in case of overflow.
llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
llvm::BasicBlock *continueBB =
    CGF.createBasicBlock("nooverflow", CGF.CurFn, initialBB->getNextNode());
llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);

Builder.CreateCondBr(overflow, overflowBB, continueBB);

// If an overflow handler is set, then we want to call it and then use its
// result, if it returns.
Builder.SetInsertPoint(overflowBB);

// Get the overflow handler.
llvm::Type *Int8Ty = CGF.Int8Ty;
llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
llvm::FunctionType *handlerTy =
    llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
llvm::FunctionCallee handler =
    CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);

// Sign extend the args to 64-bit, so that we can use the same handler for
// all types of overflow.
llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);

// Call the handler with the two arguments, the operation, and the size of
// the result.
llvm::Value *handlerArgs[] = {
  lhs,
  rhs,
  Builder.getInt8(OpID),
  Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
};
llvm::Value *handlerResult =
  CGF.EmitNounwindRuntimeCall(handler, handlerArgs);

// Truncate the result back to the desired size.
handlerResult = Builder.CreateTrunc(handlerResult, opTy);
Builder.CreateBr(continueBB);

Builder.SetInsertPoint(continueBB);
llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
phi->addIncoming(result, initialBB);
phi->addIncoming(handlerResult, overflowBB);

return phi;
3240}

3242/// Emit pointer + index arithmetic.
3243static Value *emitPointerArithmetic(CodeGenFunction &CGF,
                                  const BinOpInfo &op,
                                  bool isSubtraction) {
// Must have binary (not unary) expr here.  Unary pointer
// increment/decrement doesn't use this path.
const BinaryOperator *expr = cast<BinaryOperator>(op.E);

Value *pointer = op.LHS;
Expr *pointerOperand = expr->getLHS();
Value *index = op.RHS;
Expr *indexOperand = expr->getRHS();

// In a subtraction, the LHS is always the pointer.
if (!isSubtraction && !pointer->getType()->isPointerTy()) {
  std::swap(pointer, index);
  std::swap(pointerOperand, indexOperand);
}

bool isSigned = indexOperand->getType()->isSignedIntegerOrEnumerationType();

unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
auto &DL = CGF.CGM.getDataLayout();
auto PtrTy = cast<llvm::PointerType>(pointer->getType());

// Some versions of glibc and gcc use idioms (particularly in their malloc
// routines) that add a pointer-sized integer (known to be a pointer value)
// to a null pointer in order to cast the value back to an integer or as
// part of a pointer alignment algorithm.  This is undefined behavior, but
// we'd like to be able to compile programs that use it.
//
// Normally, we'd generate a GEP with a null-pointer base here in response
// to that code, but it's also UB to dereference a pointer created that
// way.  Instead (as an acknowledged hack to tolerate the idiom) we will
// generate a direct cast of the integer value to a pointer.
//
// The idiom (p = nullptr + N) is not met if any of the following are true:
//
//   The operation is subtraction.
//   The index is not pointer-sized.
//   The pointer type is not byte-sized.
//
if (BinaryOperator::isNullPointerArithmeticExtension(CGF.getContext(),
                                                     op.Opcode,
                                                     expr->getLHS(),
                                                     expr->getRHS()))
  return CGF.Builder.CreateIntToPtr(index, pointer->getType());

if (width != DL.getIndexTypeSizeInBits(PtrTy)) {
  // Zero-extend or sign-extend the pointer value according to
  // whether the index is signed or not.
  index = CGF.Builder.CreateIntCast(index, DL.getIndexType(PtrTy), isSigned,
                                    "idx.ext");
}

// If this is subtraction, negate the index.
if (isSubtraction)
  index = CGF.Builder.CreateNeg(index, "idx.neg");

if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
  CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
                      /*Accessed*/ false);

const PointerType *pointerType
  = pointerOperand->getType()->getAs<PointerType>();
if (!pointerType) {
  QualType objectType = pointerOperand->getType()
                                      ->castAs<ObjCObjectPointerType>()
                                      ->getPointeeType();
  llvm::Value *objectSize
    = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));

  index = CGF.Builder.CreateMul(index, objectSize);

  Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
  result = CGF.Builder.CreateGEP(result, index, "add.ptr");
  return CGF.Builder.CreateBitCast(result, pointer->getType());
}

QualType elementType = pointerType->getPointeeType();
if (const VariableArrayType *vla
      = CGF.getContext().getAsVariableArrayType(elementType)) {
  // The element count here is the total number of non-VLA elements.
  llvm::Value *numElements = CGF.getVLASize(vla).NumElts;

  // Effectively, the multiply by the VLA size is part of the GEP.
  // GEP indexes are signed, and scaling an index isn't permitted to
  // signed-overflow, so we use the same semantics for our explicit
  // multiply.  We suppress this if overflow is not undefined behavior.
  if (CGF.getLangOpts().isSignedOverflowDefined()) {
    index = CGF.Builder.CreateMul(index, numElements, "vla.index");
    pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
  } else {
    index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
    pointer =
        CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,
                                   op.E->getExprLoc(), "add.ptr");
  }
  return pointer;
}

// Explicitly handle GNU void* and function pointer arithmetic extensions. The
// GNU void* casts amount to no-ops since our void* type is i8*, but this is
// future proof.
if (elementType->isVoidType() || elementType->isFunctionType()) {
  Value *result = CGF.EmitCastToVoidPtr(pointer);
  result = CGF.Builder.CreateGEP(result, index, "add.ptr");
  return CGF.Builder.CreateBitCast(result, pointer->getType());
}

if (CGF.getLangOpts().isSignedOverflowDefined())
  return CGF.Builder.CreateGEP(pointer, index, "add.ptr");

return CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,
                                  op.E->getExprLoc(), "add.ptr");
3357}

3359// Construct an fmuladd intrinsic to represent a fused mul-add of MulOp and
3360// Addend. Use negMul and negAdd to negate the first operand of the Mul or
3361// the add operand respectively. This allows fmuladd to represent a*b-c, or
3362// c-a*b. Patterns in LLVM should catch the negated forms and translate them to
3363// efficient operations.
3364static Value* buildFMulAdd(llvm::BinaryOperator *MulOp, Value *Addend,
                         const CodeGenFunction &CGF, CGBuilderTy &Builder,
                         bool negMul, bool negAdd) {
assert(!(negMul && negAdd) && "Only one of negMul and negAdd should be set.")((!(negMul && negAdd) && "Only one of negMul and negAdd should be set."
) ? static_cast<void> (0) : __assert_fail ("!(negMul && negAdd) && \"Only one of negMul and negAdd should be set.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3367, __PRETTY_FUNCTION__));

Value *MulOp0 = MulOp->getOperand(0);
Value *MulOp1 = MulOp->getOperand(1);
if (negMul)
  MulOp0 = Builder.CreateFNeg(MulOp0, "neg");
if (negAdd)
  Addend = Builder.CreateFNeg(Addend, "neg");

Value *FMulAdd = Builder.CreateCall(
    CGF.CGM.getIntrinsic(llvm::Intrinsic::fmuladd, Addend->getType()),
    {MulOp0, MulOp1, Addend});
 MulOp->eraseFromParent();

 return FMulAdd;
3382}

3384// Check whether it would be legal to emit an fmuladd intrinsic call to
3385// represent op and if so, build the fmuladd.
3386//
3387// Checks that (a) the operation is fusable, and (b) -ffp-contract=on.
3388// Does NOT check the type of the operation - it's assumed that this function
3389// will be called from contexts where it's known that the type is contractable.
3390static Value* tryEmitFMulAdd(const BinOpInfo &op,
                       const CodeGenFunction &CGF, CGBuilderTy &Builder,
                       bool isSub=false) {

assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||(((op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode
 == BO_Sub || op.Opcode == BO_SubAssign) && "Only fadd/fsub can be the root of an fmuladd."
) ? static_cast<void> (0) : __assert_fail ("(op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) && \"Only fadd/fsub can be the root of an fmuladd.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3396, __PRETTY_FUNCTION__))
        op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&(((op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode
 == BO_Sub || op.Opcode == BO_SubAssign) && "Only fadd/fsub can be the root of an fmuladd."
) ? static_cast<void> (0) : __assert_fail ("(op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) && \"Only fadd/fsub can be the root of an fmuladd.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3396, __PRETTY_FUNCTION__))
       "Only fadd/fsub can be the root of an fmuladd.")(((op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode
 == BO_Sub || op.Opcode == BO_SubAssign) && "Only fadd/fsub can be the root of an fmuladd."
) ? static_cast<void> (0) : __assert_fail ("(op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) && \"Only fadd/fsub can be the root of an fmuladd.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3396, __PRETTY_FUNCTION__));

// Check whether this op is marked as fusable.
if (!op.FPFeatures.allowFPContractWithinStatement())
  return nullptr;

// We have a potentially fusable op. Look for a mul on one of the operands.
// Also, make sure that the mul result isn't used directly. In that case,
// there's no point creating a muladd operation.
if (auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
  if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
      LHSBinOp->use_empty())
    return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
}
if (auto *RHSBinOp = dyn_cast<llvm::BinaryOperator>(op.RHS)) {
  if (RHSBinOp->getOpcode() == llvm::Instruction::FMul &&
      RHSBinOp->use_empty())
    return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
}

return nullptr;
3417}

3419Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) {
if (op.LHS->getType()->isPointerTy() ||
    op.RHS->getType()->isPointerTy())
  return emitPointerArithmetic(CGF, op, CodeGenFunction::NotSubtraction);

if (op.Ty->isSignedIntegerOrEnumerationType()) {
  switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
  case LangOptions::SOB_Defined:
    return Builder.CreateAdd(op.LHS, op.RHS, "add");
  case LangOptions::SOB_Undefined:
    if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
      return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case LangOptions::SOB_Trapping:
    if (CanElideOverflowCheck(CGF.getContext(), op))
      return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
    return EmitOverflowCheckedBinOp(op);
  }
}

if (op.Ty->isUnsignedIntegerType() &&
    CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
    !CanElideOverflowCheck(CGF.getContext(), op))
  return EmitOverflowCheckedBinOp(op);

if (op.LHS->getType()->isFPOrFPVectorTy()) {
  // Try to form an fmuladd.
  if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
    return FMulAdd;

  Value *V = Builder.CreateFAdd(op.LHS, op.RHS, "add");
  return propagateFMFlags(V, op);
}

if (op.isFixedPointBinOp())
  return EmitFixedPointBinOp(op);

return Builder.CreateAdd(op.LHS, op.RHS, "add");
3457}

3459/// The resulting value must be calculated with exact precision, so the operands
3460/// may not be the same type.
3461Value *ScalarExprEmitter::EmitFixedPointBinOp(const BinOpInfo &op) {
using llvm::APSInt;
using llvm::ConstantInt;

const auto *BinOp = cast<BinaryOperator>(op.E);

// The result is a fixed point type and at least one of the operands is fixed
// point while the other is either fixed point or an int. This resulting type
// should be determined by Sema::handleFixedPointConversions().
QualType ResultTy = op.Ty;
QualType LHSTy = BinOp->getLHS()->getType();
QualType RHSTy = BinOp->getRHS()->getType();
ASTContext &Ctx = CGF.getContext();
Value *LHS = op.LHS;
Value *RHS = op.RHS;

auto LHSFixedSema = Ctx.getFixedPointSemantics(LHSTy);
auto RHSFixedSema = Ctx.getFixedPointSemantics(RHSTy);
auto ResultFixedSema = Ctx.getFixedPointSemantics(ResultTy);
auto CommonFixedSema = LHSFixedSema.getCommonSemantics(RHSFixedSema);

// Convert the operands to the full precision type.
Value *FullLHS = EmitFixedPointConversion(LHS, LHSFixedSema, CommonFixedSema,
                                          BinOp->getExprLoc());
Value *FullRHS = EmitFixedPointConversion(RHS, RHSFixedSema, CommonFixedSema,
                                          BinOp->getExprLoc());

// Perform the actual addition.
Value *Result;
switch (BinOp->getOpcode()) {
case BO_Add: {
  if (ResultFixedSema.isSaturated()) {
    llvm::Intrinsic::ID IID = ResultFixedSema.isSigned()
                                  ? llvm::Intrinsic::sadd_sat
                                  : llvm::Intrinsic::uadd_sat;
    Result = Builder.CreateBinaryIntrinsic(IID, FullLHS, FullRHS);
  } else {
    Result = Builder.CreateAdd(FullLHS, FullRHS);
  }
  break;
}
case BO_Sub: {
  if (ResultFixedSema.isSaturated()) {
    llvm::Intrinsic::ID IID = ResultFixedSema.isSigned()
                                  ? llvm::Intrinsic::ssub_sat
                                  : llvm::Intrinsic::usub_sat;
    Result = Builder.CreateBinaryIntrinsic(IID, FullLHS, FullRHS);
  } else {
    Result = Builder.CreateSub(FullLHS, FullRHS);
  }
  break;
}
case BO_LT:
  return CommonFixedSema.isSigned() ? Builder.CreateICmpSLT(FullLHS, FullRHS)
                                    : Builder.CreateICmpULT(FullLHS, FullRHS);
case BO_GT:
  return CommonFixedSema.isSigned() ? Builder.CreateICmpSGT(FullLHS, FullRHS)
                                    : Builder.CreateICmpUGT(FullLHS, FullRHS);
case BO_LE:
  return CommonFixedSema.isSigned() ? Builder.CreateICmpSLE(FullLHS, FullRHS)
                                    : Builder.CreateICmpULE(FullLHS, FullRHS);
case BO_GE:
  return CommonFixedSema.isSigned() ? Builder.CreateICmpSGE(FullLHS, FullRHS)
                                    : Builder.CreateICmpUGE(FullLHS, FullRHS);
case BO_EQ:
  // For equality operations, we assume any padding bits on unsigned types are
  // zero'd out. They could be overwritten through non-saturating operations
  // that cause overflow, but this leads to undefined behavior.
  return Builder.CreateICmpEQ(FullLHS, FullRHS);
case BO_NE:
  return Builder.CreateICmpNE(FullLHS, FullRHS);
case BO_Mul:
case BO_Div:
case BO_Shl:
case BO_Shr:
case BO_Cmp:
case BO_LAnd:
case BO_LOr:
case BO_MulAssign:
case BO_DivAssign:
case BO_AddAssign:
case BO_SubAssign:
case BO_ShlAssign:
case BO_ShrAssign:
  llvm_unreachable("Found unimplemented fixed point binary operation")::llvm::llvm_unreachable_internal("Found unimplemented fixed point binary operation"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3545);
case BO_PtrMemD:
case BO_PtrMemI:
case BO_Rem:
case BO_Xor:
case BO_And:
case BO_Or:
case BO_Assign:
case BO_RemAssign:
case BO_AndAssign:
case BO_XorAssign:
case BO_OrAssign:
case BO_Comma:
  llvm_unreachable("Found unsupported binary operation for fixed point types.")::llvm::llvm_unreachable_internal("Found unsupported binary operation for fixed point types."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3558);
}

// Convert to the result type.
return EmitFixedPointConversion(Result, CommonFixedSema, ResultFixedSema,
                                BinOp->getExprLoc());
3564}

3566Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) {
// The LHS is always a pointer if either side is.
if (!op.LHS->getType()->isPointerTy()) {
  if (op.Ty->isSignedIntegerOrEnumerationType()) {
    switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
    case LangOptions::SOB_Defined:
      return Builder.CreateSub(op.LHS, op.RHS, "sub");
    case LangOptions::SOB_Undefined:
      if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
        return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
      LLVM_FALLTHROUGH[[gnu::fallthrough]];
    case LangOptions::SOB_Trapping:
      if (CanElideOverflowCheck(CGF.getContext(), op))
        return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
      return EmitOverflowCheckedBinOp(op);
    }
  }

  if (op.Ty->isUnsignedIntegerType() &&
      CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
      !CanElideOverflowCheck(CGF.getContext(), op))
    return EmitOverflowCheckedBinOp(op);

  if (op.LHS->getType()->isFPOrFPVectorTy()) {
    // Try to form an fmuladd.
    if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
      return FMulAdd;
    Value *V = Builder.CreateFSub(op.LHS, op.RHS, "sub");
    return propagateFMFlags(V, op);
  }

  if (op.isFixedPointBinOp())
    return EmitFixedPointBinOp(op);

  return Builder.CreateSub(op.LHS, op.RHS, "sub");
}

// If the RHS is not a pointer, then we have normal pointer
// arithmetic.
if (!op.RHS->getType()->isPointerTy())
  return emitPointerArithmetic(CGF, op, CodeGenFunction::IsSubtraction);

// Otherwise, this is a pointer subtraction.

// Do the raw subtraction part.
llvm::Value *LHS
  = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
llvm::Value *RHS
  = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");

// Okay, figure out the element size.
const BinaryOperator *expr = cast<BinaryOperator>(op.E);
QualType elementType = expr->getLHS()->getType()->getPointeeType();

llvm::Value *divisor = nullptr;

// For a variable-length array, this is going to be non-constant.
if (const VariableArrayType *vla
      = CGF.getContext().getAsVariableArrayType(elementType)) {
  auto VlaSize = CGF.getVLASize(vla);
  elementType = VlaSize.Type;
  divisor = VlaSize.NumElts;

  // Scale the number of non-VLA elements by the non-VLA element size.
  CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
  if (!eltSize.isOne())
    divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);

// For everything elese, we can just compute it, safe in the
// assumption that Sema won't let anything through that we can't
// safely compute the size of.
} else {
  CharUnits elementSize;
  // Handle GCC extension for pointer arithmetic on void* and
  // function pointer types.
  if (elementType->isVoidType() || elementType->isFunctionType())
    elementSize = CharUnits::One();
  else
    elementSize = CGF.getContext().getTypeSizeInChars(elementType);

  // Don't even emit the divide for element size of 1.
  if (elementSize.isOne())
    return diffInChars;

  divisor = CGF.CGM.getSize(elementSize);
}

// Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since
// pointer difference in C is only defined in the case where both operands
// are pointing to elements of an array.
return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
3658}

3660Value *ScalarExprEmitter::GetWidthMinusOneValue(Value* LHS,Value* RHS) {
llvm::IntegerType *Ty;
if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
  Ty = cast<llvm::IntegerType>(VT->getElementType());
else
  Ty = cast<llvm::IntegerType>(LHS->getType());
return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
3667}

3669Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
// LLVM requires the LHS and RHS to be the same type: promote or truncate the
// RHS to the same size as the LHS.
Value *RHS = Ops.RHS;
if (Ops.LHS->getType() != RHS->getType())
  RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");

bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
                    Ops.Ty->hasSignedIntegerRepresentation() &&
                    !CGF.getLangOpts().isSignedOverflowDefined() &&
                    !CGF.getLangOpts().CPlusPlus2a;
bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
// OpenCL 6.3j: shift values are effectively % word size of LHS.
if (CGF.getLangOpts().OpenCL)
  RHS =
      Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shl.mask");
else if ((SanitizeBase || SanitizeExponent) &&
         isa<llvm::IntegerType>(Ops.LHS->getType())) {
  CodeGenFunction::SanitizerScope SanScope(&CGF);
  SmallVector<std::pair<Value *, SanitizerMask>, 2> Checks;
  llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, Ops.RHS);
  llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne);

  if (SanitizeExponent) {
    Checks.push_back(
        std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
  }

  if (SanitizeBase) {
    // Check whether we are shifting any non-zero bits off the top of the
    // integer. We only emit this check if exponent is valid - otherwise
    // instructions below will have undefined behavior themselves.
    llvm::BasicBlock *Orig = Builder.GetInsertBlock();
    llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
    llvm::BasicBlock *CheckShiftBase = CGF.createBasicBlock("check");
    Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
    llvm::Value *PromotedWidthMinusOne =
        (RHS == Ops.RHS) ? WidthMinusOne
                         : GetWidthMinusOneValue(Ops.LHS, RHS);
    CGF.EmitBlock(CheckShiftBase);
    llvm::Value *BitsShiftedOff = Builder.CreateLShr(
        Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS, "shl.zeros",
                                   /*NUW*/ true, /*NSW*/ true),
        "shl.check");
    if (CGF.getLangOpts().CPlusPlus) {
      // In C99, we are not permitted to shift a 1 bit into the sign bit.
      // Under C++11's rules, shifting a 1 bit into the sign bit is
      // OK, but shifting a 1 bit out of it is not. (C89 and C++03 don't
      // define signed left shifts, so we use the C99 and C++11 rules there).
      llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
      BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
    }
    llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
    llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
    CGF.EmitBlock(Cont);
    llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
    BaseCheck->addIncoming(Builder.getTrue(), Orig);
    BaseCheck->addIncoming(ValidBase, CheckShiftBase);
    Checks.push_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase));
  }

  assert(!Checks.empty())((!Checks.empty()) ? static_cast<void> (0) : __assert_fail
 ("!Checks.empty()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3730, __PRETTY_FUNCTION__));
  EmitBinOpCheck(Checks, Ops);
}

return Builder.CreateShl(Ops.LHS, RHS, "shl");
3735}

3737Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
// LLVM requires the LHS and RHS to be the same type: promote or truncate the
// RHS to the same size as the LHS.
Value *RHS = Ops.RHS;
if (Ops.LHS->getType() != RHS->getType())
  RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");

// OpenCL 6.3j: shift values are effectively % word size of LHS.
if (CGF.getLangOpts().OpenCL)
  RHS =
      Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shr.mask");
else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) &&
         isa<llvm::IntegerType>(Ops.LHS->getType())) {
  CodeGenFunction::SanitizerScope SanScope(&CGF);
  llvm::Value *Valid =
      Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
  EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
}

if (Ops.Ty->hasUnsignedIntegerRepresentation())
  return Builder.CreateLShr(Ops.LHS, RHS, "shr");
return Builder.CreateAShr(Ops.LHS, RHS, "shr");
3759}

3761enum IntrinsicType { VCMPEQ, VCMPGT };
3762// return corresponding comparison intrinsic for given vector type
3763static llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT,
                                      BuiltinType::Kind ElemKind) {
switch (ElemKind) {
default: llvm_unreachable("unexpected element type")::llvm::llvm_unreachable_internal("unexpected element type", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3766);
case BuiltinType::Char_U:
case BuiltinType::UChar:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtub_p;
case BuiltinType::Char_S:
case BuiltinType::SChar:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtsb_p;
case BuiltinType::UShort:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtuh_p;
case BuiltinType::Short:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtsh_p;
case BuiltinType::UInt:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtuw_p;
case BuiltinType::Int:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtsw_p;
case BuiltinType::ULong:
case BuiltinType::ULongLong:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtud_p;
case BuiltinType::Long:
case BuiltinType::LongLong:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtsd_p;
case BuiltinType::Float:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
                          llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
case BuiltinType::Double:
  return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_vsx_xvcmpeqdp_p :
                          llvm::Intrinsic::ppc_vsx_xvcmpgtdp_p;
}
3802}

3804Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,
                                    llvm::CmpInst::Predicate UICmpOpc,
                                    llvm::CmpInst::Predicate SICmpOpc,
                                    llvm::CmpInst::Predicate FCmpOpc) {
TestAndClearIgnoreResultAssign();
Value *Result;
QualType LHSTy = E->getLHS()->getType();
QualType RHSTy = E->getRHS()->getType();
if (const MemberPointerType *MPT2.1
'MPT' is null
1
'MPT' is null
 = LHSTy->getAs<MemberPointerType>()) {
2
←
Assuming the object is not a 'MemberPointerType'→
3
←
Taking false branch→
  assert(E->getOpcode() == BO_EQ ||((E->getOpcode() == BO_EQ || E->getOpcode() == BO_NE) ?
 static_cast<void> (0) : __assert_fail ("E->getOpcode() == BO_EQ || E->getOpcode() == BO_NE"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3814, __PRETTY_FUNCTION__))
         E->getOpcode() == BO_NE)((E->getOpcode() == BO_EQ || E->getOpcode() == BO_NE) ?
 static_cast<void> (0) : __assert_fail ("E->getOpcode() == BO_EQ || E->getOpcode() == BO_NE"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3814, __PRETTY_FUNCTION__));
  Value *LHS = CGF.EmitScalarExpr(E->getLHS());
  Value *RHS = CGF.EmitScalarExpr(E->getRHS());
  Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
                 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
} else if (!LHSTy->isAnyComplexType() && !RHSTy->isAnyComplexType()) {
4
←
Calling 'Type::isAnyComplexType'→
7
←
Returning from 'Type::isAnyComplexType'→
8
←
Calling 'Type::isAnyComplexType'→
11
←
Returning from 'Type::isAnyComplexType'→
12
←
Taking true branch→
  BinOpInfo BOInfo = EmitBinOps(E);
  Value *LHS = BOInfo.LHS;
  Value *RHS = BOInfo.RHS;

  // If AltiVec, the comparison results in a numeric type, so we use
  // intrinsics comparing vectors and giving 0 or 1 as a result
  if (LHSTy->isVectorType() && !E->getType()->isVectorType()) {
13
←
Taking true branch→
    // constants for mapping CR6 register bits to predicate result
    enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6;

    llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic;

    // in several cases vector arguments order will be reversed
    Value *FirstVecArg = LHS,
          *SecondVecArg = RHS;

    QualType ElTy = LHSTy->castAs<VectorType>()->getElementType();
14
←
The object is a 'VectorType'→
    const BuiltinType *BTy = ElTy->getAs<BuiltinType>();
15
←
Assuming the object is not a 'BuiltinType'→
16
←
'BTy' initialized to a null pointer value→
    BuiltinType::Kind ElementKind = BTy->getKind();
17
←
Called C++ object pointer is null

    switch(E->getOpcode()) {
    default: llvm_unreachable("is not a comparison operation")::llvm::llvm_unreachable_internal("is not a comparison operation"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3841);
    case BO_EQ:
      CR6 = CR6_LT;
      ID = GetIntrinsic(VCMPEQ, ElementKind);
      break;
    case BO_NE:
      CR6 = CR6_EQ;
      ID = GetIntrinsic(VCMPEQ, ElementKind);
      break;
    case BO_LT:
      CR6 = CR6_LT;
      ID = GetIntrinsic(VCMPGT, ElementKind);
      std::swap(FirstVecArg, SecondVecArg);
      break;
    case BO_GT:
      CR6 = CR6_LT;
      ID = GetIntrinsic(VCMPGT, ElementKind);
      break;
    case BO_LE:
      if (ElementKind == BuiltinType::Float) {
        CR6 = CR6_LT;
        ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
        std::swap(FirstVecArg, SecondVecArg);
      }
      else {
        CR6 = CR6_EQ;
        ID = GetIntrinsic(VCMPGT, ElementKind);
      }
      break;
    case BO_GE:
      if (ElementKind == BuiltinType::Float) {
        CR6 = CR6_LT;
        ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
      }
      else {
        CR6 = CR6_EQ;
        ID = GetIntrinsic(VCMPGT, ElementKind);
        std::swap(FirstVecArg, SecondVecArg);
      }
      break;
    }

    Value *CR6Param = Builder.getInt32(CR6);
    llvm::Function *F = CGF.CGM.getIntrinsic(ID);
    Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});

    // The result type of intrinsic may not be same as E->getType().
    // If E->getType() is not BoolTy, EmitScalarConversion will do the
    // conversion work. If E->getType() is BoolTy, EmitScalarConversion will
    // do nothing, if ResultTy is not i1 at the same time, it will cause
    // crash later.
    llvm::IntegerType *ResultTy = cast<llvm::IntegerType>(Result->getType());
    if (ResultTy->getBitWidth() > 1 &&
        E->getType() == CGF.getContext().BoolTy)
      Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
    return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
                                E->getExprLoc());
  }

  if (BOInfo.isFixedPointBinOp()) {
    Result = EmitFixedPointBinOp(BOInfo);
  } else if (LHS->getType()->isFPOrFPVectorTy()) {
    Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
  } else if (LHSTy->hasSignedIntegerRepresentation()) {
    Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
  } else {
    // Unsigned integers and pointers.

    if (CGF.CGM.getCodeGenOpts().StrictVTablePointers &&
        !isa<llvm::ConstantPointerNull>(LHS) &&
        !isa<llvm::ConstantPointerNull>(RHS)) {

      // Dynamic information is required to be stripped for comparisons,
      // because it could leak the dynamic information.  Based on comparisons
      // of pointers to dynamic objects, the optimizer can replace one pointer
      // with another, which might be incorrect in presence of invariant
      // groups. Comparison with null is safe because null does not carry any
      // dynamic information.
      if (LHSTy.mayBeDynamicClass())
        LHS = Builder.CreateStripInvariantGroup(LHS);
      if (RHSTy.mayBeDynamicClass())
        RHS = Builder.CreateStripInvariantGroup(RHS);
    }

    Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
  }

  // If this is a vector comparison, sign extend the result to the appropriate
  // vector integer type and return it (don't convert to bool).
  if (LHSTy->isVectorType())
    return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");

} else {
  // Complex Comparison: can only be an equality comparison.
  CodeGenFunction::ComplexPairTy LHS, RHS;
  QualType CETy;
  if (auto *CTy = LHSTy->getAs<ComplexType>()) {
    LHS = CGF.EmitComplexExpr(E->getLHS());
    CETy = CTy->getElementType();
  } else {
    LHS.first = Visit(E->getLHS());
    LHS.second = llvm::Constant::getNullValue(LHS.first->getType());
    CETy = LHSTy;
  }
  if (auto *CTy = RHSTy->getAs<ComplexType>()) {
    RHS = CGF.EmitComplexExpr(E->getRHS());
    assert(CGF.getContext().hasSameUnqualifiedType(CETy,((CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType
()) && "The element types must always match.") ? static_cast
<void> (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType()) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3949, __PRETTY_FUNCTION__))
                                                   CTy->getElementType()) &&((CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType
()) && "The element types must always match.") ? static_cast
<void> (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType()) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3949, __PRETTY_FUNCTION__))
           "The element types must always match.")((CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType
()) && "The element types must always match.") ? static_cast
<void> (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType()) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3949, __PRETTY_FUNCTION__));
    (void)CTy;
  } else {
    RHS.first = Visit(E->getRHS());
    RHS.second = llvm::Constant::getNullValue(RHS.first->getType());
    assert(CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&((CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&
 "The element types must always match.") ? static_cast<void
> (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3955, __PRETTY_FUNCTION__))
           "The element types must always match.")((CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&
 "The element types must always match.") ? static_cast<void
> (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3955, __PRETTY_FUNCTION__));
  }

  Value *ResultR, *ResultI;
  if (CETy->isRealFloatingType()) {
    ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r");
    ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i");
  } else {
    // Complex comparisons can only be equality comparisons.  As such, signed
    // and unsigned opcodes are the same.
    ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r");
    ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i");
  }

  if (E->getOpcode() == BO_EQ) {
    Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
  } else {
    assert(E->getOpcode() == BO_NE &&((E->getOpcode() == BO_NE && "Complex comparison other than == or != ?"
) ? static_cast<void> (0) : __assert_fail ("E->getOpcode() == BO_NE && \"Complex comparison other than == or != ?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3973, __PRETTY_FUNCTION__))
           "Complex comparison other than == or != ?")((E->getOpcode() == BO_NE && "Complex comparison other than == or != ?"
) ? static_cast<void> (0) : __assert_fail ("E->getOpcode() == BO_NE && \"Complex comparison other than == or != ?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 3973, __PRETTY_FUNCTION__));
    Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
  }
}

return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
                            E->getExprLoc());
3980}

3982Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
bool Ignore = TestAndClearIgnoreResultAssign();

Value *RHS;
LValue LHS;

switch (E->getLHS()->getType().getObjCLifetime()) {
case Qualifiers::OCL_Strong:
  std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
  break;

case Qualifiers::OCL_Autoreleasing:
  std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
  break;

case Qualifiers::OCL_ExplicitNone:
  std::tie(LHS, RHS) = CGF.EmitARCStoreUnsafeUnretained(E, Ignore);
  break;

case Qualifiers::OCL_Weak:
  RHS = Visit(E->getRHS());
  LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
  RHS = CGF.EmitARCStoreWeak(LHS.getAddress(CGF), RHS, Ignore);
  break;

case Qualifiers::OCL_None:
  // __block variables need to have the rhs evaluated first, plus
  // this should improve codegen just a little.
  RHS = Visit(E->getRHS());
  LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);

  // Store the value into the LHS.  Bit-fields are handled specially
  // because the result is altered by the store, i.e., [C99 6.5.16p1]
  // 'An assignment expression has the value of the left operand after
  // the assignment...'.
  if (LHS.isBitField()) {
    CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
  } else {
    CGF.EmitNullabilityCheck(LHS, RHS, E->getExprLoc());
    CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
  }
}

// If the result is clearly ignored, return now.
if (Ignore)
  return nullptr;

// The result of an assignment in C is the assigned r-value.
if (!CGF.getLangOpts().CPlusPlus)
  return RHS;

// If the lvalue is non-volatile, return the computed value of the assignment.
if (!LHS.isVolatileQualified())
  return RHS;

// Otherwise, reload the value.
return EmitLoadOfLValue(LHS, E->getExprLoc());
4039}

4041Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
// Perform vector logical and on comparisons with zero vectors.
if (E->getType()->isVectorType()) {
  CGF.incrementProfileCounter(E);

  Value *LHS = Visit(E->getLHS());
  Value *RHS = Visit(E->getRHS());
  Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
  if (LHS->getType()->isFPOrFPVectorTy()) {
    LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
    RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
  } else {
    LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
    RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
  }
  Value *And = Builder.CreateAnd(LHS, RHS);
  return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
}

llvm::Type *ResTy = ConvertType(E->getType());

// If we have 0 && RHS, see if we can elide RHS, if so, just return 0.
// If we have 1 && X, just emit X without inserting the control flow.
bool LHSCondVal;
if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
  if (LHSCondVal) { // If we have 1 && X, just emit X.
    CGF.incrementProfileCounter(E);

    Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
    // ZExt result to int or bool.
    return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
  }

  // 0 && RHS: If it is safe, just elide the RHS, and return 0/false.
  if (!CGF.ContainsLabel(E->getRHS()))
    return llvm::Constant::getNullValue(ResTy);
}

llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
llvm::BasicBlock *RHSBlock  = CGF.createBasicBlock("land.rhs");

CodeGenFunction::ConditionalEvaluation eval(CGF);

// Branch on the LHS first.  If it is false, go to the failure (cont) block.
CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock,
                         CGF.getProfileCount(E->getRHS()));

// Any edges into the ContBlock are now from an (indeterminate number of)
// edges from this first condition.  All of these values will be false.  Start
// setting up the PHI node in the Cont Block for this.
llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
                                          "", ContBlock);
for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
     PI != PE; ++PI)
  PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);

eval.begin(CGF);
CGF.EmitBlock(RHSBlock);
CGF.incrementProfileCounter(E);
Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
eval.end(CGF);

// Reaquire the RHS block, as there may be subblocks inserted.
RHSBlock = Builder.GetInsertBlock();

// Emit an unconditional branch from this block to ContBlock.
{
  // There is no need to emit line number for unconditional branch.
  auto NL = ApplyDebugLocation::CreateEmpty(CGF);
  CGF.EmitBlock(ContBlock);
}
// Insert an entry into the phi node for the edge with the value of RHSCond.
PN->addIncoming(RHSCond, RHSBlock);

// Artificial location to preserve the scope information
{
  auto NL = ApplyDebugLocation::CreateArtificial(CGF);
  PN->setDebugLoc(Builder.getCurrentDebugLocation());
}

// ZExt result to int.
return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
4123}

4125Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
// Perform vector logical or on comparisons with zero vectors.
if (E->getType()->isVectorType()) {
  CGF.incrementProfileCounter(E);

  Value *LHS = Visit(E->getLHS());
  Value *RHS = Visit(E->getRHS());
  Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
  if (LHS->getType()->isFPOrFPVectorTy()) {
    LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
    RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
  } else {
    LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
    RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
  }
  Value *Or = Builder.CreateOr(LHS, RHS);
  return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
}

llvm::Type *ResTy = ConvertType(E->getType());

// If we have 1 || RHS, see if we can elide RHS, if so, just return 1.
// If we have 0 || X, just emit X without inserting the control flow.
bool LHSCondVal;
if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
  if (!LHSCondVal) { // If we have 0 || X, just emit X.
    CGF.incrementProfileCounter(E);

    Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
    // ZExt result to int or bool.
    return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
  }

  // 1 || RHS: If it is safe, just elide the RHS, and return 1/true.
  if (!CGF.ContainsLabel(E->getRHS()))
    return llvm::ConstantInt::get(ResTy, 1);
}

llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");

CodeGenFunction::ConditionalEvaluation eval(CGF);

// Branch on the LHS first.  If it is true, go to the success (cont) block.
CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock,
                         CGF.getCurrentProfileCount() -
                             CGF.getProfileCount(E->getRHS()));

// Any edges into the ContBlock are now from an (indeterminate number of)
// edges from this first condition.  All of these values will be true.  Start
// setting up the PHI node in the Cont Block for this.
llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
                                          "", ContBlock);
for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
     PI != PE; ++PI)
  PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);

eval.begin(CGF);

// Emit the RHS condition as a bool value.
CGF.EmitBlock(RHSBlock);
CGF.incrementProfileCounter(E);
Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());

eval.end(CGF);

// Reaquire the RHS block, as there may be subblocks inserted.
RHSBlock = Builder.GetInsertBlock();

// Emit an unconditional branch from this block to ContBlock.  Insert an entry
// into the phi node for the edge with the value of RHSCond.
CGF.EmitBlock(ContBlock);
PN->addIncoming(RHSCond, RHSBlock);

// ZExt result to int.
return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
4201}

4203Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
CGF.EmitIgnoredExpr(E->getLHS());
CGF.EnsureInsertPoint();
return Visit(E->getRHS());
4207}

4209//===----------------------------------------------------------------------===//
4210//                             Other Operators
4211//===----------------------------------------------------------------------===//

4213/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified
4214/// expression is cheap enough and side-effect-free enough to evaluate
4215/// unconditionally instead of conditionally.  This is used to convert control
4216/// flow into selects in some cases.
4217static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E,
                                                 CodeGenFunction &CGF) {
// Anything that is an integer or floating point constant is fine.
return E->IgnoreParens()->isEvaluatable(CGF.getContext());

// Even non-volatile automatic variables can't be evaluated unconditionally.
// Referencing a thread_local may cause non-trivial initialization work to
// occur. If we're inside a lambda and one of the variables is from the scope
// outside the lambda, that function may have returned already. Reading its
// locals is a bad idea. Also, these reads may introduce races there didn't
// exist in the source-level program.
4228}


4231Value *ScalarExprEmitter::
4232VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
TestAndClearIgnoreResultAssign();

// Bind the common expression if necessary.
CodeGenFunction::OpaqueValueMapping binding(CGF, E);

Expr *condExpr = E->getCond();
Expr *lhsExpr = E->getTrueExpr();
Expr *rhsExpr = E->getFalseExpr();

// If the condition constant folds and can be elided, try to avoid emitting
// the condition and the dead arm.
bool CondExprBool;
if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
  Expr *live = lhsExpr, *dead = rhsExpr;
  if (!CondExprBool) std::swap(live, dead);

  // If the dead side doesn't have labels we need, just emit the Live part.
  if (!CGF.ContainsLabel(dead)) {
    if (CondExprBool)
      CGF.incrementProfileCounter(E);
    Value *Result = Visit(live);

    // If the live part is a throw expression, it acts like it has a void
    // type, so evaluating it returns a null Value*.  However, a conditional
    // with non-void type must return a non-null Value*.
    if (!Result && !E->getType()->isVoidType())
      Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));

    return Result;
  }
}

// OpenCL: If the condition is a vector, we can treat this condition like
// the select function.
if (CGF.getLangOpts().OpenCL
    && condExpr->getType()->isVectorType()) {
  CGF.incrementProfileCounter(E);

  llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
  llvm::Value *LHS = Visit(lhsExpr);
  llvm::Value *RHS = Visit(rhsExpr);

  llvm::Type *condType = ConvertType(condExpr->getType());
  llvm::VectorType *vecTy = cast<llvm::VectorType>(condType);

  unsigned numElem = vecTy->getNumElements();
  llvm::Type *elemType = vecTy->getElementType();

  llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy);
  llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
  llvm::Value *tmp = Builder.CreateSExt(TestMSB,
                                        llvm::VectorType::get(elemType,
                                                              numElem),
                                        "sext");
  llvm::Value *tmp2 = Builder.CreateNot(tmp);

  // Cast float to int to perform ANDs if necessary.
  llvm::Value *RHSTmp = RHS;
  llvm::Value *LHSTmp = LHS;
  bool wasCast = false;
  llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType());
  if (rhsVTy->getElementType()->isFloatingPointTy()) {
    RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
    LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
    wasCast = true;
  }

  llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
  llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
  llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
  if (wasCast)
    tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());

  return tmp5;
}

// If this is a really simple expression (like x ? 4 : 5), emit this as a
// select instead of as control flow.  We can only do this if it is cheap and
// safe to evaluate the LHS and RHS unconditionally.
if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
    isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) {
  llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
  llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.Int64Ty);

  CGF.incrementProfileCounter(E, StepV);

  llvm::Value *LHS = Visit(lhsExpr);
  llvm::Value *RHS = Visit(rhsExpr);
  if (!LHS) {
    // If the conditional has void type, make sure we return a null Value*.
    assert(!RHS && "LHS and RHS types must match")((!RHS && "LHS and RHS types must match") ? static_cast
<void> (0) : __assert_fail ("!RHS && \"LHS and RHS types must match\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4323, __PRETTY_FUNCTION__));
    return nullptr;
  }
  return Builder.CreateSelect(CondV, LHS, RHS, "cond");
}

llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");

CodeGenFunction::ConditionalEvaluation eval(CGF);
CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock,
                         CGF.getProfileCount(lhsExpr));

CGF.EmitBlock(LHSBlock);
CGF.incrementProfileCounter(E);
eval.begin(CGF);
Value *LHS = Visit(lhsExpr);
eval.end(CGF);

LHSBlock = Builder.GetInsertBlock();
Builder.CreateBr(ContBlock);

CGF.EmitBlock(RHSBlock);
eval.begin(CGF);
Value *RHS = Visit(rhsExpr);
eval.end(CGF);

RHSBlock = Builder.GetInsertBlock();
CGF.EmitBlock(ContBlock);

// If the LHS or RHS is a throw expression, it will be legitimately null.
if (!LHS)
  return RHS;
if (!RHS)
  return LHS;

// Create a PHI node for the real part.
llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
PN->addIncoming(LHS, LHSBlock);
PN->addIncoming(RHS, RHSBlock);
return PN;
4365}

4367Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
return Visit(E->getChosenSubExpr());
4369}

4371Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
QualType Ty = VE->getType();

if (Ty->isVariablyModifiedType())
  CGF.EmitVariablyModifiedType(Ty);

Address ArgValue = Address::invalid();
Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);

llvm::Type *ArgTy = ConvertType(VE->getType());

// If EmitVAArg fails, emit an error.
if (!ArgPtr.isValid()) {
  CGF.ErrorUnsupported(VE, "va_arg expression");
  return llvm::UndefValue::get(ArgTy);
}

// FIXME Volatility.
llvm::Value *Val = Builder.CreateLoad(ArgPtr);

// If EmitVAArg promoted the type, we must truncate it.
if (ArgTy != Val->getType()) {
  if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())
    Val = Builder.CreateIntToPtr(Val, ArgTy);
  else
    Val = Builder.CreateTrunc(Val, ArgTy);
}

return Val;
4400}

4402Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) {
return CGF.EmitBlockLiteral(block);
4404}

4406// Convert a vec3 to vec4, or vice versa.
4407static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF,
                               Value *Src, unsigned NumElementsDst) {
llvm::Value *UnV = llvm::UndefValue::get(Src->getType());
SmallVector<llvm::Constant*, 4> Args;
Args.push_back(Builder.getInt32(0));
Args.push_back(Builder.getInt32(1));
Args.push_back(Builder.getInt32(2));
if (NumElementsDst == 4)
  Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
llvm::Constant *Mask = llvm::ConstantVector::get(Args);
return Builder.CreateShuffleVector(Src, UnV, Mask);
4418}

4420// Create cast instructions for converting LLVM value \p Src to LLVM type \p
4421// DstTy. \p Src has the same size as \p DstTy. Both are single value types
4422// but could be scalar or vectors of different lengths, and either can be
4423// pointer.
4424// There are 4 cases:
4425// 1. non-pointer -> non-pointer  : needs 1 bitcast
4426// 2. pointer -> pointer          : needs 1 bitcast or addrspacecast
4427// 3. pointer -> non-pointer
4428//   a) pointer -> intptr_t       : needs 1 ptrtoint
4429//   b) pointer -> non-intptr_t   : needs 1 ptrtoint then 1 bitcast
4430// 4. non-pointer -> pointer
4431//   a) intptr_t -> pointer       : needs 1 inttoptr
4432//   b) non-intptr_t -> pointer   : needs 1 bitcast then 1 inttoptr
4433// Note: for cases 3b and 4b two casts are required since LLVM casts do not
4434// allow casting directly between pointer types and non-integer non-pointer
4435// types.
4436static Value *createCastsForTypeOfSameSize(CGBuilderTy &Builder,
                                         const llvm::DataLayout &DL,
                                         Value *Src, llvm::Type *DstTy,
                                         StringRef Name = "") {
auto SrcTy = Src->getType();

// Case 1.
if (!SrcTy->isPointerTy() && !DstTy->isPointerTy())
  return Builder.CreateBitCast(Src, DstTy, Name);

// Case 2.
if (SrcTy->isPointerTy() && DstTy->isPointerTy())
  return Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy, Name);

// Case 3.
if (SrcTy->isPointerTy() && !DstTy->isPointerTy()) {
  // Case 3b.
  if (!DstTy->isIntegerTy())
    Src = Builder.CreatePtrToInt(Src, DL.getIntPtrType(SrcTy));
  // Cases 3a and 3b.
  return Builder.CreateBitOrPointerCast(Src, DstTy, Name);
}

// Case 4b.
if (!SrcTy->isIntegerTy())
  Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
// Cases 4a and 4b.
return Builder.CreateIntToPtr(Src, DstTy, Name);
4464}

4466Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) {
Value *Src  = CGF.EmitScalarExpr(E->getSrcExpr());
llvm::Type *DstTy = ConvertType(E->getType());

llvm::Type *SrcTy = Src->getType();
unsigned NumElementsSrc = isa<llvm::VectorType>(SrcTy) ?
  cast<llvm::VectorType>(SrcTy)->getNumElements() : 0;
unsigned NumElementsDst = isa<llvm::VectorType>(DstTy) ?
  cast<llvm::VectorType>(DstTy)->getNumElements() : 0;

// Going from vec3 to non-vec3 is a special case and requires a shuffle
// vector to get a vec4, then a bitcast if the target type is different.
if (NumElementsSrc == 3 && NumElementsDst != 3) {
  Src = ConvertVec3AndVec4(Builder, CGF, Src, 4);

  if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) {
    Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
                                       DstTy);
  }

  Src->setName("astype");
  return Src;
}

// Going from non-vec3 to vec3 is a special case and requires a bitcast
// to vec4 if the original type is not vec4, then a shuffle vector to
// get a vec3.
if (NumElementsSrc != 3 && NumElementsDst == 3) {
  if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) {
    auto Vec4Ty = llvm::VectorType::get(DstTy->getVectorElementType(), 4);
    Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
                                       Vec4Ty);
  }

  Src = ConvertVec3AndVec4(Builder, CGF, Src, 3);
  Src->setName("astype");
  return Src;
}

return createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(),
                                    Src, DstTy, "astype");
4507}

4509Value *ScalarExprEmitter::VisitAtomicExpr(AtomicExpr *E) {
return CGF.EmitAtomicExpr(E).getScalarVal();
4511}

4513//===----------------------------------------------------------------------===//
4514//                         Entry Point into this File
4515//===----------------------------------------------------------------------===//

4517/// Emit the computation of the specified expression of scalar type, ignoring
4518/// the result.
4519Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
assert(E && hasScalarEvaluationKind(E->getType()) &&((E && hasScalarEvaluationKind(E->getType()) &&
 "Invalid scalar expression to emit") ? static_cast<void>
 (0) : __assert_fail ("E && hasScalarEvaluationKind(E->getType()) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4521, __PRETTY_FUNCTION__))
       "Invalid scalar expression to emit")((E && hasScalarEvaluationKind(E->getType()) &&
 "Invalid scalar expression to emit") ? static_cast<void>
 (0) : __assert_fail ("E && hasScalarEvaluationKind(E->getType()) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4521, __PRETTY_FUNCTION__));

return ScalarExprEmitter(*this, IgnoreResultAssign)
    .Visit(const_cast<Expr *>(E));
4525}

4527/// Emit a conversion from the specified type to the specified destination type,
4528/// both of which are LLVM scalar types.
4529Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy,
                                           QualType DstTy,
                                           SourceLocation Loc) {
assert(hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) &&((hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind
(DstTy) && "Invalid scalar expression to emit") ? static_cast
<void> (0) : __assert_fail ("hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4533, __PRETTY_FUNCTION__))
       "Invalid scalar expression to emit")((hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind
(DstTy) && "Invalid scalar expression to emit") ? static_cast
<void> (0) : __assert_fail ("hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4533, __PRETTY_FUNCTION__));
return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy, Loc);
4535}

4537/// Emit a conversion from the specified complex type to the specified
4538/// destination type, where the destination type is an LLVM scalar type.
4539Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
                                                    QualType SrcTy,
                                                    QualType DstTy,
                                                    SourceLocation Loc) {
assert(SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) &&((SrcTy->isAnyComplexType() && hasScalarEvaluationKind
(DstTy) && "Invalid complex -> scalar conversion")
 ? static_cast<void> (0) : __assert_fail ("SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) && \"Invalid complex -> scalar conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4544, __PRETTY_FUNCTION__))
       "Invalid complex -> scalar conversion")((SrcTy->isAnyComplexType() && hasScalarEvaluationKind
(DstTy) && "Invalid complex -> scalar conversion")
 ? static_cast<void> (0) : __assert_fail ("SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) && \"Invalid complex -> scalar conversion\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4544, __PRETTY_FUNCTION__));
return ScalarExprEmitter(*this)
    .EmitComplexToScalarConversion(Src, SrcTy, DstTy, Loc);
4547}


4550llvm::Value *CodeGenFunction::
4551EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
                      bool isInc, bool isPre) {
return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
4554}

4556LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) {
// object->isa or (*object).isa
// Generate code as for: *(Class*)object

Expr *BaseExpr = E->getBase();
Address Addr = Address::invalid();
if (BaseExpr->isRValue()) {
  Addr = Address(EmitScalarExpr(BaseExpr), getPointerAlign());
} else {
  Addr = EmitLValue(BaseExpr).getAddress(*this);
}

// Cast the address to Class*.
Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
return MakeAddrLValue(Addr, E->getType());
4571}


4574LValue CodeGenFunction::EmitCompoundAssignmentLValue(
                                          const CompoundAssignOperator *E) {
ScalarExprEmitter Scalar(*this);
Value *Result = nullptr;
switch (E->getOpcode()) {
4579#define COMPOUND_OP(Op)                                                       \
  case BO_##Op##Assign:                                                     \
    return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
                                           Result)
COMPOUND_OP(Mul);
COMPOUND_OP(Div);
COMPOUND_OP(Rem);
COMPOUND_OP(Add);
COMPOUND_OP(Sub);
COMPOUND_OP(Shl);
COMPOUND_OP(Shr);
COMPOUND_OP(And);
COMPOUND_OP(Xor);
COMPOUND_OP(Or);
4593#undef COMPOUND_OP

case BO_PtrMemD:
case BO_PtrMemI:
case BO_Mul:
case BO_Div:
case BO_Rem:
case BO_Add:
case BO_Sub:
case BO_Shl:
case BO_Shr:
case BO_LT:
case BO_GT:
case BO_LE:
case BO_GE:
case BO_EQ:
case BO_NE:
case BO_Cmp:
case BO_And:
case BO_Xor:
case BO_Or:
case BO_LAnd:
case BO_LOr:
case BO_Assign:
case BO_Comma:
  llvm_unreachable("Not valid compound assignment operators")::llvm::llvm_unreachable_internal("Not valid compound assignment operators"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4618);
}

llvm_unreachable("Unhandled compound assignment operator")::llvm::llvm_unreachable_internal("Unhandled compound assignment operator"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4621);
4622}

4624struct GEPOffsetAndOverflow {
// The total (signed) byte offset for the GEP.
llvm::Value *TotalOffset;
// The offset overflow flag - true if the total offset overflows.
llvm::Value *OffsetOverflows;
4629};

4631/// Evaluate given GEPVal, which is either an inbounds GEP, or a constant,
4632/// and compute the total offset it applies from it's base pointer BasePtr.
4633/// Returns offset in bytes and a boolean flag whether an overflow happened
4634/// during evaluation.
4635static GEPOffsetAndOverflow EmitGEPOffsetInBytes(Value *BasePtr, Value *GEPVal,
                                               llvm::LLVMContext &VMContext,
                                               CodeGenModule &CGM,
                                               CGBuilderTy Builder) {
const auto &DL = CGM.getDataLayout();

// The total (signed) byte offset for the GEP.
llvm::Value *TotalOffset = nullptr;

// Was the GEP already reduced to a constant?
if (isa<llvm::Constant>(GEPVal)) {
  // Compute the offset by casting both pointers to integers and subtracting:
  // GEPVal = BasePtr + ptr(Offset) <--> Offset = int(GEPVal) - int(BasePtr)
  Value *BasePtr_int =
      Builder.CreatePtrToInt(BasePtr, DL.getIntPtrType(BasePtr->getType()));
  Value *GEPVal_int =
      Builder.CreatePtrToInt(GEPVal, DL.getIntPtrType(GEPVal->getType()));
  TotalOffset = Builder.CreateSub(GEPVal_int, BasePtr_int);
  return {TotalOffset, /*OffsetOverflows=*/Builder.getFalse()};
}

auto *GEP = cast<llvm::GEPOperator>(GEPVal);
assert(GEP->getPointerOperand() == BasePtr &&((GEP->getPointerOperand() == BasePtr && "BasePtr must be the the base of the GEP."
) ? static_cast<void> (0) : __assert_fail ("GEP->getPointerOperand() == BasePtr && \"BasePtr must be the the base of the GEP.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4658, __PRETTY_FUNCTION__))
       "BasePtr must be the the base of the GEP.")((GEP->getPointerOperand() == BasePtr && "BasePtr must be the the base of the GEP."
) ? static_cast<void> (0) : __assert_fail ("GEP->getPointerOperand() == BasePtr && \"BasePtr must be the the base of the GEP.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4658, __PRETTY_FUNCTION__));
assert(GEP->isInBounds() && "Expected inbounds GEP")((GEP->isInBounds() && "Expected inbounds GEP") ? static_cast
<void> (0) : __assert_fail ("GEP->isInBounds() && \"Expected inbounds GEP\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4659, __PRETTY_FUNCTION__));

auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType());

// Grab references to the signed add/mul overflow intrinsics for intptr_t.
auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
auto *SAddIntrinsic =
    CGM.getIntrinsic(llvm::Intrinsic::sadd_with_overflow, IntPtrTy);
auto *SMulIntrinsic =
    CGM.getIntrinsic(llvm::Intrinsic::smul_with_overflow, IntPtrTy);

// The offset overflow flag - true if the total offset overflows.
llvm::Value *OffsetOverflows = Builder.getFalse();

/// Return the result of the given binary operation.
auto eval = [&](BinaryOperator::Opcode Opcode, llvm::Value *LHS,
                llvm::Value *RHS) -> llvm::Value * {
  assert((Opcode == BO_Add || Opcode == BO_Mul) && "Can't eval binop")(((Opcode == BO_Add || Opcode == BO_Mul) && "Can't eval binop"
) ? static_cast<void> (0) : __assert_fail ("(Opcode == BO_Add || Opcode == BO_Mul) && \"Can't eval binop\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4676, __PRETTY_FUNCTION__));

  // If the operands are constants, return a constant result.
  if (auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) {
    if (auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) {
      llvm::APInt N;
      bool HasOverflow = mayHaveIntegerOverflow(LHSCI, RHSCI, Opcode,
                                                /*Signed=*/true, N);
      if (HasOverflow)
        OffsetOverflows = Builder.getTrue();
      return llvm::ConstantInt::get(VMContext, N);
    }
  }

  // Otherwise, compute the result with checked arithmetic.
  auto *ResultAndOverflow = Builder.CreateCall(
      (Opcode == BO_Add) ? SAddIntrinsic : SMulIntrinsic, {LHS, RHS});
  OffsetOverflows = Builder.CreateOr(
      Builder.CreateExtractValue(ResultAndOverflow, 1), OffsetOverflows);
  return Builder.CreateExtractValue(ResultAndOverflow, 0);
};

// Determine the total byte offset by looking at each GEP operand.
for (auto GTI = llvm::gep_type_begin(GEP), GTE = llvm::gep_type_end(GEP);
     GTI != GTE; ++GTI) {
  llvm::Value *LocalOffset;
  auto *Index = GTI.getOperand();
  // Compute the local offset contributed by this indexing step:
  if (auto *STy = GTI.getStructTypeOrNull()) {
    // For struct indexing, the local offset is the byte position of the
    // specified field.
    unsigned FieldNo = cast<llvm::ConstantInt>(Index)->getZExtValue();
    LocalOffset = llvm::ConstantInt::get(
        IntPtrTy, DL.getStructLayout(STy)->getElementOffset(FieldNo));
  } else {
    // Otherwise this is array-like indexing. The local offset is the index
    // multiplied by the element size.
    auto *ElementSize = llvm::ConstantInt::get(
        IntPtrTy, DL.getTypeAllocSize(GTI.getIndexedType()));
    auto *IndexS = Builder.CreateIntCast(Index, IntPtrTy, /*isSigned=*/true);
    LocalOffset = eval(BO_Mul, ElementSize, IndexS);
  }

  // If this is the first offset, set it as the total offset. Otherwise, add
  // the local offset into the running total.
  if (!TotalOffset || TotalOffset == Zero)
    TotalOffset = LocalOffset;
  else
    TotalOffset = eval(BO_Add, TotalOffset, LocalOffset);
}

return {TotalOffset, OffsetOverflows};
4728}

4730Value *
4731CodeGenFunction::EmitCheckedInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
                                      bool SignedIndices, bool IsSubtraction,
                                      SourceLocation Loc, const Twine &Name) {
Value *GEPVal = Builder.CreateInBoundsGEP(Ptr, IdxList, Name);

// If the pointer overflow sanitizer isn't enabled, do nothing.
if (!SanOpts.has(SanitizerKind::PointerOverflow))
  return GEPVal;

llvm::Type *PtrTy = Ptr->getType();

// Perform nullptr-and-offset check unless the nullptr is defined.
bool PerformNullCheck = !NullPointerIsDefined(
    Builder.GetInsertBlock()->getParent(), PtrTy->getPointerAddressSpace());
// Check for overflows unless the GEP got constant-folded,
// and only in the default address space
bool PerformOverflowCheck =
    !isa<llvm::Constant>(GEPVal) && PtrTy->getPointerAddressSpace() == 0;

if (!(PerformNullCheck || PerformOverflowCheck))
  return GEPVal;

const auto &DL = CGM.getDataLayout();

SanitizerScope SanScope(this);
llvm::Type *IntPtrTy = DL.getIntPtrType(PtrTy);

GEPOffsetAndOverflow EvaluatedGEP =
    EmitGEPOffsetInBytes(Ptr, GEPVal, getLLVMContext(), CGM, Builder);

assert((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) ||(((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP
.OffsetOverflows == Builder.getFalse()) && "If the offset got constant-folded, we don't expect that there was an "
 "overflow.") ? static_cast<void> (0) : __assert_fail (
"(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4764, __PRETTY_FUNCTION__))
        EvaluatedGEP.OffsetOverflows == Builder.getFalse()) &&(((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP
.OffsetOverflows == Builder.getFalse()) && "If the offset got constant-folded, we don't expect that there was an "
 "overflow.") ? static_cast<void> (0) : __assert_fail (
"(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4764, __PRETTY_FUNCTION__))
       "If the offset got constant-folded, we don't expect that there was an "(((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP
.OffsetOverflows == Builder.getFalse()) && "If the offset got constant-folded, we don't expect that there was an "
 "overflow.") ? static_cast<void> (0) : __assert_fail (
"(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4764, __PRETTY_FUNCTION__))
       "overflow.")(((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP
.OffsetOverflows == Builder.getFalse()) && "If the offset got constant-folded, we don't expect that there was an "
 "overflow.") ? static_cast<void> (0) : __assert_fail (
"(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4764, __PRETTY_FUNCTION__));

auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);

// Common case: if the total offset is zero, and we are using C++ semantics,
// where nullptr+0 is defined, don't emit a check.
if (EvaluatedGEP.TotalOffset == Zero && CGM.getLangOpts().CPlusPlus)
  return GEPVal;

// Now that we've computed the total offset, add it to the base pointer (with
// wrapping semantics).
auto *IntPtr = Builder.CreatePtrToInt(Ptr, IntPtrTy);
auto *ComputedGEP = Builder.CreateAdd(IntPtr, EvaluatedGEP.TotalOffset);

llvm::SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks;

if (PerformNullCheck) {
  // In C++, if the base pointer evaluates to a null pointer value,
  // the only valid  pointer this inbounds GEP can produce is also
  // a null pointer, so the offset must also evaluate to zero.
  // Likewise, if we have non-zero base pointer, we can not get null pointer
  // as a result, so the offset can not be -intptr_t(BasePtr).
  // In other words, both pointers are either null, or both are non-null,
  // or the behaviour is undefined.
  //
  // C, however, is more strict in this regard, and gives more
  // optimization opportunities: in C, additionally, nullptr+0 is undefined.
  // So both the input to the 'gep inbounds' AND the output must not be null.
  auto *BaseIsNotNullptr = Builder.CreateIsNotNull(Ptr);
  auto *ResultIsNotNullptr = Builder.CreateIsNotNull(ComputedGEP);
  auto *Valid =
      CGM.getLangOpts().CPlusPlus
          ? Builder.CreateICmpEQ(BaseIsNotNullptr, ResultIsNotNullptr)
          : Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr);
  Checks.emplace_back(Valid, SanitizerKind::PointerOverflow);
}

if (PerformOverflowCheck) {
  // The GEP is valid if:
  // 1) The total offset doesn't overflow, and
  // 2) The sign of the difference between the computed address and the base
  // pointer matches the sign of the total offset.
  llvm::Value *ValidGEP;
  auto *NoOffsetOverflow = Builder.CreateNot(EvaluatedGEP.OffsetOverflows);
  if (SignedIndices) {
    // GEP is computed as `unsigned base + signed offset`, therefore:
    // * If offset was positive, then the computed pointer can not be
    //   [unsigned] less than the base pointer, unless it overflowed.
    // * If offset was negative, then the computed pointer can not be
    //   [unsigned] greater than the bas pointere, unless it overflowed.
    auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
    auto *PosOrZeroOffset =
        Builder.CreateICmpSGE(EvaluatedGEP.TotalOffset, Zero);
    llvm::Value *NegValid = Builder.CreateICmpULT(ComputedGEP, IntPtr);
    ValidGEP =
        Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid);
  } else if (!IsSubtraction) {
    // GEP is computed as `unsigned base + unsigned offset`,  therefore the
    // computed pointer can not be [unsigned] less than base pointer,
    // unless there was an overflow.
    // Equivalent to `@llvm.uadd.with.overflow(%base, %offset)`.
    ValidGEP = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
  } else {
    // GEP is computed as `unsigned base - unsigned offset`, therefore the
    // computed pointer can not be [unsigned] greater than base pointer,
    // unless there was an overflow.
    // Equivalent to `@llvm.usub.with.overflow(%base, sub(0, %offset))`.
    ValidGEP = Builder.CreateICmpULE(ComputedGEP, IntPtr);
  }
  ValidGEP = Builder.CreateAnd(ValidGEP, NoOffsetOverflow);
  Checks.emplace_back(ValidGEP, SanitizerKind::PointerOverflow);
}

assert(!Checks.empty() && "Should have produced some checks.")((!Checks.empty() && "Should have produced some checks."
) ? static_cast<void> (0) : __assert_fail ("!Checks.empty() && \"Should have produced some checks.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp"
, 4837, __PRETTY_FUNCTION__));

llvm::Constant *StaticArgs[] = {EmitCheckSourceLocation(Loc)};
// Pass the computed GEP to the runtime to avoid emitting poisoned arguments.
llvm::Value *DynamicArgs[] = {IntPtr, ComputedGEP};
EmitCheck(Checks, SanitizerHandler::PointerOverflow, StaticArgs, DynamicArgs);

return GEPVal;
4845}

←

/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h

1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
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/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H

20#include "clang/AST/NestedNameSpecifier.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/Basic/AddressSpaces.h"
23#include "clang/Basic/AttrKinds.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/ExceptionSpecificationType.h"
26#include "clang/Basic/LLVM.h"
27#include "clang/Basic/Linkage.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/SourceLocation.h"
30#include "clang/Basic/Specifiers.h"
31#include "clang/Basic/Visibility.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/ADT/APSInt.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/None.h"
37#include "llvm/ADT/Optional.h"
38#include "llvm/ADT/PointerIntPair.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/StringRef.h"
41#include "llvm/ADT/Twine.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/PointerLikeTypeTraits.h"
47#include "llvm/Support/type_traits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <cstring>
53#include <string>
54#include <type_traits>
55#include <utility>

57namespace clang {

59class ExtQuals;
60class QualType;
61class TagDecl;
62class Type;

64enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
67};

69namespace serialization {
template <class T> class AbstractTypeReader;
template <class T> class AbstractTypeWriter;
72}

74} // namespace clang

76namespace llvm {

template <typename T>
struct PointerLikeTypeTraits;
template<>
struct PointerLikeTypeTraits< ::clang::Type*> {
  static inline void *getAsVoidPointer(::clang::Type *P) { return P; }

  static inline ::clang::Type *getFromVoidPointer(void *P) {
    return static_cast< ::clang::Type*>(P);
  }

  enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
};

template<>
struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
  static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }

  static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
    return static_cast< ::clang::ExtQuals*>(P);
  }

  enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
};

102} // namespace llvm

104namespace clang {

106class ASTContext;
107template <typename> class CanQual;
108class CXXRecordDecl;
109class DeclContext;
110class EnumDecl;
111class Expr;
112class ExtQualsTypeCommonBase;
113class FunctionDecl;
114class IdentifierInfo;
115class NamedDecl;
116class ObjCInterfaceDecl;
117class ObjCProtocolDecl;
118class ObjCTypeParamDecl;
119struct PrintingPolicy;
120class RecordDecl;
121class Stmt;
122class TagDecl;
123class TemplateArgument;
124class TemplateArgumentListInfo;
125class TemplateArgumentLoc;
126class TemplateTypeParmDecl;
127class TypedefNameDecl;
128class UnresolvedUsingTypenameDecl;

130using CanQualType = CanQual<Type>;

132// Provide forward declarations for all of the *Type classes.
133#define TYPE(Class, Base) class Class##Type;
134#include "clang/AST/TypeNodes.inc"

136/// The collection of all-type qualifiers we support.
137/// Clang supports five independent qualifiers:
138/// * C99: const, volatile, and restrict
139/// * MS: __unaligned
140/// * Embedded C (TR18037): address spaces
141/// * Objective C: the GC attributes (none, weak, or strong)
142class Qualifiers {
143public:
enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
  Const    = 0x1,
  Restrict = 0x2,
  Volatile = 0x4,
  CVRMask = Const | Volatile | Restrict
};

enum GC {
  GCNone = 0,
  Weak,
  Strong
};

enum ObjCLifetime {
  /// There is no lifetime qualification on this type.
  OCL_None,

  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,

  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,

  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,

  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing
};

enum {
  /// The maximum supported address space number.
  /// 23 bits should be enough for anyone.
  MaxAddressSpace = 0x7fffffu,

  /// The width of the "fast" qualifier mask.
  FastWidth = 3,

  /// The fast qualifier mask.
  FastMask = (1 << FastWidth) - 1
};

/// Returns the common set of qualifiers while removing them from
/// the given sets.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
  // If both are only CVR-qualified, bit operations are sufficient.
  if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
    Qualifiers Q;
    Q.Mask = L.Mask & R.Mask;
    L.Mask &= ~Q.Mask;
    R.Mask &= ~Q.Mask;
    return Q;
  }

  Qualifiers Q;
  unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
  Q.addCVRQualifiers(CommonCRV);
  L.removeCVRQualifiers(CommonCRV);
  R.removeCVRQualifiers(CommonCRV);

  if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
    Q.setObjCGCAttr(L.getObjCGCAttr());
    L.removeObjCGCAttr();
    R.removeObjCGCAttr();
  }

  if (L.getObjCLifetime() == R.getObjCLifetime()) {
    Q.setObjCLifetime(L.getObjCLifetime());
    L.removeObjCLifetime();
    R.removeObjCLifetime();
  }

  if (L.getAddressSpace() == R.getAddressSpace()) {
    Q.setAddressSpace(L.getAddressSpace());
    L.removeAddressSpace();
    R.removeAddressSpace();
  }
  return Q;
}

static Qualifiers fromFastMask(unsigned Mask) {
  Qualifiers Qs;
  Qs.addFastQualifiers(Mask);
  return Qs;
}

static Qualifiers fromCVRMask(unsigned CVR) {
  Qualifiers Qs;
  Qs.addCVRQualifiers(CVR);
  return Qs;
}

static Qualifiers fromCVRUMask(unsigned CVRU) {
  Qualifiers Qs;
  Qs.addCVRUQualifiers(CVRU);
  return Qs;
}

// Deserialize qualifiers from an opaque representation.
static Qualifiers fromOpaqueValue(unsigned opaque) {
  Qualifiers Qs;
  Qs.Mask = opaque;
  return Qs;
}

// Serialize these qualifiers into an opaque representation.
unsigned getAsOpaqueValue() const {
  return Mask;
}

bool hasConst() const { return Mask & Const; }
bool hasOnlyConst() const { return Mask == Const; }
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
bool hasOnlyVolatile() const { return Mask == Volatile; }
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
bool hasOnlyRestrict() const { return Mask == Restrict; }
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }

void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 279, __PRETTY_FUNCTION__));
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 283, __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 290, __PRETTY_FUNCTION__));
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 294, __PRETTY_FUNCTION__));
  Mask |= mask;
}

bool hasUnaligned() const { return Mask & UMask; }
void setUnaligned(bool flag) {
  Mask = (Mask & ~UMask) | (flag ? UMask : 0);
}
void removeUnaligned() { Mask &= ~UMask; }
void addUnaligned() { Mask |= UMask; }

bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
void setObjCGCAttr(GC type) {
  Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
}
void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
void addObjCGCAttr(GC type) {
  assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 312, __PRETTY_FUNCTION__));
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  return qs;
}
Qualifiers withoutAddressSpace() const {
  Qualifiers qs = *this;
  qs.removeAddressSpace();
  return qs;
}

bool hasObjCLifetime() const { return Mask & LifetimeMask; }
ObjCLifetime getObjCLifetime() const {
  return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
}
void setObjCLifetime(ObjCLifetime type) {
  Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
}
void removeObjCLifetime() { setObjCLifetime(OCL_None); }
void addObjCLifetime(ObjCLifetime type) {
  assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 340, __PRETTY_FUNCTION__));
  assert(!hasObjCLifetime())((!hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 341, __PRETTY_FUNCTION__));
  Mask |= (type << LifetimeShift);
}

/// True if the lifetime is neither None or ExplicitNone.
bool hasNonTrivialObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime > OCL_ExplicitNone);
}

/// True if the lifetime is either strong or weak.
bool hasStrongOrWeakObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime == OCL_Strong || lifetime == OCL_Weak);
}

bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
LangAS getAddressSpace() const {
  return static_cast<LangAS>(Mask >> AddressSpaceShift);
}
bool hasTargetSpecificAddressSpace() const {
  return isTargetAddressSpace(getAddressSpace());
}
/// Get the address space attribute value to be printed by diagnostics.
unsigned getAddressSpaceAttributePrintValue() const {
  auto Addr = getAddressSpace();
  // This function is not supposed to be used with language specific
  // address spaces. If that happens, the diagnostic message should consider
  // printing the QualType instead of the address space value.
  assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((Addr == LangAS::Default || hasTargetSpecificAddressSpace())
 ? static_cast<void> (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 370, __PRETTY_FUNCTION__));
  if (Addr != LangAS::Default)
    return toTargetAddressSpace(Addr);
  // TODO: The diagnostic messages where Addr may be 0 should be fixed
  // since it cannot differentiate the situation where 0 denotes the default
  // address space or user specified __attribute__((address_space(0))).
  return 0;
}
void setAddressSpace(LangAS space) {
  assert((unsigned)space <= MaxAddressSpace)(((unsigned)space <= MaxAddressSpace) ? static_cast<void
> (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 379, __PRETTY_FUNCTION__));
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((space != LangAS::Default) ? static_cast<void> (0) : __assert_fail
 ("space != LangAS::Default", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 385, __PRETTY_FUNCTION__));
  setAddressSpace(space);
}

// Fast qualifiers are those that can be allocated directly
// on a QualType object.
bool hasFastQualifiers() const { return getFastQualifiers(); }
unsigned getFastQualifiers() const { return Mask & FastMask; }
void setFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 394, __PRETTY_FUNCTION__));
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 398, __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 405, __PRETTY_FUNCTION__));
  Mask |= mask;
}

/// Return true if the set contains any qualifiers which require an ExtQuals
/// node to be allocated.
bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
Qualifiers getNonFastQualifiers() const {
  Qualifiers Quals = *this;
  Quals.setFastQualifiers(0);
  return Quals;
}

/// Return true if the set contains any qualifiers.
bool hasQualifiers() const { return Mask; }
bool empty() const { return !Mask; }

/// Add the qualifiers from the given set to this set.
void addQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-or it in.
  if (!(Q.Mask & ~CVRMask))
    Mask |= Q.Mask;
  else {
    Mask |= (Q.Mask & CVRMask);
    if (Q.hasAddressSpace())
      addAddressSpace(Q.getAddressSpace());
    if (Q.hasObjCGCAttr())
      addObjCGCAttr(Q.getObjCGCAttr());
    if (Q.hasObjCLifetime())
      addObjCLifetime(Q.getObjCLifetime());
  }
}

/// Remove the qualifiers from the given set from this set.
void removeQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-and the inverse in.
  if (!(Q.Mask & ~CVRMask))
    Mask &= ~Q.Mask;
  else {
    Mask &= ~(Q.Mask & CVRMask);
    if (getObjCGCAttr() == Q.getObjCGCAttr())
      removeObjCGCAttr();
    if (getObjCLifetime() == Q.getObjCLifetime())
      removeObjCLifetime();
    if (getAddressSpace() == Q.getAddressSpace())
      removeAddressSpace();
  }
}

/// Add the qualifiers from the given set to this set, given that
/// they don't conflict.
void addConsistentQualifiers(Qualifiers qs) {
  assert(getAddressSpace() == qs.getAddressSpace() ||((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
 ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 460, __PRETTY_FUNCTION__))
         !hasAddressSpace() || !qs.hasAddressSpace())((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
 ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 460, __PRETTY_FUNCTION__));
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
 !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 462, __PRETTY_FUNCTION__))
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
 !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 462, __PRETTY_FUNCTION__));
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 464, __PRETTY_FUNCTION__))
         !hasObjCLifetime() || !qs.hasObjCLifetime())((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 464, __PRETTY_FUNCTION__));
  Mask |= qs.Mask;
}

/// Returns true if address space A is equal to or a superset of B.
/// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
/// overlapping address spaces.
/// CL1.1 or CL1.2:
///   every address space is a superset of itself.
/// CL2.0 adds:
///   __generic is a superset of any address space except for __constant.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
  // Address spaces must match exactly.
  return A == B ||
         // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
         // for __constant can be used as __generic.
         (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
         // Consider pointer size address spaces to be equivalent to default.
         ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
          (isPtrSizeAddressSpace(B) || B == LangAS::Default));
}

/// Returns true if the address space in these qualifiers is equal to or
/// a superset of the address space in the argument qualifiers.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
}

/// Determines if these qualifiers compatibly include another set.
/// Generally this answers the question of whether an object with the other
/// qualifiers can be safely used as an object with these qualifiers.
bool compatiblyIncludes(Qualifiers other) const {
  return isAddressSpaceSupersetOf(other) &&
         // ObjC GC qualifiers can match, be added, or be removed, but can't
         // be changed.
         (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
          !other.hasObjCGCAttr()) &&
         // ObjC lifetime qualifiers must match exactly.
         getObjCLifetime() == other.getObjCLifetime() &&
         // CVR qualifiers may subset.
         (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
         // U qualifier may superset.
         (!other.hasUnaligned() || hasUnaligned());
}

/// Determines if these qualifiers compatibly include another set of
/// qualifiers from the narrow perspective of Objective-C ARC lifetime.
///
/// One set of Objective-C lifetime qualifiers compatibly includes the other
/// if the lifetime qualifiers match, or if both are non-__weak and the
/// including set also contains the 'const' qualifier, or both are non-__weak
/// and one is None (which can only happen in non-ARC modes).
bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
  if (getObjCLifetime() == other.getObjCLifetime())
    return true;

  if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
    return false;

  if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
    return true;

  return hasConst();
}

/// Determine whether this set of qualifiers is a strict superset of
/// another set of qualifiers, not considering qualifier compatibility.
bool isStrictSupersetOf(Qualifiers Other) const;

bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }

explicit operator bool() const { return hasQualifiers(); }

Qualifiers &operator+=(Qualifiers R) {
  addQualifiers(R);
  return *this;
}

// Union two qualifier sets.  If an enumerated qualifier appears
// in both sets, use the one from the right.
friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
  L += R;
  return L;
}

Qualifiers &operator-=(Qualifiers R) {
  removeQualifiers(R);
  return *this;
}

/// Compute the difference between two qualifier sets.
friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
  L -= R;
  return L;
}

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

static std::string getAddrSpaceAsString(LangAS AS);

bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
void print(raw_ostream &OS, const PrintingPolicy &Policy,
           bool appendSpaceIfNonEmpty = false) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddInteger(Mask);
}

574private:
// bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
//           |C R V|U|GCAttr|Lifetime|AddressSpace|
uint32_t Mask = 0;

static const uint32_t UMask = 0x8;
static const uint32_t UShift = 3;
static const uint32_t GCAttrMask = 0x30;
static const uint32_t GCAttrShift = 4;
static const uint32_t LifetimeMask = 0x1C0;
static const uint32_t LifetimeShift = 6;
static const uint32_t AddressSpaceMask =
    ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
static const uint32_t AddressSpaceShift = 9;
588};

590/// A std::pair-like structure for storing a qualified type split
591/// into its local qualifiers and its locally-unqualified type.
592struct SplitQualType {
/// The locally-unqualified type.
const Type *Ty = nullptr;

/// The local qualifiers.
Qualifiers Quals;

SplitQualType() = default;
SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}

SplitQualType getSingleStepDesugaredType() const; // end of this file

// Make std::tie work.
std::pair<const Type *,Qualifiers> asPair() const {
  return std::pair<const Type *, Qualifiers>(Ty, Quals);
}

friend bool operator==(SplitQualType a, SplitQualType b) {
  return a.Ty == b.Ty && a.Quals == b.Quals;
}
friend bool operator!=(SplitQualType a, SplitQualType b) {
  return a.Ty != b.Ty || a.Quals != b.Quals;
}
615};

617/// The kind of type we are substituting Objective-C type arguments into.
618///
619/// The kind of substitution affects the replacement of type parameters when
620/// no concrete type information is provided, e.g., when dealing with an
621/// unspecialized type.
622enum class ObjCSubstitutionContext {
/// An ordinary type.
Ordinary,

/// The result type of a method or function.
Result,

/// The parameter type of a method or function.
Parameter,

/// The type of a property.
Property,

/// The superclass of a type.
Superclass,
637};

639/// A (possibly-)qualified type.
640///
641/// For efficiency, we don't store CV-qualified types as nodes on their
642/// own: instead each reference to a type stores the qualifiers.  This
643/// greatly reduces the number of nodes we need to allocate for types (for
644/// example we only need one for 'int', 'const int', 'volatile int',
645/// 'const volatile int', etc).
646///
647/// As an added efficiency bonus, instead of making this a pair, we
648/// just store the two bits we care about in the low bits of the
649/// pointer.  To handle the packing/unpacking, we make QualType be a
650/// simple wrapper class that acts like a smart pointer.  A third bit
651/// indicates whether there are extended qualifiers present, in which
652/// case the pointer points to a special structure.
653class QualType {
friend class QualifierCollector;

// Thankfully, these are efficiently composable.
llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
                     Qualifiers::FastWidth> Value;

const ExtQuals *getExtQualsUnsafe() const {
  return Value.getPointer().get<const ExtQuals*>();
}

const Type *getTypePtrUnsafe() const {
  return Value.getPointer().get<const Type*>();
}

const ExtQualsTypeCommonBase *getCommonPtr() const {
  assert(!isNull() && "Cannot retrieve a NULL type pointer")((!isNull() && "Cannot retrieve a NULL type pointer")
 ? static_cast<void> (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 669, __PRETTY_FUNCTION__));
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

675public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }

/// Retrieves a pointer to the underlying (unqualified) type.
///
/// This function requires that the type not be NULL. If the type might be
/// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
const Type *getTypePtr() const;

const Type *getTypePtrOrNull() const;

/// Retrieves a pointer to the name of the base type.
const IdentifierInfo *getBaseTypeIdentifier() const;

/// Divides a QualType into its unqualified type and a set of local
/// qualifiers.
SplitQualType split() const;

void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }

static QualType getFromOpaquePtr(const void *Ptr) {
  QualType T;
  T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
  return T;
}

const Type &operator*() const {
  return *getTypePtr();
}

const Type *operator->() const {
  return getTypePtr();
}

bool isCanonical() const;
bool isCanonicalAsParam() const;

/// Return true if this QualType doesn't point to a type yet.
bool isNull() const {
  return Value.getPointer().isNull();
}

/// Determine whether this particular QualType instance has the
/// "const" qualifier set, without looking through typedefs that may have
/// added "const" at a different level.
bool isLocalConstQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Const);
}

/// Determine whether this type is const-qualified.
bool isConstQualified() const;

/// Determine whether this particular QualType instance has the
/// "restrict" qualifier set, without looking through typedefs that may have
/// added "restrict" at a different level.
bool isLocalRestrictQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Restrict);
}

/// Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// Determine whether this particular QualType instance has the
/// "volatile" qualifier set, without looking through typedefs that may have
/// added "volatile" at a different level.
bool isLocalVolatileQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Volatile);
}

/// Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// Determine whether this particular QualType instance has any
/// qualifiers, without looking through any typedefs that might add
/// qualifiers at a different level.
bool hasLocalQualifiers() const {
  return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
}

/// Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// Determine whether this particular QualType instance has any
/// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
/// instance.
bool hasLocalNonFastQualifiers() const {
  return Value.getPointer().is<const ExtQuals*>();
}

/// Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// local to this particular QualType instance, not including any qualifiers
/// acquired through typedefs or other sugar.
unsigned getLocalCVRQualifiers() const {
  return getLocalFastQualifiers();
}

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// applied to this type.
unsigned getCVRQualifiers() const;

bool isConstant(const ASTContext& Ctx) const {
  return QualType::isConstant(*this, Ctx);
}

/// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isPODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the rules of the C++98
/// standard, regardless of the current compilation's language.
bool isCXX98PODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the more relaxed rules
/// of the C++11 standard, regardless of the current compilation's language.
/// (C++0x [basic.types]p9). Note that, unlike
/// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
bool isCXX11PODType(const ASTContext &Context) const;

/// Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isTrivialType(const ASTContext &Context) const;

/// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTriviallyCopyableType(const ASTContext &Context) const;


/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;

/// Returns true if it is not a class or if the class might not be dynamic.
bool mayBeNotDynamicClass() const;

// Don't promise in the API that anything besides 'const' can be
// easily added.

/// Add the `const` type qualifier to this QualType.
void addConst() {
  addFastQualifiers(Qualifiers::Const);
}
QualType withConst() const {
  return withFastQualifiers(Qualifiers::Const);
}

/// Add the `volatile` type qualifier to this QualType.
void addVolatile() {
  addFastQualifiers(Qualifiers::Volatile);
}
QualType withVolatile() const {
  return withFastQualifiers(Qualifiers::Volatile);
}

/// Add the `restrict` qualifier to this QualType.
void addRestrict() {
  addFastQualifiers(Qualifiers::Restrict);
}
QualType withRestrict() const {
  return withFastQualifiers(Qualifiers::Restrict);
}

QualType withCVRQualifiers(unsigned CVR) const {
  return withFastQualifiers(CVR);
}

void addFastQualifiers(unsigned TQs) {
  assert(!(TQs & ~Qualifiers::FastMask)((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 851, __PRETTY_FUNCTION__))
         && "non-fast qualifier bits set in mask!")((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 851, __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() | TQs);
}

void removeLocalConst();
void removeLocalVolatile();
void removeLocalRestrict();
void removeLocalCVRQualifiers(unsigned Mask);

void removeLocalFastQualifiers() { Value.setInt(0); }
void removeLocalFastQualifiers(unsigned Mask) {
  assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 862, __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() & ~Mask);
}

// Creates a type with the given qualifiers in addition to any
// qualifiers already on this type.
QualType withFastQualifiers(unsigned TQs) const {
  QualType T = *this;
  T.addFastQualifiers(TQs);
  return T;
}

// Creates a type with exactly the given fast qualifiers, removing
// any existing fast qualifiers.
QualType withExactLocalFastQualifiers(unsigned TQs) const {
  return withoutLocalFastQualifiers().withFastQualifiers(TQs);
}

// Removes fast qualifiers, but leaves any extended qualifiers in place.
QualType withoutLocalFastQualifiers() const {
  QualType T = *this;
  T.removeLocalFastQualifiers();
  return T;
}

QualType getCanonicalType() const;

/// Return this type with all of the instance-specific qualifiers
/// removed, but without removing any qualifiers that may have been applied
/// through typedefs.
QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }

/// Retrieve the unqualified variant of the given type,
/// removing as little sugar as possible.
///
/// This routine looks through various kinds of sugar to find the
/// least-desugared type that is unqualified. For example, given:
///
/// \code
/// typedef int Integer;
/// typedef const Integer CInteger;
/// typedef CInteger DifferenceType;
/// \endcode
///
/// Executing \c getUnqualifiedType() on the type \c DifferenceType will
/// desugar until we hit the type \c Integer, which has no qualifiers on it.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline QualType getUnqualifiedType() const;

/// Retrieve the unqualified variant of the given type, removing as little
/// sugar as possible.
///
/// Like getUnqualifiedType(), but also returns the set of
/// qualifiers that were built up.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline SplitQualType getSplitUnqualifiedType() const;

/// Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// Determine whether this type is at least as qualified as the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isAtLeastAsQualifiedAs(QualType Other) const;

QualType getNonReferenceType() const;

/// Determine the type of a (typically non-lvalue) expression with the
/// specified result type.
///
/// This routine should be used for expressions for which the return type is
/// explicitly specified (e.g., in a cast or call) and isn't necessarily
/// an lvalue. It removes a top-level reference (since there are no
/// expressions of reference type) and deletes top-level cvr-qualifiers
/// from non-class types (in C++) or all types (in C).
QualType getNonLValueExprType(const ASTContext &Context) const;

/// Return the specified type with any "sugar" removed from
/// the type.  This takes off typedefs, typeof's etc.  If the outer level of
/// the type is already concrete, it returns it unmodified.  This is similar
/// to getting the canonical type, but it doesn't remove *all* typedefs.  For
/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
/// concrete.
///
/// Qualifiers are left in place.
QualType getDesugaredType(const ASTContext &Context) const {
  return getDesugaredType(*this, Context);
}

SplitQualType getSplitDesugaredType() const {
  return getSplitDesugaredType(*this);
}

/// Return the specified type with one level of "sugar" removed from
/// the type.
///
/// This routine takes off the first typedef, typeof, etc. If the outer level
/// of the type is already concrete, it returns it unmodified.
QualType getSingleStepDesugaredType(const ASTContext &Context) const {
  return getSingleStepDesugaredTypeImpl(*this, Context);
}

/// Returns the specified type after dropping any
/// outer-level parentheses.
QualType IgnoreParens() const {
  if (isa<ParenType>(*this))
    return QualType::IgnoreParens(*this);
  return *this;
}

/// Indicate whether the specified types and qualifiers are identical.
friend bool operator==(const QualType &LHS, const QualType &RHS) {
  return LHS.Value == RHS.Value;
}
friend bool operator!=(const QualType &LHS, const QualType &RHS) {
  return LHS.Value != RHS.Value;
}
friend bool operator<(const QualType &LHS, const QualType &RHS) {
  return LHS.Value < RHS.Value;
}

static std::string getAsString(SplitQualType split,
                               const PrintingPolicy &Policy) {
  return getAsString(split.Ty, split.Quals, Policy);
}
static std::string getAsString(const Type *ty, Qualifiers qs,
                               const PrintingPolicy &Policy);

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

void print(raw_ostream &OS, const PrintingPolicy &Policy,
           const Twine &PlaceHolder = Twine(),
           unsigned Indentation = 0) const;

static void print(SplitQualType split, raw_ostream &OS,
                  const PrintingPolicy &policy, const Twine &PlaceHolder,
                  unsigned Indentation = 0) {
  return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
}

static void print(const Type *ty, Qualifiers qs,
                  raw_ostream &OS, const PrintingPolicy &policy,
                  const Twine &PlaceHolder,
                  unsigned Indentation = 0);

void getAsStringInternal(std::string &Str,
                         const PrintingPolicy &Policy) const;

static void getAsStringInternal(SplitQualType split, std::string &out,
                                const PrintingPolicy &policy) {
  return getAsStringInternal(split.Ty, split.Quals, out, policy);
}

static void getAsStringInternal(const Type *ty, Qualifiers qs,
                                std::string &out,
                                const PrintingPolicy &policy);

class StreamedQualTypeHelper {
  const QualType &T;
  const PrintingPolicy &Policy;
  const Twine &PlaceHolder;
  unsigned Indentation;

public:
  StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
                         const Twine &PlaceHolder, unsigned Indentation)
      : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
        Indentation(Indentation) {}

  friend raw_ostream &operator<<(raw_ostream &OS,
                                 const StreamedQualTypeHelper &SQT) {
    SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
    return OS;
  }
};

StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
                              const Twine &PlaceHolder = Twine(),
                              unsigned Indentation = 0) const {
  return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
}

void dump(const char *s) const;
void dump() const;
void dump(llvm::raw_ostream &OS) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddPointer(getAsOpaquePtr());
}

/// Check if this type has any address space qualifier.
inline bool hasAddressSpace() const;

/// Return the address space of this type.
inline LangAS getAddressSpace() const;

/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;

/// true when Type is objc's weak.
bool isObjCGCWeak() const {
  return getObjCGCAttr() == Qualifiers::Weak;
}

/// true when Type is objc's strong.
bool isObjCGCStrong() const {
  return getObjCGCAttr() == Qualifiers::Strong;
}

/// Returns lifetime attribute of this type.
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return getQualifiers().getObjCLifetime();
}

bool hasNonTrivialObjCLifetime() const {
  return getQualifiers().hasNonTrivialObjCLifetime();
}

bool hasStrongOrWeakObjCLifetime() const {
  return getQualifiers().hasStrongOrWeakObjCLifetime();
}

// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;

enum PrimitiveDefaultInitializeKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,

  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct
};

/// Functions to query basic properties of non-trivial C struct types.

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to default initialize
/// and return the kind.
PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const;

enum PrimitiveCopyKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,

  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,

  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct
};

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to copy and return the
/// kind.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to destructively
/// move and return the kind. Destructive move in this context is a C++-style
/// move in which the source object is placed in a valid but unspecified state
/// after it is moved, as opposed to a truly destructive move in which the
/// source object is placed in an uninitialized state.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;

enum DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct
};

/// Returns a nonzero value if objects of this type require
/// non-trivial work to clean up after.  Non-zero because it's
/// conceivable that qualifiers (objc_gc(weak)?) could make
/// something require destruction.
DestructionKind isDestructedType() const {
  return isDestructedTypeImpl(*this);
}

/// Check if this is or contains a C union that is non-trivial to
/// default-initialize, which is a union that has a member that is non-trivial
/// to default-initialize. If this returns true,
/// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;

/// Check if this is or contains a C union that is non-trivial to destruct,
/// which is a union that has a member that is non-trivial to destruct. If
/// this returns true, isDestructedType returns DK_nontrivial_c_struct.
bool hasNonTrivialToPrimitiveDestructCUnion() const;

/// Check if this is or contains a C union that is non-trivial to copy, which
/// is a union that has a member that is non-trivial to copy. If this returns
/// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
bool hasNonTrivialToPrimitiveCopyCUnion() const;

/// Determine whether expressions of the given type are forbidden
/// from being lvalues in C.
///
/// The expression types that are forbidden to be lvalues are:
///   - 'void', but not qualified void
///   - function types
///
/// The exact rule here is C99 6.3.2.1:
///   An lvalue is an expression with an object type or an incomplete
///   type other than void.
bool isCForbiddenLValueType() const;

/// Substitute type arguments for the Objective-C type parameters used in the
/// subject type.
///
/// \param ctx ASTContext in which the type exists.
///
/// \param typeArgs The type arguments that will be substituted for the
/// Objective-C type parameters in the subject type, which are generally
/// computed via \c Type::getObjCSubstitutions. If empty, the type
/// parameters will be replaced with their bounds or id/Class, as appropriate
/// for the context.
///
/// \param context The context in which the subject type was written.
///
/// \returns the resulting type.
QualType substObjCTypeArgs(ASTContext &ctx,
                           ArrayRef<QualType> typeArgs,
                           ObjCSubstitutionContext context) const;

/// Substitute type arguments from an object type for the Objective-C type
/// parameters used in the subject type.
///
/// This operation combines the computation of type arguments for
/// substitution (\c Type::getObjCSubstitutions) with the actual process of
/// substitution (\c QualType::substObjCTypeArgs) for the convenience of
/// callers that need to perform a single substitution in isolation.
///
/// \param objectType The type of the object whose member type we're
/// substituting into. For example, this might be the receiver of a message
/// or the base of a property access.
///
/// \param dc The declaration context from which the subject type was
/// retrieved, which indicates (for example) which type parameters should
/// be substituted.
///
/// \param context The context in which the subject type was written.
///
/// \returns the subject type after replacing all of the Objective-C type
/// parameters with their corresponding arguments.
QualType substObjCMemberType(QualType objectType,
                             const DeclContext *dc,
                             ObjCSubstitutionContext context) const;

/// Strip Objective-C "__kindof" types from the given type.
QualType stripObjCKindOfType(const ASTContext &ctx) const;

/// Remove all qualifiers including _Atomic.
QualType getAtomicUnqualifiedType() const;

1253private:
// These methods are implemented in a separate translation unit;
// "static"-ize them to avoid creating temporary QualTypes in the
// caller.
static bool isConstant(QualType T, const ASTContext& Ctx);
static QualType getDesugaredType(QualType T, const ASTContext &Context);
static SplitQualType getSplitDesugaredType(QualType T);
static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
static QualType getSingleStepDesugaredTypeImpl(QualType type,
                                               const ASTContext &C);
static QualType IgnoreParens(QualType T);
static DestructionKind isDestructedTypeImpl(QualType type);

/// Check if \param RD is or contains a non-trivial C union.
static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1270};

1272} // namespace clang

1274namespace llvm {

1276/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1277/// to a specific Type class.
1278template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1284};

1286// Teach SmallPtrSet that QualType is "basically a pointer".
1287template<>
1288struct PointerLikeTypeTraits<clang::QualType> {
static inline void *getAsVoidPointer(clang::QualType P) {
  return P.getAsOpaquePtr();
}

static inline clang::QualType getFromVoidPointer(void *P) {
  return clang::QualType::getFromOpaquePtr(P);
}

// Various qualifiers go in low bits.
enum { NumLowBitsAvailable = 0 };
1299};

1301} // namespace llvm

1303namespace clang {

1305/// Base class that is common to both the \c ExtQuals and \c Type
1306/// classes, which allows \c QualType to access the common fields between the
1307/// two.
1308class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// The "base" type of an extended qualifiers type (\c ExtQuals) or
/// a self-referential pointer (for \c Type).
///
/// This pointer allows an efficient mapping from a QualType to its
/// underlying type pointer.
const Type *const BaseType;

/// The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1325};

1327/// We can encode up to four bits in the low bits of a
1328/// type pointer, but there are many more type qualifiers that we want
1329/// to be able to apply to an arbitrary type.  Therefore we have this
1330/// struct, intended to be heap-allocated and used by QualType to
1331/// store qualifiers.
1332///
1333/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1334/// in three low bits on the QualType pointer; a fourth bit records whether
1335/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1336/// Objective-C GC attributes) are much more rare.
1337class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
// NOTE: changing the fast qualifiers should be straightforward as
// long as you don't make 'const' non-fast.
// 1. Qualifiers:
//    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
//       Fast qualifiers must occupy the low-order bits.
//    b) Update Qualifiers::FastWidth and FastMask.
// 2. QualType:
//    a) Update is{Volatile,Restrict}Qualified(), defined inline.
//    b) Update remove{Volatile,Restrict}, defined near the end of
//       this header.
// 3. ASTContext:
//    a) Update get{Volatile,Restrict}Type.

/// The immutable set of qualifiers applied by this node. Always contains
/// extended qualifiers.
Qualifiers Quals;

ExtQuals *this_() { return this; }

1357public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1363, __PRETTY_FUNCTION__))
         && "ExtQuals created with no fast qualifiers")((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1363, __PRETTY_FUNCTION__));
  assert(!Quals.hasFastQualifiers()((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1365, __PRETTY_FUNCTION__))
         && "ExtQuals created with fast qualifiers")((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1365, __PRETTY_FUNCTION__));
}

Qualifiers getQualifiers() const { return Quals; }

bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }

bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return Quals.getObjCLifetime();
}

bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
LangAS getAddressSpace() const { return Quals.getAddressSpace(); }

const Type *getBaseType() const { return BaseType; }

1383public:
void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, getBaseType(), Quals);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const Type *BaseType,
                    Qualifiers Quals) {
  assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1391, __PRETTY_FUNCTION__));
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1395};

1397/// The kind of C++11 ref-qualifier associated with a function type.
1398/// This determines whether a member function's "this" object can be an
1399/// lvalue, rvalue, or neither.
1400enum RefQualifierKind {
/// No ref-qualifier was provided.
RQ_None = 0,

/// An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1409};

1411/// Which keyword(s) were used to create an AutoType.
1412enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1421};

1423/// The base class of the type hierarchy.
1424///
1425/// A central concept with types is that each type always has a canonical
1426/// type.  A canonical type is the type with any typedef names stripped out
1427/// of it or the types it references.  For example, consider:
1428///
1429///  typedef int  foo;
1430///  typedef foo* bar;
1431///    'int *'    'foo *'    'bar'
1432///
1433/// There will be a Type object created for 'int'.  Since int is canonical, its
1434/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1435/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1436/// there is a PointerType that represents 'int*', which, like 'int', is
1437/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1438/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1439/// is also 'int*'.
1440///
1441/// Non-canonical types are useful for emitting diagnostics, without losing
1442/// information about typedefs being used.  Canonical types are useful for type
1443/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1444/// about whether something has a particular form (e.g. is a function type),
1445/// because they implicitly, recursively, strip all typedefs out of a type.
1446///
1447/// Types, once created, are immutable.
1448///
1449class alignas(8) Type : public ExtQualsTypeCommonBase {
1450public:
enum TypeClass {
1452#define TYPE(Class, Base) Class,
1453#define LAST_TYPE(Class) TypeLast = Class
1454#define ABSTRACT_TYPE(Class, Base)
1455#include "clang/AST/TypeNodes.inc"
};

1458private:
/// Bitfields required by the Type class.
class TypeBitfields {
  friend class Type;
  template <class T> friend class TypePropertyCache;

  /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
  unsigned TC : 8;

  /// Whether this type is a dependent type (C++ [temp.dep.type]).
  unsigned Dependent : 1;

  /// Whether this type somehow involves a template parameter, even
  /// if the resolution of the type does not depend on a template parameter.
  unsigned InstantiationDependent : 1;

  /// Whether this type is a variably-modified type (C99 6.7.5).
  unsigned VariablyModified : 1;

  /// Whether this type contains an unexpanded parameter pack
  /// (for C++11 variadic templates).
  unsigned ContainsUnexpandedParameterPack : 1;

  /// True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// Whether this type comes from an AST file.
  mutable unsigned FromAST : 1;

  bool isCacheValid() const {
    return CacheValid;
  }

  Linkage getLinkage() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1499, __PRETTY_FUNCTION__));
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1504, __PRETTY_FUNCTION__));
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 18 };

1510protected:
// These classes allow subclasses to somewhat cleanly pack bitfields
// into Type.

class ArrayTypeBitfields {
  friend class ArrayType;

  unsigned : NumTypeBits;

  /// CVR qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  unsigned IndexTypeQuals : 3;

  /// Storage class qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  /// Actually an ArrayType::ArraySizeModifier.
  unsigned SizeModifier : 3;
};

class ConstantArrayTypeBitfields {
  friend class ConstantArrayType;

  unsigned : NumTypeBits + 3 + 3;

  /// Whether we have a stored size expression.
  unsigned HasStoredSizeExpr : 1;
};

class BuiltinTypeBitfields {
  friend class BuiltinType;

  unsigned : NumTypeBits;

  /// The kind (BuiltinType::Kind) of builtin type this is.
  unsigned Kind : 8;
};

/// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
/// Only common bits are stored here. Additional uncommon bits are stored
/// in a trailing object after FunctionProtoType.
class FunctionTypeBitfields {
  friend class FunctionProtoType;
  friend class FunctionType;

  unsigned : NumTypeBits;

  /// Extra information which affects how the function is called, like
  /// regparm and the calling convention.
  unsigned ExtInfo : 12;

  /// The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;

  /// Used only by FunctionProtoType, put here to pack with the
  /// other bitfields.
  /// The qualifiers are part of FunctionProtoType because...
  ///
  /// C++ 8.3.5p4: The return type, the parameter type list and the
  /// cv-qualifier-seq, [...], are part of the function type.
  unsigned FastTypeQuals : Qualifiers::FastWidth;
  /// Whether this function has extended Qualifiers.
  unsigned HasExtQuals : 1;

  /// The number of parameters this function has, not counting '...'.
  /// According to [implimits] 8 bits should be enough here but this is
  /// somewhat easy to exceed with metaprogramming and so we would like to
  /// keep NumParams as wide as reasonably possible.
  unsigned NumParams : 16;

  /// The type of exception specification this function has.
  unsigned ExceptionSpecType : 4;

  /// Whether this function has extended parameter information.
  unsigned HasExtParameterInfos : 1;

  /// Whether the function is variadic.
  unsigned Variadic : 1;

  /// Whether this function has a trailing return type.
  unsigned HasTrailingReturn : 1;
};

class ObjCObjectTypeBitfields {
  friend class ObjCObjectType;

  unsigned : NumTypeBits;

  /// The number of type arguments stored directly on this object type.
  unsigned NumTypeArgs : 7;

  /// The number of protocols stored directly on this object type.
  unsigned NumProtocols : 6;

  /// Whether this is a "kindof" type.
  unsigned IsKindOf : 1;
};

class ReferenceTypeBitfields {
  friend class ReferenceType;

  unsigned : NumTypeBits;

  /// True if the type was originally spelled with an lvalue sigil.
  /// This is never true of rvalue references but can also be false
  /// on lvalue references because of C++0x [dcl.typedef]p9,
  /// as follows:
  ///
  ///   typedef int &ref;    // lvalue, spelled lvalue
  ///   typedef int &&rvref; // rvalue
  ///   ref &a;              // lvalue, inner ref, spelled lvalue
  ///   ref &&a;             // lvalue, inner ref
  ///   rvref &a;            // lvalue, inner ref, spelled lvalue
  ///   rvref &&a;           // rvalue, inner ref
  unsigned SpelledAsLValue : 1;

  /// True if the inner type is a reference type.  This only happens
  /// in non-canonical forms.
  unsigned InnerRef : 1;
};

class TypeWithKeywordBitfields {
  friend class TypeWithKeyword;

  unsigned : NumTypeBits;

  /// An ElaboratedTypeKeyword.  8 bits for efficient access.
  unsigned Keyword : 8;
};

enum { NumTypeWithKeywordBits = 8 };

class ElaboratedTypeBitfields {
  friend class ElaboratedType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// Whether the ElaboratedType has a trailing OwnedTagDecl.
  unsigned HasOwnedTagDecl : 1;
};

class VectorTypeBitfields {
  friend class VectorType;
  friend class DependentVectorType;

  unsigned : NumTypeBits;

  /// The kind of vector, either a generic vector type or some
  /// target-specific vector type such as for AltiVec or Neon.
  unsigned VecKind : 3;

  /// The number of elements in the vector.
  unsigned NumElements : 29 - NumTypeBits;

  enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 };
};

class AttributedTypeBitfields {
  friend class AttributedType;

  unsigned : NumTypeBits;

  /// An AttributedType::Kind
  unsigned AttrKind : 32 - NumTypeBits;
};

class AutoTypeBitfields {
  friend class AutoType;

  unsigned : NumTypeBits;

  /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
  /// or '__auto_type'?  AutoTypeKeyword value.
  unsigned Keyword : 2;
};

class SubstTemplateTypeParmPackTypeBitfields {
  friend class SubstTemplateTypeParmPackType;

  unsigned : NumTypeBits;

  /// The number of template arguments in \c Arguments, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class TemplateSpecializationTypeBitfields {
  friend class TemplateSpecializationType;

  unsigned : NumTypeBits;

  /// Whether this template specialization type is a substituted type alias.
  unsigned TypeAlias : 1;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class DependentTemplateSpecializationTypeBitfields {
  friend class DependentTemplateSpecializationType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class PackExpansionTypeBitfields {
  friend class PackExpansionType;

  unsigned : NumTypeBits;

  /// The number of expansions that this pack expansion will
  /// generate when substituted (+1), which is expected to be able to
  /// hold at least 1024 according to [implimits]. However, as this limit
  /// is somewhat easy to hit with template metaprogramming we'd prefer to
  /// keep it as large as possible. At the moment it has been left as a
  /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
  /// there is no reason to introduce the performance impact of a bitfield.
  ///
  /// This field will only have a non-zero value when some of the parameter
  /// packs that occur within the pattern have been substituted but others
  /// have not.
  unsigned NumExpansions;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  ConstantArrayTypeBitfields ConstantArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  ElaboratedTypeBitfields ElaboratedTypeBits;
  VectorTypeBitfields VectorTypeBits;
  SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
  TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
  DependentTemplateSpecializationTypeBitfields
    DependentTemplateSpecializationTypeBits;
  PackExpansionTypeBitfields PackExpansionTypeBits;

  static_assert(sizeof(TypeBitfields) <= 8,
                "TypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ArrayTypeBitfields) <= 8,
                "ArrayTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(AttributedTypeBitfields) <= 8,
                "AttributedTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(AutoTypeBitfields) <= 8,
                "AutoTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(BuiltinTypeBitfields) <= 8,
                "BuiltinTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(FunctionTypeBitfields) <= 8,
                "FunctionTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCObjectTypeBitfields) <= 8,
                "ObjCObjectTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ReferenceTypeBitfields) <= 8,
                "ReferenceTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(TypeWithKeywordBitfields) <= 8,
                "TypeWithKeywordBitfields is larger than 8 bytes!");
  static_assert(sizeof(ElaboratedTypeBitfields) <= 8,
                "ElaboratedTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(VectorTypeBitfields) <= 8,
                "VectorTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(SubstTemplateTypeParmPackTypeBitfields) <= 8,
                "SubstTemplateTypeParmPackTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8,
                "TemplateSpecializationTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(DependentTemplateSpecializationTypeBitfields) <= 8,
                "DependentTemplateSpecializationTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(PackExpansionTypeBitfields) <= 8,
                "PackExpansionTypeBitfields is larger than 8 bytes");
};

1810private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1818protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, bool Dependent,
     bool InstantiationDependent, bool VariablyModified,
     bool ContainsUnexpandedParameterPack)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  TypeBits.TC = tc;
  TypeBits.Dependent = Dependent;
  TypeBits.InstantiationDependent = Dependent || InstantiationDependent;
  TypeBits.VariablyModified = VariablyModified;
  TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
  TypeBits.CacheValid = false;
  TypeBits.CachedLocalOrUnnamed = false;
  TypeBits.CachedLinkage = NoLinkage;
  TypeBits.FromAST = false;
}

// silence VC++ warning C4355: 'this' : used in base member initializer list
Type *this_() { return this; }

void setDependent(bool D = true) {
  TypeBits.Dependent = D;
  if (D)
    TypeBits.InstantiationDependent = true;
}

void setInstantiationDependent(bool D = true) {
  TypeBits.InstantiationDependent = D; }

void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM; }

void setContainsUnexpandedParameterPack(bool PP = true) {
  TypeBits.ContainsUnexpandedParameterPack = PP;
}

1855public:
friend class ASTReader;
friend class ASTWriter;
template <class T> friend class serialization::AbstractTypeReader;
template <class T> friend class serialization::AbstractTypeWriter;

Type(const Type &) = delete;
Type(Type &&) = delete;
Type &operator=(const Type &) = delete;
Type &operator=(Type &&) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// Whether this type is or contains an unexpanded parameter
/// pack, used to support C++0x variadic templates.
///
/// A type that contains a parameter pack shall be expanded by the
/// ellipsis operator at some point. For example, the typedef in the
/// following example contains an unexpanded parameter pack 'T':
///
/// \code
/// template<typename ...T>
/// struct X {
///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
/// };
/// \endcode
///
/// Note that this routine does not specify which
bool containsUnexpandedParameterPack() const {
  return TypeBits.ContainsUnexpandedParameterPack;
}

/// Determines if this type would be canonical if it had no further
/// qualification.
bool isCanonicalUnqualified() const {
  return CanonicalType == QualType(this, 0);
}

/// Pull a single level of sugar off of this locally-unqualified type.
/// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
/// or QualType::getSingleStepDesugaredType(const ASTContext&).
QualType getLocallyUnqualifiedSingleStepDesugaredType() const;

/// Types are partitioned into 3 broad categories (C99 6.2.5p1):
/// object types, function types, and incomplete types.

/// Return true if this is an incomplete type.
/// A type that can describe objects, but which lacks information needed to
/// determine its size (e.g. void, or a fwd declared struct). Clients of this
/// routine will need to determine if the size is actually required.
///
/// Def If non-null, and the type refers to some kind of declaration
/// that can be completed (such as a C struct, C++ class, or Objective-C
/// class), will be set to the declaration.
bool isIncompleteType(NamedDecl **Def = nullptr) const;

/// Return true if this is an incomplete or object
/// type, in other words, not a function type.
bool isIncompleteOrObjectType() const {
  return !isFunctionType();
}

/// Determine whether this type is an object type.
bool isObjectType() const {
  // C++ [basic.types]p8:
  //   An object type is a (possibly cv-qualified) type that is not a
  //   function type, not a reference type, and not a void type.
  return !isReferenceType() && !isFunctionType() && !isVoidType();
}

/// Return true if this is a literal type
/// (C++11 [basic.types]p10)
bool isLiteralType(const ASTContext &Ctx) const;

/// Test if this type is a standard-layout type.
/// (C++0x [basic.type]p9)
bool isStandardLayoutType() const;

/// Helper methods to distinguish type categories. All type predicates
/// operate on the canonical type, ignoring typedefs and qualifiers.

/// Returns true if the type is a builtin type.
bool isBuiltinType() const;

/// Test for a particular builtin type.
bool isSpecificBuiltinType(unsigned K) const;

/// Test for a type which does not represent an actual type-system type but
/// is instead used as a placeholder for various convenient purposes within
/// Clang.  All such types are BuiltinTypes.
bool isPlaceholderType() const;
const BuiltinType *getAsPlaceholderType() const;

/// Test for a specific placeholder type.
bool isSpecificPlaceholderType(unsigned K) const;

/// Test for a placeholder type other than Overload; see
/// BuiltinType::isNonOverloadPlaceholderType.
bool isNonOverloadPlaceholderType() const;

/// isIntegerType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
bool isEnumeralType() const;

/// Determine whether this type is a scoped enumeration type.
bool isScopedEnumeralType() const;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() const;
bool isChar8Type() const;
bool isChar16Type() const;
bool isChar32Type() const;
bool isAnyCharacterType() const;
bool isIntegralType(const ASTContext &Ctx) const;

/// Determine whether this type is an integral or enumeration type.
bool isIntegralOrEnumerationType() const;

/// Determine whether this type is an integral or unscoped enumeration type.
bool isIntegralOrUnscopedEnumerationType() const;
bool isUnscopedEnumerationType() const;

/// Floating point categories.
bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
/// isComplexType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isComplexType() const;      // C99 6.2.5p11 (complex)
bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
bool isFloat128Type() const;
bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
bool isVoidType() const;         // C99 6.2.5p19
bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
bool isAggregateType() const;
bool isFundamentalType() const;
bool isCompoundType() const;

// Type Predicates: Check to see if this type is structurally the specified
// type, ignoring typedefs and qualifiers.
bool isFunctionType() const;
bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
bool isPointerType() const;
bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
bool isBlockPointerType() const;
bool isVoidPointerType() const;
bool isReferenceType() const;
bool isLValueReferenceType() const;
bool isRValueReferenceType() const;
bool isObjectPointerType() const;
bool isFunctionPointerType() const;
bool isFunctionReferenceType() const;
bool isMemberPointerType() const;
bool isMemberFunctionPointerType() const;
bool isMemberDataPointerType() const;
bool isArrayType() const;
bool isConstantArrayType() const;
bool isIncompleteArrayType() const;
bool isVariableArrayType() const;
bool isDependentSizedArrayType() const;
bool isRecordType() const;
bool isClassType() const;
bool isStructureType() const;
bool isObjCBoxableRecordType() const;
bool isInterfaceType() const;
bool isStructureOrClassType() const;
bool isUnionType() const;
bool isComplexIntegerType() const;            // GCC _Complex integer type.
bool isVectorType() const;                    // GCC vector type.
bool isExtVectorType() const;                 // Extended vector type.
bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
bool isObjCObjectPointerType() const;         // pointer to ObjC object
bool isObjCRetainableType() const;            // ObjC object or block pointer
bool isObjCLifetimeType() const;              // (array of)* retainable type
bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
bool isObjCNSObjectType() const;              // __attribute__((NSObject))
bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
// FIXME: change this to 'raw' interface type, so we can used 'interface' type
// for the common case.
bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
bool isObjCQualifiedIdType() const;           // id<foo>
bool isObjCQualifiedClassType() const;        // Class<foo>
bool isObjCObjectOrInterfaceType() const;
bool isObjCIdType() const;                    // id
bool isDecltypeType() const;
/// Was this type written with the special inert-in-ARC __unsafe_unretained
/// qualifier?
///
/// This approximates the answer to the following question: if this
/// translation unit were compiled in ARC, would this type be qualified
/// with __unsafe_unretained?
bool isObjCInertUnsafeUnretainedType() const {
  return hasAttr(attr::ObjCInertUnsafeUnretained);
}

/// Whether the type is Objective-C 'id' or a __kindof type of an
/// object type, e.g., __kindof NSView * or __kindof id
/// <NSCopying>.
///
/// \param bound Will be set to the bound on non-id subtype types,
/// which will be (possibly specialized) Objective-C class type, or
/// null for 'id.
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
                                const ObjCObjectType *&bound) const;

bool isObjCClassType() const;                 // Class

/// Whether the type is Objective-C 'Class' or a __kindof type of an
/// Class type, e.g., __kindof Class <NSCopying>.
///
/// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
/// here because Objective-C's type system cannot express "a class
/// object for a subclass of NSFoo".
bool isObjCClassOrClassKindOfType() const;

bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
bool isObjCSelType() const;                 // Class
bool isObjCBuiltinType() const;               // 'id' or 'Class'
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const;          // C++ template type parameter
bool isNullPtrType() const;                   // C++11 std::nullptr_t
bool isNothrowT() const;                      // C++   std::nothrow_t
bool isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()
bool isUndeducedAutoType() const;             // C++11 auto or
                                              // C++14 decltype(auto)

2092#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2094#include "clang/Basic/OpenCLImageTypes.def"

bool isImageType() const;                     // Any OpenCL image type

bool isSamplerT() const;                      // OpenCL sampler_t
bool isEventT() const;                        // OpenCL event_t
bool isClkEventT() const;                     // OpenCL clk_event_t
bool isQueueT() const;                        // OpenCL queue_t
bool isReserveIDT() const;                    // OpenCL reserve_id_t

2104#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2106#include "clang/Basic/OpenCLExtensionTypes.def"
// Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
bool isOCLIntelSubgroupAVCType() const;
bool isOCLExtOpaqueType() const;              // Any OpenCL extension type

bool isPipeType() const;                      // OpenCL pipe type
bool isOpenCLSpecificType() const;            // Any OpenCL specific type

/// Determines if this type, which must satisfy
/// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
/// than implicitly __strong.
bool isObjCARCImplicitlyUnretainedType() const;

/// Return the implicit lifetime for this type, which must not be dependent.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;

enum ScalarTypeKind {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
  STK_FixedPoint
};

/// Given that this is a scalar type, classify it.
ScalarTypeKind getScalarTypeKind() const;

/// Whether this type is a dependent type, meaning that its definition
/// somehow depends on a template parameter (C++ [temp.dep.type]).
bool isDependentType() const { return TypeBits.Dependent; }

/// Determine whether this type is an instantiation-dependent type,
/// meaning that the type involves a template parameter (even if the
/// definition does not actually depend on the type substituted for that
/// template parameter).
bool isInstantiationDependentType() const {
  return TypeBits.InstantiationDependent;
}

/// Determine whether this type is an undeduced type, meaning that
/// it somehow involves a C++11 'auto' type or similar which has not yet been
/// deduced.
bool isUndeducedType() const;

/// Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const { return TypeBits.VariablyModified; }

/// Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// Determine wither this type is a C++ elaborated-type-specifier.
bool isElaboratedTypeSpecifier() const;

bool canDecayToPointerType() const;

/// Whether this type is represented natively as a pointer.  This includes
/// pointers, references, block pointers, and Objective-C interface,
/// qualified id, and qualified interface types, as well as nullptr_t.
bool hasPointerRepresentation() const;

/// Whether this type can represent an objective pointer type for the
/// purpose of GC'ability
bool hasObjCPointerRepresentation() const;

/// Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// Determine whether this type has an signed integer representation
/// of some sort, e.g., it is an signed integer type or a vector.
bool hasSignedIntegerRepresentation() const;

/// Determine whether this type has an unsigned integer representation
/// of some sort, e.g., it is an unsigned integer type or a vector.
bool hasUnsignedIntegerRepresentation() const;

/// Determine whether this type has a floating-point representation
/// of some sort, e.g., it is a floating-point type or a vector thereof.
bool hasFloatingRepresentation() const;

// Type Checking Functions: Check to see if this type is structurally the
// specified type, ignoring typedefs and qualifiers, and return a pointer to
// the best type we can.
const RecordType *getAsStructureType() const;
/// NOTE: getAs*ArrayType are methods on ASTContext.
const RecordType *getAsUnionType() const;
const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
const ObjCObjectType *getAsObjCInterfaceType() const;

// The following is a convenience method that returns an ObjCObjectPointerType
// for object declared using an interface.
const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;

/// Retrieves the CXXRecordDecl that this type refers to, either
/// because the type is a RecordType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
CXXRecordDecl *getAsCXXRecordDecl() const;

/// Retrieves the RecordDecl this type refers to.
RecordDecl *getAsRecordDecl() const;

/// Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const;

/// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that the type refers to.
///
/// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const;

/// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
DeducedType *getContainedDeducedType() const;

/// Get the AutoType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
AutoType *getContainedAutoType() const {
  return dyn_cast_or_null<AutoType>(getContainedDeducedType());
}

/// Determine whether this type was written with a leading 'auto'
/// corresponding to a trailing return type (possibly for a nested
/// function type within a pointer to function type or similar).
bool hasAutoForTrailingReturnType() const;

/// Member-template getAs<specific type>'.  Look through sugar for
/// an instance of \<specific type>.   This scheme will eventually
/// replace the specific getAsXXXX methods above.
///
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;

/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
/// This is used when you need to walk over sugar nodes that represent some
/// kind of type adjustment from a type that was written as a \<specific type>
/// to another type that is still canonically a \<specific type>.
template <typename T> const T *getAsAdjusted() const;

/// A variant of getAs<> for array types which silently discards
/// qualifiers from the outermost type.
const ArrayType *getAsArrayTypeUnsafe() const;

/// Member-template castAs<specific type>.  Look through sugar for
/// the underlying instance of \<specific type>.
///
/// This method has the same relationship to getAs<T> as cast<T> has
/// to dyn_cast<T>; which is to say, the underlying type *must*
/// have the intended type, and this method will never return null.
template <typename T> const T *castAs() const;

/// A variant of castAs<> for array type which silently discards
/// qualifiers from the outermost type.
const ArrayType *castAsArrayTypeUnsafe() const;

/// Determine whether this type had the specified attribute applied to it
/// (looking through top-level type sugar).
bool hasAttr(attr::Kind AK) const;

/// Get the base element type of this type, potentially discarding type
/// qualifiers.  This should never be used when type qualifiers
/// are meaningful.
const Type *getBaseElementTypeUnsafe() const;

/// If this is an array type, return the element type of the array,
/// potentially with type qualifiers missing.
/// This should never be used when type qualifiers are meaningful.
const Type *getArrayElementTypeNoTypeQual() const;

/// If this is a pointer type, return the pointee type.
/// If this is an array type, return the array element type.
/// This should never be used when type qualifiers are meaningful.
const Type *getPointeeOrArrayElementType() const;

/// If this is a pointer, ObjC object pointer, or block
/// pointer, this returns the respective pointee.
QualType getPointeeType() const;

/// Return the specified type with any "sugar" removed from the type,
/// removing any typedefs, typeofs, etc., as well as any qualifiers.
const Type *getUnqualifiedDesugaredType() const;

/// More type predicates useful for type checking/promotion
bool isPromotableIntegerType() const; // C99 6.3.1.1p2

/// Return true if this is an integer type that is
/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
/// or an enum decl which has a signed representation.
bool isSignedIntegerType() const;

/// Return true if this is an integer type that is
/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
/// or an enum decl which has an unsigned representation.
bool isUnsignedIntegerType() const;

/// Determines whether this is an integer type that is signed or an
/// enumeration types whose underlying type is a signed integer type.
bool isSignedIntegerOrEnumerationType() const;

/// Determines whether this is an integer type that is unsigned or an
/// enumeration types whose underlying type is a unsigned integer type.
bool isUnsignedIntegerOrEnumerationType() const;

/// Return true if this is a fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169.
bool isFixedPointType() const;

/// Return true if this is a fixed point or integer type.
bool isFixedPointOrIntegerType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isSaturatedFixedPointType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isUnsaturatedFixedPointType() const;

/// Return true if this is a fixed point type that is signed according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isSignedFixedPointType() const;

/// Return true if this is a fixed point type that is unsigned according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isUnsignedFixedPointType() const;

/// Return true if this is not a variable sized type,
/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
/// incomplete types.
bool isConstantSizeType() const;

/// Returns true if this type can be represented by some
/// set of type specifiers.
bool isSpecifierType() const;

/// Determine the linkage of this type.
Linkage getLinkage() const;

/// Determine the visibility of this type.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Return true if the visibility was explicitly set is the code.
bool isVisibilityExplicit() const {
  return getLinkageAndVisibility().isVisibilityExplicit();
}

/// Determine the linkage and visibility of this type.
LinkageInfo getLinkageAndVisibility() const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// Determine the nullability of the given type.
///
/// Note that nullability is only captured as sugar within the type
/// system, not as part of the canonical type, so nullability will
/// be lost by canonicalization and desugaring.
Optional<NullabilityKind> getNullability(const ASTContext &context) const;

/// Determine whether the given type can have a nullability
/// specifier applied to it, i.e., if it is any kind of pointer type.
///
/// \param ResultIfUnknown The value to return if we don't yet know whether
///        this type can have nullability because it is dependent.
bool canHaveNullability(bool ResultIfUnknown = true) const;

/// Retrieve the set of substitutions required when accessing a member
/// of the Objective-C receiver type that is declared in the given context.
///
/// \c *this is the type of the object we're operating on, e.g., the
/// receiver for a message send or the base of a property access, and is
/// expected to be of some object or object pointer type.
///
/// \param dc The declaration context for which we are building up a
/// substitution mapping, which should be an Objective-C class, extension,
/// category, or method within.
///
/// \returns an array of type arguments that can be substituted for
/// the type parameters of the given declaration context in any type described
/// within that context, or an empty optional to indicate that no
/// substitution is required.
Optional<ArrayRef<QualType>>
getObjCSubstitutions(const DeclContext *dc) const;

/// Determines if this is an ObjC interface type that may accept type
/// parameters.
bool acceptsObjCTypeParams() const;

const char *getTypeClassName() const;

QualType getCanonicalTypeInternal() const {
  return CanonicalType;
}

CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
void dump() const;
void dump(llvm::raw_ostream &OS) const;
2426};

2428/// This will check for a TypedefType by removing any existing sugar
2429/// until it reaches a TypedefType or a non-sugared type.
2430template <> const TypedefType *Type::getAs() const;

2432/// This will check for a TemplateSpecializationType by removing any
2433/// existing sugar until it reaches a TemplateSpecializationType or a
2434/// non-sugared type.
2435template <> const TemplateSpecializationType *Type::getAs() const;

2437/// This will check for an AttributedType by removing any existing sugar
2438/// until it reaches an AttributedType or a non-sugared type.
2439template <> const AttributedType *Type::getAs() const;

2441// We can do canonical leaf types faster, because we don't have to
2442// worry about preserving child type decoration.
2443#define TYPE(Class, Base)
2444#define LEAF_TYPE(Class) \
2445template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2447} \
2448template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2450}
2451#include "clang/AST/TypeNodes.inc"

2453/// This class is used for builtin types like 'int'.  Builtin
2454/// types are always canonical and have a literal name field.
2455class BuiltinType : public Type {
2456public:
enum Kind {
2458// OpenCL image types
2459#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2460#include "clang/Basic/OpenCLImageTypes.def"
2461// OpenCL extension types
2462#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2463#include "clang/Basic/OpenCLExtensionTypes.def"
2464// SVE Types
2465#define SVE_TYPE(Name, Id, SingletonId) Id,
2466#include "clang/Basic/AArch64SVEACLETypes.def"
2467// All other builtin types
2468#define BUILTIN_TYPE(Id, SingletonId) Id,
2469#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2470#include "clang/AST/BuiltinTypes.def"
};

2473private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent),
           /*InstantiationDependent=*/(K == Dependent),
           /*VariablyModified=*/false,
           /*Unexpanded parameter pack=*/false) {
  BuiltinTypeBits.Kind = K;
}

2484public:
Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
StringRef getName(const PrintingPolicy &Policy) const;

const char *getNameAsCString(const PrintingPolicy &Policy) const {
  // The StringRef is null-terminated.
  StringRef str = getName(Policy);
  assert(!str.empty() && str.data()[str.size()] == '\0')((!str.empty() && str.data()[str.size()] == '\0') ? static_cast
<void> (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 2491, __PRETTY_FUNCTION__));
  return str.data();
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

bool isInteger() const {
  return getKind() >= Bool && getKind() <= Int128;
}

bool isSignedInteger() const {
  return getKind() >= Char_S && getKind() <= Int128;
}

bool isUnsignedInteger() const {
  return getKind() >= Bool && getKind() <= UInt128;
}

bool isFloatingPoint() const {
  return getKind() >= Half && getKind() <= Float128;
}

/// Determines whether the given kind corresponds to a placeholder type.
static bool isPlaceholderTypeKind(Kind K) {
  return K >= Overload;
}

/// Determines whether this type is a placeholder type, i.e. a type
/// which cannot appear in arbitrary positions in a fully-formed
/// expression.
bool isPlaceholderType() const {
  return isPlaceholderTypeKind(getKind());
}

/// Determines whether this type is a placeholder type other than
/// Overload.  Most placeholder types require only syntactic
/// information about their context in order to be resolved (e.g.
/// whether it is a call expression), which means they can (and
/// should) be resolved in an earlier "phase" of analysis.
/// Overload expressions sometimes pick up further information
/// from their context, like whether the context expects a
/// specific function-pointer type, and so frequently need
/// special treatment.
bool isNonOverloadPlaceholderType() const {
  return getKind() > Overload;
}

static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2540};

2542/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2543/// types (_Complex float etc) as well as the GCC integer complex extensions.
2544class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->isDependentType(),
           Element->isInstantiationDependentType(),
           Element->isVariablyModifiedType(),
           Element->containsUnexpandedParameterPack()),
      ElementType(Element) {}

2556public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
  ID.AddPointer(Element.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2571};

2573/// Sugar for parentheses used when specifying types.
2574class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->isDependentType(),
           InnerType->isInstantiationDependentType(),
           InnerType->isVariablyModifiedType(),
           InnerType->containsUnexpandedParameterPack()),
      Inner(InnerType) {}

2586public:
QualType getInnerType() const { return Inner; }

bool isSugared() const { return true; }
QualType desugar() const { return getInnerType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getInnerType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
  Inner.Profile(ID);
}

static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2601};

2603/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2604class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

2616public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if address spaces of pointers overlap.
/// OpenCL v2.0 defines conversion rules for pointers to different
/// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping
/// address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// CL2.0 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(const PointerType &other) const {
  Qualifiers thisQuals = PointeeType.getQualifiers();
  Qualifiers otherQuals = other.getPointeeType().getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return thisQuals.isAddressSpaceSupersetOf(otherQuals) ||
         otherQuals.isAddressSpaceSupersetOf(thisQuals);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2647};

2649/// Represents a type which was implicitly adjusted by the semantic
2650/// engine for arbitrary reasons.  For example, array and function types can
2651/// decay, and function types can have their calling conventions adjusted.
2652class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2656protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->isDependentType(),
           OriginalTy->isInstantiationDependentType(),
           OriginalTy->isVariablyModifiedType(),
           OriginalTy->containsUnexpandedParameterPack()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2667public:
QualType getOriginalType() const { return OriginalTy; }
QualType getAdjustedType() const { return AdjustedTy; }

bool isSugared() const { return true; }
QualType desugar() const { return AdjustedTy; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, OriginalTy, AdjustedTy);
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
  ID.AddPointer(Orig.getAsOpaquePtr());
  ID.AddPointer(New.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
}
2686};

2688/// Represents a pointer type decayed from an array or function type.
2689class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2695public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2701};

2703/// Pointer to a block type.
2704/// This type is to represent types syntactically represented as
2705/// "void (^)(int)", etc. Pointee is required to always be a function type.
2706class BlockPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

// Block is some kind of pointer type
QualType PointeeType;

BlockPointerType(QualType Pointee, QualType CanonicalCls)
    : Type(BlockPointer, CanonicalCls, Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

2719public:
// Get the pointee type. Pointee is required to always be a function type.
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
    Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
    ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == BlockPointer;
}
2737};

2739/// Base for LValueReferenceType and RValueReferenceType
2740class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2743protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->isDependentType(),
           Referencee->isInstantiationDependentType(),
           Referencee->isVariablyModifiedType(),
           Referencee->containsUnexpandedParameterPack()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2755public:
bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }

QualType getPointeeTypeAsWritten() const { return PointeeType; }

QualType getPointeeType() const {
  // FIXME: this might strip inner qualifiers; okay?
  const ReferenceType *T = this;
  while (T->isInnerRef())
    T = T->PointeeType->castAs<ReferenceType>();
  return T->PointeeType;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, PointeeType, isSpelledAsLValue());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Referencee,
                    bool SpelledAsLValue) {
  ID.AddPointer(Referencee.getAsOpaquePtr());
  ID.AddBoolean(SpelledAsLValue);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference ||
         T->getTypeClass() == RValueReference;
}
2784};

2786/// An lvalue reference type, per C++11 [dcl.ref].
2787class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2795public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2802};

2804/// An rvalue reference type, per C++11 [dcl.ref].
2805class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2811public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2818};

2820/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2821///
2822/// This includes both pointers to data members and pointer to member functions.
2823class MemberPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

/// The class of which the pointee is a member. Must ultimately be a
/// RecordType, but could be a typedef or a template parameter too.
const Type *Class;

MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
    : Type(MemberPointer, CanonicalPtr,
           Cls->isDependentType() || Pointee->isDependentType(),
           (Cls->isInstantiationDependentType() ||
            Pointee->isInstantiationDependentType()),
           Pointee->isVariablyModifiedType(),
           (Cls->containsUnexpandedParameterPack() ||
            Pointee->containsUnexpandedParameterPack())),
           PointeeType(Pointee), Class(Cls) {}

2842public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if the member type (i.e. the pointee type) is a
/// function type rather than a data-member type.
bool isMemberFunctionPointer() const {
  return PointeeType->isFunctionProtoType();
}

/// Returns true if the member type (i.e. the pointee type) is a
/// data type rather than a function type.
bool isMemberDataPointer() const {
  return !PointeeType->isFunctionProtoType();
}

const Type *getClass() const { return Class; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType(), getClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
                    const Type *Class) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
  ID.AddPointer(Class);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == MemberPointer;
}
2876};

2878/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2879class ArrayType : public Type, public llvm::FoldingSetNode {
2880public:
/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum ArraySizeModifier {
  Normal, Static, Star
};

2889private:
/// The element type of the array.
QualType ElementType;

2893protected:
friend class ASTContext; // ASTContext creates these.

ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
          unsigned tq, const Expr *sz = nullptr);

2899public:
QualType getElementType() const { return ElementType; }

ArraySizeModifier getSizeModifier() const {
  return ArraySizeModifier(ArrayTypeBits.SizeModifier);
}

Qualifiers getIndexTypeQualifiers() const {
  return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
}

unsigned getIndexTypeCVRQualifiers() const {
  return ArrayTypeBits.IndexTypeQuals;
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray ||
         T->getTypeClass() == VariableArray ||
         T->getTypeClass() == IncompleteArray ||
         T->getTypeClass() == DependentSizedArray;
}
2920};

2922/// Represents the canonical version of C arrays with a specified constant size.
2923/// For example, the canonical type for 'int A[4 + 4*100]' is a
2924/// ConstantArrayType where the element type is 'int' and the size is 404.
2925class ConstantArrayType final
  : public ArrayType,
    private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

llvm::APInt Size; // Allows us to unique the type.

ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
                  const Expr *sz, ArraySizeModifier sm, unsigned tq)
    : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
  ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
  if (ConstantArrayTypeBits.HasStoredSizeExpr) {
    assert(!can.isNull() && "canonical constant array should not have size")((!can.isNull() && "canonical constant array should not have size"
) ? static_cast<void> (0) : __assert_fail ("!can.isNull() && \"canonical constant array should not have size\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 2938, __PRETTY_FUNCTION__));
    *getTrailingObjects<const Expr*>() = sz;
  }
}

unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
  return ConstantArrayTypeBits.HasStoredSizeExpr;
}

2947public:
const llvm::APInt &getSize() const { return Size; }
const Expr *getSizeExpr() const {
  return ConstantArrayTypeBits.HasStoredSizeExpr
             ? *getTrailingObjects<const Expr *>()
             : nullptr;
}
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Determine the number of bits required to address a member of
// an array with the given element type and number of elements.
static unsigned getNumAddressingBits(const ASTContext &Context,
                                     QualType ElementType,
                                     const llvm::APInt &NumElements);

/// Determine the maximum number of active bits that an array's size
/// can require, which limits the maximum size of the array.
static unsigned getMaxSizeBits(const ASTContext &Context);

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
          getSizeModifier(), getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
                    QualType ET, const llvm::APInt &ArraySize,
                    const Expr *SizeExpr, ArraySizeModifier SizeMod,
                    unsigned TypeQuals);

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray;
}
2980};

2982/// Represents a C array with an unspecified size.  For example 'int A[]' has
2983/// an IncompleteArrayType where the element type is 'int' and the size is
2984/// unspecified.
2985class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq) {}

2992public:
friend class StmtIteratorBase;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == IncompleteArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSizeModifier(),
          getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    ArraySizeModifier SizeMod, unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}
3013};

3015/// Represents a C array with a specified size that is not an
3016/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3017/// Since the size expression is an arbitrary expression, we store it as such.
3018///
3019/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3020/// should not be: two lexically equivalent variable array types could mean
3021/// different things, for example, these variables do not have the same type
3022/// dynamically:
3023///
3024/// void foo(int x) {
3025///   int Y[x];
3026///   ++x;
3027///   int Z[x];
3028/// }
3029class VariableArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

/// An assignment-expression. VLA's are only permitted within
/// a function block.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

VariableArrayType(QualType et, QualType can, Expr *e,
                  ArraySizeModifier sm, unsigned tq,
                  SourceRange brackets)
    : ArrayType(VariableArray, et, can, sm, tq, e),
      SizeExpr((Stmt*) e), Brackets(brackets) {}

3045public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == VariableArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  llvm_unreachable("Cannot unique VariableArrayTypes.")::llvm::llvm_unreachable_internal("Cannot unique VariableArrayTypes."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3066);
}
3068};

3070/// Represents an array type in C++ whose size is a value-dependent expression.
3071///
3072/// For example:
3073/// \code
3074/// template<typename T, int Size>
3075/// class array {
3076///   T data[Size];
3077/// };
3078/// \endcode
3079///
3080/// For these types, we won't actually know what the array bound is
3081/// until template instantiation occurs, at which point this will
3082/// become either a ConstantArrayType or a VariableArrayType.
3083class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// An assignment expression that will instantiate to the
/// size of the array.
///
/// The expression itself might be null, in which case the array
/// type will have its size deduced from an initializer.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
                        Expr *e, ArraySizeModifier sm, unsigned tq,
                        SourceRange brackets);

3102public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(),
          getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ET, ArraySizeModifier SizeMod,
                    unsigned TypeQuals, Expr *E);
3130};

3132/// Represents an extended address space qualifier where the input address space
3133/// value is dependent. Non-dependent address spaces are not represented with a
3134/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3135///
3136/// For example:
3137/// \code
3138/// template<typename T, int AddrSpace>
3139/// class AddressSpace {
3140///   typedef T __attribute__((address_space(AddrSpace))) type;
3141/// }
3142/// \endcode
3143class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *AddrSpaceExpr;
QualType PointeeType;
SourceLocation loc;

DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
                          QualType can, Expr *AddrSpaceExpr,
                          SourceLocation loc);

3155public:
Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
QualType getPointeeType() const { return PointeeType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentAddressSpace;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType PointeeType, Expr *AddrSpaceExpr);
3173};

3175/// Represents an extended vector type where either the type or size is
3176/// dependent.
3177///
3178/// For example:
3179/// \code
3180/// template<typename T, int Size>
3181/// class vector {
3182///   typedef T __attribute__((ext_vector_type(Size))) type;
3183/// }
3184/// \endcode
3185class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *SizeExpr;

/// The element type of the array.
QualType ElementType;

SourceLocation loc;

DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
                            QualType can, Expr *SizeExpr, SourceLocation loc);

3199public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedExtVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *SizeExpr);
3217};


3220/// Represents a GCC generic vector type. This type is created using
3221/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3222/// bytes; or from an Altivec __vector or vector declaration.
3223/// Since the constructor takes the number of vector elements, the
3224/// client is responsible for converting the size into the number of elements.
3225class VectorType : public Type, public llvm::FoldingSetNode {
3226public:
enum VectorKind {
  /// not a target-specific vector type
  GenericVector,

  /// is AltiVec vector
  AltiVecVector,

  /// is AltiVec 'vector Pixel'
  AltiVecPixel,

  /// is AltiVec 'vector bool ...'
  AltiVecBool,

  /// is ARM Neon vector
  NeonVector,

  /// is ARM Neon polynomial vector
  NeonPolyVector
};

3247protected:
friend class ASTContext; // ASTContext creates these.

/// The element type of the vector.
QualType ElementType;

VectorType(QualType vecType, unsigned nElements, QualType canonType,
           VectorKind vecKind);

VectorType(TypeClass tc, QualType vecType, unsigned nElements,
           QualType canonType, VectorKind vecKind);

3259public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

static bool isVectorSizeTooLarge(unsigned NumElements) {
  return NumElements > VectorTypeBitfields::MaxNumElements;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

VectorKind getVectorKind() const {
  return VectorKind(VectorTypeBits.VecKind);
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumElements(),
          getTypeClass(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumElements, TypeClass TypeClass,
                    VectorKind VecKind) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumElements);
  ID.AddInteger(TypeClass);
  ID.AddInteger(VecKind);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
}
3291};

3293/// Represents a vector type where either the type or size is dependent.
3294////
3295/// For example:
3296/// \code
3297/// template<typename T, int Size>
3298/// class vector {
3299///   typedef T __attribute__((vector_size(Size))) type;
3300/// }
3301/// \endcode
3302class DependentVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
QualType ElementType;
Expr *SizeExpr;
SourceLocation Loc;

DependentVectorType(const ASTContext &Context, QualType ElementType,
                         QualType CanonType, Expr *SizeExpr,
                         SourceLocation Loc, VectorType::VectorKind vecKind);

3314public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return Loc; }
VectorType::VectorKind getVectorKind() const {
  return VectorType::VectorKind(VectorTypeBits.VecKind);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, const Expr *SizeExpr,
                    VectorType::VectorKind VecKind);
3336};

3338/// ExtVectorType - Extended vector type. This type is created using
3339/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341/// class enables syntactic extensions, like Vector Components for accessing
3342/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343/// Shading Language).
3344class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3350public:
static int getPointAccessorIdx(char c) {
  switch (c) {
  default: return -1;
  case 'x': case 'r': return 0;
  case 'y': case 'g': return 1;
  case 'z': case 'b': return 2;
  case 'w': case 'a': return 3;
  }
}

static int getNumericAccessorIdx(char c) {
  switch (c) {
    default: return -1;
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'A':
    case 'a': return 10;
    case 'B':
    case 'b': return 11;
    case 'C':
    case 'c': return 12;
    case 'D':
    case 'd': return 13;
    case 'E':
    case 'e': return 14;
    case 'F':
    case 'f': return 15;
  }
}

static int getAccessorIdx(char c, bool isNumericAccessor) {
  if (isNumericAccessor)
    return getNumericAccessorIdx(c);
  else
    return getPointAccessorIdx(c);
}

bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
  if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
    return unsigned(idx-1) < getNumElements();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ExtVector;
}
3408};

3410/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3411/// class of FunctionNoProtoType and FunctionProtoType.
3412class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3416public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type. This is only used by FunctionProtoType
/// but is in FunctionType to make this class available during the
/// specification of the bases of FunctionProtoType.
///
/// It makes sense to model language features this way when there's some
/// sort of parameter-specific override (such as an attribute) that
/// affects how the function is called.  For example, the ARC ns_consumed
/// attribute changes whether a parameter is passed at +0 (the default)
/// or +1 (ns_consumed).  This must be reflected in the function type,
/// but isn't really a change to the parameter type.
///
/// One serious disadvantage of modelling language features this way is
/// that they generally do not work with language features that attempt
/// to destructure types.  For example, template argument deduction will
/// not be able to match a parameter declared as
///   T (*)(U)
/// against an argument of type
///   void (*)(__attribute__((ns_consumed)) id)
/// because the substitution of T=void, U=id into the former will
/// not produce the latter.
class ExtParameterInfo {
  enum {
    ABIMask = 0x0F,
    IsConsumed = 0x10,
    HasPassObjSize = 0x20,
    IsNoEscape = 0x40,
  };
  unsigned char Data = 0;

public:
  ExtParameterInfo() = default;

  /// Return the ABI treatment of this parameter.
  ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
  ExtParameterInfo withABI(ParameterABI kind) const {
    ExtParameterInfo copy = *this;
    copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
    return copy;
  }

  /// Is this parameter considered "consumed" by Objective-C ARC?
  /// Consumed parameters must have retainable object type.
  bool isConsumed() const { return (Data & IsConsumed); }
  ExtParameterInfo withIsConsumed(bool consumed) const {
    ExtParameterInfo copy = *this;
    if (consumed)
      copy.Data |= IsConsumed;
    else
      copy.Data &= ~IsConsumed;
    return copy;
  }

  bool hasPassObjectSize() const { return Data & HasPassObjSize; }
  ExtParameterInfo withHasPassObjectSize() const {
    ExtParameterInfo Copy = *this;
    Copy.Data |= HasPassObjSize;
    return Copy;
  }

  bool isNoEscape() const { return Data & IsNoEscape; }
  ExtParameterInfo withIsNoEscape(bool NoEscape) const {
    ExtParameterInfo Copy = *this;
    if (NoEscape)
      Copy.Data |= IsNoEscape;
    else
      Copy.Data &= ~IsNoEscape;
    return Copy;
  }

  unsigned char getOpaqueValue() const { return Data; }
  static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
    ExtParameterInfo result;
    result.Data = data;
    return result;
  }

  friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data == rhs.Data;
  }

  friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data != rhs.Data;
  }
};

/// A class which abstracts out some details necessary for
/// making a call.
///
/// It is not actually used directly for storing this information in
/// a FunctionType, although FunctionType does currently use the
/// same bit-pattern.
///
// If you add a field (say Foo), other than the obvious places (both,
// constructors, compile failures), what you need to update is
// * Operator==
// * getFoo
// * withFoo
// * functionType. Add Foo, getFoo.
// * ASTContext::getFooType
// * ASTContext::mergeFunctionTypes
// * FunctionNoProtoType::Profile
// * FunctionProtoType::Profile
// * TypePrinter::PrintFunctionProto
// * AST read and write
// * Codegen
class ExtInfo {
  friend class FunctionType;

  // Feel free to rearrange or add bits, but if you go over 12,
  // you'll need to adjust both the Bits field below and
  // Type::FunctionTypeBitfields.

  //   |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|
  //   |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |
  //
  // regparm is either 0 (no regparm attribute) or the regparm value+1.
  enum { CallConvMask = 0x1F };
  enum { NoReturnMask = 0x20 };
  enum { ProducesResultMask = 0x40 };
  enum { NoCallerSavedRegsMask = 0x80 };
  enum { NoCfCheckMask = 0x800 };
  enum {
    RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask |
                    NoCallerSavedRegsMask | NoCfCheckMask),
    RegParmOffset = 8
  }; // Assumed to be the last field
  uint16_t Bits = CC_C;

  ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

 public:
   // Constructor with no defaults. Use this when you know that you
   // have all the elements (when reading an AST file for example).
   ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
           bool producesResult, bool noCallerSavedRegs, bool NoCfCheck) {
     assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(((!hasRegParm || regParm < 7) && "Invalid regparm value"
) ? static_cast<void> (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3553, __PRETTY_FUNCTION__));
     Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
            (producesResult ? ProducesResultMask : 0) |
            (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
            (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
            (NoCfCheck ? NoCfCheckMask : 0);
  }

  // Constructor with all defaults. Use when for example creating a
  // function known to use defaults.
  ExtInfo() = default;

  // Constructor with just the calling convention, which is an important part
  // of the canonical type.
  ExtInfo(CallingConv CC) : Bits(CC) {}

  bool getNoReturn() const { return Bits & NoReturnMask; }
  bool getProducesResult() const { return Bits & ProducesResultMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
    if (RegParm > 0)
      --RegParm;
    return RegParm;
  }

  CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }

  bool operator==(ExtInfo Other) const {
    return Bits == Other.Bits;
  }
  bool operator!=(ExtInfo Other) const {
    return Bits != Other.Bits;
  }

  // Note that we don't have setters. That is by design, use
  // the following with methods instead of mutating these objects.

  ExtInfo withNoReturn(bool noReturn) const {
    if (noReturn)
      return ExtInfo(Bits | NoReturnMask);
    else
      return ExtInfo(Bits & ~NoReturnMask);
  }

  ExtInfo withProducesResult(bool producesResult) const {
    if (producesResult)
      return ExtInfo(Bits | ProducesResultMask);
    else
      return ExtInfo(Bits & ~ProducesResultMask);
  }

  ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
    if (noCallerSavedRegs)
      return ExtInfo(Bits | NoCallerSavedRegsMask);
    else
      return ExtInfo(Bits & ~NoCallerSavedRegsMask);
  }

  ExtInfo withNoCfCheck(bool noCfCheck) const {
    if (noCfCheck)
      return ExtInfo(Bits | NoCfCheckMask);
    else
      return ExtInfo(Bits & ~NoCfCheckMask);
  }

  ExtInfo withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")((RegParm < 7 && "Invalid regparm value") ? static_cast
<void> (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3623, __PRETTY_FUNCTION__));
    return ExtInfo((Bits & ~RegParmMask) |
                   ((RegParm + 1) << RegParmOffset));
  }

  ExtInfo withCallingConv(CallingConv cc) const {
    return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
  }

  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.AddInteger(Bits);
  }
};

/// A simple holder for a QualType representing a type in an
/// exception specification. Unfortunately needed by FunctionProtoType
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };

/// A simple holder for various uncommon bits which do not fit in
/// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
/// alignment of subsequent objects in TrailingObjects. You must update
/// hasExtraBitfields in FunctionProtoType after adding extra data here.
struct alignas(void *) FunctionTypeExtraBitfields {
  /// The number of types in the exception specification.
  /// A whole unsigned is not needed here and according to
  /// [implimits] 8 bits would be enough here.
  unsigned NumExceptionType;
};

3653protected:
FunctionType(TypeClass tc, QualType res,
             QualType Canonical, bool Dependent,
             bool InstantiationDependent,
             bool VariablyModified, bool ContainsUnexpandedParameterPack,
             ExtInfo Info)
    : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
           ContainsUnexpandedParameterPack),
      ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3669public:
QualType getReturnType() const { return ResultType; }

bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
unsigned getRegParmType() const { return getExtInfo().getRegParm(); }

/// Determine whether this function type includes the GNU noreturn
/// attribute. The C++11 [[noreturn]] attribute does not affect the function
/// type.
bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }

CallingConv getCallConv() const { return getExtInfo().getCC(); }
ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }

static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
              "Const, volatile and restrict are assumed to be a subset of "
              "the fast qualifiers.");

bool isConst() const { return getFastTypeQuals().hasConst(); }
bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }

/// Determine the type of an expression that calls a function of
/// this type.
QualType getCallResultType(const ASTContext &Context) const {
  return getReturnType().getNonLValueExprType(Context);
}

static StringRef getNameForCallConv(CallingConv CC);

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto ||
         T->getTypeClass() == FunctionProto;
}
3703};

3705/// Represents a K&R-style 'int foo()' function, which has
3706/// no information available about its arguments.
3707class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   /*Dependent=*/false, /*InstantiationDependent=*/false,
                   Result->isVariablyModifiedType(),
                   /*ContainsUnexpandedParameterPack=*/false, Info) {}

3716public:
// No additional state past what FunctionType provides.

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReturnType(), getExtInfo());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
                    ExtInfo Info) {
  Info.Profile(ID);
  ID.AddPointer(ResultType.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto;
}
3735};

3737/// Represents a prototype with parameter type info, e.g.
3738/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3739/// parameters, not as having a single void parameter. Such a type can have
3740/// an exception specification, but this specification is not part of the
3741/// canonical type. FunctionProtoType has several trailing objects, some of
3742/// which optional. For more information about the trailing objects see
3743/// the first comment inside FunctionProtoType.
3744class FunctionProtoType final
  : public FunctionType,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<
        FunctionProtoType, QualType, SourceLocation,
        FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
        Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

// FunctionProtoType is followed by several trailing objects, some of
// which optional. They are in order:
//
// * An array of getNumParams() QualType holding the parameter types.
//   Always present. Note that for the vast majority of FunctionProtoType,
//   these will be the only trailing objects.
//
// * Optionally if the function is variadic, the SourceLocation of the
//   ellipsis.
//
// * Optionally if some extra data is stored in FunctionTypeExtraBitfields
//   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
//   a single FunctionTypeExtraBitfields. Present if and only if
//   hasExtraBitfields() is true.
//
// * Optionally exactly one of:
//   * an array of getNumExceptions() ExceptionType,
//   * a single Expr *,
//   * a pair of FunctionDecl *,
//   * a single FunctionDecl *
//   used to store information about the various types of exception
//   specification. See getExceptionSpecSize for the details.
//
// * Optionally an array of getNumParams() ExtParameterInfo holding
//   an ExtParameterInfo for each of the parameters. Present if and
//   only if hasExtParameterInfos() is true.
//
// * Optionally a Qualifiers object to represent extra qualifiers that can't
//   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
//   if hasExtQualifiers() is true.
//
// The optional FunctionTypeExtraBitfields has to be before the data
// related to the exception specification since it contains the number
// of exception types.
//
// We put the ExtParameterInfos last.  If all were equal, it would make
// more sense to put these before the exception specification, because
// it's much easier to skip past them compared to the elaborate switch
// required to skip the exception specification.  However, all is not
// equal; ExtParameterInfos are used to model very uncommon features,
// and it's better not to burden the more common paths.

3796public:
/// Holds information about the various types of exception specification.
/// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
/// used to group together the various bits of information about the
/// exception specification.
struct ExceptionSpecInfo {
  /// The kind of exception specification this is.
  ExceptionSpecificationType Type = EST_None;

  /// Explicitly-specified list of exception types.
  ArrayRef<QualType> Exceptions;

  /// Noexcept expression, if this is a computed noexcept specification.
  Expr *NoexceptExpr = nullptr;

  /// The function whose exception specification this is, for
  /// EST_Unevaluated and EST_Uninstantiated.
  FunctionDecl *SourceDecl = nullptr;

  /// The function template whose exception specification this is instantiated
  /// from, for EST_Uninstantiated.
  FunctionDecl *SourceTemplate = nullptr;

  ExceptionSpecInfo() = default;

  ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
};

/// Extra information about a function prototype. ExtProtoInfo is not
/// stored as such in FunctionProtoType but is used to group together
/// the various bits of extra information about a function prototype.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  Qualifiers TypeQuals;
  RefQualifierKind RefQualifier = RQ_None;
  ExceptionSpecInfo ExceptionSpec;
  const ExtParameterInfo *ExtParameterInfos = nullptr;
  SourceLocation EllipsisLoc;

  ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo(CallingConv CC)
      : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = ESI;
    return Result;
  }
};

3849private:
unsigned numTrailingObjects(OverloadToken<QualType>) const {
  return getNumParams();
}

unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
  return isVariadic();
}

unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
  return hasExtraBitfields();
}

unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
  return getExceptionSpecSize().NumExceptionType;
}

unsigned numTrailingObjects(OverloadToken<Expr *>) const {
  return getExceptionSpecSize().NumExprPtr;
}

unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
  return getExceptionSpecSize().NumFunctionDeclPtr;
}

unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
  return hasExtParameterInfos() ? getNumParams() : 0;
}

/// Determine whether there are any argument types that
/// contain an unexpanded parameter pack.
static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
                                               unsigned numArgs) {
  for (unsigned Idx = 0; Idx < numArgs; ++Idx)
    if (ArgArray[Idx]->containsUnexpandedParameterPack())
      return true;

  return false;
}

FunctionProtoType(QualType result, ArrayRef<QualType> params,
                  QualType canonical, const ExtProtoInfo &epi);

/// This struct is returned by getExceptionSpecSize and is used to
/// translate an ExceptionSpecificationType to the number and kind
/// of trailing objects related to the exception specification.
struct ExceptionSpecSizeHolder {
  unsigned NumExceptionType;
  unsigned NumExprPtr;
  unsigned NumFunctionDeclPtr;
};

/// Return the number and kind of trailing objects
/// related to the exception specification.
static ExceptionSpecSizeHolder
getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
  switch (EST) {
  case EST_None:
  case EST_DynamicNone:
  case EST_MSAny:
  case EST_BasicNoexcept:
  case EST_Unparsed:
  case EST_NoThrow:
    return {0, 0, 0};

  case EST_Dynamic:
    return {NumExceptions, 0, 0};

  case EST_DependentNoexcept:
  case EST_NoexceptFalse:
  case EST_NoexceptTrue:
    return {0, 1, 0};

  case EST_Uninstantiated:
    return {0, 0, 2};

  case EST_Unevaluated:
    return {0, 0, 1};
  }
  llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3928);
}

/// Return the number and kind of trailing objects
/// related to the exception specification.
ExceptionSpecSizeHolder getExceptionSpecSize() const {
  return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
static bool hasExtraBitfields(ExceptionSpecificationType EST) {
  // If the exception spec type is EST_Dynamic then we have > 0 exception
  // types and the exact number is stored in FunctionTypeExtraBitfields.
  return EST == EST_Dynamic;
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
bool hasExtraBitfields() const {
  return hasExtraBitfields(getExceptionSpecType());
}

bool hasExtQualifiers() const {
  return FunctionTypeBits.HasExtQuals;
}

3953public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((i < getNumParams() && "invalid parameter index")
 ? static_cast<void> (0) : __assert_fail ("i < getNumParams() && \"invalid parameter index\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3957, __PRETTY_FUNCTION__));
  return param_type_begin()[i];
}

ArrayRef<QualType> getParamTypes() const {
  return llvm::makeArrayRef(param_type_begin(), param_type_end());
}

ExtProtoInfo getExtProtoInfo() const {
  ExtProtoInfo EPI;
  EPI.ExtInfo = getExtInfo();
  EPI.Variadic = isVariadic();
  EPI.EllipsisLoc = getEllipsisLoc();
  EPI.HasTrailingReturn = hasTrailingReturn();
  EPI.ExceptionSpec = getExceptionSpecInfo();
  EPI.TypeQuals = getMethodQuals();
  EPI.RefQualifier = getRefQualifier();
  EPI.ExtParameterInfos = getExtParameterInfosOrNull();
  return EPI;
}

/// Get the kind of exception specification on this function.
ExceptionSpecificationType getExceptionSpecType() const {
  return static_cast<ExceptionSpecificationType>(
      FunctionTypeBits.ExceptionSpecType);
}

/// Return whether this function has any kind of exception spec.
bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }

/// Return whether this function has a dynamic (throw) exception spec.
bool hasDynamicExceptionSpec() const {
  return isDynamicExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a noexcept exception spec.
bool hasNoexceptExceptionSpec() const {
  return isNoexceptExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a dependent exception spec.
bool hasDependentExceptionSpec() const;

/// Return whether this function has an instantiation-dependent exception
/// spec.
bool hasInstantiationDependentExceptionSpec() const;

/// Return all the available information about this type's exception spec.
ExceptionSpecInfo getExceptionSpecInfo() const {
  ExceptionSpecInfo Result;
  Result.Type = getExceptionSpecType();
  if (Result.Type == EST_Dynamic) {
    Result.Exceptions = exceptions();
  } else if (isComputedNoexcept(Result.Type)) {
    Result.NoexceptExpr = getNoexceptExpr();
  } else if (Result.Type == EST_Uninstantiated) {
    Result.SourceDecl = getExceptionSpecDecl();
    Result.SourceTemplate = getExceptionSpecTemplate();
  } else if (Result.Type == EST_Unevaluated) {
    Result.SourceDecl = getExceptionSpecDecl();
  }
  return Result;
}

/// Return the number of types in the exception specification.
unsigned getNumExceptions() const {
  return getExceptionSpecType() == EST_Dynamic
             ? getTrailingObjects<FunctionTypeExtraBitfields>()
                   ->NumExceptionType
             : 0;
}

/// Return the ith exception type, where 0 <= i < getNumExceptions().
QualType getExceptionType(unsigned i) const {
  assert(i < getNumExceptions() && "Invalid exception number!")((i < getNumExceptions() && "Invalid exception number!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumExceptions() && \"Invalid exception number!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4031, __PRETTY_FUNCTION__));
  return exception_begin()[i];
}

/// Return the expression inside noexcept(expression), or a null pointer
/// if there is none (because the exception spec is not of this form).
Expr *getNoexceptExpr() const {
  if (!isComputedNoexcept(getExceptionSpecType()))
    return nullptr;
  return *getTrailingObjects<Expr *>();
}

/// If this function type has an exception specification which hasn't
/// been determined yet (either because it has not been evaluated or because
/// it has not been instantiated), this is the function whose exception
/// specification is represented by this type.
FunctionDecl *getExceptionSpecDecl() const {
  if (getExceptionSpecType() != EST_Uninstantiated &&
      getExceptionSpecType() != EST_Unevaluated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[0];
}

/// If this function type has an uninstantiated exception
/// specification, this is the function whose exception specification
/// should be instantiated to find the exception specification for
/// this type.
FunctionDecl *getExceptionSpecTemplate() const {
  if (getExceptionSpecType() != EST_Uninstantiated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow() const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
}

/// Whether this function prototype is variadic.
bool isVariadic() const { return FunctionTypeBits.Variadic; }

SourceLocation getEllipsisLoc() const {
  return isVariadic() ? *getTrailingObjects<SourceLocation>()
                      : SourceLocation();
}

/// Determines whether this function prototype contains a
/// parameter pack at the end.
///
/// A function template whose last parameter is a parameter pack can be
/// called with an arbitrary number of arguments, much like a variadic
/// function.
bool isTemplateVariadic() const;

/// Whether this function prototype has a trailing return type.
bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }

Qualifiers getMethodQuals() const {
  if (hasExtQualifiers())
    return *getTrailingObjects<Qualifiers>();
  else
    return getFastTypeQuals();
}

/// Retrieve the ref-qualifier associated with this function type.
RefQualifierKind getRefQualifier() const {
  return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
}

using param_type_iterator = const QualType *;
using param_type_range = llvm::iterator_range<param_type_iterator>;

param_type_range param_types() const {
  return param_type_range(param_type_begin(), param_type_end());
}

param_type_iterator param_type_begin() const {
  return getTrailingObjects<QualType>();
}

param_type_iterator param_type_end() const {
  return param_type_begin() + getNumParams();
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  return reinterpret_cast<exception_iterator>(
      getTrailingObjects<ExceptionType>());
}

exception_iterator exception_end() const {
  return exception_begin() + getNumExceptions();
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const {
  return FunctionTypeBits.HasExtParameterInfos;
}

ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())((hasExtParameterInfos()) ? static_cast<void> (0) : __assert_fail
 ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4143, __PRETTY_FUNCTION__));
  return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
                                    getNumParams());
}

/// Return a pointer to the beginning of the array of extra parameter
/// information, if present, or else null if none of the parameters
/// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
const ExtParameterInfo *getExtParameterInfosOrNull() const {
  if (!hasExtParameterInfos())
    return nullptr;
  return getTrailingObjects<ExtParameterInfo>();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4158, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4165, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4172, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void printExceptionSpecification(raw_ostream &OS,
                                 const PrintingPolicy &Policy) const;

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionProto;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                    param_type_iterator ArgTys, unsigned NumArgs,
                    const ExtProtoInfo &EPI, const ASTContext &Context,
                    bool Canonical);
4193};

4195/// Represents the dependent type named by a dependently-scoped
4196/// typename using declaration, e.g.
4197///   using typename Base<T>::foo;
4198///
4199/// Template instantiation turns these into the underlying type.
4200class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(), true, true, false,
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(const_cast<UnresolvedUsingTypenameDecl*>(D)) {}

4210public:
UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnresolvedUsing;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  return Profile(ID, Decl);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    UnresolvedUsingTypenameDecl *D) {
  ID.AddPointer(D);
}
4228};

4230class TypedefType : public Type {
TypedefNameDecl *Decl;

4233protected:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can)
    : Type(tc, can, can->isDependentType(),
           can->isInstantiationDependentType(),
           can->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(const_cast<TypedefNameDecl*>(D)) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4242, __PRETTY_FUNCTION__));
}

4245public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4252};

4254/// Sugar type that represents a type that was qualified by a qualifier written
4255/// as a macro invocation.
4256class MacroQualifiedType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType UnderlyingTy;
const IdentifierInfo *MacroII;

MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
                   const IdentifierInfo *MacroII)
    : Type(MacroQualified, CanonTy, UnderlyingTy->isDependentType(),
           UnderlyingTy->isInstantiationDependentType(),
           UnderlyingTy->isVariablyModifiedType(),
           UnderlyingTy->containsUnexpandedParameterPack()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4270, __PRETTY_FUNCTION__))
         "Expected a macro qualified type to only wrap attributed types.")((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4270, __PRETTY_FUNCTION__));
}

4273public:
const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
QualType getUnderlyingType() const { return UnderlyingTy; }

/// Return this attributed type's modified type with no qualifiers attached to
/// it.
QualType getModifiedType() const;

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == MacroQualified;
}
4287};

4289/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4290class TypeOfExprType : public Type {
Expr *TOExpr;

4293protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4298public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4308};

4310/// Internal representation of canonical, dependent
4311/// `typeof(expr)` types.
4312///
4313/// This class is used internally by the ASTContext to manage
4314/// canonical, dependent types, only. Clients will only see instances
4315/// of this class via TypeOfExprType nodes.
4316class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4320public:
DependentTypeOfExprType(const ASTContext &Context, Expr *E)
    : TypeOfExprType(E), Context(Context) {}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4330};

4332/// Represents `typeof(type)`, a GCC extension.
4333class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->isDependentType(),
           T->isInstantiationDependentType(),
           T->isVariablyModifiedType(),
           T->containsUnexpandedParameterPack()),
      TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4344, __PRETTY_FUNCTION__));
}

4347public:
QualType getUnderlyingType() const { return TOType; }

/// Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4357};

4359/// Represents the type `decltype(expr)` (C++11).
4360class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4364protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4369public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4380};

4382/// Internal representation of canonical, dependent
4383/// decltype(expr) types.
4384///
4385/// This class is used internally by the ASTContext to manage
4386/// canonical, dependent types, only. Clients will only see instances
4387/// of this class via DecltypeType nodes.
4388class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4391public:
DependentDecltypeType(const ASTContext &Context, Expr *E);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4400};

4402/// A unary type transform, which is a type constructed from another.
4403class UnaryTransformType : public Type {
4404public:
enum UTTKind {
  EnumUnderlyingType
};

4409private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4418protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4424public:
bool isSugared() const { return !isDependentType(); }
QualType desugar() const { return UnderlyingType; }

QualType getUnderlyingType() const { return UnderlyingType; }
QualType getBaseType() const { return BaseType; }

UTTKind getUTTKind() const { return UKind; }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnaryTransform;
}
4436};

4438/// Internal representation of canonical, dependent
4439/// __underlying_type(type) types.
4440///
4441/// This class is used internally by the ASTContext to manage
4442/// canonical, dependent types, only. Clients will only see instances
4443/// of this class via UnaryTransformType nodes.
4444class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4446public:
DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
                            UTTKind UKind);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getBaseType(), getUTTKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                    UTTKind UKind) {
  ID.AddPointer(BaseType.getAsOpaquePtr());
  ID.AddInteger((unsigned)UKind);
}
4459};

4461class TagType : public Type {
friend class ASTReader;
template <class T> friend class serialization::AbstractTypeReader;

/// Stores the TagDecl associated with this type. The decl may point to any
/// TagDecl that declares the entity.
TagDecl *decl;

4469protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4472public:
TagDecl *getDecl() const;

/// Determines whether this type is in the process of being defined.
bool isBeingDefined() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == Enum || T->getTypeClass() == Record;
}
4481};

4483/// A helper class that allows the use of isa/cast/dyncast
4484/// to detect TagType objects of structs/unions/classes.
4485class RecordType : public TagType {
4486protected:
friend class ASTContext; // ASTContext creates these.

explicit RecordType(const RecordDecl *D)
    : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
explicit RecordType(TypeClass TC, RecordDecl *D)
    : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4494public:
RecordDecl *getDecl() const {
  return reinterpret_cast<RecordDecl*>(TagType::getDecl());
}

/// Recursively check all fields in the record for const-ness. If any field
/// is declared const, return true. Otherwise, return false.
bool hasConstFields() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4507};

4509/// A helper class that allows the use of isa/cast/dyncast
4510/// to detect TagType objects of enums.
4511class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4517public:
EnumDecl *getDecl() const {
  return reinterpret_cast<EnumDecl*>(TagType::getDecl());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4526};

4528/// An attributed type is a type to which a type attribute has been applied.
4529///
4530/// The "modified type" is the fully-sugared type to which the attributed
4531/// type was applied; generally it is not canonically equivalent to the
4532/// attributed type. The "equivalent type" is the minimally-desugared type
4533/// which the type is canonically equivalent to.
4534///
4535/// For example, in the following attributed type:
4536///     int32_t __attribute__((vector_size(16)))
4537///   - the modified type is the TypedefType for int32_t
4538///   - the equivalent type is VectorType(16, int32_t)
4539///   - the canonical type is VectorType(16, int)
4540class AttributedType : public Type, public llvm::FoldingSetNode {
4541public:
using Kind = attr::Kind;

4544private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->isDependentType(),
           equivalent->isInstantiationDependentType(),
           equivalent->isVariablyModifiedType(),
           equivalent->containsUnexpandedParameterPack()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4560public:
Kind getAttrKind() const {
  return static_cast<Kind>(AttributedTypeBits.AttrKind);
}

QualType getModifiedType() const { return ModifiedType; }
QualType getEquivalentType() const { return EquivalentType; }

bool isSugared() const { return true; }
QualType desugar() const { return getEquivalentType(); }

/// Does this attribute behave like a type qualifier?
///
/// A type qualifier adjusts a type to provide specialized rules for
/// a specific object, like the standard const and volatile qualifiers.
/// This includes attributes controlling things like nullability,
/// address spaces, and ARC ownership.  The value of the object is still
/// largely described by the modified type.
///
/// In contrast, many type attributes "rewrite" their modified type to
/// produce a fundamentally different type, not necessarily related in any
/// formalizable way to the original type.  For example, calling convention
/// and vector attributes are not simple type qualifiers.
///
/// Type qualifiers are often, but not always, reflected in the canonical
/// type.
bool isQualifier() const;

bool isMSTypeSpec() const;

bool isCallingConv() const;

llvm::Optional<NullabilityKind> getImmediateNullability() const;

/// Retrieve the attribute kind corresponding to the given
/// nullability kind.
static Kind getNullabilityAttrKind(NullabilityKind kind) {
  switch (kind) {
  case NullabilityKind::NonNull:
    return attr::TypeNonNull;

  case NullabilityKind::Nullable:
    return attr::TypeNullable;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4607);
}

/// Strip off the top-level nullability annotation on the given
/// type, if it's there.
///
/// \param T The type to strip. If the type is exactly an
/// AttributedType specifying nullability (without looking through
/// type sugar), the nullability is returned and this type changed
/// to the underlying modified type.
///
/// \returns the top-level nullability, if present.
static Optional<NullabilityKind> stripOuterNullability(QualType &T);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
}

static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
                    QualType modified, QualType equivalent) {
  ID.AddInteger(attrKind);
  ID.AddPointer(modified.getAsOpaquePtr());
  ID.AddPointer(equivalent.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}
4635};

4637class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

// Helper data collector for canonical types.
struct CanonicalTTPTInfo {
  unsigned Depth : 15;
  unsigned ParameterPack : 1;
  unsigned Index : 16;
};

union {
  // Info for the canonical type.
  CanonicalTTPTInfo CanTTPTInfo;

  // Info for the non-canonical type.
  TemplateTypeParmDecl *TTPDecl;
};

/// Build a non-canonical type.
TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
    : Type(TemplateTypeParm, Canon, /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false,
           Canon->containsUnexpandedParameterPack()),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false, PP) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4679public:
unsigned getDepth() const { return getCanTTPTInfo().Depth; }
unsigned getIndex() const { return getCanTTPTInfo().Index; }
bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }

TemplateTypeParmDecl *getDecl() const {
  return isCanonicalUnqualified() ? nullptr : TTPDecl;
}

IdentifierInfo *getIdentifier() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
                    unsigned Index, bool ParameterPack,
                    TemplateTypeParmDecl *TTPDecl) {
  ID.AddInteger(Depth);
  ID.AddInteger(Index);
  ID.AddBoolean(ParameterPack);
  ID.AddPointer(TTPDecl);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateTypeParm;
}
4709};

4711/// Represents the result of substituting a type for a template
4712/// type parameter.
4713///
4714/// Within an instantiated template, all template type parameters have
4715/// been replaced with these.  They are used solely to record that a
4716/// type was originally written as a template type parameter;
4717/// therefore they are never canonical.
4718class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

// The original type parameter.
const TemplateTypeParmType *Replaced;

SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
    : Type(SubstTemplateTypeParm, Canon, Canon->isDependentType(),
           Canon->isInstantiationDependentType(),
           Canon->isVariablyModifiedType(),
           Canon->containsUnexpandedParameterPack()),
      Replaced(Param) {}

4731public:
/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

/// Gets the type that was substituted for the template
/// parameter.
QualType getReplacementType() const {
  return getCanonicalTypeInternal();
}

bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReplacedParameter(), getReplacementType());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    QualType Replacement) {
  ID.AddPointer(Replaced);
  ID.AddPointer(Replacement.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParm;
}
4760};

4762/// Represents the result of substituting a set of types for a template
4763/// type parameter pack.
4764///
4765/// When a pack expansion in the source code contains multiple parameter packs
4766/// and those parameter packs correspond to different levels of template
4767/// parameter lists, this type node is used to represent a template type
4768/// parameter pack from an outer level, which has already had its argument pack
4769/// substituted but that still lives within a pack expansion that itself
4770/// could not be instantiated. When actually performing a substitution into
4771/// that pack expansion (e.g., when all template parameters have corresponding
4772/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4773/// at the current pack substitution index.
4774class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// The original type parameter.
const TemplateTypeParmType *Replaced;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4788public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

unsigned getNumArgs() const {
  return SubstTemplateTypeParmPackTypeBits.NumArgs;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

TemplateArgument getArgumentPack() const;

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    const TemplateArgument &ArgPack);

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParmPack;
}
4813};

4815/// Common base class for placeholders for types that get replaced by
4816/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4817/// class template types, and (eventually) constrained type names from the C++
4818/// Concepts TS.
4819///
4820/// These types are usually a placeholder for a deduced type. However, before
4821/// the initializer is attached, or (usually) if the initializer is
4822/// type-dependent, there is no deduced type and the type is canonical. In
4823/// the latter case, it is also a dependent type.
4824class DeducedType : public Type {
4825protected:
DeducedType(TypeClass TC, QualType DeducedAsType, bool IsDependent,
            bool IsInstantiationDependent, bool ContainsParameterPack)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           IsDependent, IsInstantiationDependent,
           /*VariablyModified=*/false, ContainsParameterPack) {
  if (!DeducedAsType.isNull()) {
    if (DeducedAsType->isDependentType())
      setDependent();
    if (DeducedAsType->isInstantiationDependentType())
      setInstantiationDependent();
    if (DeducedAsType->containsUnexpandedParameterPack())
      setContainsUnexpandedParameterPack();
  }
}

4844public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// Get the type deduced for this placeholder type, or null if it's
/// either not been deduced or was deduced to a dependent type.
QualType getDeducedType() const {
  return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
}
bool isDeduced() const {
  return !isCanonicalUnqualified() || isDependentType();
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto ||
         T->getTypeClass() == DeducedTemplateSpecialization;
}
4861};

4863/// Represents a C++11 auto or C++14 decltype(auto) type.
4864class AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         bool IsDeducedAsDependent, bool IsDeducedAsPack)
    : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent,
                  IsDeducedAsDependent, IsDeducedAsPack) {
  AutoTypeBits.Keyword = (unsigned)Keyword;
}

4874public:
bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDeducedType(), getKeyword(), isDependentType(),
          containsUnexpandedParameterPack());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced,
                    AutoTypeKeyword Keyword, bool IsDependent, bool IsPack) {
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddInteger((unsigned)Keyword);
  ID.AddBoolean(IsDependent);
  ID.AddBoolean(IsPack);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
4899};

4901/// Represents a C++17 deduced template specialization type.
4902class DeducedTemplateSpecializationType : public DeducedType,
                                        public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template whose arguments will be deduced.
TemplateName Template;

DeducedTemplateSpecializationType(TemplateName Template,
                                  QualType DeducedAsType,
                                  bool IsDeducedAsDependent)
    : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                  IsDeducedAsDependent || Template.isDependent(),
                  IsDeducedAsDependent || Template.isInstantiationDependent(),
                  Template.containsUnexpandedParameterPack()),
      Template(Template) {}

4918public:
/// Retrieve the name of the template that we are deducing.
TemplateName getTemplateName() const { return Template;}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
                    QualType Deduced, bool IsDependent) {
  Template.Profile(ID);
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DeducedTemplateSpecialization;
}
4936};

4938/// Represents a type template specialization; the template
4939/// must be a class template, a type alias template, or a template
4940/// template parameter.  A template which cannot be resolved to one of
4941/// these, e.g. because it is written with a dependent scope
4942/// specifier, is instead represented as a
4943/// @c DependentTemplateSpecializationType.
4944///
4945/// A non-dependent template specialization type is always "sugar",
4946/// typically for a \c RecordType.  For example, a class template
4947/// specialization type of \c vector<int> will refer to a tag type for
4948/// the instantiation \c std::vector<int, std::allocator<int>>
4949///
4950/// Template specializations are dependent if either the template or
4951/// any of the template arguments are dependent, in which case the
4952/// type may also be canonical.
4953///
4954/// Instances of this type are allocated with a trailing array of
4955/// TemplateArguments, followed by a QualType representing the
4956/// non-canonical aliased type when the template is a type alias
4957/// template.
4958class alignas(8) TemplateSpecializationType
  : public Type,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template being specialized.  This is
/// either a TemplateName::Template (in which case it is a
/// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
/// TypeAliasTemplateDecl*), a
/// TemplateName::SubstTemplateTemplateParmPack, or a
/// TemplateName::SubstTemplateTemplateParm (in which case the
/// replacement must, recursively, be one of these).
TemplateName Template;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

4977public:
/// Determine whether any of the given template arguments are dependent.
static bool anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                                          bool &InstantiationDependent);

static bool anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                                          bool &InstantiationDependent);

/// True if this template specialization type matches a current
/// instantiation in the context in which it is found.
bool isCurrentInstantiation() const {
  return isa<InjectedClassNameType>(getCanonicalTypeInternal());
}

/// Determine if this template specialization type is for a type alias
/// template that has been substituted.
///
/// Nearly every template specialization type whose template is an alias
/// template will be substituted. However, this is not the case when
/// the specialization contains a pack expansion but the template alias
/// does not have a corresponding parameter pack, e.g.,
///
/// \code
/// template<typename T, typename U, typename V> struct S;
/// template<typename T, typename U> using A = S<T, int, U>;
/// template<typename... Ts> struct X {
///   typedef A<Ts...> type; // not a type alias
/// };
/// \endcode
bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }

/// Get the aliased type, if this is a specialization of a type alias
/// template.
QualType getAliasedType() const {
  assert(isTypeAlias() && "not a type alias template specialization")((isTypeAlias() && "not a type alias template specialization"
) ? static_cast<void> (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5011, __PRETTY_FUNCTION__));
  return *reinterpret_cast<const QualType*>(end());
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // defined inline in TemplateBase.h

/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return reinterpret_cast<const TemplateArgument *>(this + 1);
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return TemplateSpecializationTypeBits.NumArgs;
}

/// Retrieve a specific template argument as a type.
/// \pre \c isArgType(Arg)
const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const {
  return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Template, template_arguments(), Ctx);
  if (isTypeAlias())
    getAliasedType().Profile(ID);
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                    ArrayRef<TemplateArgument> Args,
                    const ASTContext &Context);

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateSpecialization;
}
5062};

5064/// Print a template argument list, including the '<' and '>'
5065/// enclosing the template arguments.
5066void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy);

5070void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy);

5074void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy);

5078/// The injected class name of a C++ class template or class
5079/// template partial specialization.  Used to record that a type was
5080/// spelled with a bare identifier rather than as a template-id; the
5081/// equivalent for non-templated classes is just RecordType.
5082///
5083/// Injected class name types are always dependent.  Template
5084/// instantiation turns these into RecordTypes.
5085///
5086/// Injected class name types are always canonical.  This works
5087/// because it is impossible to compare an injected class name type
5088/// with the corresponding non-injected template type, for the same
5089/// reason that it is impossible to directly compare template
5090/// parameters from different dependent contexts: injected class name
5091/// types can only occur within the scope of a particular templated
5092/// declaration, and within that scope every template specialization
5093/// will canonicalize to the injected class name (when appropriate
5094/// according to the rules of the language).
5095class InjectedClassNameType : public Type {
friend class ASTContext; // ASTContext creates these.
friend class ASTNodeImporter;
friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                        // currently suitable for AST reading, too much
                        // interdependencies.
template <class T> friend class serialization::AbstractTypeReader;

CXXRecordDecl *Decl;

/// The template specialization which this type represents.
/// For example, in
///   template <class T> class A { ... };
/// this is A<T>, whereas in
///   template <class X, class Y> class A<B<X,Y> > { ... };
/// this is A<B<X,Y> >.
///
/// It is always unqualified, always a template specialization type,
/// and always dependent.
QualType InjectedType;

InjectedClassNameType(CXXRecordDecl *D, QualType TST)
    : Type(InjectedClassName, QualType(), /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false,
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))((isa<TemplateSpecializationType>(TST)) ? static_cast<
void> (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5122, __PRETTY_FUNCTION__));
  assert(!TST.hasQualifiers())((!TST.hasQualifiers()) ? static_cast<void> (0) : __assert_fail
 ("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5123, __PRETTY_FUNCTION__));
  assert(TST->isDependentType())((TST->isDependentType()) ? static_cast<void> (0) : __assert_fail
 ("TST->isDependentType()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5124, __PRETTY_FUNCTION__));
}

5127public:
QualType getInjectedSpecializationType() const { return InjectedType; }

const TemplateSpecializationType *getInjectedTST() const {
  return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
}

TemplateName getTemplateName() const {
  return getInjectedTST()->getTemplateName();
}

CXXRecordDecl *getDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == InjectedClassName;
}
5146};

5148/// The kind of a tag type.
5149enum TagTypeKind {
/// The "struct" keyword.
TTK_Struct,

/// The "__interface" keyword.
TTK_Interface,

/// The "union" keyword.
TTK_Union,

/// The "class" keyword.
TTK_Class,

/// The "enum" keyword.
TTK_Enum
5164};

5166/// The elaboration keyword that precedes a qualified type name or
5167/// introduces an elaborated-type-specifier.
5168enum ElaboratedTypeKeyword {
/// The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// No keyword precedes the qualified type name.
ETK_None
5190};

5192/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5193/// The keyword in stored in the free bits of the base class.
5194/// Also provides a few static helpers for converting and printing
5195/// elaborated type keyword and tag type kind enumerations.
5196class TypeWithKeyword : public Type {
5197protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, bool Dependent,
                bool InstantiationDependent, bool VariablyModified,
                bool ContainsUnexpandedParameterPack)
    : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
           ContainsUnexpandedParameterPack) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5207public:
ElaboratedTypeKeyword getKeyword() const {
  return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
}

/// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);

/// Converts a type specifier (DeclSpec::TST) into a tag type kind.
/// It is an error to provide a type specifier which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);

/// Converts a TagTypeKind into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);

/// Converts an elaborated type keyword into a TagTypeKind.
/// It is an error to provide an elaborated type keyword
/// which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);

static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);

static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);

static StringRef getTagTypeKindName(TagTypeKind Kind) {
  return getKeywordName(getKeywordForTagTypeKind(Kind));
}

class CannotCastToThisType {};
static CannotCastToThisType classof(const Type *);
5237};

5239/// Represents a type that was referred to using an elaborated type
5240/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5241/// or both.
5242///
5243/// This type is used to keep track of a type name as written in the
5244/// source code, including tag keywords and any nested-name-specifiers.
5245/// The type itself is always "sugar", used to express what was written
5246/// in the source code but containing no additional semantic information.
5247class ElaboratedType final
  : public TypeWithKeyword,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
friend class ASTContext; // ASTContext creates these
friend TrailingObjects;

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

/// The (re)declaration of this tag type owned by this occurrence is stored
/// as a trailing object if there is one. Use getOwnedTagDecl to obtain
/// it, or obtain a null pointer if there is none.

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
    : TypeWithKeyword(Keyword, Elaborated, CanonType,
                      NamedType->isDependentType(),
                      NamedType->isInstantiationDependentType(),
                      NamedType->isVariablyModifiedType(),
                      NamedType->containsUnexpandedParameterPack()),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5279, __PRETTY_FUNCTION__))
         "ElaboratedType cannot have elaborated type keyword "((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5279, __PRETTY_FUNCTION__))
         "and name qualifier both null.")((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5279, __PRETTY_FUNCTION__));
}

5282public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the qualified-id.
QualType getNamedType() const { return NamedType; }

/// Remove a single level of sugar.
QualType desugar() const { return getNamedType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if there is none.
TagDecl *getOwnedTagDecl() const {
  return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
                                            : nullptr;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType,
                    TagDecl *OwnedTagDecl) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
  ID.AddPointer(OwnedTagDecl);
}

static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5316};

5318/// Represents a qualified type name for which the type name is
5319/// dependent.
5320///
5321/// DependentNameType represents a class of dependent types that involve a
5322/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5323/// name of a type. The DependentNameType may start with a "typename" (for a
5324/// typename-specifier), "class", "struct", "union", or "enum" (for a
5325/// dependent elaborated-type-specifier), or nothing (in contexts where we
5326/// know that we must be referring to a type, e.g., in a base class specifier).
5327/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5328/// mode, this type is used with non-dependent names to delay name lookup until
5329/// instantiation.
5330class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this typename specifier refers to.
const IdentifierInfo *Name;

DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
                  const IdentifierInfo *Name, QualType CanonType)
    : TypeWithKeyword(Keyword, DependentName, CanonType, /*Dependent=*/true,
                      /*InstantiationDependent=*/true,
                      /*VariablyModified=*/false,
                      NNS->containsUnexpandedParameterPack()),
      NNS(NNS), Name(Name) {}

5347public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the typename specifier as an identifier.
///
/// This routine will return a non-NULL identifier pointer when the
/// form of the original typename was terminated by an identifier,
/// e.g., "typename T::type".
const IdentifierInfo *getIdentifier() const {
  return Name;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, Name);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  ID.AddPointer(Name);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentName;
}
5377};

5379/// Represents a template specialization type whose template cannot be
5380/// resolved, e.g.
5381///   A<T>::template B<T>
5382class alignas(8) DependentTemplateSpecializationType
  : public TypeWithKeyword,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The identifier of the template.
const IdentifierInfo *Name;

DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                    NestedNameSpecifier *NNS,
                                    const IdentifierInfo *Name,
                                    ArrayRef<TemplateArgument> Args,
                                    QualType Canon);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

5407public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return DependentTemplateSpecializationTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // inline in TemplateBase.h

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const ASTContext &Context,
                    ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *Qualifier,
                    const IdentifierInfo *Name,
                    ArrayRef<TemplateArgument> Args);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentTemplateSpecialization;
}
5449};

5451/// Represents a pack expansion of types.
5452///
5453/// Pack expansions are part of C++11 variadic templates. A pack
5454/// expansion contains a pattern, which itself contains one or more
5455/// "unexpanded" parameter packs. When instantiated, a pack expansion
5456/// produces a series of types, each instantiated from the pattern of
5457/// the expansion, where the Ith instantiation of the pattern uses the
5458/// Ith arguments bound to each of the unexpanded parameter packs. The
5459/// pack expansion is considered to "expand" these unexpanded
5460/// parameter packs.
5461///
5462/// \code
5463/// template<typename ...Types> struct tuple;
5464///
5465/// template<typename ...Types>
5466/// struct tuple_of_references {
5467///   typedef tuple<Types&...> type;
5468/// };
5469/// \endcode
5470///
5471/// Here, the pack expansion \c Types&... is represented via a
5472/// PackExpansionType whose pattern is Types&.
5473class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The pattern of the pack expansion.
QualType Pattern;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(),
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/Pattern->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5490public:
/// Retrieve the pattern of this pack expansion, which is the
/// type that will be repeatedly instantiated when instantiating the
/// pack expansion itself.
QualType getPattern() const { return Pattern; }

/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (PackExpansionTypeBits.NumExpansions)
    return PackExpansionTypeBits.NumExpansions - 1;
  return None;
}

bool isSugared() const { return !Pattern->isDependentType(); }
QualType desugar() const { return isSugared() ? Pattern : QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPattern(), getNumExpansions());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
                    Optional<unsigned> NumExpansions) {
  ID.AddPointer(Pattern.getAsOpaquePtr());
  ID.AddBoolean(NumExpansions.hasValue());
  if (NumExpansions)
    ID.AddInteger(*NumExpansions);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == PackExpansion;
}
5522};

5524/// This class wraps the list of protocol qualifiers. For types that can
5525/// take ObjC protocol qualifers, they can subclass this class.
5526template <class T>
5527class ObjCProtocolQualifiers {
5528protected:
ObjCProtocolQualifiers() = default;

ObjCProtocolDecl * const *getProtocolStorage() const {
  return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
}

ObjCProtocolDecl **getProtocolStorage() {
  return static_cast<T*>(this)->getProtocolStorageImpl();
}

void setNumProtocols(unsigned N) {
  static_cast<T*>(this)->setNumProtocolsImpl(N);
}

void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
  setNumProtocols(protocols.size());
  assert(getNumProtocols() == protocols.size() &&((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5546, __PRETTY_FUNCTION__))
         "bitfield overflow in protocol count")((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5546, __PRETTY_FUNCTION__));
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5552public:
using qual_iterator = ObjCProtocolDecl * const *;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
qual_iterator qual_begin() const { return getProtocolStorage(); }
qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }

bool qual_empty() const { return getNumProtocols() == 0; }

/// Return the number of qualifying protocols in this type, or 0 if
/// there are none.
unsigned getNumProtocols() const {
  return static_cast<const T*>(this)->getNumProtocolsImpl();
}

/// Fetch a protocol by index.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  assert(I < getNumProtocols() && "Out-of-range protocol access")((I < getNumProtocols() && "Out-of-range protocol access"
) ? static_cast<void> (0) : __assert_fail ("I < getNumProtocols() && \"Out-of-range protocol access\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5570, __PRETTY_FUNCTION__));
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5578};

5580/// Represents a type parameter type in Objective C. It can take
5581/// a list of protocols.
5582class ObjCTypeParamType : public Type,
                        public ObjCProtocolQualifiers<ObjCTypeParamType>,
                        public llvm::FoldingSetNode {
friend class ASTContext;
friend class ObjCProtocolQualifiers<ObjCTypeParamType>;

/// The number of protocols stored on this type.
unsigned NumProtocols : 6;

ObjCTypeParamDecl *OTPDecl;

/// The protocols are stored after the ObjCTypeParamType node. In the
/// canonical type, the list of protocols are sorted alphabetically
/// and uniqued.
ObjCProtocolDecl **getProtocolStorageImpl();

/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return NumProtocols;
}

void setNumProtocolsImpl(unsigned N) {
  NumProtocols = N;
}

ObjCTypeParamType(const ObjCTypeParamDecl *D,
                  QualType can,
                  ArrayRef<ObjCProtocolDecl *> protocols);

5612public:
bool isSugared() const { return true; }
QualType desugar() const { return getCanonicalTypeInternal(); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCTypeParam;
}

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const ObjCTypeParamDecl *OTPDecl,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5626};

5628/// Represents a class type in Objective C.
5629///
5630/// Every Objective C type is a combination of a base type, a set of
5631/// type arguments (optional, for parameterized classes) and a list of
5632/// protocols.
5633///
5634/// Given the following declarations:
5635/// \code
5636///   \@class C<T>;
5637///   \@protocol P;
5638/// \endcode
5639///
5640/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5641/// with base C and no protocols.
5642///
5643/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5644/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5645/// protocol list.
5646/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5647/// and protocol list [P].
5648///
5649/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5650/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5651/// and no protocols.
5652///
5653/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5654/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5655/// this should get its own sugar class to better represent the source.
5656class ObjCObjectType : public Type,
                     public ObjCProtocolQualifiers<ObjCObjectType> {
friend class ObjCProtocolQualifiers<ObjCObjectType>;

// ObjCObjectType.NumTypeArgs - the number of type arguments stored
// after the ObjCObjectPointerType node.
// ObjCObjectType.NumProtocols - the number of protocols stored
// after the type arguments of ObjCObjectPointerType node.
//
// These protocols are those written directly on the type.  If
// protocol qualifiers ever become additive, the iterators will need
// to get kindof complicated.
//
// In the canonical object type, these are sorted alphabetically
// and uniqued.

/// Either a BuiltinType or an InterfaceType or sugar for either.
QualType BaseType;

/// Cached superclass type.
mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
  CachedSuperClassType;

QualType *getTypeArgStorage();
const QualType *getTypeArgStorage() const {
  return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
}

ObjCProtocolDecl **getProtocolStorageImpl();
/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return ObjCObjectTypeBits.NumProtocols;
}
void setNumProtocolsImpl(unsigned N) {
  ObjCObjectTypeBits.NumProtocols = N;
}

5694protected:
enum Nonce_ObjCInterface { Nonce_ObjCInterface };

ObjCObjectType(QualType Canonical, QualType Base,
               ArrayRef<QualType> typeArgs,
               ArrayRef<ObjCProtocolDecl *> protocols,
               bool isKindOf);

ObjCObjectType(enum Nonce_ObjCInterface)
      : Type(ObjCInterface, QualType(), false, false, false, false),
        BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5712public:
/// Gets the base type of this object type.  This is always (possibly
/// sugar for) one of:
///  - the 'id' builtin type (as opposed to the 'id' type visible to the
///    user, which is a typedef for an ObjCObjectPointerType)
///  - the 'Class' builtin type (same caveat)
///  - an ObjCObjectType (currently always an ObjCInterfaceType)
QualType getBaseType() const { return BaseType; }

bool isObjCId() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
}

bool isObjCClass() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
}

bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
bool isObjCUnqualifiedIdOrClass() const {
  if (!qual_empty()) return false;
  if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
    return T->getKind() == BuiltinType::ObjCId ||
           T->getKind() == BuiltinType::ObjCClass;
  return false;
}
bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }

/// Gets the interface declaration for this object type, if the base type
/// really is an interface.
ObjCInterfaceDecl *getInterface() const;

/// Determine whether this object type is "specialized", meaning
/// that it has type arguments.
bool isSpecialized() const;

/// Determine whether this object type was written with type arguments.
bool isSpecializedAsWritten() const {
  return ObjCObjectTypeBits.NumTypeArgs > 0;
}

/// Determine whether this object type is "unspecialized", meaning
/// that it has no type arguments.
bool isUnspecialized() const { return !isSpecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments of this object type (semantically).
ArrayRef<QualType> getTypeArgs() const;

/// Retrieve the type arguments of this object type as they were
/// written.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return llvm::makeArrayRef(getTypeArgStorage(),
                            ObjCObjectTypeBits.NumTypeArgs);
}

/// Whether this is a "__kindof" type as written.
bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }

/// Whether this ia a "__kindof" type (semantically).
bool isKindOfType() const;

/// Retrieve the type of the superclass of this object type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// specialization of the superclass type. Produces a null type if
/// there is no superclass.
QualType getSuperClassType() const {
  if (!CachedSuperClassType.getInt())
    computeSuperClassTypeSlow();

  assert(CachedSuperClassType.getInt() && "Superclass not set?")((CachedSuperClassType.getInt() && "Superclass not set?"
) ? static_cast<void> (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5788, __PRETTY_FUNCTION__));
  return QualType(CachedSuperClassType.getPointer(), 0);
}

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObject ||
         T->getTypeClass() == ObjCInterface;
}
5803};

5805/// A class providing a concrete implementation
5806/// of ObjCObjectType, so as to not increase the footprint of
5807/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5808/// system should not reference this type.
5809class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
friend class ASTContext;

// If anyone adds fields here, ObjCObjectType::getProtocolStorage()
// will need to be modified.

ObjCObjectTypeImpl(QualType Canonical, QualType Base,
                   ArrayRef<QualType> typeArgs,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   bool isKindOf)
    : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}

5821public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5828};

5830inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5832}

5834inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5837}

5839inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
5842}

5844/// Interfaces are the core concept in Objective-C for object oriented design.
5845/// They basically correspond to C++ classes.  There are two kinds of interface
5846/// types: normal interfaces like `NSString`, and qualified interfaces, which
5847/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
5848///
5849/// ObjCInterfaceType guarantees the following properties when considered
5850/// as a subtype of its superclass, ObjCObjectType:
5851///   - There are no protocol qualifiers.  To reinforce this, code which
5852///     tries to invoke the protocol methods via an ObjCInterfaceType will
5853///     fail to compile.
5854///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
5855///     T->getBaseType() == QualType(T, 0).
5856class ObjCInterfaceType : public ObjCObjectType {
friend class ASTContext; // ASTContext creates these.
friend class ASTReader;
friend class ObjCInterfaceDecl;
template <class T> friend class serialization::AbstractTypeReader;

mutable ObjCInterfaceDecl *Decl;

ObjCInterfaceType(const ObjCInterfaceDecl *D)
    : ObjCObjectType(Nonce_ObjCInterface),
      Decl(const_cast<ObjCInterfaceDecl*>(D)) {}

5868public:
/// Get the declaration of this interface.
ObjCInterfaceDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCInterface;
}

// Nonsense to "hide" certain members of ObjCObjectType within this
// class.  People asking for protocols on an ObjCInterfaceType are
// not going to get what they want: ObjCInterfaceTypes are
// guaranteed to have no protocols.
enum {
  qual_iterator,
  qual_begin,
  qual_end,
  getNumProtocols,
  getProtocol
};
5890};

5892inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
5902}

5904/// Represents a pointer to an Objective C object.
5905///
5906/// These are constructed from pointer declarators when the pointee type is
5907/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
5908/// types are typedefs for these, and the protocol-qualified types 'id<P>'
5909/// and 'Class<P>' are translated into these.
5910///
5911/// Pointers to pointers to Objective C objects are still PointerTypes;
5912/// only the first level of pointer gets it own type implementation.
5913class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical,
           Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

5926public:
/// Gets the type pointed to by this ObjC pointer.
/// The result will always be an ObjCObjectType or sugar thereof.
QualType getPointeeType() const { return PointeeType; }

/// Gets the type pointed to by this ObjC pointer.  Always returns non-null.
///
/// This method is equivalent to getPointeeType() except that
/// it discards any typedefs (or other sugar) between this
/// type and the "outermost" object type.  So for:
/// \code
///   \@class A; \@protocol P; \@protocol Q;
///   typedef A<P> AP;
///   typedef A A1;
///   typedef A1<P> A1P;
///   typedef A1P<Q> A1PQ;
/// \endcode
/// For 'A*', getObjectType() will return 'A'.
/// For 'A<P>*', getObjectType() will return 'A<P>'.
/// For 'AP*', getObjectType() will return 'A<P>'.
/// For 'A1*', getObjectType() will return 'A'.
/// For 'A1<P>*', getObjectType() will return 'A1<P>'.
/// For 'A1P*', getObjectType() will return 'A1<P>'.
/// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
///   adding protocols to a protocol-qualified base discards the
///   old qualifiers (for now).  But if it didn't, getObjectType()
///   would return 'A1P<Q>' (and we'd have to make iterating over
///   qualifiers more complicated).
const ObjCObjectType *getObjectType() const {
  return PointeeType->castAs<ObjCObjectType>();
}

/// If this pointer points to an Objective C
/// \@interface type, gets the type for that interface.  Any protocol
/// qualifiers on the interface are ignored.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
const ObjCInterfaceType *getInterfaceType() const;

/// If this pointer points to an Objective \@interface
/// type, gets the declaration for that interface.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
ObjCInterfaceDecl *getInterfaceDecl() const {
  return getObjectType()->getInterface();
}

/// True if this is equivalent to the 'id' type, i.e. if
/// its object type is the primitive 'id' type with no protocols.
bool isObjCIdType() const {
  return getObjectType()->isObjCUnqualifiedId();
}

/// True if this is equivalent to the 'Class' type,
/// i.e. if its object tive is the primitive 'Class' type with no protocols.
bool isObjCClassType() const {
  return getObjectType()->isObjCUnqualifiedClass();
}

/// True if this is equivalent to the 'id' or 'Class' type,
bool isObjCIdOrClassType() const {
  return getObjectType()->isObjCUnqualifiedIdOrClass();
}

/// True if this is equivalent to 'id<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedIdType() const {
  return getObjectType()->isObjCQualifiedId();
}

/// True if this is equivalent to 'Class<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedClassType() const {
  return getObjectType()->isObjCQualifiedClass();
}

/// Whether this is a "__kindof" type.
bool isKindOfType() const { return getObjectType()->isKindOfType(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecialized() const { return getObjectType()->isSpecialized(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecializedAsWritten() const {
  return getObjectType()->isSpecializedAsWritten();
}

/// Whether this type is unspecialized, meaning that is has no type arguments.
bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgs() const {
  return getObjectType()->getTypeArgs();
}

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return getObjectType()->getTypeArgsAsWritten();
}

/// An iterator over the qualifiers on the object type.  Provided
/// for convenience.  This will always iterate over the full set of
/// protocols on a type, not just those provided directly.
using qual_iterator = ObjCObjectType::qual_iterator;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }

qual_iterator qual_begin() const {
  return getObjectType()->qual_begin();
}

qual_iterator qual_end() const {
  return getObjectType()->qual_end();
}

bool qual_empty() const { return getObjectType()->qual_empty(); }

/// Return the number of qualifying protocols on the object type.
unsigned getNumProtocols() const {
  return getObjectType()->getNumProtocols();
}

/// Retrieve a qualifying protocol by index on the object type.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  return getObjectType()->getProtocol(I);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Retrieve the type of the superclass of this object pointer type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// pointer to a specialization of the superclass type. Produces a
/// null type if there is no superclass.
QualType getSuperClassType() const;

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
                               const ASTContext &ctx) const;

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObjectPointer;
}
6085};

6087class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->isDependentType(),
           ValTy->isInstantiationDependentType(),
           ValTy->isVariablyModifiedType(),
           ValTy->containsUnexpandedParameterPack()),
      ValueType(ValTy) {}

6099public:
/// Gets the type contained by this atomic type, i.e.
/// the type returned by performing an atomic load of this atomic type.
QualType getValueType() const { return ValueType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getValueType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Atomic;
}
6118};

6120/// PipeType - OpenCL20.
6121class PipeType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;
bool isRead;

PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
    : Type(Pipe, CanonicalPtr, elemType->isDependentType(),
           elemType->isInstantiationDependentType(),
           elemType->isVariablyModifiedType(),
           elemType->containsUnexpandedParameterPack()),
      ElementType(elemType), isRead(isRead) {}

6134public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }

QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), isReadOnly());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
  ID.AddPointer(T.getAsOpaquePtr());
  ID.AddBoolean(isRead);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Pipe;
}

bool isReadOnly() const { return isRead; }
6155};

6157/// A qualifier set is used to build a set of qualifiers.
6158class QualifierCollector : public Qualifiers {
6159public:
QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}

/// Collect any qualifiers on the given type and return an
/// unqualified type.  The qualifiers are assumed to be consistent
/// with those already in the type.
const Type *strip(QualType type) {
  addFastQualifiers(type.getLocalFastQualifiers());
  if (!type.hasLocalNonFastQualifiers())
    return type.getTypePtrUnsafe();

  const ExtQuals *extQuals = type.getExtQualsUnsafe();
  addConsistentQualifiers(extQuals->getQualifiers());
  return extQuals->getBaseType();
}

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, QualType QT) const;

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, const Type* T) const;
6180};

6182/// A container of type source information.
6183///
6184/// A client can read the relevant info using TypeLoc wrappers, e.g:
6185/// @code
6186/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6187/// TL.getBeginLoc().print(OS, SrcMgr);
6188/// @endcode
6189class alignas(8) TypeSourceInfo {
// Contains a memory block after the class, used for type source information,
// allocated by ASTContext.
friend class ASTContext;

QualType Ty;

TypeSourceInfo(QualType ty) : Ty(ty) {}

6198public:
/// Return the type wrapped by this type source info.
QualType getType() const { return Ty; }

/// Return the TypeLoc wrapper for the type source info.
TypeLoc getTypeLoc() const; // implemented in TypeLoc.h

/// Override the type stored in this TypeSourceInfo. Use with caution!
void overrideType(QualType T) { Ty = T; }
6207};

6209// Inline function definitions.

6211inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6216}

6218inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6220}

6222inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6224}

6226inline SplitQualType QualType::split() const {
if (!hasLocalNonFastQualifiers())
  return SplitQualType(getTypePtrUnsafe(),
                       Qualifiers::fromFastMask(getLocalFastQualifiers()));

const ExtQuals *eq = getExtQualsUnsafe();
Qualifiers qs = eq->getQualifiers();
qs.addFastQualifiers(getLocalFastQualifiers());
return SplitQualType(eq->getBaseType(), qs);
6235}

6237inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6243}

6245inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6249}

6251inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6255}

6257inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6260}

6262inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6264}

6266inline bool QualType::isCanonicalAsParam() const {
if (!isCanonical()) return false;
if (hasLocalQualifiers()) return false;

const Type *T = getTypePtr();
if (T->isVariablyModifiedType() && T->hasSizedVLAType())
  return false;

return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6275}

6277inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6280}

6282inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6285}


6288inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6291}

6293inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6296}

6298inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6303}

6305inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6310}

6312inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6314}

6316inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6318}

6320inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6322}

6324inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 6325, __PRETTY_FUNCTION__));
static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
              "Fast bits differ from CVR bits!");

// Fast path: we don't need to touch the slow qualifiers.
removeLocalFastQualifiers(Mask);
6331}

6333/// Check if this type has any address space qualifier.
6334inline bool QualType::hasAddressSpace() const {
return getQualifiers().hasAddressSpace();
6336}

6338/// Return the address space of this type.
6339inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6341}

6343/// Return the gc attribute of this type.
6344inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6346}

6348inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6352}

6354inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6358}

6360inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6364}

6366inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const auto *PT = t.getAs<PointerType>()) {
  if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const auto *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
6374}

6376inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6378}

6380/// Determine whether this type is more
6381/// qualified than the Other type. For example, "const volatile int"
6382/// is more qualified than "const int", "volatile int", and
6383/// "int". However, it is not more qualified than "const volatile
6384/// int".
6385inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6389}

6391/// Determine whether this type is at last
6392/// as qualified as the Other type. For example, "const volatile
6393/// int" is at least as qualified as "const int", "volatile int",
6394/// "int", and "const volatile int".
6395inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
Qualifiers OtherQuals = other.getQualifiers();

// Ignore __unaligned qualifier if this type is a void.
if (getUnqualifiedType()->isVoidType())
  OtherQuals.removeUnaligned();

return getQualifiers().compatiblyIncludes(OtherQuals);
6403}

6405/// If Type is a reference type (e.g., const
6406/// int&), returns the type that the reference refers to ("const
6407/// int"). Otherwise, returns the type itself. This routine is used
6408/// throughout Sema to implement C++ 5p6:
6409///
6410///   If an expression initially has the type "reference to T" (8.3.2,
6411///   8.5.3), the type is adjusted to "T" prior to any further
6412///   analysis, the expression designates the object or function
6413///   denoted by the reference, and the expression is an lvalue.
6414inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6419}

6421inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6424}

6426/// Tests whether the type is categorized as a fundamental type.
6427///
6428/// \returns True for types specified in C++0x [basic.fundamental].
6429inline bool Type::isFundamentalType() const {
return isVoidType() ||
       isNullPtrType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
6435}

6437/// Tests whether the type is categorized as a compound type.
6438///
6439/// \returns True for types specified in C++0x [basic.compound].
6440inline bool Type::isCompoundType() const {
// C++0x [basic.compound]p1:
//   Compound types can be constructed in the following ways:
//    -- arrays of objects of a given type [...];
return isArrayType() ||
//    -- functions, which have parameters of given types [...];
       isFunctionType() ||
//    -- pointers to void or objects or functions [...];
       isPointerType() ||
//    -- references to objects or functions of a given type. [...]
       isReferenceType() ||
//    -- classes containing a sequence of objects of various types, [...];
       isRecordType() ||
//    -- unions, which are classes capable of containing objects of different
//               types at different times;
       isUnionType() ||
//    -- enumerations, which comprise a set of named constant values. [...];
       isEnumeralType() ||
//    -- pointers to non-static class members, [...].
       isMemberPointerType();
6460}

6462inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6464}

6466inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6468}

6470inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6472}

6474inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6476}

6478inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6480}

6482inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6484}

6486inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6488}

6490inline bool Type::isObjectPointerType() const {
// Note: an "object pointer type" is not the same thing as a pointer to an
// object type; rather, it is a pointer to an object type or a pointer to cv
// void.
if (const auto *T = getAs<PointerType>())
  return !T->getPointeeType()->isFunctionType();
else
  return false;
6498}

6500inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6505}

6507inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6512}

6514inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6516}

6518inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6523}

6525inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6530}

6532inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6534}

6536inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6538}

6540inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6542}

6544inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6546}

6548inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6550}

6552inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6554}

6556inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6558}

6560inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6562}

6564inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
5
←
Assuming field 'CanonicalType' is not a 'ComplexType'→
6
←
Returning zero, which participates in a condition later→
9
←
Assuming field 'CanonicalType' is not a 'ComplexType'→
10
←
Returning zero, which participates in a condition later→
6566}

6568inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6570}

6572inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6574}

6576inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6578}

6580inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6582}

6584inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6586}

6588inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6591}

6593inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6595}

6597inline bool Type::isUndeducedAutoType() const {
return isa<AutoType>(CanonicalType);
6599}

6601inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6605}

6607inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6611}

6613inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6617}

6619inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6623}

6625inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6629}

6631inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6633}

6635inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6637}

6639#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6643#include "clang/Basic/OpenCLImageTypes.def"

6645inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6647}

6649inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6651}

6653inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6655}

6657inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6659}

6661inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6663}

6665inline bool Type::isImageType() const {
6666#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6668#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6670}

6672inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6674}

6676#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6680#include "clang/Basic/OpenCLExtensionTypes.def"

6682inline bool Type::isOCLIntelSubgroupAVCType() const {
6683#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6686#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6688}

6690inline bool Type::isOCLExtOpaqueType() const {
6691#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6693#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6695}

6697inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6700}

6702inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6704}

6706inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>())
  if (BT->getKind() == (BuiltinType::Kind) K)
    return true;
return false;
6711}

6713inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6717}

6719inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6724}

6726inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)) ?
 static_cast<void> (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 6727, __PRETTY_FUNCTION__));
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return (BT->getKind() == (BuiltinType::Kind) K);
return false;
6731}

6733inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6737}

6739inline bool Type::isVoidType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Void;
return false;
6743}

6745inline bool Type::isHalfType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Half;
// FIXME: Should we allow complex __fp16? Probably not.
return false;
6750}

6752inline bool Type::isFloat16Type() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float16;
return false;
6756}

6758inline bool Type::isFloat128Type() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float128;
return false;
6762}

6764inline bool Type::isNullPtrType() const {
if (const auto *BT = getAs<BuiltinType>())
  return BT->getKind() == BuiltinType::NullPtr;
return false;
6768}

6770bool IsEnumDeclComplete(EnumDecl *);
6771bool IsEnumDeclScoped(EnumDecl *);

6773inline bool Type::isIntegerType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
  // Incomplete enum types are not treated as integer types.
  // FIXME: In C++, enum types are never integer types.
  return IsEnumDeclComplete(ET->getDecl()) &&
    !IsEnumDeclScoped(ET->getDecl());
}
return false;
6784}

6786inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
6792}

6794inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
6796}

6798inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
6804}

6806inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
6808}

6810inline bool Type::isSignedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return ((BT->getKind() >= BuiltinType::ShortAccum &&
           BT->getKind() <= BuiltinType::LongAccum) ||
          (BT->getKind() >= BuiltinType::ShortFract &&
           BT->getKind() <= BuiltinType::LongFract) ||
          (BT->getKind() >= BuiltinType::SatShortAccum &&
           BT->getKind() <= BuiltinType::SatLongAccum) ||
          (BT->getKind() >= BuiltinType::SatShortFract &&
           BT->getKind() <= BuiltinType::SatLongFract));
}
return false;
6822}

6824inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
6826}

6828inline bool Type::isScalarType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() > BuiltinType::Void &&
         BT->getKind() <= BuiltinType::NullPtr;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  // Enums are scalar types, but only if they are defined.  Incomplete enums
  // are not treated as scalar types.
  return IsEnumDeclComplete(ET->getDecl());
return isa<PointerType>(CanonicalType) ||
       isa<BlockPointerType>(CanonicalType) ||
       isa<MemberPointerType>(CanonicalType) ||
       isa<ComplexType>(CanonicalType) ||
       isa<ObjCObjectPointerType>(CanonicalType);
6841}

6843inline bool Type::isIntegralOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;

// Check for a complete enum type; incomplete enum types are not properly an
// enumeration type in the sense required here.
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return false;
6854}

6856inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
6860}

6862inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
6865}

6867/// Determines whether this is a type for which one can define
6868/// an overloaded operator.
6869inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
6871}

6873/// Determines whether this type can decay to a pointer type.
6874inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
6876}

6878inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
6881}

6883inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
6885}

6887inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
6892}

6894inline const Type *Type::getPointeeOrArrayElementType() const {
const Type *type = this;
if (type->isAnyPointerType())
  return type->getPointeeType().getTypePtr();
else if (type->isArrayType())
  return type->getBaseElementTypeUnsafe();
return type;
6901}
6902/// Insertion operator for diagnostics. This allows sending address spaces into
6903/// a diagnostic with <<.
6904inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         LangAS AS) {
DB.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return DB;
6909}

6911/// Insertion operator for partial diagnostics. This allows sending adress
6912/// spaces into a diagnostic with <<.
6913inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         LangAS AS) {
PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return PD;
6918}

6920/// Insertion operator for diagnostics. This allows sending Qualifiers into a
6921/// diagnostic with <<.
6922inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         Qualifiers Q) {
DB.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return DB;
6927}

6929/// Insertion operator for partial diagnostics. This allows sending Qualifiers
6930/// into a diagnostic with <<.
6931inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
6936}

6938/// Insertion operator for diagnostics.  This allows sending QualType's into a
6939/// diagnostic with <<.
6940inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         QualType T) {
DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return DB;
6945}

6947/// Insertion operator for partial diagnostics.  This allows sending QualType's
6948/// into a diagnostic with <<.
6949inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
6954}

6956// Helper class template that is used by Type::getAs to ensure that one does
6957// not try to look through a qualified type to get to an array type.
6958template <typename T>
6959using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

6963// Member-template getAs<specific type>'.
6964template <typename T> const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with getAs!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
6979}

6981template <typename T> const T *Type::getAsAdjusted() const {
static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// Strip off type adjustments that do not modify the underlying nature of the
// type.
const Type *Ty = this;
while (Ty) {
  if (const auto *A = dyn_cast<AttributedType>(Ty))
    Ty = A->getModifiedType().getTypePtr();
  else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
    Ty = E->desugar().getTypePtr();
  else if (const auto *P = dyn_cast<ParenType>(Ty))
    Ty = P->desugar().getTypePtr();
  else if (const auto *A = dyn_cast<AdjustedType>(Ty))
    Ty = A->desugar().getTypePtr();
  else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
    Ty = M->desugar().getTypePtr();
  else
    break;
}

// Just because the canonical type is correct does not mean we can use cast<>,
// since we may not have stripped off all the sugar down to the base type.
return dyn_cast<T>(Ty);
7013}

7015inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const auto *arr = dyn_cast<ArrayType>(this))
  return arr;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<ArrayType>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType());
7027}

7029template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const auto *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))((isa<T>(CanonicalType)) ? static_cast<void> (0) :
 __assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 7034, __PRETTY_FUNCTION__));
return cast<T>(getUnqualifiedDesugaredType());
7036}

7038inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((isa<ArrayType>(CanonicalType)) ? static_cast<void>
 (0) : __assert_fail ("isa<ArrayType>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 7039, __PRETTY_FUNCTION__));
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
7042}

7044DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7047#ifndef NDEBUG
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((isa<PointerType>(Adjusted)) ? static_cast<void>
 (0) : __assert_fail ("isa<PointerType>(Adjusted)", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 7050, __PRETTY_FUNCTION__));
7051#endif
7052}

7054QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
7058}

7060// Get the decimal string representation of a fixed point type, represented
7061// as a scaled integer.
7062// TODO: At some point, we should change the arguments to instead just accept an
7063// APFixedPoint instead of APSInt and scale.
7064void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

7067} // namespace clang

7069#endif // LLVM_CLANG_AST_TYPE_H