/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include/llvm/IR/Instructions.h

Bug Summary

File:	src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include/llvm/IR/Instructions.h
Warning:	line 1259, column 33 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name 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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGExprScalar.cpp

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/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/TargetInfo.h"
30#include "llvm/ADT/APFixedPoint.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/FixedPointBuilder.h"
36#include "llvm/IR/Function.h"
37#include "llvm/IR/GetElementPtrTypeIterator.h"
38#include "llvm/IR/GlobalVariable.h"
39#include "llvm/IR/Intrinsics.h"
40#include "llvm/IR/IntrinsicsPowerPC.h"
41#include "llvm/IR/MatrixBuilder.h"
42#include "llvm/IR/Module.h"
43#include <cstdarg>

45using namespace clang;
46using namespace CodeGen;
47using llvm::Value;

49//===----------------------------------------------------------------------===//
50//                         Scalar Expression Emitter
51//===----------------------------------------------------------------------===//

53namespace {

55/// Determine whether the given binary operation may overflow.
56/// Sets \p Result to the value of the operation for BO_Add, BO_Sub, BO_Mul,
57/// and signed BO_{Div,Rem}. For these opcodes, and for unsigned BO_{Div,Rem},
58/// the returned overflow check is precise. The returned value is 'true' for
59/// all other opcodes, to be conservative.
60bool 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;
89}

91struct 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 at least one operand is a fixed point type. In such cases, this
/// operation did not follow usual arithmetic conversion and both operands
/// might not be of the same type.
bool isFixedPointOp() 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();
  }
  if (const auto *UnOp = dyn_cast<UnaryOperator>(E))
    return UnOp->getSubExpr()->getType()->isFixedPointType();
  return false;
}
149};

151static 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();
156}

158/// If \p E is a widened promoted integer, get its base (unpromoted) type.
159static 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;
171}

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

178/// Check if we can skip the overflow check for \p Op.
179static bool CanElideOverflowCheck(const ASTContext &Ctx, const BinOpInfo &Op) {
assert((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) &&((void)0)
       "Expected a unary or binary operator")((void)0);

// 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;
217}

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

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 *EmitScalarCast(Value *Src, QualType SrcType, QualType DstType,
                      llvm::Type *SrcTy, llvm::Type *DstTy,
                      ScalarConversionOpts Opts);
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);

/// 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(llvm::errs(), CGF.getContext());
  llvm_unreachable("Stmt can't have complex result type!")__builtin_unreachable();
}
Value *VisitExpr(Expr *S);

Value *VisitConstantExpr(ConstantExpr *E) {
  if (Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
    if (E->isGLValue())
      return CGF.Builder.CreateLoad(Address(
          Result, CGF.getContext().getTypeAlignInChars(E->getType())));
    return Result;
  }
  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 *VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E);

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);

  return CGF.EmitBuiltinAvailable(Version);
}

Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
Value *VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E);
Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E);
Value *VisitConvertVectorExpr(ConvertVectorExpr *E);
Value *VisitMemberExpr(MemberExpr *E);
Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
  // Strictly speaking, we shouldn't be calling EmitLoadOfLValue, which
  // transitively calls EmitCompoundLiteralLValue, here in C++ since compound
  // literals aren't l-values in C++. We do so simply because that's the
  // cleanest way to handle compound literals in C++.
  // See the discussion here: https://reviews.llvm.org/D64464
  return EmitLoadOfLValue(E);
}

Value *VisitInitListExpr(InitListExpr *E);

Value *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
  assert(CGF.getArrayInitIndex() &&((void)0)
         "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?")((void)0);
  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 *VisitRequiresExpr(const RequiresExpr *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->isConstantMatrixType()) {
    llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
    // We need to check the types of the operands of the operator to get the
    // correct matrix dimensions.
    auto *BO = cast<BinaryOperator>(Ops.E);
    auto *LHSMatTy = dyn_cast<ConstantMatrixType>(
        BO->getLHS()->getType().getCanonicalType());
    auto *RHSMatTy = dyn_cast<ConstantMatrixType>(
        BO->getRHS()->getType().getCanonicalType());
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
    if (LHSMatTy && RHSMatTy)
      return MB.CreateMatrixMultiply(Ops.LHS, Ops.RHS, LHSMatTy->getNumRows(),
                                     LHSMatTy->getNumColumns(),
                                     RHSMatTy->getNumColumns());
    return MB.CreateScalarMultiply(Ops.LHS, Ops.RHS);
  }

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

  if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
    //  Preserve the old values
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
    return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
  }
  if (Ops.isFixedPointOp())
    return EmitFixedPointBinOp(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);

// Used for shifting constraints for OpenCL, do mask for powers of 2, URem for
// non powers of two.
Value *ConstrainShiftValue(Value *LHS, Value *RHS, const Twine &Name);

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.
801#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)
818#undef HANDLEBINOP

// Comparisons.
Value *EmitCompare(const BinaryOperator *E, llvm::CmpInst::Predicate UICmpOpc,
                   llvm::CmpInst::Predicate SICmpOpc,
                   llvm::CmpInst::Predicate FCmpOpc, bool IsSignaling);
824#define VISITCOMP(CODE, UI, SI, FP, SIG) \
  Value *VisitBin##CODE(const BinaryOperator *E) { \
    return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
                       llvm::FCmpInst::FP, SIG); }
VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT, true)
VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT, true)
VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE, true)
VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE, true)
VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ, false)
VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE, false)
834#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);
868};
869}  // end anonymous namespace.

871//===----------------------------------------------------------------------===//
872//                                Utilities
873//===----------------------------------------------------------------------===//

875/// EmitConversionToBool - Convert the specified expression value to a
876/// boolean (i1) truth value.  This is equivalent to "Val != 0".
877Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs")((void)0);

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())) &&((void)0)
       "Unknown scalar type to convert")((void)0);

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

assert(isa<llvm::PointerType>(Src->getType()))((void)0);
return EmitPointerToBoolConversion(Src, SrcType);
894}

896void 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")((void)0);
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);
962}

964// Should be called within CodeGenFunction::SanitizerScope RAII scope.
965// Returns 'i1 false' when the truncation Src -> Dst was lossy.
966static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
               std::pair<llvm::Value *, SanitizerMask>>
968EmitIntegerTruncationCheckHelper(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)((void)0);
assert(SrcTy->getScalarSizeInBits() > Dst->getType()->getScalarSizeInBits())((void)0);
assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&((void)0)
       "non-integer llvm type")((void)0);

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));
1002}

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

1009void 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.")((void)0);

// 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});
1056}

1058// Should be called within CodeGenFunction::SanitizerScope RAII scope.
1059// Returns 'i1 false' when the conversion Src -> Dst changed the sign.
1060static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
               std::pair<llvm::Value *, SanitizerMask>>
1062EmitIntegerSignChangeCheckHelper(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) &&((void)0)
       "non-integer llvm type")((void)0);

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)) &&((void)0)
       "either the widths should be different, or the signednesses.")((void)0);

// 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));
1116}

1118void 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});
1198}

1200Value *ScalarExprEmitter::EmitScalarCast(Value *Src, QualType SrcType,
                                       QualType DstType, llvm::Type *SrcTy,
                                       llvm::Type *DstTy,
                                       ScalarConversionOpts Opts) {
// The Element types determine the type of cast to perform.
llvm::Type *SrcElementTy;
llvm::Type *DstElementTy;
QualType SrcElementType;
QualType DstElementType;
if (SrcType->isMatrixType() && DstType->isMatrixType()) {
  SrcElementTy = cast<llvm::VectorType>(SrcTy)->getElementType();
  DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
  SrcElementType = SrcType->castAs<MatrixType>()->getElementType();
  DstElementType = DstType->castAs<MatrixType>()->getElementType();
} else {
  assert(!SrcType->isMatrixType() && !DstType->isMatrixType() &&((void)0)
         "cannot cast between matrix and non-matrix types")((void)0);
  SrcElementTy = SrcTy;
  DstElementTy = DstTy;
  SrcElementType = SrcType;
  DstElementType = DstType;
}

if (isa<llvm::IntegerType>(SrcElementTy)) {
  bool InputSigned = SrcElementType->isSignedIntegerOrEnumerationType();
  if (SrcElementType->isBooleanType() && Opts.TreatBooleanAsSigned) {
    InputSigned = true;
  }

  if (isa<llvm::IntegerType>(DstElementTy))
    return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
  if (InputSigned)
    return Builder.CreateSIToFP(Src, DstTy, "conv");
  return Builder.CreateUIToFP(Src, DstTy, "conv");
}

if (isa<llvm::IntegerType>(DstElementTy)) {
  assert(SrcElementTy->isFloatingPointTy() && "Unknown real conversion")((void)0);
  if (DstElementType->isSignedIntegerOrEnumerationType())
    return Builder.CreateFPToSI(Src, DstTy, "conv");
  return Builder.CreateFPToUI(Src, DstTy, "conv");
}

if (DstElementTy->getTypeID() < SrcElementTy->getTypeID())
  return Builder.CreateFPTrunc(Src, DstTy, "conv");
return Builder.CreateFPExt(Src, DstTy, "conv");
1246}

1248/// Emit a conversion from the specified type to the specified destination type,
1249/// both of which are LLVM scalar types.
1250Value *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() ||
      DstType->isRealFloatingType())
    return EmitFixedPointConversion(Src, SrcType, DstType, Loc);

  llvm_unreachable(__builtin_unreachable()
      "Unhandled scalar conversion from a fixed point type to another type.")__builtin_unreachable();
} else if (DstType->isFixedPointType()) {
  if (SrcType->isIntegerType() || SrcType->isRealFloatingType())
    // This also includes converting booleans and enums to fixed point types.
    return EmitFixedPointConversion(Src, SrcType, DstType, Loc);

  llvm_unreachable(__builtin_unreachable()
      "Unhandled scalar conversion to a fixed point type from another type.")__builtin_unreachable();
}

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?")((void)0);
  // 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?")((void)0);
  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() ==((void)0)
             SrcType.getTypePtr() &&((void)0)
         "Splatted expr doesn't match with vector element type?")((void)0);

  // Splat the element across to all elements
  unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
  return Builder.CreateVectorSplat(NumElements, Src, "splat");
}

if (SrcType->isMatrixType() && DstType->isMatrixType())
  return EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);

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 = cast<llvm::VectorType>(SrcTy)->getElementType();
  llvm::Type *DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
  (void)DstElementTy;

  assert(((SrcElementTy->isIntegerTy() &&((void)0)
           DstElementTy->isIntegerTy()) ||((void)0)
          (SrcElementTy->isFloatingPointTy() &&((void)0)
           DstElementTy->isFloatingPointTy())) &&((void)0)
         "unexpected conversion between a floating-point vector and an "((void)0)
         "integer vector")((void)0);

  // 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;
}

Res = EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);

if (DstTy != ResTy) {
  if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
    assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion")((void)0);
    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;
1466}

1468Value *ScalarExprEmitter::EmitFixedPointConversion(Value *Src, QualType SrcTy,
                                                 QualType DstTy,
                                                 SourceLocation Loc) {
llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
llvm::Value *Result;
if (SrcTy->isRealFloatingType())
  Result = FPBuilder.CreateFloatingToFixed(Src,
      CGF.getContext().getFixedPointSemantics(DstTy));
else if (DstTy->isRealFloatingType())
  Result = FPBuilder.CreateFixedToFloating(Src,
      CGF.getContext().getFixedPointSemantics(SrcTy),
      ConvertType(DstTy));
else {
  auto SrcFPSema = CGF.getContext().getFixedPointSemantics(SrcTy);
  auto DstFPSema = CGF.getContext().getFixedPointSemantics(DstTy);

  if (DstTy->isIntegerType())
    Result = FPBuilder.CreateFixedToInteger(Src, SrcFPSema,
                                            DstFPSema.getWidth(),
                                            DstFPSema.isSigned());
  else if (SrcTy->isIntegerType())
    Result =  FPBuilder.CreateIntegerToFixed(Src, SrcFPSema.isSigned(),
                                             DstFPSema);
  else
    Result = FPBuilder.CreateFixedToFixed(Src, SrcFPSema, DstFPSema);
}
return Result;
1495}

1497/// Emit a conversion from the specified complex type to the specified
1498/// destination type, where the destination type is an LLVM scalar type.
1499Value *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);
1518}

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

1524/// Emit a sanitization check for the given "binary" operation (which
1525/// might actually be a unary increment which has been lowered to a binary
1526/// operation). The check passes if all values in \p Checks (which are \c i1),
1527/// are \c true.
1528void ScalarExprEmitter::EmitBinOpCheck(
  ArrayRef<std::pair<Value *, SanitizerMask>> Checks, const BinOpInfo &Info) {
assert(CGF.IsSanitizerScope)((void)0);
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")__builtin_unreachable();
    }
    StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
  }
  DynamicData.push_back(Info.LHS);
  DynamicData.push_back(Info.RHS);
}

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

1575//===----------------------------------------------------------------------===//
1576//                            Visitor Methods
1577//===----------------------------------------------------------------------===//

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

1586Value *
1587ScalarExprEmitter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
ASTContext &Context = CGF.getContext();
llvm::Optional<LangAS> GlobalAS =
    Context.getTargetInfo().getConstantAddressSpace();
llvm::Constant *GlobalConstStr = Builder.CreateGlobalStringPtr(
    E->ComputeName(Context), "__usn_str",
    static_cast<unsigned>(GlobalAS.getValueOr(LangAS::Default)));

unsigned ExprAS = Context.getTargetAddressSpace(E->getType());

if (GlobalConstStr->getType()->getPointerAddressSpace() == ExprAS)
  return GlobalConstStr;

llvm::Type *EltTy = GlobalConstStr->getType()->getPointerElementType();
llvm::PointerType *NewPtrTy = llvm::PointerType::get(EltTy, ExprAS);
return Builder.CreateAddrSpaceCast(GlobalConstStr, NewPtrTy, "usn_addr_cast");
1603}

1605Value *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;

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

  Mask = RHS;

  auto *MTy = cast<llvm::FixedVectorType>(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
  auto *RTy = llvm::FixedVectorType::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<int, 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(-1);
  else
    Indices.push_back(Idx.getZExtValue());
}

return Builder.CreateShuffleVector(V1, V2, Indices, "shuffle");
1657}

1659Value *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() &&((void)0)
       "ConvertVector source type must be a vector")((void)0);
assert(DstType->isVectorType() &&((void)0)
       "ConvertVector destination type must be a vector")((void)0);

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() &&((void)0)
       "ConvertVector source IR type must be a vector")((void)0);
assert(DstTy->isVectorTy() &&((void)0)
       "ConvertVector destination IR type must be a vector")((void)0);

llvm::Type *SrcEltTy = cast<llvm::VectorType>(SrcTy)->getElementType(),
           *DstEltTy = cast<llvm::VectorType>(DstTy)->getElementType();

if (DstEltType->isBooleanType()) {
  assert((SrcEltTy->isFloatingPointTy() ||((void)0)
          isa<llvm::IntegerType>(SrcEltTy)) && "Unknown boolean conversion")((void)0);

  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")((void)0);
  if (DstEltType->isSignedIntegerOrEnumerationType())
    Res = Builder.CreateFPToSI(Src, DstTy, "conv");
  else
    Res = Builder.CreateFPToUI(Src, DstTy, "conv");
} else {
  assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&((void)0)
         "Unknown real conversion")((void)0);
  if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
    Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
  else
    Res = Builder.CreateFPExt(Src, DstTy, "conv");
}

return Res;
1731}

1733Value *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);
1747}

1749Value *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");
1769}

1771Value *ScalarExprEmitter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
TestAndClearIgnoreResultAssign();

// Handle the vector case.  The base must be a vector, the index must be an
// integer value.
Value *RowIdx = Visit(E->getRowIdx());
Value *ColumnIdx = Visit(E->getColumnIdx());
Value *Matrix = Visit(E->getBase());

// TODO: Should we emit bounds checks with SanitizerKind::ArrayBounds?
llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
return MB.CreateExtractElement(
    Matrix, RowIdx, ColumnIdx,
    E->getBase()->getType()->castAs<ConstantMatrixType>()->getNumRows());
1785}

1787static int getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx,
                    unsigned Off) {
int MV = SVI->getMaskValue(Idx);
if (MV == -1)
  return -1;
return Off + MV;
1793}

1795static int getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty) {
assert(llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) &&((void)0)
       "Index operand too large for shufflevector mask!")((void)0);
return C->getZExtValue();
1799}

1801Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
bool Ignore = TestAndClearIgnoreResultAssign();
(void)Ignore;
assert (Ignore == false && "init list ignored")((void)0);
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 = cast<llvm::FixedVectorType>(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<int, 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 (cast<llvm::FixedVectorType>(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, -1);

          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));
          Args.push_back(ResElts + C->getZExtValue());
          Args.resize(ResElts, -1);

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

  unsigned InitElts = cast<llvm::FixedVectorType>(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);
    auto *OpTy = cast<llvm::FixedVectorType>(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));
        } else {
          Args.push_back(j);
        }
      }
      for (unsigned j = 0, je = InitElts; j != je; ++j)
        Args.push_back(getMaskElt(SVI, j, Offset));
      Args.resize(ResElts, -1);

      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(j);
    Args.resize(ResElts, -1);
    Init = Builder.CreateShuffleVector(Init, Args, "vext");

    Args.clear();
    for (unsigned j = 0; j != CurIdx; ++j)
      Args.push_back(j);
    for (unsigned j = 0; j != InitElts; ++j)
      Args.push_back(j + Offset);
    Args.resize(ResElts, -1);
  }

  // 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);
  V = Builder.CreateShuffleVector(V, Init, Args, "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;
1953}

1955bool 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->isGLValue())
    return false;
}

return true;
1973}

1975// VisitCastExpr - Emit code for an explicit or implicit cast.  Implicit casts
1976// have to handle a more broad range of conversions than explicit casts, as they
1977// handle things like function to ptr-to-function decay etc.
1978Value *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!")__builtin_unreachable();
case CK_BuiltinFnToFnPtr:
  llvm_unreachable("builtin functions are handled elsewhere")__builtin_unreachable();

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"__builtin_unreachable()
                     "(must be an address space cast)!")__builtin_unreachable();
  }

  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 pointer cast.
  if (auto *CI = dyn_cast<llvm::CallBase>(Src)) {
    if (CI->getMetadata("heapallocsite") && isa<ExplicitCastExpr>(CE)) {
      QualType PointeeType = DestTy->getPointeeType();
      if (!PointeeType.isNull())
        CGF.getDebugInfo()->addHeapAllocSiteMetadata(CI, PointeeType,
                                                     CE->getExprLoc());
    }
  }

  // If Src is a fixed vector and Dst is a scalable vector, and both have the
  // same element type, use the llvm.experimental.vector.insert intrinsic to
  // perform the bitcast.
  if (const auto *FixedSrc = dyn_cast<llvm::FixedVectorType>(SrcTy)) {
    if (const auto *ScalableDst = dyn_cast<llvm::ScalableVectorType>(DstTy)) {
      if (FixedSrc->getElementType() == ScalableDst->getElementType()) {
        llvm::Value *UndefVec = llvm::UndefValue::get(DstTy);
        llvm::Value *Zero = llvm::Constant::getNullValue(CGF.CGM.Int64Ty);
        return Builder.CreateInsertVector(DstTy, UndefVec, Src, Zero,
                                          "castScalableSve");
      }
    }
  }

  // If Src is a scalable vector and Dst is a fixed vector, and both have the
  // same element type, use the llvm.experimental.vector.extract intrinsic to
  // perform the bitcast.
  if (const auto *ScalableSrc = dyn_cast<llvm::ScalableVectorType>(SrcTy)) {
    if (const auto *FixedDst = dyn_cast<llvm::FixedVectorType>(DstTy)) {
      if (ScalableSrc->getElementType() == FixedDst->getElementType()) {
        llvm::Value *Zero = llvm::Constant::getNullValue(CGF.CGM.Int64Ty);
        return Builder.CreateExtractVector(DstTy, Src, Zero, "castFixedSve");
      }
    }
  }

  // Perform VLAT <-> VLST bitcast through memory.
  // TODO: since the llvm.experimental.vector.{insert,extract} intrinsics
  //       require the element types of the vectors to be the same, we
  //       need to keep this around for casting between predicates, or more
  //       generally for bitcasts between VLAT <-> VLST where the element
  //       types of the vectors are not the same, until we figure out a better
  //       way of doing these casts.
  if ((isa<llvm::FixedVectorType>(SrcTy) &&
       isa<llvm::ScalableVectorType>(DstTy)) ||
      (isa<llvm::ScalableVectorType>(SrcTy) &&
       isa<llvm::FixedVectorType>(DstTy))) {
    Address Addr = CGF.CreateDefaultAlignTempAlloca(SrcTy, "saved-value");
    LValue LV = CGF.MakeAddrLValue(Addr, E->getType());
    CGF.EmitStoreOfScalar(Src, LV);
    Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy),
                                        "castFixedSve");
    LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
    DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
    return EmitLoadOfLValue(DestLV, 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!")((void)0);

  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")__builtin_unreachable();

case CK_LValueToRValue:
  assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy))((void)0);
  assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!")((void)0);
  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")((void)0);
  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_MatrixCast: {
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());
}
case CK_VectorSplat: {
  llvm::Type *DstTy = ConvertType(DestTy);
  Value *Elt = Visit(const_cast<Expr*>(E));
  // Splat the element across to all elements
  unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
  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() &&((void)0)
         "Expected src type to be fixed point type")((void)0);
  assert(DestTy->isBooleanType() && "Expected dest type to be boolean type")((void)0);
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());

case CK_FixedPointToIntegral:
  assert(E->getType()->isFixedPointType() &&((void)0)
         "Expected src type to be fixed point type")((void)0);
  assert(DestTy->isIntegerType() && "Expected dest type to be an integer")((void)0);
  return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                              CE->getExprLoc());

case CK_IntegralToFixedPoint:
  assert(E->getType()->isIntegerType() &&((void)0)
         "Expected src type to be an integer")((void)0);
  assert(DestTy->isFixedPointType() &&((void)0)
         "Expected dest type to be fixed point type")((void)0);
  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:
case CK_FixedPointToFloating:
case CK_FloatingToFixedPoint: {
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, CE);
  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: {
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, CE);
  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() ||((void)0)
          DestTy->isOCLIntelSubgroupAVCType()) &&((void)0)
         "CK_ZeroToOCLEvent cast on non-event type")((void)0);
  return llvm::Constant::getNullValue(ConvertType(DestTy));
}

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

} // end of switch

llvm_unreachable("unknown scalar cast")__builtin_unreachable();
2374}

2376Value *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());
2384}

2386Value *ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *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;
2393}

2395//===----------------------------------------------------------------------===//
2396//                             Unary Operators
2397//===----------------------------------------------------------------------===//

2399static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E,
                                         llvm::Value *InVal, bool IsInc,
                                         FPOptions FPFeatures) {
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;
BinOp.FPFeatures = FPFeatures;
BinOp.E = E;
return BinOp;
2410}

2412llvm::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, E->getFPFeaturesInEffect(CGF.getLangOpts())));
}
llvm_unreachable("Unknown SignedOverflowBehaviorTy")__builtin_unreachable();
2431}

2433namespace {
2434/// Handles check and update for lastprivate conditional variables.
2435class OMPLastprivateConditionalUpdateRAII {
2436private:
CodeGenFunction &CGF;
const UnaryOperator *E;

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

2452llvm::Value *
2453ScalarExprEmitter::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.")((void)0);
    canPerformLossyDemotionCheck = true;
    canPerformLossyDemotionCheck &=
        CGF.getContext().getCanonicalType(type) !=
        CGF.getContext().getCanonicalType(promotedType);
    canPerformLossyDemotionCheck &=
        PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(
            type, promotedType);
    assert((!canPerformLossyDemotionCheck ||((void)0)
            type->isSignedIntegerOrEnumerationType() ||((void)0)
            promotedType->isSignedIntegerOrEnumerationType() ||((void)0)
            ConvertType(type)->getScalarSizeInBits() ==((void)0)
                ConvertType(promotedType)->getScalarSizeInBits()) &&((void)0)
           "The following check expects that if we do promotion to different "((void)0)
           "underlying canonical type, at least one of the types (either "((void)0)
           "base or promoted) will be signed, or the bitwidths will match.")((void)0);
  }
  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, E->getFPFeaturesInEffect(CGF.getLangOpts())));
  } 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->getType()->getPointerElementType(),
                                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(CGF.Int8Ty, 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->getType()->getPointerElementType(),
                                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;
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);

  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");
    }
  }

// Fixed-point types.
} else if (type->isFixedPointType()) {
  // Fixed-point types are tricky. In some cases, it isn't possible to
  // represent a 1 or a -1 in the type at all. Piggyback off of
  // EmitFixedPointBinOp to avoid having to reimplement saturation.
  BinOpInfo Info;
  Info.E = E;
  Info.Ty = E->getType();
  Info.Opcode = isInc ? BO_Add : BO_Sub;
  Info.LHS = value;
  Info.RHS = llvm::ConstantInt::get(value->getType(), 1, false);
  // If the type is signed, it's better to represent this as +(-1) or -(-1),
  // since -1 is guaranteed to be representable.
  if (type->isSignedFixedPointType()) {
    Info.Opcode = isInc ? BO_Sub : BO_Add;
    Info.RHS = Builder.CreateNeg(Info.RHS);
  }
  // Now, convert from our invented integer literal to the type of the unary
  // op. This will upscale and saturate if necessary. This value can become
  // undef in some cases.
  llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
  auto DstSema = CGF.getContext().getFixedPointSemantics(Info.Ty);
  Info.RHS = FPBuilder.CreateIntegerToFixed(Info.RHS, true, DstSema);
  value = EmitFixedPointBinOp(Info);

// 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(CGF.Int8Ty, 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;
2755}



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

// Generate a unary FNeg for FP ops.
if (Op->getType()->isFPOrFPVectorTy())
1
Taking false branch→
  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;
BinOp.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
BinOp.E = E;
return EmitSub(BinOp);
2
←
Calling 'ScalarExprEmitter::EmitSub'→
2776}

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

2784Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
// Perform vector logical not on comparison with zero vector.
if (E->getType()->isVectorType() &&
    E->getType()->castAs<VectorType>()->getVectorKind() ==
        VectorType::GenericVector) {
  Value *Oper = Visit(E->getSubExpr());
  Value *Zero = llvm::Constant::getNullValue(Oper->getType());
  Value *Result;
  if (Oper->getType()->isFPOrFPVectorTy()) {
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(
        CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
    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");
2811}

2813Value *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")((void)0);

    // 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")__builtin_unreachable();

  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;
2902}

2904/// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of
2905/// argument of the sizeof expression as an integer.
2906Value *
2907ScalarExprEmitter::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()));
2944}

2946Value *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);
2961}

2963Value *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()));
2984}

2986//===----------------------------------------------------------------------===//
2987//                           Binary Operators
2988//===----------------------------------------------------------------------===//

2990BinOpInfo 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->getFPFeaturesInEffect(CGF.getLangOpts());
Result.E = E;
return Result;
3000}

3002LValue 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->getFPFeaturesInEffect(CGF.getLangOpts());
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")__builtin_unreachable();
    }
    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());

CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, OpInfo.FPFeatures);
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;
3131}

3133Value *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());
3153}

3155void 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::Constant::getAllOnesValue(Ty);

  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);
3184}

3186Value *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.Ty->isConstantMatrixType()) {
  llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
  // We need to check the types of the operands of the operator to get the
  // correct matrix dimensions.
  auto *BO = cast<BinaryOperator>(Ops.E);
  (void)BO;
  assert(((void)0)
      isa<ConstantMatrixType>(BO->getLHS()->getType().getCanonicalType()) &&((void)0)
      "first operand must be a matrix")((void)0);
  assert(BO->getRHS()->getType().getCanonicalType()->isArithmeticType() &&((void)0)
         "second operand must be an arithmetic type")((void)0);
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
  return MB.CreateScalarDiv(Ops.LHS, Ops.RHS,
                            Ops.Ty->hasUnsignedIntegerRepresentation());
}

if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
  llvm::Value *Val;
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
  Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
  if ((CGF.getLangOpts().OpenCL &&
       !CGF.CGM.getCodeGenOpts().OpenCLCorrectlyRoundedDivSqrt) ||
      (CGF.getLangOpts().HIP && CGF.getLangOpts().CUDAIsDevice &&
       !CGF.CGM.getCodeGenOpts().HIPCorrectlyRoundedDivSqrt)) {
    // 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.isFixedPointOp())
  return EmitFixedPointBinOp(Ops);
else if (Ops.Ty->hasUnsignedIntegerRepresentation())
  return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
else
  return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
3248}

3250Value *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");
3265}

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

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;
  OverflowKind = SanitizerHandler::AddOverflow;
  break;
case BO_Sub:
case BO_SubAssign:
  OpID = 2;
  IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
                   llvm::Intrinsic::usub_with_overflow;
  OverflowKind = SanitizerHandler::SubOverflow;
  break;
case BO_Mul:
case BO_MulAssign:
  OpID = 3;
  IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
                   llvm::Intrinsic::umul_with_overflow;
  OverflowKind = SanitizerHandler::MulOverflow;
  break;
default:
  llvm_unreachable("Unsupported operation for overflow detection")__builtin_unreachable();
}
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), OverflowKind);
  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;
3373}

3375/// Emit pointer + index arithmetic.
3376static 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);
6
←
Field 'E' is a 'BinaryOperator'→

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 (!isSubtraction6.1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
 && !pointer->getType()->isPointerTy()) {
  std::swap(pointer, index);
  std::swap(pointerOperand, indexOperand);
}

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

unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
7
←
The object is a 'IntegerType'→
auto &DL = CGF.CGM.getDataLayout();
auto PtrTy = cast<llvm::PointerType>(pointer->getType());
8
←
The object is a 'PointerType'→

// 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(),
9
←
Assuming the condition is false→
10
←
Taking false branch→
                                                     op.Opcode,
                                                     expr->getLHS(),
                                                     expr->getRHS()))
  return CGF.Builder.CreateIntToPtr(index, pointer->getType());

if (width != DL.getIndexTypeSizeInBits(PtrTy)) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
  // 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 (isSubtraction12.1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
1
'isSubtraction' is true
)
13
←
Taking true branch→
  index = CGF.Builder.CreateNeg(index, "idx.neg");

if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
14
←
Assuming the condition is false→
15
←
Taking false branch→
  CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
                      /*Accessed*/ false);

const PointerType *pointerType
  = pointerOperand->getType()->getAs<PointerType>();
16
←
Assuming the object is a 'PointerType'→
if (!pointerType) {
17
←
Assuming 'pointerType' is non-null→
18
←
Taking false branch→
  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(CGF.Int8Ty, result, index, "add.ptr");
  return CGF.Builder.CreateBitCast(result, pointer->getType());
}

QualType elementType = pointerType->getPointeeType();
if (const VariableArrayType *vla22.1
'vla' is null
1
'vla' is null
1
'vla' is null
1
'vla' is null
1
'vla' is null

22.1	'vla' is null

←

Taking false branch

→

3456 = CGF.getContext().getAsVariableArrayType(elementType)) {

←

Calling 'ASTContext::getAsVariableArrayType'

→

←

Returning from 'ASTContext::getAsVariableArrayType'

→

3457 // The element count here is the total number of non-VLA elements. 3458 llvm::Value *numElements = CGF.getVLASize(vla).NumElts; 3459 3460 // Effectively, the multiply by the VLA size is part of the GEP. 3461 // GEP indexes are signed, and scaling an index isn't permitted to 3462 // signed-overflow, so we use the same semantics for our explicit 3463 // multiply. We suppress this if overflow is not undefined behavior. 3464 if (CGF.getLangOpts().isSignedOverflowDefined()) { 3465 index = CGF.Builder.CreateMul(index, numElements, "vla.index"); 3466 pointer = CGF.Builder.CreateGEP( 3467 pointer->getType()->getPointerElementType(), pointer, index, 3468 "add.ptr"); 3469 } else { 3470 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index"); 3471 pointer = 3472 CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction, 3473 op.E->getExprLoc(), "add.ptr"); 3474 } 3475 return pointer; 3476 } 3477 3478 // Explicitly handle GNU void* and function pointer arithmetic extensions. The 3479 // GNU void* casts amount to no-ops since our void* type is i8*, but this is 3480 // future proof. 3481 if (elementType->isVoidType() || elementType->isFunctionType()) {

←

Calling 'Type::isVoidType'

→

←

Returning from 'Type::isVoidType'

→

←

Calling 'Type::isFunctionType'

→

←

Returning from 'Type::isFunctionType'

→

←

Taking false branch

→

3482 Value *result = CGF.EmitCastToVoidPtr(pointer); 3483 result = CGF.Builder.CreateGEP(CGF.Int8Ty, result, index, "add.ptr"); 3484 return CGF.Builder.CreateBitCast(result, pointer->getType()); 3485 } 3486 3487 if (CGF.getLangOpts().isSignedOverflowDefined())

←

Calling 'LangOptions::isSignedOverflowDefined'

→

←

Returning from 'LangOptions::isSignedOverflowDefined'

→

←

Taking false branch

→

3488 return CGF.Builder.CreateGEP( 3489 pointer->getType()->getPointerElementType(), pointer, index, "add.ptr"); 3490 3491 return CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,

←

Calling 'CodeGenFunction::EmitCheckedInBoundsGEP'

→

3492 op.E->getExprLoc(), "add.ptr"); 3493} 3494 3495// Construct an fmuladd intrinsic to represent a fused mul-add of MulOp and 3496// Addend. Use negMul and negAdd to negate the first operand of the Mul or 3497// the add operand respectively. This allows fmuladd to represent a*b-c, or 3498// c-a*b. Patterns in LLVM should catch the negated forms and translate them to 3499// efficient operations. 3500static Value* buildFMulAdd(llvm::Instruction *MulOp, Value *Addend, 3501 const CodeGenFunction &CGF, CGBuilderTy &Builder, 3502 bool negMul, bool negAdd) { 3503 assert(!(negMul && negAdd) && "Only one of negMul and negAdd should be set.")((void)0); 3504 3505 Value *MulOp0 = MulOp->getOperand(0); 3506 Value *MulOp1 = MulOp->getOperand(1); 3507 if (negMul) 3508 MulOp0 = Builder.CreateFNeg(MulOp0, "neg"); 3509 if (negAdd) 3510 Addend = Builder.CreateFNeg(Addend, "neg"); 3511 3512 Value *FMulAdd = nullptr; 3513 if (Builder.getIsFPConstrained()) { 3514 assert(isa<llvm::ConstrainedFPIntrinsic>(MulOp) &&((void)0) 3515 "Only constrained operation should be created when Builder is in FP "((void)0) 3516 "constrained mode")((void)0); 3517 FMulAdd = Builder.CreateConstrainedFPCall( 3518 CGF.CGM.getIntrinsic(llvm::Intrinsic::experimental_constrained_fmuladd, 3519 Addend->getType()), 3520 {MulOp0, MulOp1, Addend}); 3521 } else { 3522 FMulAdd = Builder.CreateCall( 3523 CGF.CGM.getIntrinsic(llvm::Intrinsic::fmuladd, Addend->getType()), 3524 {MulOp0, MulOp1, Addend}); 3525 } 3526 MulOp->eraseFromParent(); 3527 3528 return FMulAdd; 3529} 3530 3531// Check whether it would be legal to emit an fmuladd intrinsic call to 3532// represent op and if so, build the fmuladd. 3533// 3534// Checks that (a) the operation is fusable, and (b) -ffp-contract=on. 3535// Does NOT check the type of the operation - it's assumed that this function 3536// will be called from contexts where it's known that the type is contractable. 3537static Value* tryEmitFMulAdd(const BinOpInfo &op, 3538 const CodeGenFunction &CGF, CGBuilderTy &Builder, 3539 bool isSub=false) { 3540 3541 assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||((void)0) 3542 op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&((void)0) 3543 "Only fadd/fsub can be the root of an fmuladd.")((void)0); 3544 3545 // Check whether this op is marked as fusable. 3546 if (!op.FPFeatures.allowFPContractWithinStatement()) 3547 return nullptr; 3548 3549 // We have a potentially fusable op. Look for a mul on one of the operands. 3550 // Also, make sure that the mul result isn't used directly. In that case, 3551 // there's no point creating a muladd operation. 3552 if (auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) { 3553 if (LHSBinOp->getOpcode() == llvm::Instruction::FMul && 3554 LHSBinOp->use_empty()) 3555 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub); 3556 } 3557 if (auto *RHSBinOp = dyn_cast<llvm::BinaryOperator>(op.RHS)) { 3558 if (RHSBinOp->getOpcode() == llvm::Instruction::FMul && 3559 RHSBinOp->use_empty()) 3560 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false); 3561 } 3562 3563 if (auto *LHSBinOp = dyn_cast<llvm::CallBase>(op.LHS)) { 3564 if (LHSBinOp->getIntrinsicID() == 3565 llvm::Intrinsic::experimental_constrained_fmul && 3566 LHSBinOp->use_empty()) 3567 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub); 3568 } 3569 if (auto *RHSBinOp = dyn_cast<llvm::CallBase>(op.RHS)) { 3570 if (RHSBinOp->getIntrinsicID() == 3571 llvm::Intrinsic::experimental_constrained_fmul && 3572 RHSBinOp->use_empty()) 3573 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false); 3574 } 3575 3576 return nullptr; 3577} 3578 3579Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) { 3580 if (op.LHS->getType()->isPointerTy() || 3581 op.RHS->getType()->isPointerTy()) 3582 return emitPointerArithmetic(CGF, op, CodeGenFunction::NotSubtraction); 3583 3584 if (op.Ty->isSignedIntegerOrEnumerationType()) { 3585 switch (CGF.getLangOpts().getSignedOverflowBehavior()) { 3586 case LangOptions::SOB_Defined: 3587 return Builder.CreateAdd(op.LHS, op.RHS, "add"); 3588 case LangOptions::SOB_Undefined: 3589 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) 3590 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add"); 3591 LLVM_FALLTHROUGH[[gnu::fallthrough]]; 3592 case LangOptions::SOB_Trapping: 3593 if (CanElideOverflowCheck(CGF.getContext(), op)) 3594 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add"); 3595 return EmitOverflowCheckedBinOp(op); 3596 } 3597 } 3598 3599 if (op.Ty->isConstantMatrixType()) { 3600 llvm::MatrixBuilder<CGBuilderTy> MB(Builder); 3601 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures); 3602 return MB.CreateAdd(op.LHS, op.RHS); 3603 } 3604 3605 if (op.Ty->isUnsignedIntegerType() && 3606 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) && 3607 !CanElideOverflowCheck(CGF.getContext(), op)) 3608 return EmitOverflowCheckedBinOp(op); 3609 3610 if (op.LHS->getType()->isFPOrFPVectorTy()) { 3611 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures); 3612 // Try to form an fmuladd. 3613 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder)) 3614 return FMulAdd; 3615 3616 return Builder.CreateFAdd(op.LHS, op.RHS, "add"); 3617 } 3618 3619 if (op.isFixedPointOp()) 3620 return EmitFixedPointBinOp(op); 3621 3622 return Builder.CreateAdd(op.LHS, op.RHS, "add"); 3623} 3624 3625/// The resulting value must be calculated with exact precision, so the operands 3626/// may not be the same type. 3627Value *ScalarExprEmitter::EmitFixedPointBinOp(const BinOpInfo &op) { 3628 using llvm::APSInt; 3629 using llvm::ConstantInt; 3630 3631 // This is either a binary operation where at least one of the operands is 3632 // a fixed-point type, or a unary operation where the operand is a fixed-point 3633 // type. The result type of a binary operation is determined by 3634 // Sema::handleFixedPointConversions(). 3635 QualType ResultTy = op.Ty; 3636 QualType LHSTy, RHSTy; 3637 if (const auto *BinOp = dyn_cast<BinaryOperator>(op.E)) { 3638 RHSTy = BinOp->getRHS()->getType(); 3639 if (const auto *CAO = dyn_cast<CompoundAssignOperator>(BinOp)) { 3640 // For compound assignment, the effective type of the LHS at this point 3641 // is the computation LHS type, not the actual LHS type, and the final 3642 // result type is not the type of the expression but rather the 3643 // computation result type. 3644 LHSTy = CAO->getComputationLHSType(); 3645 ResultTy = CAO->getComputationResultType(); 3646 } else 3647 LHSTy = BinOp->getLHS()->getType(); 3648 } else if (const auto *UnOp = dyn_cast<UnaryOperator>(op.E)) { 3649 LHSTy = UnOp->getSubExpr()->getType(); 3650 RHSTy = UnOp->getSubExpr()->getType(); 3651 } 3652 ASTContext &Ctx = CGF.getContext(); 3653 Value *LHS = op.LHS; 3654 Value *RHS = op.RHS; 3655 3656 auto LHSFixedSema = Ctx.getFixedPointSemantics(LHSTy); 3657 auto RHSFixedSema = Ctx.getFixedPointSemantics(RHSTy); 3658 auto ResultFixedSema = Ctx.getFixedPointSemantics(ResultTy); 3659 auto CommonFixedSema = LHSFixedSema.getCommonSemantics(RHSFixedSema); 3660 3661 // Perform the actual operation. 3662 Value *Result; 3663 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder); 3664 switch (op.Opcode) { 3665 case BO_AddAssign: 3666 case BO_Add: 3667 Result = FPBuilder.CreateAdd(LHS, LHSFixedSema, RHS, RHSFixedSema); 3668 break; 3669 case BO_SubAssign: 3670 case BO_Sub: 3671 Result = FPBuilder.CreateSub(LHS, LHSFixedSema, RHS, RHSFixedSema); 3672 break; 3673 case BO_MulAssign: 3674 case BO_Mul: 3675 Result = FPBuilder.CreateMul(LHS, LHSFixedSema, RHS, RHSFixedSema); 3676 break; 3677 case BO_DivAssign: 3678 case BO_Div: 3679 Result = FPBuilder.CreateDiv(LHS, LHSFixedSema, RHS, RHSFixedSema); 3680 break; 3681 case BO_ShlAssign: 3682 case BO_Shl: 3683 Result = FPBuilder.CreateShl(LHS, LHSFixedSema, RHS); 3684 break; 3685 case BO_ShrAssign: 3686 case BO_Shr: 3687 Result = FPBuilder.CreateShr(LHS, LHSFixedSema, RHS); 3688 break; 3689 case BO_LT: 3690 return FPBuilder.CreateLT(LHS, LHSFixedSema, RHS, RHSFixedSema); 3691 case BO_GT: 3692 return FPBuilder.CreateGT(LHS, LHSFixedSema, RHS, RHSFixedSema); 3693 case BO_LE: 3694 return FPBuilder.CreateLE(LHS, LHSFixedSema, RHS, RHSFixedSema); 3695 case BO_GE: 3696 return FPBuilder.CreateGE(LHS, LHSFixedSema, RHS, RHSFixedSema); 3697 case BO_EQ: 3698 // For equality operations, we assume any padding bits on unsigned types are 3699 // zero'd out. They could be overwritten through non-saturating operations 3700 // that cause overflow, but this leads to undefined behavior. 3701 return FPBuilder.CreateEQ(LHS, LHSFixedSema, RHS, RHSFixedSema); 3702 case BO_NE: 3703 return FPBuilder.CreateNE(LHS, LHSFixedSema, RHS, RHSFixedSema); 3704 case BO_Cmp: 3705 case BO_LAnd: 3706 case BO_LOr: 3707 llvm_unreachable("Found unimplemented fixed point binary operation")__builtin_unreachable(); 3708 case BO_PtrMemD: 3709 case BO_PtrMemI: 3710 case BO_Rem: 3711 case BO_Xor: 3712 case BO_And: 3713 case BO_Or: 3714 case BO_Assign: 3715 case BO_RemAssign: 3716 case BO_AndAssign: 3717 case BO_XorAssign: 3718 case BO_OrAssign: 3719 case BO_Comma: 3720 llvm_unreachable("Found unsupported binary operation for fixed point types.")__builtin_unreachable(); 3721 } 3722 3723 bool IsShift = BinaryOperator::isShiftOp(op.Opcode) || 3724 BinaryOperator::isShiftAssignOp(op.Opcode); 3725 // Convert to the result type. 3726 return FPBuilder.CreateFixedToFixed(Result, IsShift ? LHSFixedSema 3727 : CommonFixedSema, 3728 ResultFixedSema); 3729} 3730 3731Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) { 3732 // The LHS is always a pointer if either side is. 3733 if (!op.LHS->getType()->isPointerTy()) {

←

Taking false branch

→

3734 if (op.Ty->isSignedIntegerOrEnumerationType()) { 3735 switch (CGF.getLangOpts().getSignedOverflowBehavior()) { 3736 case LangOptions::SOB_Defined: 3737 return Builder.CreateSub(op.LHS, op.RHS, "sub"); 3738 case LangOptions::SOB_Undefined: 3739 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) 3740 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub"); 3741 LLVM_FALLTHROUGH[[gnu::fallthrough]]; 3742 case LangOptions::SOB_Trapping: 3743 if (CanElideOverflowCheck(CGF.getContext(), op)) 3744 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub"); 3745 return EmitOverflowCheckedBinOp(op); 3746 } 3747 } 3748 3749 if (op.Ty->isConstantMatrixType()) { 3750 llvm::MatrixBuilder<CGBuilderTy> MB(Builder); 3751 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures); 3752 return MB.CreateSub(op.LHS, op.RHS); 3753 } 3754 3755 if (op.Ty->isUnsignedIntegerType() && 3756 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) && 3757 !CanElideOverflowCheck(CGF.getContext(), op)) 3758 return EmitOverflowCheckedBinOp(op); 3759 3760 if (op.LHS->getType()->isFPOrFPVectorTy()) { 3761 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures); 3762 // Try to form an fmuladd. 3763 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true)) 3764 return FMulAdd; 3765 return Builder.CreateFSub(op.LHS, op.RHS, "sub"); 3766 } 3767 3768 if (op.isFixedPointOp()) 3769 return EmitFixedPointBinOp(op); 3770 3771 return Builder.CreateSub(op.LHS, op.RHS, "sub"); 3772 } 3773 3774 // If the RHS is not a pointer, then we have normal pointer 3775 // arithmetic. 3776 if (!op.RHS->getType()->isPointerTy())

←

Taking true branch

→

3777 return emitPointerArithmetic(CGF, op, CodeGenFunction::IsSubtraction);

←

Calling 'emitPointerArithmetic'

→

3778 3779 // Otherwise, this is a pointer subtraction. 3780 3781 // Do the raw subtraction part. 3782 llvm::Value *LHS 3783 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast"); 3784 llvm::Value *RHS 3785 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast"); 3786 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 3787 3788 // Okay, figure out the element size. 3789 const BinaryOperator *expr = cast<BinaryOperator>(op.E); 3790 QualType elementType = expr->getLHS()->getType()->getPointeeType(); 3791 3792 llvm::Value *divisor = nullptr; 3793 3794 // For a variable-length array, this is going to be non-constant. 3795 if (const VariableArrayType *vla 3796 = CGF.getContext().getAsVariableArrayType(elementType)) { 3797 auto VlaSize = CGF.getVLASize(vla); 3798 elementType = VlaSize.Type; 3799 divisor = VlaSize.NumElts; 3800 3801 // Scale the number of non-VLA elements by the non-VLA element size. 3802 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType); 3803 if (!eltSize.isOne()) 3804 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor); 3805 3806 // For everything elese, we can just compute it, safe in the 3807 // assumption that Sema won't let anything through that we can't 3808 // safely compute the size of. 3809 } else { 3810 CharUnits elementSize; 3811 // Handle GCC extension for pointer arithmetic on void* and 3812 // function pointer types. 3813 if (elementType->isVoidType() || elementType->isFunctionType()) 3814 elementSize = CharUnits::One(); 3815 else 3816 elementSize = CGF.getContext().getTypeSizeInChars(elementType); 3817 3818 // Don't even emit the divide for element size of 1. 3819 if (elementSize.isOne()) 3820 return diffInChars; 3821 3822 divisor = CGF.CGM.getSize(elementSize); 3823 } 3824 3825 // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 3826 // pointer difference in C is only defined in the case where both operands 3827 // are pointing to elements of an array. 3828 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div"); 3829} 3830 3831Value *ScalarExprEmitter::GetWidthMinusOneValue(Value* LHS,Value* RHS) { 3832 llvm::IntegerType *Ty; 3833 if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType())) 3834 Ty = cast<llvm::IntegerType>(VT->getElementType()); 3835 else 3836 Ty = cast<llvm::IntegerType>(LHS->getType()); 3837 return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1); 3838} 3839 3840Value *ScalarExprEmitter::ConstrainShiftValue(Value *LHS, Value *RHS, 3841 const Twine &Name) { 3842 llvm::IntegerType *Ty; 3843 if (auto *VT = dyn_cast<llvm::VectorType>(LHS->getType())) 3844 Ty = cast<llvm::IntegerType>(VT->getElementType()); 3845 else 3846 Ty = cast<llvm::IntegerType>(LHS->getType()); 3847 3848 if (llvm::isPowerOf2_64(Ty->getBitWidth())) 3849 return Builder.CreateAnd(RHS, GetWidthMinusOneValue(LHS, RHS), Name); 3850 3851 return Builder.CreateURem( 3852 RHS, llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth()), Name); 3853} 3854 3855Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 3856 // TODO: This misses out on the sanitizer check below. 3857 if (Ops.isFixedPointOp()) 3858 return EmitFixedPointBinOp(Ops); 3859 3860 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 3861 // RHS to the same size as the LHS. 3862 Value *RHS = Ops.RHS; 3863 if (Ops.LHS->getType() != RHS->getType()) 3864 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 3865 3866 bool SanitizeSignedBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) && 3867 Ops.Ty->hasSignedIntegerRepresentation() && 3868 !CGF.getLangOpts().isSignedOverflowDefined() && 3869 !CGF.getLangOpts().CPlusPlus20; 3870 bool SanitizeUnsignedBase = 3871 CGF.SanOpts.has(SanitizerKind::UnsignedShiftBase) && 3872 Ops.Ty->hasUnsignedIntegerRepresentation(); 3873 bool SanitizeBase = SanitizeSignedBase || SanitizeUnsignedBase; 3874 bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent); 3875 // OpenCL 6.3j: shift values are effectively % word size of LHS. 3876 if (CGF.getLangOpts().OpenCL) 3877 RHS = ConstrainShiftValue(Ops.LHS, RHS, "shl.mask"); 3878 else if ((SanitizeBase || SanitizeExponent) && 3879 isa<llvm::IntegerType>(Ops.LHS->getType())) { 3880 CodeGenFunction::SanitizerScope SanScope(&CGF); 3881 SmallVector<std::pair<Value *, SanitizerMask>, 2> Checks; 3882 llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, Ops.RHS); 3883 llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne); 3884 3885 if (SanitizeExponent) { 3886 Checks.push_back( 3887 std::make_pair(ValidExponent, SanitizerKind::ShiftExponent)); 3888 } 3889 3890 if (SanitizeBase) { 3891 // Check whether we are shifting any non-zero bits off the top of the 3892 // integer. We only emit this check if exponent is valid - otherwise 3893 // instructions below will have undefined behavior themselves. 3894 llvm::BasicBlock *Orig = Builder.GetInsertBlock(); 3895 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 3896 llvm::BasicBlock *CheckShiftBase = CGF.createBasicBlock("check"); 3897 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont); 3898 llvm::Value *PromotedWidthMinusOne = 3899 (RHS == Ops.RHS) ? WidthMinusOne 3900 : GetWidthMinusOneValue(Ops.LHS, RHS); 3901 CGF.EmitBlock(CheckShiftBase); 3902 llvm::Value *BitsShiftedOff = Builder.CreateLShr( 3903 Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS, "shl.zeros", 3904 /*NUW*/ true, /*NSW*/ true), 3905 "shl.check"); 3906 if (SanitizeUnsignedBase || CGF.getLangOpts().CPlusPlus) { 3907 // In C99, we are not permitted to shift a 1 bit into the sign bit. 3908 // Under C++11's rules, shifting a 1 bit into the sign bit is 3909 // OK, but shifting a 1 bit out of it is not. (C89 and C++03 don't 3910 // define signed left shifts, so we use the C99 and C++11 rules there). 3911 // Unsigned shifts can always shift into the top bit. 3912 llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1); 3913 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One); 3914 } 3915 llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0); 3916 llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero); 3917 CGF.EmitBlock(Cont); 3918 llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2); 3919 BaseCheck->addIncoming(Builder.getTrue(), Orig); 3920 BaseCheck->addIncoming(ValidBase, CheckShiftBase); 3921 Checks.push_back(std::make_pair( 3922 BaseCheck, SanitizeSignedBase ? SanitizerKind::ShiftBase 3923 : SanitizerKind::UnsignedShiftBase)); 3924 } 3925 3926 assert(!Checks.empty())((void)0); 3927 EmitBinOpCheck(Checks, Ops); 3928 } 3929 3930 return Builder.CreateShl(Ops.LHS, RHS, "shl"); 3931} 3932 3933Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 3934 // TODO: This misses out on the sanitizer check below. 3935 if (Ops.isFixedPointOp()) 3936 return EmitFixedPointBinOp(Ops); 3937 3938 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 3939 // RHS to the same size as the LHS. 3940 Value *RHS = Ops.RHS; 3941 if (Ops.LHS->getType() != RHS->getType()) 3942 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 3943 3944 // OpenCL 6.3j: shift values are effectively % word size of LHS. 3945 if (CGF.getLangOpts().OpenCL) 3946 RHS = ConstrainShiftValue(Ops.LHS, RHS, "shr.mask"); 3947 else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) && 3948 isa<llvm::IntegerType>(Ops.LHS->getType())) { 3949 CodeGenFunction::SanitizerScope SanScope(&CGF); 3950 llvm::Value *Valid = 3951 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS)); 3952 EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops); 3953 } 3954 3955 if (Ops.Ty->hasUnsignedIntegerRepresentation()) 3956 return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 3957 return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 3958} 3959 3960enum IntrinsicType { VCMPEQ, VCMPGT }; 3961// return corresponding comparison intrinsic for given vector type 3962static llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, 3963 BuiltinType::Kind ElemKind) { 3964 switch (ElemKind) { 3965 default: llvm_unreachable("unexpected element type")__builtin_unreachable(); 3966 case BuiltinType::Char_U: 3967 case BuiltinType::UChar: 3968 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 3969 llvm::Intrinsic::ppc_altivec_vcmpgtub_p; 3970 case BuiltinType::Char_S: 3971 case BuiltinType::SChar: 3972 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 3973 llvm::Intrinsic::ppc_altivec_vcmpgtsb_p; 3974 case BuiltinType::UShort: 3975 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 3976 llvm::Intrinsic::ppc_altivec_vcmpgtuh_p; 3977 case BuiltinType::Short: 3978 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 3979 llvm::Intrinsic::ppc_altivec_vcmpgtsh_p; 3980 case BuiltinType::UInt: 3981 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 3982 llvm::Intrinsic::ppc_altivec_vcmpgtuw_p; 3983 case BuiltinType::Int: 3984 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 3985 llvm::Intrinsic::ppc_altivec_vcmpgtsw_p; 3986 case BuiltinType::ULong: 3987 case BuiltinType::ULongLong: 3988 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p : 3989 llvm::Intrinsic::ppc_altivec_vcmpgtud_p; 3990 case BuiltinType::Long: 3991 case BuiltinType::LongLong: 3992 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p : 3993 llvm::Intrinsic::ppc_altivec_vcmpgtsd_p; 3994 case BuiltinType::Float: 3995 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p : 3996 llvm::Intrinsic::ppc_altivec_vcmpgtfp_p; 3997 case BuiltinType::Double: 3998 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_vsx_xvcmpeqdp_p : 3999 llvm::Intrinsic::ppc_vsx_xvcmpgtdp_p; 4000 case BuiltinType::UInt128: 4001 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequq_p 4002 : llvm::Intrinsic::ppc_altivec_vcmpgtuq_p; 4003 case BuiltinType::Int128: 4004 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequq_p 4005 : llvm::Intrinsic::ppc_altivec_vcmpgtsq_p; 4006 } 4007} 4008 4009Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E, 4010 llvm::CmpInst::Predicate UICmpOpc, 4011 llvm::CmpInst::Predicate SICmpOpc, 4012 llvm::CmpInst::Predicate FCmpOpc, 4013 bool IsSignaling) { 4014 TestAndClearIgnoreResultAssign(); 4015 Value *Result; 4016 QualType LHSTy = E->getLHS()->getType(); 4017 QualType RHSTy = E->getRHS()->getType(); 4018 if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 4019 assert(E->getOpcode() == BO_EQ ||((void)0) 4020 E->getOpcode() == BO_NE)((void)0); 4021 Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 4022 Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 4023 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 4024 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 4025 } else if (!LHSTy->isAnyComplexType() && !RHSTy->isAnyComplexType()) { 4026 BinOpInfo BOInfo = EmitBinOps(E); 4027 Value *LHS = BOInfo.LHS; 4028 Value *RHS = BOInfo.RHS; 4029 4030 // If AltiVec, the comparison results in a numeric type, so we use 4031 // intrinsics comparing vectors and giving 0 or 1 as a result 4032 if (LHSTy->isVectorType() && !E->getType()->isVectorType()) { 4033 // constants for mapping CR6 register bits to predicate result 4034 enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6; 4035 4036 llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic; 4037 4038 // in several cases vector arguments order will be reversed 4039 Value *FirstVecArg = LHS, 4040 *SecondVecArg = RHS; 4041 4042 QualType ElTy = LHSTy->castAs<VectorType>()->getElementType(); 4043 BuiltinType::Kind ElementKind = ElTy->castAs<BuiltinType>()->getKind(); 4044 4045 switch(E->getOpcode()) { 4046 default: llvm_unreachable("is not a comparison operation")__builtin_unreachable(); 4047 case BO_EQ: 4048 CR6 = CR6_LT; 4049 ID = GetIntrinsic(VCMPEQ, ElementKind); 4050 break; 4051 case BO_NE: 4052 CR6 = CR6_EQ; 4053 ID = GetIntrinsic(VCMPEQ, ElementKind); 4054 break; 4055 case BO_LT: 4056 CR6 = CR6_LT; 4057 ID = GetIntrinsic(VCMPGT, ElementKind); 4058 std::swap(FirstVecArg, SecondVecArg); 4059 break; 4060 case BO_GT: 4061 CR6 = CR6_LT; 4062 ID = GetIntrinsic(VCMPGT, ElementKind); 4063 break; 4064 case BO_LE: 4065 if (ElementKind == BuiltinType::Float) { 4066 CR6 = CR6_LT; 4067 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 4068 std::swap(FirstVecArg, SecondVecArg); 4069 } 4070 else { 4071 CR6 = CR6_EQ; 4072 ID = GetIntrinsic(VCMPGT, ElementKind); 4073 } 4074 break; 4075 case BO_GE: 4076 if (ElementKind == BuiltinType::Float) { 4077 CR6 = CR6_LT; 4078 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 4079 } 4080 else { 4081 CR6 = CR6_EQ; 4082 ID = GetIntrinsic(VCMPGT, ElementKind); 4083 std::swap(FirstVecArg, SecondVecArg); 4084 } 4085 break; 4086 } 4087 4088 Value *CR6Param = Builder.getInt32(CR6); 4089 llvm::Function *F = CGF.CGM.getIntrinsic(ID); 4090 Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg}); 4091 4092 // The result type of intrinsic may not be same as E->getType(). 4093 // If E->getType() is not BoolTy, EmitScalarConversion will do the 4094 // conversion work. If E->getType() is BoolTy, EmitScalarConversion will 4095 // do nothing, if ResultTy is not i1 at the same time, it will cause 4096 // crash later. 4097 llvm::IntegerType *ResultTy = cast<llvm::IntegerType>(Result->getType()); 4098 if (ResultTy->getBitWidth() > 1 && 4099 E->getType() == CGF.getContext().BoolTy) 4100 Result = Builder.CreateTrunc(Result, Builder.getInt1Ty()); 4101 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(), 4102 E->getExprLoc()); 4103 } 4104 4105 if (BOInfo.isFixedPointOp()) { 4106 Result = EmitFixedPointBinOp(BOInfo); 4107 } else if (LHS->getType()->isFPOrFPVectorTy()) { 4108 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, BOInfo.FPFeatures); 4109 if (!IsSignaling) 4110 Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp"); 4111 else 4112 Result = Builder.CreateFCmpS(FCmpOpc, LHS, RHS, "cmp"); 4113 } else if (LHSTy->hasSignedIntegerRepresentation()) { 4114 Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp"); 4115 } else { 4116 // Unsigned integers and pointers. 4117 4118 if (CGF.CGM.getCodeGenOpts().StrictVTablePointers && 4119 !isa<llvm::ConstantPointerNull>(LHS) && 4120 !isa<llvm::ConstantPointerNull>(RHS)) { 4121 4122 // Dynamic information is required to be stripped for comparisons, 4123 // because it could leak the dynamic information. Based on comparisons 4124 // of pointers to dynamic objects, the optimizer can replace one pointer 4125 // with another, which might be incorrect in presence of invariant 4126 // groups. Comparison with null is safe because null does not carry any 4127 // dynamic information. 4128 if (LHSTy.mayBeDynamicClass()) 4129 LHS = Builder.CreateStripInvariantGroup(LHS); 4130 if (RHSTy.mayBeDynamicClass()) 4131 RHS = Builder.CreateStripInvariantGroup(RHS); 4132 } 4133 4134 Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp"); 4135 } 4136 4137 // If this is a vector comparison, sign extend the result to the appropriate 4138 // vector integer type and return it (don't convert to bool). 4139 if (LHSTy->isVectorType()) 4140 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 4141 4142 } else { 4143 // Complex Comparison: can only be an equality comparison. 4144 CodeGenFunction::ComplexPairTy LHS, RHS; 4145 QualType CETy; 4146 if (auto *CTy = LHSTy->getAs<ComplexType>()) { 4147 LHS = CGF.EmitComplexExpr(E->getLHS()); 4148 CETy = CTy->getElementType(); 4149 } else { 4150 LHS.first = Visit(E->getLHS()); 4151 LHS.second = llvm::Constant::getNullValue(LHS.first->getType()); 4152 CETy = LHSTy; 4153 } 4154 if (auto *CTy = RHSTy->getAs<ComplexType>()) { 4155 RHS = CGF.EmitComplexExpr(E->getRHS()); 4156 assert(CGF.getContext().hasSameUnqualifiedType(CETy,((void)0) 4157 CTy->getElementType()) &&((void)0) 4158 "The element types must always match.")((void)0); 4159 (void)CTy; 4160 } else { 4161 RHS.first = Visit(E->getRHS()); 4162 RHS.second = llvm::Constant::getNullValue(RHS.first->getType()); 4163 assert(CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&((void)0) 4164 "The element types must always match.")((void)0); 4165 } 4166 4167 Value *ResultR, *ResultI; 4168 if (CETy->isRealFloatingType()) { 4169 // As complex comparisons can only be equality comparisons, they 4170 // are never signaling comparisons. 4171 ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r"); 4172 ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i"); 4173 } else { 4174 // Complex comparisons can only be equality comparisons. As such, signed 4175 // and unsigned opcodes are the same. 4176 ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r"); 4177 ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i"); 4178 } 4179 4180 if (E->getOpcode() == BO_EQ) { 4181 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 4182 } else { 4183 assert(E->getOpcode() == BO_NE &&((void)0) 4184 "Complex comparison other than == or != ?")((void)0); 4185 Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 4186 } 4187 } 4188 4189 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(), 4190 E->getExprLoc()); 4191} 4192 4193Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 4194 bool Ignore = TestAndClearIgnoreResultAssign(); 4195 4196 Value *RHS; 4197 LValue LHS; 4198 4199 switch (E->getLHS()->getType().getObjCLifetime()) { 4200 case Qualifiers::OCL_Strong: 4201 std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore); 4202 break; 4203 4204 case Qualifiers::OCL_Autoreleasing: 4205 std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E); 4206 break; 4207 4208 case Qualifiers::OCL_ExplicitNone: 4209 std::tie(LHS, RHS) = CGF.EmitARCStoreUnsafeUnretained(E, Ignore); 4210 break; 4211 4212 case Qualifiers::OCL_Weak: 4213 RHS = Visit(E->getRHS()); 4214 LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store); 4215 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(CGF), RHS, Ignore); 4216 break; 4217 4218 case Qualifiers::OCL_None: 4219 // __block variables need to have the rhs evaluated first, plus 4220 // this should improve codegen just a little. 4221 RHS = Visit(E->getRHS()); 4222 LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store); 4223 4224 // Store the value into the LHS. Bit-fields are handled specially 4225 // because the result is altered by the store, i.e., [C99 6.5.16p1] 4226 // 'An assignment expression has the value of the left operand after 4227 // the assignment...'. 4228 if (LHS.isBitField()) { 4229 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS); 4230 } else { 4231 CGF.EmitNullabilityCheck(LHS, RHS, E->getExprLoc()); 4232 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS); 4233 } 4234 } 4235 4236 // If the result is clearly ignored, return now. 4237 if (Ignore) 4238 return nullptr; 4239 4240 // The result of an assignment in C is the assigned r-value. 4241 if (!CGF.getLangOpts().CPlusPlus) 4242 return RHS; 4243 4244 // If the lvalue is non-volatile, return the computed value of the assignment. 4245 if (!LHS.isVolatileQualified()) 4246 return RHS; 4247 4248 // Otherwise, reload the value. 4249 return EmitLoadOfLValue(LHS, E->getExprLoc()); 4250} 4251 4252Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 4253 // Perform vector logical and on comparisons with zero vectors. 4254 if (E->getType()->isVectorType()) { 4255 CGF.incrementProfileCounter(E); 4256 4257 Value *LHS = Visit(E->getLHS()); 4258 Value *RHS = Visit(E->getRHS()); 4259 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType()); 4260 if (LHS->getType()->isFPOrFPVectorTy()) { 4261 CodeGenFunction::CGFPOptionsRAII FPOptsRAII( 4262 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts())); 4263 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp"); 4264 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp"); 4265 } else { 4266 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp"); 4267 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp"); 4268 } 4269 Value *And = Builder.CreateAnd(LHS, RHS); 4270 return Builder.CreateSExt(And, ConvertType(E->getType()), "sext"); 4271 } 4272 4273 bool InstrumentRegions = CGF.CGM.getCodeGenOpts().hasProfileClangInstr(); 4274 llvm::Type *ResTy = ConvertType(E->getType()); 4275 4276 // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 4277 // If we have 1 && X, just emit X without inserting the control flow. 4278 bool LHSCondVal; 4279 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 4280 if (LHSCondVal) { // If we have 1 && X, just emit X. 4281 CGF.incrementProfileCounter(E); 4282 4283 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 4284 4285 // If we're generating for profiling or coverage, generate a branch to a 4286 // block that increments the RHS counter needed to track branch condition 4287 // coverage. In this case, use "FBlock" as both the final "TrueBlock" and 4288 // "FalseBlock" after the increment is done. 4289 if (InstrumentRegions && 4290 CodeGenFunction::isInstrumentedCondition(E->getRHS())) { 4291 llvm::BasicBlock *FBlock = CGF.createBasicBlock("land.end"); 4292 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt"); 4293 Builder.CreateCondBr(RHSCond, RHSBlockCnt, FBlock); 4294 CGF.EmitBlock(RHSBlockCnt); 4295 CGF.incrementProfileCounter(E->getRHS()); 4296 CGF.EmitBranch(FBlock); 4297 CGF.EmitBlock(FBlock); 4298 } 4299 4300 // ZExt result to int or bool. 4301 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 4302 } 4303 4304 // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 4305 if (!CGF.ContainsLabel(E->getRHS())) 4306 return llvm::Constant::getNullValue(ResTy); 4307 } 4308 4309 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 4310 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 4311 4312 CodeGenFunction::ConditionalEvaluation eval(CGF); 4313 4314 // Branch on the LHS first. If it is false, go to the failure (cont) block. 4315 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock, 4316 CGF.getProfileCount(E->getRHS())); 4317 4318 // Any edges into the ContBlock are now from an (indeterminate number of) 4319 // edges from this first condition. All of these values will be false. Start 4320 // setting up the PHI node in the Cont Block for this. 4321 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 4322 "", ContBlock); 4323 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 4324 PI != PE; ++PI) 4325 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 4326 4327 eval.begin(CGF); 4328 CGF.EmitBlock(RHSBlock); 4329 CGF.incrementProfileCounter(E); 4330 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 4331 eval.end(CGF); 4332 4333 // Reaquire the RHS block, as there may be subblocks inserted. 4334 RHSBlock = Builder.GetInsertBlock(); 4335 4336 // If we're generating for profiling or coverage, generate a branch on the 4337 // RHS to a block that increments the RHS true counter needed to track branch 4338 // condition coverage. 4339 if (InstrumentRegions && 4340 CodeGenFunction::isInstrumentedCondition(E->getRHS())) { 4341 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt"); 4342 Builder.CreateCondBr(RHSCond, RHSBlockCnt, ContBlock); 4343 CGF.EmitBlock(RHSBlockCnt); 4344 CGF.incrementProfileCounter(E->getRHS()); 4345 CGF.EmitBranch(ContBlock); 4346 PN->addIncoming(RHSCond, RHSBlockCnt); 4347 } 4348 4349 // Emit an unconditional branch from this block to ContBlock. 4350 { 4351 // There is no need to emit line number for unconditional branch. 4352 auto NL = ApplyDebugLocation::CreateEmpty(CGF); 4353 CGF.EmitBlock(ContBlock); 4354 } 4355 // Insert an entry into the phi node for the edge with the value of RHSCond. 4356 PN->addIncoming(RHSCond, RHSBlock); 4357 4358 // Artificial location to preserve the scope information 4359 { 4360 auto NL = ApplyDebugLocation::CreateArtificial(CGF); 4361 PN->setDebugLoc(Builder.getCurrentDebugLocation()); 4362 } 4363 4364 // ZExt result to int. 4365 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 4366} 4367 4368Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 4369 // Perform vector logical or on comparisons with zero vectors. 4370 if (E->getType()->isVectorType()) { 4371 CGF.incrementProfileCounter(E); 4372 4373 Value *LHS = Visit(E->getLHS()); 4374 Value *RHS = Visit(E->getRHS()); 4375 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType()); 4376 if (LHS->getType()->isFPOrFPVectorTy()) { 4377 CodeGenFunction::CGFPOptionsRAII FPOptsRAII( 4378 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts())); 4379 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp"); 4380 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp"); 4381 } else { 4382 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp"); 4383 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp"); 4384 } 4385 Value *Or = Builder.CreateOr(LHS, RHS); 4386 return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext"); 4387 } 4388 4389 bool InstrumentRegions = CGF.CGM.getCodeGenOpts().hasProfileClangInstr(); 4390 llvm::Type *ResTy = ConvertType(E->getType()); 4391 4392 // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 4393 // If we have 0 || X, just emit X without inserting the control flow. 4394 bool LHSCondVal; 4395 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 4396 if (!LHSCondVal) { // If we have 0 || X, just emit X. 4397 CGF.incrementProfileCounter(E); 4398 4399 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 4400 4401 // If we're generating for profiling or coverage, generate a branch to a 4402 // block that increments the RHS counter need to track branch condition 4403 // coverage. In this case, use "FBlock" as both the final "TrueBlock" and 4404 // "FalseBlock" after the increment is done. 4405 if (InstrumentRegions && 4406 CodeGenFunction::isInstrumentedCondition(E->getRHS())) { 4407 llvm::BasicBlock *FBlock = CGF.createBasicBlock("lor.end"); 4408 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt"); 4409 Builder.CreateCondBr(RHSCond, FBlock, RHSBlockCnt); 4410 CGF.EmitBlock(RHSBlockCnt); 4411 CGF.incrementProfileCounter(E->getRHS()); 4412 CGF.EmitBranch(FBlock); 4413 CGF.EmitBlock(FBlock); 4414 } 4415 4416 // ZExt result to int or bool. 4417 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 4418 } 4419 4420 // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 4421 if (!CGF.ContainsLabel(E->getRHS())) 4422 return llvm::ConstantInt::get(ResTy, 1); 4423 } 4424 4425 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 4426 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 4427 4428 CodeGenFunction::ConditionalEvaluation eval(CGF); 4429 4430 // Branch on the LHS first. If it is true, go to the success (cont) block. 4431 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock, 4432 CGF.getCurrentProfileCount() - 4433 CGF.getProfileCount(E->getRHS())); 4434 4435 // Any edges into the ContBlock are now from an (indeterminate number of) 4436 // edges from this first condition. All of these values will be true. Start 4437 // setting up the PHI node in the Cont Block for this. 4438 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 4439 "", ContBlock); 4440 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 4441 PI != PE; ++PI) 4442 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 4443 4444 eval.begin(CGF); 4445 4446 // Emit the RHS condition as a bool value. 4447 CGF.EmitBlock(RHSBlock); 4448 CGF.incrementProfileCounter(E); 4449 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 4450 4451 eval.end(CGF); 4452 4453 // Reaquire the RHS block, as there may be subblocks inserted. 4454 RHSBlock = Builder.GetInsertBlock(); 4455 4456 // If we're generating for profiling or coverage, generate a branch on the 4457 // RHS to a block that increments the RHS true counter needed to track branch 4458 // condition coverage. 4459 if (InstrumentRegions && 4460 CodeGenFunction::isInstrumentedCondition(E->getRHS())) { 4461 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt"); 4462 Builder.CreateCondBr(RHSCond, ContBlock, RHSBlockCnt); 4463 CGF.EmitBlock(RHSBlockCnt); 4464 CGF.incrementProfileCounter(E->getRHS()); 4465 CGF.EmitBranch(ContBlock); 4466 PN->addIncoming(RHSCond, RHSBlockCnt); 4467 } 4468 4469 // Emit an unconditional branch from this block to ContBlock. Insert an entry 4470 // into the phi node for the edge with the value of RHSCond. 4471 CGF.EmitBlock(ContBlock); 4472 PN->addIncoming(RHSCond, RHSBlock); 4473 4474 // ZExt result to int. 4475 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 4476} 4477 4478Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 4479 CGF.EmitIgnoredExpr(E->getLHS()); 4480 CGF.EnsureInsertPoint(); 4481 return Visit(E->getRHS()); 4482} 4483 4484//===----------------------------------------------------------------------===// 4485// Other Operators 4486//===----------------------------------------------------------------------===// 4487 4488/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 4489/// expression is cheap enough and side-effect-free enough to evaluate 4490/// unconditionally instead of conditionally. This is used to convert control 4491/// flow into selects in some cases. 4492static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 4493 CodeGenFunction &CGF) { 4494 // Anything that is an integer or floating point constant is fine. 4495 return E->IgnoreParens()->isEvaluatable(CGF.getContext()); 4496 4497 // Even non-volatile automatic variables can't be evaluated unconditionally. 4498 // Referencing a thread_local may cause non-trivial initialization work to 4499 // occur. If we're inside a lambda and one of the variables is from the scope 4500 // outside the lambda, that function may have returned already. Reading its 4501 // locals is a bad idea. Also, these reads may introduce races there didn't 4502 // exist in the source-level program. 4503} 4504 4505 4506Value *ScalarExprEmitter:: 4507VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 4508 TestAndClearIgnoreResultAssign(); 4509 4510 // Bind the common expression if necessary. 4511 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 4512 4513 Expr *condExpr = E->getCond(); 4514 Expr *lhsExpr = E->getTrueExpr(); 4515 Expr *rhsExpr = E->getFalseExpr(); 4516 4517 // If the condition constant folds and can be elided, try to avoid emitting 4518 // the condition and the dead arm. 4519 bool CondExprBool; 4520 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 4521 Expr *live = lhsExpr, *dead = rhsExpr; 4522 if (!CondExprBool) std::swap(live, dead); 4523 4524 // If the dead side doesn't have labels we need, just emit the Live part. 4525 if (!CGF.ContainsLabel(dead)) { 4526 if (CondExprBool) 4527 CGF.incrementProfileCounter(E); 4528 Value *Result = Visit(live); 4529 4530 // If the live part is a throw expression, it acts like it has a void 4531 // type, so evaluating it returns a null Value*. However, a conditional 4532 // with non-void type must return a non-null Value*. 4533 if (!Result && !E->getType()->isVoidType()) 4534 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 4535 4536 return Result; 4537 } 4538 } 4539 4540 // OpenCL: If the condition is a vector, we can treat this condition like 4541 // the select function. 4542 if ((CGF.getLangOpts().OpenCL && condExpr->getType()->isVectorType()) || 4543 condExpr->getType()->isExtVectorType()) { 4544 CGF.incrementProfileCounter(E); 4545 4546 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr); 4547 llvm::Value *LHS = Visit(lhsExpr); 4548 llvm::Value *RHS = Visit(rhsExpr); 4549 4550 llvm::Type *condType = ConvertType(condExpr->getType()); 4551 auto *vecTy = cast<llvm::FixedVectorType>(condType); 4552 4553 unsigned numElem = vecTy->getNumElements(); 4554 llvm::Type *elemType = vecTy->getElementType(); 4555 4556 llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy); 4557 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 4558 llvm::Value *tmp = Builder.CreateSExt( 4559 TestMSB, llvm::FixedVectorType::get(elemType, numElem), "sext"); 4560 llvm::Value *tmp2 = Builder.CreateNot(tmp); 4561 4562 // Cast float to int to perform ANDs if necessary. 4563 llvm::Value *RHSTmp = RHS; 4564 llvm::Value *LHSTmp = LHS; 4565 bool wasCast = false; 4566 llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 4567 if (rhsVTy->getElementType()->isFloatingPointTy()) { 4568 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 4569 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 4570 wasCast = true; 4571 } 4572 4573 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 4574 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 4575 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 4576 if (wasCast) 4577 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 4578 4579 return tmp5; 4580 } 4581 4582 if (condExpr->getType()->isVectorType()) { 4583 CGF.incrementProfileCounter(E); 4584 4585 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr); 4586 llvm::Value *LHS = Visit(lhsExpr); 4587 llvm::Value *RHS = Visit(rhsExpr); 4588 4589 llvm::Type *CondType = ConvertType(condExpr->getType()); 4590 auto *VecTy = cast<llvm::VectorType>(CondType); 4591 llvm::Value *ZeroVec = llvm::Constant::getNullValue(VecTy); 4592 4593 CondV = Builder.CreateICmpNE(CondV, ZeroVec, "vector_cond"); 4594 return Builder.CreateSelect(CondV, LHS, RHS, "vector_select"); 4595 } 4596 4597 // If this is a really simple expression (like x ? 4 : 5), emit this as a 4598 // select instead of as control flow. We can only do this if it is cheap and 4599 // safe to evaluate the LHS and RHS unconditionally. 4600 if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) && 4601 isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) { 4602 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr); 4603 llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.Int64Ty); 4604 4605 CGF.incrementProfileCounter(E, StepV); 4606 4607 llvm::Value *LHS = Visit(lhsExpr); 4608 llvm::Value *RHS = Visit(rhsExpr); 4609 if (!LHS) { 4610 // If the conditional has void type, make sure we return a null Value*. 4611 assert(!RHS && "LHS and RHS types must match")((void)0); 4612 return nullptr; 4613 } 4614 return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 4615 } 4616 4617 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 4618 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 4619 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 4620 4621 CodeGenFunction::ConditionalEvaluation eval(CGF); 4622 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock, 4623 CGF.getProfileCount(lhsExpr)); 4624 4625 CGF.EmitBlock(LHSBlock); 4626 CGF.incrementProfileCounter(E); 4627 eval.begin(CGF); 4628 Value *LHS = Visit(lhsExpr); 4629 eval.end(CGF); 4630 4631 LHSBlock = Builder.GetInsertBlock(); 4632 Builder.CreateBr(ContBlock); 4633 4634 CGF.EmitBlock(RHSBlock); 4635 eval.begin(CGF); 4636 Value *RHS = Visit(rhsExpr); 4637 eval.end(CGF); 4638 4639 RHSBlock = Builder.GetInsertBlock(); 4640 CGF.EmitBlock(ContBlock); 4641 4642 // If the LHS or RHS is a throw expression, it will be legitimately null. 4643 if (!LHS) 4644 return RHS; 4645 if (!RHS) 4646 return LHS; 4647 4648 // Create a PHI node for the real part. 4649 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond"); 4650 PN->addIncoming(LHS, LHSBlock); 4651 PN->addIncoming(RHS, RHSBlock); 4652 return PN; 4653} 4654 4655Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 4656 return Visit(E->getChosenSubExpr()); 4657} 4658 4659Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 4660 QualType Ty = VE->getType(); 4661 4662 if (Ty->isVariablyModifiedType()) 4663 CGF.EmitVariablyModifiedType(Ty); 4664 4665 Address ArgValue = Address::invalid(); 4666 Address ArgPtr = CGF.EmitVAArg(VE, ArgValue); 4667 4668 llvm::Type *ArgTy = ConvertType(VE->getType()); 4669 4670 // If EmitVAArg fails, emit an error. 4671 if (!ArgPtr.isValid()) { 4672 CGF.ErrorUnsupported(VE, "va_arg expression"); 4673 return llvm::UndefValue::get(ArgTy); 4674 } 4675 4676 // FIXME Volatility. 4677 llvm::Value *Val = Builder.CreateLoad(ArgPtr); 4678 4679 // If EmitVAArg promoted the type, we must truncate it. 4680 if (ArgTy != Val->getType()) { 4681 if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy()) 4682 Val = Builder.CreateIntToPtr(Val, ArgTy); 4683 else 4684 Val = Builder.CreateTrunc(Val, ArgTy); 4685 } 4686 4687 return Val; 4688} 4689 4690Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) { 4691 return CGF.EmitBlockLiteral(block); 4692} 4693 4694// Convert a vec3 to vec4, or vice versa. 4695static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF, 4696 Value *Src, unsigned NumElementsDst) { 4697 static constexpr int Mask[] = {0, 1, 2, -1}; 4698 return Builder.CreateShuffleVector(Src, 4699 llvm::makeArrayRef(Mask, NumElementsDst)); 4700} 4701 4702// Create cast instructions for converting LLVM value \p Src to LLVM type \p 4703// DstTy. \p Src has the same size as \p DstTy. Both are single value types 4704// but could be scalar or vectors of different lengths, and either can be 4705// pointer. 4706// There are 4 cases: 4707// 1. non-pointer -> non-pointer : needs 1 bitcast 4708// 2. pointer -> pointer : needs 1 bitcast or addrspacecast 4709// 3. pointer -> non-pointer 4710// a) pointer -> intptr_t : needs 1 ptrtoint 4711// b) pointer -> non-intptr_t : needs 1 ptrtoint then 1 bitcast 4712// 4. non-pointer -> pointer 4713// a) intptr_t -> pointer : needs 1 inttoptr 4714// b) non-intptr_t -> pointer : needs 1 bitcast then 1 inttoptr 4715// Note: for cases 3b and 4b two casts are required since LLVM casts do not 4716// allow casting directly between pointer types and non-integer non-pointer 4717// types. 4718static Value *createCastsForTypeOfSameSize(CGBuilderTy &Builder, 4719 const llvm::DataLayout &DL, 4720 Value *Src, llvm::Type *DstTy, 4721 StringRef Name = "") { 4722 auto SrcTy = Src->getType(); 4723 4724 // Case 1. 4725 if (!SrcTy->isPointerTy() && !DstTy->isPointerTy()) 4726 return Builder.CreateBitCast(Src, DstTy, Name); 4727 4728 // Case 2. 4729 if (SrcTy->isPointerTy() && DstTy->isPointerTy()) 4730 return Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy, Name); 4731 4732 // Case 3. 4733 if (SrcTy->isPointerTy() && !DstTy->isPointerTy()) { 4734 // Case 3b. 4735 if (!DstTy->isIntegerTy()) 4736 Src = Builder.CreatePtrToInt(Src, DL.getIntPtrType(SrcTy)); 4737 // Cases 3a and 3b. 4738 return Builder.CreateBitOrPointerCast(Src, DstTy, Name); 4739 } 4740 4741 // Case 4b. 4742 if (!SrcTy->isIntegerTy()) 4743 Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy)); 4744 // Cases 4a and 4b. 4745 return Builder.CreateIntToPtr(Src, DstTy, Name); 4746} 4747 4748Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) { 4749 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr()); 4750 llvm::Type *DstTy = ConvertType(E->getType()); 4751 4752 llvm::Type *SrcTy = Src->getType(); 4753 unsigned NumElementsSrc = 4754 isa<llvm::VectorType>(SrcTy) 4755 ? cast<llvm::FixedVectorType>(SrcTy)->getNumElements() 4756 : 0; 4757 unsigned NumElementsDst = 4758 isa<llvm::VectorType>(DstTy) 4759 ? cast<llvm::FixedVectorType>(DstTy)->getNumElements() 4760 : 0; 4761 4762 // Going from vec3 to non-vec3 is a special case and requires a shuffle 4763 // vector to get a vec4, then a bitcast if the target type is different. 4764 if (NumElementsSrc == 3 && NumElementsDst != 3) { 4765 Src = ConvertVec3AndVec4(Builder, CGF, Src, 4); 4766 4767 if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) { 4768 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src, 4769 DstTy); 4770 } 4771 4772 Src->setName("astype"); 4773 return Src; 4774 } 4775 4776 // Going from non-vec3 to vec3 is a special case and requires a bitcast 4777 // to vec4 if the original type is not vec4, then a shuffle vector to 4778 // get a vec3. 4779 if (NumElementsSrc != 3 && NumElementsDst == 3) { 4780 if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) { 4781 auto *Vec4Ty = llvm::FixedVectorType::get( 4782 cast<llvm::VectorType>(DstTy)->getElementType(), 4); 4783 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src, 4784 Vec4Ty); 4785 } 4786 4787 Src = ConvertVec3AndVec4(Builder, CGF, Src, 3); 4788 Src->setName("astype"); 4789 return Src; 4790 } 4791 4792 return createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), 4793 Src, DstTy, "astype"); 4794} 4795 4796Value *ScalarExprEmitter::VisitAtomicExpr(AtomicExpr *E) { 4797 return CGF.EmitAtomicExpr(E).getScalarVal(); 4798} 4799 4800//===----------------------------------------------------------------------===// 4801// Entry Point into this File 4802//===----------------------------------------------------------------------===// 4803 4804/// Emit the computation of the specified expression of scalar type, ignoring 4805/// the result. 4806Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 4807 assert(E && hasScalarEvaluationKind(E->getType()) &&((void)0) 4808 "Invalid scalar expression to emit")((void)0); 4809 4810 return ScalarExprEmitter(*this, IgnoreResultAssign) 4811 .Visit(const_cast<Expr *>(E)); 4812} 4813 4814/// Emit a conversion from the specified type to the specified destination type, 4815/// both of which are LLVM scalar types. 4816Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 4817 QualType DstTy, 4818 SourceLocation Loc) { 4819 assert(hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) &&((void)0) 4820 "Invalid scalar expression to emit")((void)0); 4821 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy, Loc); 4822} 4823 4824/// Emit a conversion from the specified complex type to the specified 4825/// destination type, where the destination type is an LLVM scalar type. 4826Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 4827 QualType SrcTy, 4828 QualType DstTy, 4829 SourceLocation Loc) { 4830 assert(SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) &&((void)0) 4831 "Invalid complex -> scalar conversion")((void)0); 4832 return ScalarExprEmitter(*this) 4833 .EmitComplexToScalarConversion(Src, SrcTy, DstTy, Loc); 4834} 4835 4836 4837llvm::Value *CodeGenFunction:: 4838EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 4839 bool isInc, bool isPre) { 4840 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 4841} 4842 4843LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 4844 // object->isa or (*object).isa 4845 // Generate code as for: *(Class*)object 4846 4847 Expr *BaseExpr = E->getBase(); 4848 Address Addr = Address::invalid(); 4849 if (BaseExpr->isPRValue()) { 4850 Addr = Address(EmitScalarExpr(BaseExpr), getPointerAlign()); 4851 } else { 4852 Addr = EmitLValue(BaseExpr).getAddress(*this); 4853 } 4854 4855 // Cast the address to Class*. 4856 Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType())); 4857 return MakeAddrLValue(Addr, E->getType()); 4858} 4859 4860 4861LValue CodeGenFunction::EmitCompoundAssignmentLValue( 4862 const CompoundAssignOperator *E) { 4863 ScalarExprEmitter Scalar(*this); 4864 Value *Result = nullptr; 4865 switch (E->getOpcode()) { 4866#define COMPOUND_OP(Op) \ 4867 case BO_##Op##Assign: \ 4868 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 4869 Result) 4870 COMPOUND_OP(Mul); 4871 COMPOUND_OP(Div); 4872 COMPOUND_OP(Rem); 4873 COMPOUND_OP(Add); 4874 COMPOUND_OP(Sub); 4875 COMPOUND_OP(Shl); 4876 COMPOUND_OP(Shr); 4877 COMPOUND_OP(And); 4878 COMPOUND_OP(Xor); 4879 COMPOUND_OP(Or); 4880#undef COMPOUND_OP 4881 4882 case BO_PtrMemD: 4883 case BO_PtrMemI: 4884 case BO_Mul: 4885 case BO_Div: 4886 case BO_Rem: 4887 case BO_Add: 4888 case BO_Sub: 4889 case BO_Shl: 4890 case BO_Shr: 4891 case BO_LT: 4892 case BO_GT: 4893 case BO_LE: 4894 case BO_GE: 4895 case BO_EQ: 4896 case BO_NE: 4897 case BO_Cmp: 4898 case BO_And: 4899 case BO_Xor: 4900 case BO_Or: 4901 case BO_LAnd: 4902 case BO_LOr: 4903 case BO_Assign: 4904 case BO_Comma: 4905 llvm_unreachable("Not valid compound assignment operators")__builtin_unreachable(); 4906 } 4907 4908 llvm_unreachable("Unhandled compound assignment operator")__builtin_unreachable(); 4909} 4910 4911struct GEPOffsetAndOverflow { 4912 // The total (signed) byte offset for the GEP. 4913 llvm::Value *TotalOffset; 4914 // The offset overflow flag - true if the total offset overflows. 4915 llvm::Value *OffsetOverflows; 4916}; 4917 4918/// Evaluate given GEPVal, which is either an inbounds GEP, or a constant, 4919/// and compute the total offset it applies from it's base pointer BasePtr. 4920/// Returns offset in bytes and a boolean flag whether an overflow happened 4921/// during evaluation. 4922static GEPOffsetAndOverflow EmitGEPOffsetInBytes(Value *BasePtr, Value *GEPVal, 4923 llvm::LLVMContext &VMContext, 4924 CodeGenModule &CGM, 4925 CGBuilderTy &Builder) { 4926 const auto &DL = CGM.getDataLayout(); 4927 4928 // The total (signed) byte offset for the GEP. 4929 llvm::Value *TotalOffset = nullptr; 4930 4931 // Was the GEP already reduced to a constant? 4932 if (isa<llvm::Constant>(GEPVal)) { 4933 // Compute the offset by casting both pointers to integers and subtracting: 4934 // GEPVal = BasePtr + ptr(Offset) <--> Offset = int(GEPVal) - int(BasePtr) 4935 Value *BasePtr_int = 4936 Builder.CreatePtrToInt(BasePtr, DL.getIntPtrType(BasePtr->getType())); 4937 Value *GEPVal_int = 4938 Builder.CreatePtrToInt(GEPVal, DL.getIntPtrType(GEPVal->getType())); 4939 TotalOffset = Builder.CreateSub(GEPVal_int, BasePtr_int); 4940 return {TotalOffset, /*OffsetOverflows=*/Builder.getFalse()}; 4941 } 4942 4943 auto *GEP = cast<llvm::GEPOperator>(GEPVal); 4944 assert(GEP->getPointerOperand() == BasePtr &&((void)0) 4945 "BasePtr must be the the base of the GEP.")((void)0); 4946 assert(GEP->isInBounds() && "Expected inbounds GEP")((void)0); 4947 4948 auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType()); 4949 4950 // Grab references to the signed add/mul overflow intrinsics for intptr_t. 4951 auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy); 4952 auto *SAddIntrinsic = 4953 CGM.getIntrinsic(llvm::Intrinsic::sadd_with_overflow, IntPtrTy); 4954 auto *SMulIntrinsic = 4955 CGM.getIntrinsic(llvm::Intrinsic::smul_with_overflow, IntPtrTy); 4956 4957 // The offset overflow flag - true if the total offset overflows. 4958 llvm::Value *OffsetOverflows = Builder.getFalse(); 4959 4960 /// Return the result of the given binary operation. 4961 auto eval = [&](BinaryOperator::Opcode Opcode, llvm::Value *LHS, 4962 llvm::Value *RHS) -> llvm::Value * { 4963 assert((Opcode == BO_Add || Opcode == BO_Mul) && "Can't eval binop")((void)0); 4964 4965 // If the operands are constants, return a constant result. 4966 if (auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) { 4967 if (auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) { 4968 llvm::APInt N; 4969 bool HasOverflow = mayHaveIntegerOverflow(LHSCI, RHSCI, Opcode, 4970 /*Signed=*/true, N); 4971 if (HasOverflow) 4972 OffsetOverflows = Builder.getTrue(); 4973 return llvm::ConstantInt::get(VMContext, N); 4974 } 4975 } 4976 4977 // Otherwise, compute the result with checked arithmetic. 4978 auto *ResultAndOverflow = Builder.CreateCall( 4979 (Opcode == BO_Add) ? SAddIntrinsic : SMulIntrinsic, {LHS, RHS}); 4980 OffsetOverflows = Builder.CreateOr( 4981 Builder.CreateExtractValue(ResultAndOverflow, 1), OffsetOverflows); 4982 return Builder.CreateExtractValue(ResultAndOverflow, 0); 4983 }; 4984 4985 // Determine the total byte offset by looking at each GEP operand. 4986 for (auto GTI = llvm::gep_type_begin(GEP), GTE = llvm::gep_type_end(GEP); 4987 GTI != GTE; ++GTI) { 4988 llvm::Value *LocalOffset; 4989 auto *Index = GTI.getOperand(); 4990 // Compute the local offset contributed by this indexing step: 4991 if (auto *STy = GTI.getStructTypeOrNull()) { 4992 // For struct indexing, the local offset is the byte position of the 4993 // specified field. 4994 unsigned FieldNo = cast<llvm::ConstantInt>(Index)->getZExtValue(); 4995 LocalOffset = llvm::ConstantInt::get( 4996 IntPtrTy, DL.getStructLayout(STy)->getElementOffset(FieldNo)); 4997 } else { 4998 // Otherwise this is array-like indexing. The local offset is the index 4999 // multiplied by the element size. 5000 auto *ElementSize = llvm::ConstantInt::get( 5001 IntPtrTy, DL.getTypeAllocSize(GTI.getIndexedType())); 5002 auto *IndexS = Builder.CreateIntCast(Index, IntPtrTy, /*isSigned=*/true); 5003 LocalOffset = eval(BO_Mul, ElementSize, IndexS); 5004 } 5005 5006 // If this is the first offset, set it as the total offset. Otherwise, add 5007 // the local offset into the running total. 5008 if (!TotalOffset || TotalOffset == Zero) 5009 TotalOffset = LocalOffset; 5010 else 5011 TotalOffset = eval(BO_Add, TotalOffset, LocalOffset); 5012 } 5013 5014 return {TotalOffset, OffsetOverflows}; 5015} 5016 5017Value * 5018CodeGenFunction::EmitCheckedInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList, 5019 bool SignedIndices, bool IsSubtraction, 5020 SourceLocation Loc, const Twine &Name) { 5021 llvm::Type *PtrTy = Ptr->getType(); 5022 Value *GEPVal = Builder.CreateInBoundsGEP( 5023 PtrTy->getPointerElementType(), Ptr, IdxList, Name); 5024 5025 // If the pointer overflow sanitizer isn't enabled, do nothing. 5026 if (!SanOpts.has(SanitizerKind::PointerOverflow))

←

Assuming the condition is false

→

←

Taking false branch

→

5027 return GEPVal; 5028 5029 // Perform nullptr-and-offset check unless the nullptr is defined. 5030 bool PerformNullCheck = !NullPointerIsDefined(

←

Assuming the condition is false

→

5031 Builder.GetInsertBlock()->getParent(), PtrTy->getPointerAddressSpace()); 5032 // Check for overflows unless the GEP got constant-folded, 5033 // and only in the default address space 5034 bool PerformOverflowCheck = 5035 !isa<llvm::Constant>(GEPVal) && PtrTy->getPointerAddressSpace() == 0;

←

Assuming 'GEPVal' is not a 'Constant'

→

←

Assuming the condition is true

→

5036 5037 if (!(PerformNullCheck

47.1	'PerformNullCheck' is false

47.1	'PerformNullCheck' is false

47.1	'PerformNullCheck' is false

47.1	'PerformNullCheck' is false

47.1	'PerformNullCheck' is false

47.1	'PerformNullCheck' is false

|| PerformOverflowCheck))

←

Taking false branch

→

5038 return GEPVal; 5039 5040 const auto &DL = CGM.getDataLayout(); 5041 5042 SanitizerScope SanScope(this); 5043 llvm::Type *IntPtrTy = DL.getIntPtrType(PtrTy); 5044 5045 GEPOffsetAndOverflow EvaluatedGEP = 5046 EmitGEPOffsetInBytes(Ptr, GEPVal, getLLVMContext(), CGM, Builder);

←

Null pointer value stored to 'EvaluatedGEP.TotalOffset'

→

5047 5048 assert((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) ||((void)0) 5049 EvaluatedGEP.OffsetOverflows == Builder.getFalse()) &&((void)0) 5050 "If the offset got constant-folded, we don't expect that there was an "((void)0) 5051 "overflow.")((void)0); 5052 5053 auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy); 5054 5055 // Common case: if the total offset is zero, and we are using C++ semantics, 5056 // where nullptr+0 is defined, don't emit a check. 5057 if (EvaluatedGEP.TotalOffset == Zero && CGM.getLangOpts().CPlusPlus)

←

Assuming 'Zero' is not equal to field 'TotalOffset'

→

5058 return GEPVal; 5059 5060 // Now that we've computed the total offset, add it to the base pointer (with 5061 // wrapping semantics). 5062 auto *IntPtr = Builder.CreatePtrToInt(Ptr, IntPtrTy); 5063 auto *ComputedGEP = Builder.CreateAdd(IntPtr, EvaluatedGEP.TotalOffset); 5064 5065 llvm::SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks; 5066 5067 if (PerformNullCheck

50.1	'PerformNullCheck' is false

50.1	'PerformNullCheck' is false

50.1	'PerformNullCheck' is false

50.1	'PerformNullCheck' is false

50.1	'PerformNullCheck' is false

50.1	'PerformNullCheck' is false

) {

←

Taking false branch

→

5068 // In C++, if the base pointer evaluates to a null pointer value, 5069 // the only valid pointer this inbounds GEP can produce is also 5070 // a null pointer, so the offset must also evaluate to zero. 5071 // Likewise, if we have non-zero base pointer, we can not get null pointer 5072 // as a result, so the offset can not be -intptr_t(BasePtr). 5073 // In other words, both pointers are either null, or both are non-null, 5074 // or the behaviour is undefined. 5075 // 5076 // C, however, is more strict in this regard, and gives more 5077 // optimization opportunities: in C, additionally, nullptr+0 is undefined. 5078 // So both the input to the 'gep inbounds' AND the output must not be null. 5079 auto *BaseIsNotNullptr = Builder.CreateIsNotNull(Ptr); 5080 auto *ResultIsNotNullptr = Builder.CreateIsNotNull(ComputedGEP); 5081 auto *Valid = 5082 CGM.getLangOpts().CPlusPlus 5083 ? Builder.CreateICmpEQ(BaseIsNotNullptr, ResultIsNotNullptr) 5084 : Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr); 5085 Checks.emplace_back(Valid, SanitizerKind::PointerOverflow); 5086 } 5087 5088 if (PerformOverflowCheck

51.1	'PerformOverflowCheck' is true

51.1	'PerformOverflowCheck' is true

51.1	'PerformOverflowCheck' is true

51.1	'PerformOverflowCheck' is true

51.1	'PerformOverflowCheck' is true

51.1	'PerformOverflowCheck' is true

) {

←

Taking true branch

→

5089 // The GEP is valid if: 5090 // 1) The total offset doesn't overflow, and 5091 // 2) The sign of the difference between the computed address and the base 5092 // pointer matches the sign of the total offset. 5093 llvm::Value *ValidGEP; 5094 auto *NoOffsetOverflow = Builder.CreateNot(EvaluatedGEP.OffsetOverflows); 5095 if (SignedIndices) {

←

Assuming 'SignedIndices' is true

→

←

Taking true branch

→

5096 // GEP is computed as `unsigned base + signed offset`, therefore: 5097 // * If offset was positive, then the computed pointer can not be 5098 // [unsigned] less than the base pointer, unless it overflowed. 5099 // * If offset was negative, then the computed pointer can not be 5100 // [unsigned] greater than the bas pointere, unless it overflowed. 5101 auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr); 5102 auto *PosOrZeroOffset = 5103 Builder.CreateICmpSGE(EvaluatedGEP.TotalOffset, Zero);

←

Passing null pointer value via 1st parameter 'LHS'

→

←

Calling 'IRBuilderBase::CreateICmpSGE'

→

5104 llvm::Value *NegValid = Builder.CreateICmpULT(ComputedGEP, IntPtr); 5105 ValidGEP = 5106 Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid); 5107 } else if (!IsSubtraction) { 5108 // GEP is computed as `unsigned base + unsigned offset`, therefore the 5109 // computed pointer can not be [unsigned] less than base pointer, 5110 // unless there was an overflow. 5111 // Equivalent to `@llvm.uadd.with.overflow(%base, %offset)`. 5112 ValidGEP = Builder.CreateICmpUGE(ComputedGEP, IntPtr); 5113 } else { 5114 // GEP is computed as `unsigned base - unsigned offset`, therefore the 5115 // computed pointer can not be [unsigned] greater than base pointer, 5116 // unless there was an overflow. 5117 // Equivalent to `@llvm.usub.with.overflow(%base, sub(0, %offset))`. 5118 ValidGEP = Builder.CreateICmpULE(ComputedGEP, IntPtr); 5119 } 5120 ValidGEP = Builder.CreateAnd(ValidGEP, NoOffsetOverflow); 5121 Checks.emplace_back(ValidGEP, SanitizerKind::PointerOverflow); 5122 } 5123 5124 assert(!Checks.empty() && "Should have produced some checks.")((void)0); 5125 5126 llvm::Constant *StaticArgs[] = {EmitCheckSourceLocation(Loc)}; 5127 // Pass the computed GEP to the runtime to avoid emitting poisoned arguments. 5128 llvm::Value *DynamicArgs[] = {IntPtr, ComputedGEP}; 5129 EmitCheck(Checks, SanitizerHandler::PointerOverflow, StaticArgs, DynamicArgs); 5130 5131 return GEPVal; 5132}

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include/clang/AST/ASTContext.h

→

1//===- ASTContext.h - Context to hold long-lived AST nodes ------*- 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/// Defines the clang::ASTContext interface.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
15#define LLVM_CLANG_AST_ASTCONTEXT_H

17#include "clang/AST/ASTContextAllocate.h"
18#include "clang/AST/ASTFwd.h"
19#include "clang/AST/CanonicalType.h"
20#include "clang/AST/CommentCommandTraits.h"
21#include "clang/AST/ComparisonCategories.h"
22#include "clang/AST/Decl.h"
23#include "clang/AST/DeclBase.h"
24#include "clang/AST/DeclarationName.h"
25#include "clang/AST/ExternalASTSource.h"
26#include "clang/AST/NestedNameSpecifier.h"
27#include "clang/AST/PrettyPrinter.h"
28#include "clang/AST/RawCommentList.h"
29#include "clang/AST/TemplateName.h"
30#include "clang/AST/Type.h"
31#include "clang/Basic/AddressSpaces.h"
32#include "clang/Basic/AttrKinds.h"
33#include "clang/Basic/IdentifierTable.h"
34#include "clang/Basic/LLVM.h"
35#include "clang/Basic/LangOptions.h"
36#include "clang/Basic/Linkage.h"
37#include "clang/Basic/NoSanitizeList.h"
38#include "clang/Basic/OperatorKinds.h"
39#include "clang/Basic/PartialDiagnostic.h"
40#include "clang/Basic/ProfileList.h"
41#include "clang/Basic/SourceLocation.h"
42#include "clang/Basic/Specifiers.h"
43#include "clang/Basic/TargetCXXABI.h"
44#include "clang/Basic/XRayLists.h"
45#include "llvm/ADT/APSInt.h"
46#include "llvm/ADT/ArrayRef.h"
47#include "llvm/ADT/DenseMap.h"
48#include "llvm/ADT/DenseSet.h"
49#include "llvm/ADT/FoldingSet.h"
50#include "llvm/ADT/IntrusiveRefCntPtr.h"
51#include "llvm/ADT/MapVector.h"
52#include "llvm/ADT/None.h"
53#include "llvm/ADT/Optional.h"
54#include "llvm/ADT/PointerIntPair.h"
55#include "llvm/ADT/PointerUnion.h"
56#include "llvm/ADT/SmallVector.h"
57#include "llvm/ADT/StringMap.h"
58#include "llvm/ADT/StringRef.h"
59#include "llvm/ADT/TinyPtrVector.h"
60#include "llvm/ADT/Triple.h"
61#include "llvm/ADT/iterator_range.h"
62#include "llvm/Support/AlignOf.h"
63#include "llvm/Support/Allocator.h"
64#include "llvm/Support/Casting.h"
65#include "llvm/Support/Compiler.h"
66#include "llvm/Support/TypeSize.h"
67#include <cassert>
68#include <cstddef>
69#include <cstdint>
70#include <iterator>
71#include <memory>
72#include <string>
73#include <type_traits>
74#include <utility>
75#include <vector>

77namespace llvm {

79class APFixedPoint;
80class FixedPointSemantics;
81struct fltSemantics;
82template <typename T, unsigned N> class SmallPtrSet;

84} // namespace llvm

86namespace clang {

88class APValue;
89class ASTMutationListener;
90class ASTRecordLayout;
91class AtomicExpr;
92class BlockExpr;
93class BuiltinTemplateDecl;
94class CharUnits;
95class ConceptDecl;
96class CXXABI;
97class CXXConstructorDecl;
98class CXXMethodDecl;
99class CXXRecordDecl;
100class DiagnosticsEngine;
101class ParentMapContext;
102class DynTypedNode;
103class DynTypedNodeList;
104class Expr;
105class GlobalDecl;
106class ItaniumMangleContext;
107class MangleContext;
108class MangleNumberingContext;
109class MaterializeTemporaryExpr;
110class MemberSpecializationInfo;
111class Module;
112struct MSGuidDeclParts;
113class ObjCCategoryDecl;
114class ObjCCategoryImplDecl;
115class ObjCContainerDecl;
116class ObjCImplDecl;
117class ObjCImplementationDecl;
118class ObjCInterfaceDecl;
119class ObjCIvarDecl;
120class ObjCMethodDecl;
121class ObjCPropertyDecl;
122class ObjCPropertyImplDecl;
123class ObjCProtocolDecl;
124class ObjCTypeParamDecl;
125class OMPTraitInfo;
126struct ParsedTargetAttr;
127class Preprocessor;
128class Stmt;
129class StoredDeclsMap;
130class TargetAttr;
131class TargetInfo;
132class TemplateDecl;
133class TemplateParameterList;
134class TemplateTemplateParmDecl;
135class TemplateTypeParmDecl;
136class UnresolvedSetIterator;
137class UsingShadowDecl;
138class VarTemplateDecl;
139class VTableContextBase;
140struct BlockVarCopyInit;

142namespace Builtin {

144class Context;

146} // namespace Builtin

148enum BuiltinTemplateKind : int;
149enum OpenCLTypeKind : uint8_t;

151namespace comments {

153class FullComment;

155} // namespace comments

157namespace interp {

159class Context;

161} // namespace interp

163namespace serialization {
164template <class> class AbstractTypeReader;
165} // namespace serialization

167struct TypeInfo {
uint64_t Width = 0;
unsigned Align = 0;
bool AlignIsRequired : 1;

TypeInfo() : AlignIsRequired(false) {}
TypeInfo(uint64_t Width, unsigned Align, bool AlignIsRequired)
    : Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
175};

177struct TypeInfoChars {
CharUnits Width;
CharUnits Align;
bool AlignIsRequired : 1;

TypeInfoChars() : AlignIsRequired(false) {}
TypeInfoChars(CharUnits Width, CharUnits Align, bool AlignIsRequired)
    : Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
185};

187/// Holds long-lived AST nodes (such as types and decls) that can be
188/// referred to throughout the semantic analysis of a file.
189class ASTContext : public RefCountedBase<ASTContext> {
friend class NestedNameSpecifier;

mutable SmallVector<Type *, 0> Types;
mutable llvm::FoldingSet<ExtQuals> ExtQualNodes;
mutable llvm::FoldingSet<ComplexType> ComplexTypes;
mutable llvm::FoldingSet<PointerType> PointerTypes;
mutable llvm::FoldingSet<AdjustedType> AdjustedTypes;
mutable llvm::FoldingSet<BlockPointerType> BlockPointerTypes;
mutable llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;
mutable llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;
mutable llvm::FoldingSet<MemberPointerType> MemberPointerTypes;
mutable llvm::ContextualFoldingSet<ConstantArrayType, ASTContext &>
    ConstantArrayTypes;
mutable llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;
mutable std::vector<VariableArrayType*> VariableArrayTypes;
mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;
mutable llvm::FoldingSet<DependentSizedExtVectorType>
  DependentSizedExtVectorTypes;
mutable llvm::FoldingSet<DependentAddressSpaceType>
    DependentAddressSpaceTypes;
mutable llvm::FoldingSet<VectorType> VectorTypes;
mutable llvm::FoldingSet<DependentVectorType> DependentVectorTypes;
mutable llvm::FoldingSet<ConstantMatrixType> MatrixTypes;
mutable llvm::FoldingSet<DependentSizedMatrixType> DependentSizedMatrixTypes;
mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>
  FunctionProtoTypes;
mutable llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;
mutable llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;
mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
mutable llvm::FoldingSet<ObjCTypeParamType> ObjCTypeParamTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmType>
  SubstTemplateTypeParmTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>
  SubstTemplateTypeParmPackTypes;
mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>
  TemplateSpecializationTypes;
mutable llvm::FoldingSet<ParenType> ParenTypes;
mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes;
mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;
mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,
                                   ASTContext&>
  DependentTemplateSpecializationTypes;
llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;
mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
mutable llvm::FoldingSet<DependentUnaryTransformType>
  DependentUnaryTransformTypes;
mutable llvm::ContextualFoldingSet<AutoType, ASTContext&> AutoTypes;
mutable llvm::FoldingSet<DeducedTemplateSpecializationType>
  DeducedTemplateSpecializationTypes;
mutable llvm::FoldingSet<AtomicType> AtomicTypes;
llvm::FoldingSet<AttributedType> AttributedTypes;
mutable llvm::FoldingSet<PipeType> PipeTypes;
mutable llvm::FoldingSet<ExtIntType> ExtIntTypes;
mutable llvm::FoldingSet<DependentExtIntType> DependentExtIntTypes;

mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
  SubstTemplateTemplateParms;
mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
                                   ASTContext&>
  SubstTemplateTemplateParmPacks;

/// The set of nested name specifiers.
///
/// This set is managed by the NestedNameSpecifier class.
mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;

/// A cache mapping from RecordDecls to ASTRecordLayouts.
///
/// This is lazily created.  This is intentionally not serialized.
mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>
  ASTRecordLayouts;
mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>
  ObjCLayouts;

/// A cache from types to size and alignment information.
using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
mutable TypeInfoMap MemoizedTypeInfo;

/// A cache from types to unadjusted alignment information. Only ARM and
/// AArch64 targets need this information, keeping it separate prevents
/// imposing overhead on TypeInfo size.
using UnadjustedAlignMap = llvm::DenseMap<const Type *, unsigned>;
mutable UnadjustedAlignMap MemoizedUnadjustedAlign;

/// A cache mapping from CXXRecordDecls to key functions.
llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;

/// Mapping from ObjCContainers to their ObjCImplementations.
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;

/// Mapping from ObjCMethod to its duplicate declaration in the same
/// interface.
llvm::DenseMap<const ObjCMethodDecl*,const ObjCMethodDecl*> ObjCMethodRedecls;

/// Mapping from __block VarDecls to BlockVarCopyInit.
llvm::DenseMap<const VarDecl *, BlockVarCopyInit> BlockVarCopyInits;

/// Mapping from GUIDs to the corresponding MSGuidDecl.
mutable llvm::FoldingSet<MSGuidDecl> MSGuidDecls;

/// Mapping from APValues to the corresponding TemplateParamObjects.
mutable llvm::FoldingSet<TemplateParamObjectDecl> TemplateParamObjectDecls;

/// A cache mapping a string value to a StringLiteral object with the same
/// value.
///
/// This is lazily created.  This is intentionally not serialized.
mutable llvm::StringMap<StringLiteral *> StringLiteralCache;

/// MD5 hash of CUID. It is calculated when first used and cached by this
/// data member.
mutable std::string CUIDHash;

/// Representation of a "canonical" template template parameter that
/// is used in canonical template names.
class CanonicalTemplateTemplateParm : public llvm::FoldingSetNode {
  TemplateTemplateParmDecl *Parm;

public:
  CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm)
      : Parm(Parm) {}

  TemplateTemplateParmDecl *getParam() const { return Parm; }

  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) {
    Profile(ID, C, Parm);
  }

  static void Profile(llvm::FoldingSetNodeID &ID,
                      const ASTContext &C,
                      TemplateTemplateParmDecl *Parm);
};
mutable llvm::ContextualFoldingSet<CanonicalTemplateTemplateParm,
                                   const ASTContext&>
  CanonTemplateTemplateParms;

TemplateTemplateParmDecl *
  getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const;

/// The typedef for the __int128_t type.
mutable TypedefDecl *Int128Decl = nullptr;

/// The typedef for the __uint128_t type.
mutable TypedefDecl *UInt128Decl = nullptr;

/// The typedef for the target specific predefined
/// __builtin_va_list type.
mutable TypedefDecl *BuiltinVaListDecl = nullptr;

/// The typedef for the predefined \c __builtin_ms_va_list type.
mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;

/// The typedef for the predefined \c id type.
mutable TypedefDecl *ObjCIdDecl = nullptr;

/// The typedef for the predefined \c SEL type.
mutable TypedefDecl *ObjCSelDecl = nullptr;

/// The typedef for the predefined \c Class type.
mutable TypedefDecl *ObjCClassDecl = nullptr;

/// The typedef for the predefined \c Protocol class in Objective-C.
mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;

/// The typedef for the predefined 'BOOL' type.
mutable TypedefDecl *BOOLDecl = nullptr;

// Typedefs which may be provided defining the structure of Objective-C
// pseudo-builtins
QualType ObjCIdRedefinitionType;
QualType ObjCClassRedefinitionType;
QualType ObjCSelRedefinitionType;

/// The identifier 'bool'.
mutable IdentifierInfo *BoolName = nullptr;

/// The identifier 'NSObject'.
mutable IdentifierInfo *NSObjectName = nullptr;

/// The identifier 'NSCopying'.
IdentifierInfo *NSCopyingName = nullptr;

/// The identifier '__make_integer_seq'.
mutable IdentifierInfo *MakeIntegerSeqName = nullptr;

/// The identifier '__type_pack_element'.
mutable IdentifierInfo *TypePackElementName = nullptr;

QualType ObjCConstantStringType;
mutable RecordDecl *CFConstantStringTagDecl = nullptr;
mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;

mutable QualType ObjCSuperType;

QualType ObjCNSStringType;

/// The typedef declaration for the Objective-C "instancetype" type.
TypedefDecl *ObjCInstanceTypeDecl = nullptr;

/// The type for the C FILE type.
TypeDecl *FILEDecl = nullptr;

/// The type for the C jmp_buf type.
TypeDecl *jmp_bufDecl = nullptr;

/// The type for the C sigjmp_buf type.
TypeDecl *sigjmp_bufDecl = nullptr;

/// The type for the C ucontext_t type.
TypeDecl *ucontext_tDecl = nullptr;

/// Type for the Block descriptor for Blocks CodeGen.
///
/// Since this is only used for generation of debug info, it is not
/// serialized.
mutable RecordDecl *BlockDescriptorType = nullptr;

/// Type for the Block descriptor for Blocks CodeGen.
///
/// Since this is only used for generation of debug info, it is not
/// serialized.
mutable RecordDecl *BlockDescriptorExtendedType = nullptr;

/// Declaration for the CUDA cudaConfigureCall function.
FunctionDecl *cudaConfigureCallDecl = nullptr;

/// Keeps track of all declaration attributes.
///
/// Since so few decls have attrs, we keep them in a hash map instead of
/// wasting space in the Decl class.
llvm::DenseMap<const Decl*, AttrVec*> DeclAttrs;

/// A mapping from non-redeclarable declarations in modules that were
/// merged with other declarations to the canonical declaration that they were
/// merged into.
llvm::DenseMap<Decl*, Decl*> MergedDecls;

/// A mapping from a defining declaration to a list of modules (other
/// than the owning module of the declaration) that contain merged
/// definitions of that entity.
llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;

/// Initializers for a module, in order. Each Decl will be either
/// something that has a semantic effect on startup (such as a variable with
/// a non-constant initializer), or an ImportDecl (which recursively triggers
/// initialization of another module).
struct PerModuleInitializers {
  llvm::SmallVector<Decl*, 4> Initializers;
  llvm::SmallVector<uint32_t, 4> LazyInitializers;

  void resolve(ASTContext &Ctx);
};
llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;

ASTContext &this_() { return *this; }

451public:
/// A type synonym for the TemplateOrInstantiation mapping.
using TemplateOrSpecializationInfo =
    llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *>;

456private:
friend class ASTDeclReader;
friend class ASTReader;
friend class ASTWriter;
template <class> friend class serialization::AbstractTypeReader;
friend class CXXRecordDecl;
friend class IncrementalParser;

/// A mapping to contain the template or declaration that
/// a variable declaration describes or was instantiated from,
/// respectively.
///
/// For non-templates, this value will be NULL. For variable
/// declarations that describe a variable template, this will be a
/// pointer to a VarTemplateDecl. For static data members
/// of class template specializations, this will be the
/// MemberSpecializationInfo referring to the member variable that was
/// instantiated or specialized. Thus, the mapping will keep track of
/// the static data member templates from which static data members of
/// class template specializations were instantiated.
///
/// Given the following example:
///
/// \code
/// template<typename T>
/// struct X {
///   static T value;
/// };
///
/// template<typename T>
///   T X<T>::value = T(17);
///
/// int *x = &X<int>::value;
/// \endcode
///
/// This mapping will contain an entry that maps from the VarDecl for
/// X<int>::value to the corresponding VarDecl for X<T>::value (within the
/// class template X) and will be marked TSK_ImplicitInstantiation.
llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
TemplateOrInstantiation;

/// Keeps track of the declaration from which a using declaration was
/// created during instantiation.
///
/// The source and target declarations are always a UsingDecl, an
/// UnresolvedUsingValueDecl, or an UnresolvedUsingTypenameDecl.
///
/// For example:
/// \code
/// template<typename T>
/// struct A {
///   void f();
/// };
///
/// template<typename T>
/// struct B : A<T> {
///   using A<T>::f;
/// };
///
/// template struct B<int>;
/// \endcode
///
/// This mapping will contain an entry that maps from the UsingDecl in
/// B<int> to the UnresolvedUsingDecl in B<T>.
llvm::DenseMap<NamedDecl *, NamedDecl *> InstantiatedFromUsingDecl;

/// Like InstantiatedFromUsingDecl, but for using-enum-declarations. Maps
/// from the instantiated using-enum to the templated decl from whence it
/// came.
/// Note that using-enum-declarations cannot be dependent and
/// thus will never be instantiated from an "unresolved"
/// version thereof (as with using-declarations), so each mapping is from
/// a (resolved) UsingEnumDecl to a (resolved) UsingEnumDecl.
llvm::DenseMap<UsingEnumDecl *, UsingEnumDecl *>
    InstantiatedFromUsingEnumDecl;

/// Simlarly maps instantiated UsingShadowDecls to their origin.
llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
  InstantiatedFromUsingShadowDecl;

llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;

/// Mapping that stores the methods overridden by a given C++
/// member function.
///
/// Since most C++ member functions aren't virtual and therefore
/// don't override anything, we store the overridden functions in
/// this map on the side rather than within the CXXMethodDecl structure.
using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>;
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;

/// Mapping from each declaration context to its corresponding
/// mangling numbering context (used for constructs like lambdas which
/// need to be consistently numbered for the mangler).
llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>
    MangleNumberingContexts;
llvm::DenseMap<const Decl *, std::unique_ptr<MangleNumberingContext>>
    ExtraMangleNumberingContexts;

/// Side-table of mangling numbers for declarations which rarely
/// need them (like static local vars).
llvm::MapVector<const NamedDecl *, unsigned> MangleNumbers;
llvm::MapVector<const VarDecl *, unsigned> StaticLocalNumbers;
/// Mapping the associated device lambda mangling number if present.
mutable llvm::DenseMap<const CXXRecordDecl *, unsigned>
    DeviceLambdaManglingNumbers;

/// Mapping that stores parameterIndex values for ParmVarDecls when
/// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex.
using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;
ParameterIndexTable ParamIndices;

ImportDecl *FirstLocalImport = nullptr;
ImportDecl *LastLocalImport = nullptr;

TranslationUnitDecl *TUDecl = nullptr;
mutable ExternCContextDecl *ExternCContext = nullptr;
mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;

/// The associated SourceManager object.
SourceManager &SourceMgr;

/// The language options used to create the AST associated with
///  this ASTContext object.
LangOptions &LangOpts;

/// NoSanitizeList object that is used by sanitizers to decide which
/// entities should not be instrumented.
std::unique_ptr<NoSanitizeList> NoSanitizeL;

/// Function filtering mechanism to determine whether a given function
/// should be imbued with the XRay "always" or "never" attributes.
std::unique_ptr<XRayFunctionFilter> XRayFilter;

/// ProfileList object that is used by the profile instrumentation
/// to decide which entities should be instrumented.
std::unique_ptr<ProfileList> ProfList;

/// The allocator used to create AST objects.
///
/// AST objects are never destructed; rather, all memory associated with the
/// AST objects will be released when the ASTContext itself is destroyed.
mutable llvm::BumpPtrAllocator BumpAlloc;

/// Allocator for partial diagnostics.
PartialDiagnostic::DiagStorageAllocator DiagAllocator;

/// The current C++ ABI.
std::unique_ptr<CXXABI> ABI;
CXXABI *createCXXABI(const TargetInfo &T);

/// The logical -> physical address space map.
const LangASMap *AddrSpaceMap = nullptr;

/// Address space map mangling must be used with language specific
/// address spaces (e.g. OpenCL/CUDA)
bool AddrSpaceMapMangling;

const TargetInfo *Target = nullptr;
const TargetInfo *AuxTarget = nullptr;
clang::PrintingPolicy PrintingPolicy;
std::unique_ptr<interp::Context> InterpContext;
std::unique_ptr<ParentMapContext> ParentMapCtx;

/// Keeps track of the deallocated DeclListNodes for future reuse.
DeclListNode *ListNodeFreeList = nullptr;

624public:
IdentifierTable &Idents;
SelectorTable &Selectors;
Builtin::Context &BuiltinInfo;
const TranslationUnitKind TUKind;
mutable DeclarationNameTable DeclarationNames;
IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;
ASTMutationListener *Listener = nullptr;

/// Returns the clang bytecode interpreter context.
interp::Context &getInterpContext();

/// Returns the dynamic AST node parent map context.
ParentMapContext &getParentMapContext();

// A traversal scope limits the parts of the AST visible to certain analyses.
// RecursiveASTVisitor only visits specified children of TranslationUnitDecl.
// getParents() will only observe reachable parent edges.
//
// The scope is defined by a set of "top-level" declarations which will be
// visible under the TranslationUnitDecl.
// Initially, it is the entire TU, represented by {getTranslationUnitDecl()}.
//
// After setTraversalScope({foo, bar}), the exposed AST looks like:
// TranslationUnitDecl
//  - foo
//    - ...
//  - bar
//    - ...
// All other siblings of foo and bar are pruned from the tree.
// (However they are still accessible via TranslationUnitDecl->decls())
//
// Changing the scope clears the parent cache, which is expensive to rebuild.
std::vector<Decl *> getTraversalScope() const { return TraversalScope; }
void setTraversalScope(const std::vector<Decl *> &);

/// Forwards to get node parents from the ParentMapContext. New callers should
/// use ParentMapContext::getParents() directly.
template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);

const clang::PrintingPolicy &getPrintingPolicy() const {
  return PrintingPolicy;
}

void setPrintingPolicy(const clang::PrintingPolicy &Policy) {
  PrintingPolicy = Policy;
}

SourceManager& getSourceManager() { return SourceMgr; }
const SourceManager& getSourceManager() const { return SourceMgr; }

llvm::BumpPtrAllocator &getAllocator() const {
  return BumpAlloc;
}

void *Allocate(size_t Size, unsigned Align = 8) const {
  return BumpAlloc.Allocate(Size, Align);
}
template <typename T> T *Allocate(size_t Num = 1) const {
  return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
}
void Deallocate(void *Ptr) const {}

/// Allocates a \c DeclListNode or returns one from the \c ListNodeFreeList
/// pool.
DeclListNode *AllocateDeclListNode(clang::NamedDecl *ND) {
  if (DeclListNode *Alloc = ListNodeFreeList) {
    ListNodeFreeList = Alloc->Rest.dyn_cast<DeclListNode*>();
    Alloc->D = ND;
    Alloc->Rest = nullptr;
    return Alloc;
  }
  return new (*this) DeclListNode(ND);
}
/// Deallcates a \c DeclListNode by returning it to the \c ListNodeFreeList
/// pool.
void DeallocateDeclListNode(DeclListNode *N) {
  N->Rest = ListNodeFreeList;
  ListNodeFreeList = N;
}

/// Return the total amount of physical memory allocated for representing
/// AST nodes and type information.
size_t getASTAllocatedMemory() const {
  return BumpAlloc.getTotalMemory();
}

/// Return the total memory used for various side tables.
size_t getSideTableAllocatedMemory() const;

PartialDiagnostic::DiagStorageAllocator &getDiagAllocator() {
  return DiagAllocator;
}

const TargetInfo &getTargetInfo() const { return *Target; }
const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }

/// getIntTypeForBitwidth -
/// sets integer QualTy according to specified details:
/// bitwidth, signed/unsigned.
/// Returns empty type if there is no appropriate target types.
QualType getIntTypeForBitwidth(unsigned DestWidth,
                               unsigned Signed) const;

/// getRealTypeForBitwidth -
/// sets floating point QualTy according to specified bitwidth.
/// Returns empty type if there is no appropriate target types.
QualType getRealTypeForBitwidth(unsigned DestWidth, bool ExplicitIEEE) const;

bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const;

const LangOptions& getLangOpts() const { return LangOpts; }

// If this condition is false, typo correction must be performed eagerly
// rather than delayed in many places, as it makes use of dependent types.
// the condition is false for clang's C-only codepath, as it doesn't support
// dependent types yet.
bool isDependenceAllowed() const {
  return LangOpts.CPlusPlus || LangOpts.RecoveryAST;
}

const NoSanitizeList &getNoSanitizeList() const { return *NoSanitizeL; }

const XRayFunctionFilter &getXRayFilter() const {
  return *XRayFilter;
}

const ProfileList &getProfileList() const { return *ProfList; }

DiagnosticsEngine &getDiagnostics() const;

FullSourceLoc getFullLoc(SourceLocation Loc) const {
  return FullSourceLoc(Loc,SourceMgr);
}

/// Return the C++ ABI kind that should be used. The C++ ABI can be overriden
/// at compile time with `-fc++-abi=`. If this is not provided, we instead use
/// the default ABI set by the target.
TargetCXXABI::Kind getCXXABIKind() const;

/// All comments in this translation unit.
RawCommentList Comments;

/// True if comments are already loaded from ExternalASTSource.
mutable bool CommentsLoaded = false;

/// Mapping from declaration to directly attached comment.
///
/// Raw comments are owned by Comments list.  This mapping is populated
/// lazily.
mutable llvm::DenseMap<const Decl *, const RawComment *> DeclRawComments;

/// Mapping from canonical declaration to the first redeclaration in chain
/// that has a comment attached.
///
/// Raw comments are owned by Comments list.  This mapping is populated
/// lazily.
mutable llvm::DenseMap<const Decl *, const Decl *> RedeclChainComments;

/// Keeps track of redeclaration chains that don't have any comment attached.
/// Mapping from canonical declaration to redeclaration chain that has no
/// comments attached to any redeclaration. Specifically it's mapping to
/// the last redeclaration we've checked.
///
/// Shall not contain declarations that have comments attached to any
/// redeclaration in their chain.
mutable llvm::DenseMap<const Decl *, const Decl *> CommentlessRedeclChains;

/// Mapping from declarations to parsed comments attached to any
/// redeclaration.
mutable llvm::DenseMap<const Decl *, comments::FullComment *> ParsedComments;

/// Attaches \p Comment to \p OriginalD and to its redeclaration chain
/// and removes the redeclaration chain from the set of commentless chains.
///
/// Don't do anything if a comment has already been attached to \p OriginalD
/// or its redeclaration chain.
void cacheRawCommentForDecl(const Decl &OriginalD,
                            const RawComment &Comment) const;

/// \returns searches \p CommentsInFile for doc comment for \p D.
///
/// \p RepresentativeLocForDecl is used as a location for searching doc
/// comments. \p CommentsInFile is a mapping offset -> comment of files in the
/// same file where \p RepresentativeLocForDecl is.
RawComment *getRawCommentForDeclNoCacheImpl(
    const Decl *D, const SourceLocation RepresentativeLocForDecl,
    const std::map<unsigned, RawComment *> &CommentsInFile) const;

/// Return the documentation comment attached to a given declaration,
/// without looking into cache.
RawComment *getRawCommentForDeclNoCache(const Decl *D) const;

817public:
void addComment(const RawComment &RC);

/// Return the documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached.
///
/// \param OriginalDecl if not nullptr, is set to declaration AST node that
/// had the comment, if the comment we found comes from a redeclaration.
const RawComment *
getRawCommentForAnyRedecl(const Decl *D,
                          const Decl **OriginalDecl = nullptr) const;

/// Searches existing comments for doc comments that should be attached to \p
/// Decls. If any doc comment is found, it is parsed.
///
/// Requirement: All \p Decls are in the same file.
///
/// If the last comment in the file is already attached we assume
/// there are not comments left to be attached to \p Decls.
void attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls,
                                     const Preprocessor *PP);

/// Return parsed documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached.
///
/// \param PP the Preprocessor used with this TU.  Could be nullptr if
/// preprocessor is not available.
comments::FullComment *getCommentForDecl(const Decl *D,
                                         const Preprocessor *PP) const;

/// Return parsed documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached. Does not look at any
/// redeclarations of the declaration.
comments::FullComment *getLocalCommentForDeclUncached(const Decl *D) const;

comments::FullComment *cloneFullComment(comments::FullComment *FC,
                                       const Decl *D) const;

855private:
mutable comments::CommandTraits CommentCommandTraits;

/// Iterator that visits import declarations.
class import_iterator {
  ImportDecl *Import = nullptr;

public:
  using value_type = ImportDecl *;
  using reference = ImportDecl *;
  using pointer = ImportDecl *;
  using difference_type = int;
  using iterator_category = std::forward_iterator_tag;

  import_iterator() = default;
  explicit import_iterator(ImportDecl *Import) : Import(Import) {}

  reference operator*() const { return Import; }
  pointer operator->() const { return Import; }

  import_iterator &operator++() {
    Import = ASTContext::getNextLocalImport(Import);
    return *this;
  }

  import_iterator operator++(int) {
    import_iterator Other(*this);
    ++(*this);
    return Other;
  }

  friend bool operator==(import_iterator X, import_iterator Y) {
    return X.Import == Y.Import;
  }

  friend bool operator!=(import_iterator X, import_iterator Y) {
    return X.Import != Y.Import;
  }
};

895public:
comments::CommandTraits &getCommentCommandTraits() const {
  return CommentCommandTraits;
}

/// Retrieve the attributes for the given declaration.
AttrVec& getDeclAttrs(const Decl *D);

/// Erase the attributes corresponding to the given declaration.
void eraseDeclAttrs(const Decl *D);

/// If this variable is an instantiated static data member of a
/// class template specialization, returns the templated static data member
/// from which it was instantiated.
// FIXME: Remove ?
MemberSpecializationInfo *getInstantiatedFromStaticDataMember(
                                                         const VarDecl *Var);

/// Note that the static data member \p Inst is an instantiation of
/// the static data member template \p Tmpl of a class template.
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
                                         TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

TemplateOrSpecializationInfo
getTemplateOrSpecializationInfo(const VarDecl *Var);

void setTemplateOrSpecializationInfo(VarDecl *Inst,
                                     TemplateOrSpecializationInfo TSI);

/// If the given using decl \p Inst is an instantiation of
/// another (possibly unresolved) using decl, return it.
NamedDecl *getInstantiatedFromUsingDecl(NamedDecl *Inst);

/// Remember that the using decl \p Inst is an instantiation
/// of the using decl \p Pattern of a class template.
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern);

/// If the given using-enum decl \p Inst is an instantiation of
/// another using-enum decl, return it.
UsingEnumDecl *getInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst);

/// Remember that the using enum decl \p Inst is an instantiation
/// of the using enum decl \p Pattern of a class template.
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst,
                                      UsingEnumDecl *Pattern);

UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
                                        UsingShadowDecl *Pattern);

FieldDecl *getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field);

void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl);

// Access to the set of methods overridden by the given C++ method.
using overridden_cxx_method_iterator = CXXMethodVector::const_iterator;
overridden_cxx_method_iterator
overridden_methods_begin(const CXXMethodDecl *Method) const;

overridden_cxx_method_iterator
overridden_methods_end(const CXXMethodDecl *Method) const;

unsigned overridden_methods_size(const CXXMethodDecl *Method) const;

using overridden_method_range =
    llvm::iterator_range<overridden_cxx_method_iterator>;

overridden_method_range overridden_methods(const CXXMethodDecl *Method) const;

/// Note that the given C++ \p Method overrides the given \p
/// Overridden method.
void addOverriddenMethod(const CXXMethodDecl *Method,
                         const CXXMethodDecl *Overridden);

/// Return C++ or ObjC overridden methods for the given \p Method.
///
/// An ObjC method is considered to override any method in the class's
/// base classes, its protocols, or its categories' protocols, that has
/// the same selector and is of the same kind (class or instance).
/// A method in an implementation is not considered as overriding the same
/// method in the interface or its categories.
void getOverriddenMethods(
                      const NamedDecl *Method,
                      SmallVectorImpl<const NamedDecl *> &Overridden) const;

/// Notify the AST context that a new import declaration has been
/// parsed or implicitly created within this translation unit.
void addedLocalImportDecl(ImportDecl *Import);

static ImportDecl *getNextLocalImport(ImportDecl *Import) {
  return Import->getNextLocalImport();
}

using import_range = llvm::iterator_range<import_iterator>;

import_range local_imports() const {
  return import_range(import_iterator(FirstLocalImport), import_iterator());
}

Decl *getPrimaryMergedDecl(Decl *D) {
  Decl *Result = MergedDecls.lookup(D);
  return Result ? Result : D;
}
void setPrimaryMergedDecl(Decl *D, Decl *Primary) {
  MergedDecls[D] = Primary;
}

/// Note that the definition \p ND has been merged into module \p M,
/// and should be visible whenever \p M is visible.
void mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
                               bool NotifyListeners = true);

/// Clean up the merged definition list. Call this if you might have
/// added duplicates into the list.
void deduplicateMergedDefinitonsFor(NamedDecl *ND);

/// Get the additional modules in which the definition \p Def has
/// been merged.
ArrayRef<Module*> getModulesWithMergedDefinition(const NamedDecl *Def);

/// Add a declaration to the list of declarations that are initialized
/// for a module. This will typically be a global variable (with internal
/// linkage) that runs module initializers, such as the iostream initializer,
/// or an ImportDecl nominating another module that has initializers.
void addModuleInitializer(Module *M, Decl *Init);

void addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs);

/// Get the initializations to perform when importing a module, if any.
ArrayRef<Decl*> getModuleInitializers(Module *M);

TranslationUnitDecl *getTranslationUnitDecl() const {
  return TUDecl->getMostRecentDecl();
}
void addTranslationUnitDecl() {
  assert(!TUDecl || TUKind == TU_Incremental)((void)0);
  TranslationUnitDecl *NewTUDecl = TranslationUnitDecl::Create(*this);
  if (TraversalScope.empty() || TraversalScope.back() == TUDecl)
    TraversalScope = {NewTUDecl};
  if (TUDecl)
    NewTUDecl->setPreviousDecl(TUDecl);
  TUDecl = NewTUDecl;
}

ExternCContextDecl *getExternCContextDecl() const;
BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;
BuiltinTemplateDecl *getTypePackElementDecl() const;

// Builtin Types.
CanQualType VoidTy;
CanQualType BoolTy;
CanQualType CharTy;
CanQualType WCharTy;  // [C++ 3.9.1p5].
CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.
CanQualType Char8Ty;  // [C++20 proposal]
CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;
CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
CanQualType UnsignedLongLongTy, UnsignedInt128Ty;
CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty;
CanQualType ShortAccumTy, AccumTy,
    LongAccumTy;  // ISO/IEC JTC1 SC22 WG14 N1169 Extension
CanQualType UnsignedShortAccumTy, UnsignedAccumTy, UnsignedLongAccumTy;
CanQualType ShortFractTy, FractTy, LongFractTy;
CanQualType UnsignedShortFractTy, UnsignedFractTy, UnsignedLongFractTy;
CanQualType SatShortAccumTy, SatAccumTy, SatLongAccumTy;
CanQualType SatUnsignedShortAccumTy, SatUnsignedAccumTy,
    SatUnsignedLongAccumTy;
CanQualType SatShortFractTy, SatFractTy, SatLongFractTy;
CanQualType SatUnsignedShortFractTy, SatUnsignedFractTy,
    SatUnsignedLongFractTy;
CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
CanQualType BFloat16Ty;
CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
CanQualType Float128ComplexTy;
CanQualType VoidPtrTy, NullPtrTy;
CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
CanQualType BuiltinFnTy;
CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
CanQualType ObjCBuiltinBoolTy;
1080#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
CanQualType SingletonId;
1082#include "clang/Basic/OpenCLImageTypes.def"
CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;
CanQualType OCLQueueTy, OCLReserveIDTy;
CanQualType IncompleteMatrixIdxTy;
CanQualType OMPArraySectionTy, OMPArrayShapingTy, OMPIteratorTy;
1087#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
CanQualType Id##Ty;
1089#include "clang/Basic/OpenCLExtensionTypes.def"
1090#define SVE_TYPE(Name, Id, SingletonId) \
CanQualType SingletonId;
1092#include "clang/Basic/AArch64SVEACLETypes.def"
1093#define PPC_VECTOR_TYPE(Name, Id, Size) \
CanQualType Id##Ty;
1095#include "clang/Basic/PPCTypes.def"
1096#define RVV_TYPE(Name, Id, SingletonId) \
CanQualType SingletonId;
1098#include "clang/Basic/RISCVVTypes.def"

// Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
mutable QualType AutoDeductTy;     // Deduction against 'auto'.
mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.

// Decl used to help define __builtin_va_list for some targets.
// The decl is built when constructing 'BuiltinVaListDecl'.
mutable Decl *VaListTagDecl = nullptr;

// Implicitly-declared type 'struct _GUID'.
mutable TagDecl *MSGuidTagDecl = nullptr;

/// Keep track of CUDA/HIP device-side variables ODR-used by host code.
llvm::DenseSet<const VarDecl *> CUDADeviceVarODRUsedByHost;

ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents,
           SelectorTable &sels, Builtin::Context &builtins,
           TranslationUnitKind TUKind);
ASTContext(const ASTContext &) = delete;
ASTContext &operator=(const ASTContext &) = delete;
~ASTContext();

/// Attach an external AST source to the AST context.
///
/// The external AST source provides the ability to load parts of
/// the abstract syntax tree as needed from some external storage,
/// e.g., a precompiled header.
void setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source);

/// Retrieve a pointer to the external AST source associated
/// with this AST context, if any.
ExternalASTSource *getExternalSource() const {
  return ExternalSource.get();
}

/// Attach an AST mutation listener to the AST context.
///
/// The AST mutation listener provides the ability to track modifications to
/// the abstract syntax tree entities committed after they were initially
/// created.
void setASTMutationListener(ASTMutationListener *Listener) {
  this->Listener = Listener;
}

/// Retrieve a pointer to the AST mutation listener associated
/// with this AST context, if any.
ASTMutationListener *getASTMutationListener() const { return Listener; }

void PrintStats() const;
const SmallVectorImpl<Type *>& getTypes() const { return Types; }

BuiltinTemplateDecl *buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
                                              const IdentifierInfo *II) const;

/// Create a new implicit TU-level CXXRecordDecl or RecordDecl
/// declaration.
RecordDecl *buildImplicitRecord(StringRef Name,
                                RecordDecl::TagKind TK = TTK_Struct) const;

/// Create a new implicit TU-level typedef declaration.
TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;

/// Retrieve the declaration for the 128-bit signed integer type.
TypedefDecl *getInt128Decl() const;

/// Retrieve the declaration for the 128-bit unsigned integer type.
TypedefDecl *getUInt128Decl() const;

//===--------------------------------------------------------------------===//
//                           Type Constructors
//===--------------------------------------------------------------------===//

1171private:
/// Return a type with extended qualifiers.
QualType getExtQualType(const Type *Base, Qualifiers Quals) const;

QualType getTypeDeclTypeSlow(const TypeDecl *Decl) const;

QualType getPipeType(QualType T, bool ReadOnly) const;

1179public:
/// Return the uniqued reference to the type for an address space
/// qualified type with the specified type and address space.
///
/// The resulting type has a union of the qualifiers from T and the address
/// space. If T already has an address space specifier, it is silently
/// replaced.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const;

/// Remove any existing address space on the type and returns the type
/// with qualifiers intact (or that's the idea anyway)
///
/// The return type should be T with all prior qualifiers minus the address
/// space.
QualType removeAddrSpaceQualType(QualType T) const;

/// Apply Objective-C protocol qualifiers to the given type.
/// \param allowOnPointerType specifies if we can apply protocol
/// qualifiers on ObjCObjectPointerType. It can be set to true when
/// constructing the canonical type of a Objective-C type parameter.
QualType applyObjCProtocolQualifiers(QualType type,
    ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
    bool allowOnPointerType = false) const;

/// Return the uniqued reference to the type for an Objective-C
/// gc-qualified type.
///
/// The resulting type has a union of the qualifiers from T and the gc
/// attribute.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const;

/// Remove the existing address space on the type if it is a pointer size
/// address space and return the type with qualifiers intact.
QualType removePtrSizeAddrSpace(QualType T) const;

/// Return the uniqued reference to the type for a \c restrict
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and
/// \c restrict.
QualType getRestrictType(QualType T) const {
  return T.withFastQualifiers(Qualifiers::Restrict);
}

/// Return the uniqued reference to the type for a \c volatile
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and
/// \c volatile.
QualType getVolatileType(QualType T) const {
  return T.withFastQualifiers(Qualifiers::Volatile);
}

/// Return the uniqued reference to the type for a \c const
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and \c const.
///
/// It can be reasonably expected that this will always be equivalent to
/// calling T.withConst().
QualType getConstType(QualType T) const { return T.withConst(); }

/// Change the ExtInfo on a function type.
const FunctionType *adjustFunctionType(const FunctionType *Fn,
                                       FunctionType::ExtInfo EInfo);

/// Adjust the given function result type.
CanQualType getCanonicalFunctionResultType(QualType ResultType) const;

/// Change the result type of a function type once it is deduced.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType);

/// Get a function type and produce the equivalent function type with the
/// specified exception specification. Type sugar that can be present on a
/// declaration of a function with an exception specification is permitted
/// and preserved. Other type sugar (for instance, typedefs) is not.
QualType getFunctionTypeWithExceptionSpec(
    QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI);

/// Determine whether two function types are the same, ignoring
/// exception specifications in cases where they're part of the type.
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U);

/// Change the exception specification on a function once it is
/// delay-parsed, instantiated, or computed.
void adjustExceptionSpec(FunctionDecl *FD,
                         const FunctionProtoType::ExceptionSpecInfo &ESI,
                         bool AsWritten = false);

/// Get a function type and produce the equivalent function type where
/// pointer size address spaces in the return type and parameter tyeps are
/// replaced with the default address space.
QualType getFunctionTypeWithoutPtrSizes(QualType T);

/// Determine whether two function types are the same, ignoring pointer sizes
/// in the return type and parameter types.
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U);

/// Return the uniqued reference to the type for a complex
/// number with the specified element type.
QualType getComplexType(QualType T) const;
CanQualType getComplexType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getComplexType((QualType) T));
}

/// Return the uniqued reference to the type for a pointer to
/// the specified type.
QualType getPointerType(QualType T) const;
CanQualType getPointerType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getPointerType((QualType) T));
}

/// Return the uniqued reference to a type adjusted from the original
/// type to a new type.
QualType getAdjustedType(QualType Orig, QualType New) const;
CanQualType getAdjustedType(CanQualType Orig, CanQualType New) const {
  return CanQualType::CreateUnsafe(
      getAdjustedType((QualType)Orig, (QualType)New));
}

/// Return the uniqued reference to the decayed version of the given
/// type.  Can only be called on array and function types which decay to
/// pointer types.
QualType getDecayedType(QualType T) const;
CanQualType getDecayedType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getDecayedType((QualType) T));
}

/// Return the uniqued reference to the atomic type for the specified
/// type.
QualType getAtomicType(QualType T) const;

/// Return the uniqued reference to the type for a block of the
/// specified type.
QualType getBlockPointerType(QualType T) const;

/// Gets the struct used to keep track of the descriptor for pointer to
/// blocks.
QualType getBlockDescriptorType() const;

/// Return a read_only pipe type for the specified type.
QualType getReadPipeType(QualType T) const;

/// Return a write_only pipe type for the specified type.
QualType getWritePipeType(QualType T) const;

/// Return an extended integer type with the specified signedness and bit
/// count.
QualType getExtIntType(bool Unsigned, unsigned NumBits) const;

/// Return a dependent extended integer type with the specified signedness and
/// bit count.
QualType getDependentExtIntType(bool Unsigned, Expr *BitsExpr) const;

/// Gets the struct used to keep track of the extended descriptor for
/// pointer to blocks.
QualType getBlockDescriptorExtendedType() const;

/// Map an AST Type to an OpenCLTypeKind enum value.
OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;

/// Get address space for OpenCL type.
LangAS getOpenCLTypeAddrSpace(const Type *T) const;

void setcudaConfigureCallDecl(FunctionDecl *FD) {
  cudaConfigureCallDecl = FD;
}

FunctionDecl *getcudaConfigureCallDecl() {
  return cudaConfigureCallDecl;
}

/// Returns true iff we need copy/dispose helpers for the given type.
bool BlockRequiresCopying(QualType Ty, const VarDecl *D);

/// Returns true, if given type has a known lifetime. HasByrefExtendedLayout
/// is set to false in this case. If HasByrefExtendedLayout returns true,
/// byref variable has extended lifetime.
bool getByrefLifetime(QualType Ty,
                      Qualifiers::ObjCLifetime &Lifetime,
                      bool &HasByrefExtendedLayout) const;

/// Return the uniqued reference to the type for an lvalue reference
/// to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue = true)
  const;

/// Return the uniqued reference to the type for an rvalue reference
/// to the specified type.
QualType getRValueReferenceType(QualType T) const;

/// Return the uniqued reference to the type for a member pointer to
/// the specified type in the specified class.
///
/// The class \p Cls is a \c Type because it could be a dependent name.
QualType getMemberPointerType(QualType T, const Type *Cls) const;

/// Return a non-unique reference to the type for a variable array of
/// the specified element type.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts,
                              ArrayType::ArraySizeModifier ASM,
                              unsigned IndexTypeQuals,
                              SourceRange Brackets) const;

/// Return a non-unique reference to the type for a dependently-sized
/// array of the specified element type.
///
/// FIXME: We will need these to be uniqued, or at least comparable, at some
/// point.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts,
                                    ArrayType::ArraySizeModifier ASM,
                                    unsigned IndexTypeQuals,
                                    SourceRange Brackets) const;

/// Return a unique reference to the type for an incomplete array of
/// the specified element type.
QualType getIncompleteArrayType(QualType EltTy,
                                ArrayType::ArraySizeModifier ASM,
                                unsigned IndexTypeQuals) const;

/// Return the unique reference to the type for a constant array of
/// the specified element type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,
                              const Expr *SizeExpr,
                              ArrayType::ArraySizeModifier ASM,
                              unsigned IndexTypeQuals) const;

/// Return a type for a constant array for a string literal of the
/// specified element type and length.
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const;

/// Returns a vla type where known sizes are replaced with [*].
QualType getVariableArrayDecayedType(QualType Ty) const;

// Convenience struct to return information about a builtin vector type.
struct BuiltinVectorTypeInfo {
  QualType ElementType;
  llvm::ElementCount EC;
  unsigned NumVectors;
  BuiltinVectorTypeInfo(QualType ElementType, llvm::ElementCount EC,
                        unsigned NumVectors)
      : ElementType(ElementType), EC(EC), NumVectors(NumVectors) {}
};

/// Returns the element type, element count and number of vectors
/// (in case of tuple) for a builtin vector type.
BuiltinVectorTypeInfo
getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const;

/// Return the unique reference to a scalable vector type of the specified
/// element type and scalable number of elements.
///
/// \pre \p EltTy must be a built-in type.
QualType getScalableVectorType(QualType EltTy, unsigned NumElts) const;

/// Return the unique reference to a vector type of the specified
/// element type and size.
///
/// \pre \p VectorType must be a built-in type.
QualType getVectorType(QualType VectorType, unsigned NumElts,
                       VectorType::VectorKind VecKind) const;
/// Return the unique reference to the type for a dependently sized vector of
/// the specified element type.
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr,
                                SourceLocation AttrLoc,
                                VectorType::VectorKind VecKind) const;

/// Return the unique reference to an extended vector type
/// of the specified element type and size.
///
/// \pre \p VectorType must be a built-in type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const;

/// \pre Return a non-unique reference to the type for a dependently-sized
/// vector of the specified element type.
///
/// FIXME: We will need these to be uniqued, or at least comparable, at some
/// point.
QualType getDependentSizedExtVectorType(QualType VectorType,
                                        Expr *SizeExpr,
                                        SourceLocation AttrLoc) const;

/// Return the unique reference to the matrix type of the specified element
/// type and size
///
/// \pre \p ElementType must be a valid matrix element type (see
/// MatrixType::isValidElementType).
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows,
                               unsigned NumColumns) const;

/// Return the unique reference to the matrix type of the specified element
/// type and size
QualType getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
                                     Expr *ColumnExpr,
                                     SourceLocation AttrLoc) const;

QualType getDependentAddressSpaceType(QualType PointeeType,
                                      Expr *AddrSpaceExpr,
                                      SourceLocation AttrLoc) const;

/// Return a K&R style C function type like 'int()'.
QualType getFunctionNoProtoType(QualType ResultTy,
                                const FunctionType::ExtInfo &Info) const;

QualType getFunctionNoProtoType(QualType ResultTy) const {
  return getFunctionNoProtoType(ResultTy, FunctionType::ExtInfo());
}

/// Return a normal function type with a typed argument list.
QualType getFunctionType(QualType ResultTy, ArrayRef<QualType> Args,
                         const FunctionProtoType::ExtProtoInfo &EPI) const {
  return getFunctionTypeInternal(ResultTy, Args, EPI, false);
}

QualType adjustStringLiteralBaseType(QualType StrLTy) const;

1495private:
/// Return a normal function type with a typed argument list.
QualType getFunctionTypeInternal(QualType ResultTy, ArrayRef<QualType> Args,
                                 const FunctionProtoType::ExtProtoInfo &EPI,
                                 bool OnlyWantCanonical) const;

1501public:
/// Return the unique reference to the type for the specified type
/// declaration.
QualType getTypeDeclType(const TypeDecl *Decl,
                         const TypeDecl *PrevDecl = nullptr) const {
  assert(Decl && "Passed null for Decl param")((void)0);
  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

  if (PrevDecl) {
    assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl")((void)0);
    Decl->TypeForDecl = PrevDecl->TypeForDecl;
    return QualType(PrevDecl->TypeForDecl, 0);
  }

  return getTypeDeclTypeSlow(Decl);
}

/// Return the unique reference to the type for the specified
/// typedef-name decl.
QualType getTypedefType(const TypedefNameDecl *Decl,
                        QualType Underlying = QualType()) const;

QualType getRecordType(const RecordDecl *Decl) const;

QualType getEnumType(const EnumDecl *Decl) const;

QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const;

QualType getAttributedType(attr::Kind attrKind,
                           QualType modifiedType,
                           QualType equivalentType);

QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced,
                                      QualType Replacement) const;
QualType getSubstTemplateTypeParmPackType(
                                        const TemplateTypeParmType *Replaced,
                                          const TemplateArgument &ArgPack);

QualType
getTemplateTypeParmType(unsigned Depth, unsigned Index,
                        bool ParameterPack,
                        TemplateTypeParmDecl *ParmDecl = nullptr) const;

QualType getTemplateSpecializationType(TemplateName T,
                                       ArrayRef<TemplateArgument> Args,
                                       QualType Canon = QualType()) const;

QualType
getCanonicalTemplateSpecializationType(TemplateName T,
                                       ArrayRef<TemplateArgument> Args) const;

QualType getTemplateSpecializationType(TemplateName T,
                                       const TemplateArgumentListInfo &Args,
                                       QualType Canon = QualType()) const;

TypeSourceInfo *
getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,
                                  const TemplateArgumentListInfo &Args,
                                  QualType Canon = QualType()) const;

QualType getParenType(QualType NamedType) const;

QualType getMacroQualifiedType(QualType UnderlyingTy,
                               const IdentifierInfo *MacroII) const;

QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
                           NestedNameSpecifier *NNS, QualType NamedType,
                           TagDecl *OwnedTagDecl = nullptr) const;
QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
                              NestedNameSpecifier *NNS,
                              const IdentifierInfo *Name,
                              QualType Canon = QualType()) const;

QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                                NestedNameSpecifier *NNS,
                                                const IdentifierInfo *Name,
                                  const TemplateArgumentListInfo &Args) const;
QualType getDependentTemplateSpecializationType(
    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
    const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;

TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl);

/// Get a template argument list with one argument per template parameter
/// in a template parameter list, such as for the injected class name of
/// a class template.
void getInjectedTemplateArgs(const TemplateParameterList *Params,
                             SmallVectorImpl<TemplateArgument> &Args);

/// Form a pack expansion type with the given pattern.
/// \param NumExpansions The number of expansions for the pack, if known.
/// \param ExpectPackInType If \c false, we should not expect \p Pattern to
///        contain an unexpanded pack. This only makes sense if the pack
///        expansion is used in a context where the arity is inferred from
///        elsewhere, such as if the pattern contains a placeholder type or
///        if this is the canonical type of another pack expansion type.
QualType getPackExpansionType(QualType Pattern,
                              Optional<unsigned> NumExpansions,
                              bool ExpectPackInType = true);

QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
                              ObjCInterfaceDecl *PrevDecl = nullptr) const;

/// Legacy interface: cannot provide type arguments or __kindof.
QualType getObjCObjectType(QualType Base,
                           ObjCProtocolDecl * const *Protocols,
                           unsigned NumProtocols) const;

QualType getObjCObjectType(QualType Base,
                           ArrayRef<QualType> typeArgs,
                           ArrayRef<ObjCProtocolDecl *> protocols,
                           bool isKindOf) const;

QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                              ArrayRef<ObjCProtocolDecl *> protocols) const;
void adjustObjCTypeParamBoundType(const ObjCTypeParamDecl *Orig,
                                  ObjCTypeParamDecl *New) const;

bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl);

/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
/// QT's qualified-id protocol list adopt all protocols in IDecl's list
/// of protocols.
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
                                          ObjCInterfaceDecl *IDecl);

/// Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectPointerType(QualType OIT) const;

/// GCC extension.
QualType getTypeOfExprType(Expr *e) const;
QualType getTypeOfType(QualType t) const;

/// C++11 decltype.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;

/// Unary type transforms
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
                               UnaryTransformType::UTTKind UKind) const;

/// C++11 deduced auto type.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
                     bool IsDependent, bool IsPack = false,
                     ConceptDecl *TypeConstraintConcept = nullptr,
                     ArrayRef<TemplateArgument> TypeConstraintArgs ={}) const;

/// C++11 deduction pattern for 'auto' type.
QualType getAutoDeductType() const;

/// C++11 deduction pattern for 'auto &&' type.
QualType getAutoRRefDeductType() const;

/// C++17 deduced class template specialization type.
QualType getDeducedTemplateSpecializationType(TemplateName Template,
                                              QualType DeducedType,
                                              bool IsDependent) const;

/// Return the unique reference to the type for the specified TagDecl
/// (struct/union/class/enum) decl.
QualType getTagDeclType(const TagDecl *Decl) const;

/// Return the unique type for "size_t" (C99 7.17), defined in
/// <stddef.h>.
///
/// The sizeof operator requires this (C99 6.5.3.4p4).
CanQualType getSizeType() const;

/// Return the unique signed counterpart of
/// the integer type corresponding to size_t.
CanQualType getSignedSizeType() const;

/// Return the unique type for "intmax_t" (C99 7.18.1.5), defined in
/// <stdint.h>.
CanQualType getIntMaxType() const;

/// Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in
/// <stdint.h>.
CanQualType getUIntMaxType() const;

/// Return the unique wchar_t type available in C++ (and available as
/// __wchar_t as a Microsoft extension).
QualType getWCharType() const { return WCharTy; }

/// Return the type of wide characters. In C++, this returns the
/// unique wchar_t type. In C99, this returns a type compatible with the type
/// defined in <stddef.h> as defined by the target.
QualType getWideCharType() const { return WideCharTy; }

/// Return the type of "signed wchar_t".
///
/// Used when in C++, as a GCC extension.
QualType getSignedWCharType() const;

/// Return the type of "unsigned wchar_t".
///
/// Used when in C++, as a GCC extension.
QualType getUnsignedWCharType() const;

/// In C99, this returns a type compatible with the type
/// defined in <stddef.h> as defined by the target.
QualType getWIntType() const { return WIntTy; }

/// Return a type compatible with "intptr_t" (C99 7.18.1.4),
/// as defined by the target.
QualType getIntPtrType() const;

/// Return a type compatible with "uintptr_t" (C99 7.18.1.4),
/// as defined by the target.
QualType getUIntPtrType() const;

/// Return the unique type for "ptrdiff_t" (C99 7.17) defined in
/// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
QualType getPointerDiffType() const;

/// Return the unique unsigned counterpart of "ptrdiff_t"
/// integer type. The standard (C11 7.21.6.1p7) refers to this type
/// in the definition of %tu format specifier.
QualType getUnsignedPointerDiffType() const;

/// Return the unique type for "pid_t" defined in
/// <sys/types.h>. We need this to compute the correct type for vfork().
QualType getProcessIDType() const;

/// Return the C structure type used to represent constant CFStrings.
QualType getCFConstantStringType() const;

/// Returns the C struct type for objc_super
QualType getObjCSuperType() const;
void setObjCSuperType(QualType ST) { ObjCSuperType = ST; }

/// Get the structure type used to representation CFStrings, or NULL
/// if it hasn't yet been built.
QualType getRawCFConstantStringType() const {
  if (CFConstantStringTypeDecl)
    return getTypedefType(CFConstantStringTypeDecl);
  return QualType();
}
void setCFConstantStringType(QualType T);
TypedefDecl *getCFConstantStringDecl() const;
RecordDecl *getCFConstantStringTagDecl() const;

// This setter/getter represents the ObjC type for an NSConstantString.
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl);
QualType getObjCConstantStringInterface() const {
  return ObjCConstantStringType;
}

QualType getObjCNSStringType() const {
  return ObjCNSStringType;
}

void setObjCNSStringType(QualType T) {
  ObjCNSStringType = T;
}

/// Retrieve the type that \c id has been defined to, which may be
/// different from the built-in \c id if \c id has been typedef'd.
QualType getObjCIdRedefinitionType() const {
  if (ObjCIdRedefinitionType.isNull())
    return getObjCIdType();
  return ObjCIdRedefinitionType;
}

/// Set the user-written type that redefines \c id.
void setObjCIdRedefinitionType(QualType RedefType) {
  ObjCIdRedefinitionType = RedefType;
}

/// Retrieve the type that \c Class has been defined to, which may be
/// different from the built-in \c Class if \c Class has been typedef'd.
QualType getObjCClassRedefinitionType() const {
  if (ObjCClassRedefinitionType.isNull())
    return getObjCClassType();
  return ObjCClassRedefinitionType;
}

/// Set the user-written type that redefines 'SEL'.
void setObjCClassRedefinitionType(QualType RedefType) {
  ObjCClassRedefinitionType = RedefType;
}

/// Retrieve the type that 'SEL' has been defined to, which may be
/// different from the built-in 'SEL' if 'SEL' has been typedef'd.
QualType getObjCSelRedefinitionType() const {
  if (ObjCSelRedefinitionType.isNull())
    return getObjCSelType();
  return ObjCSelRedefinitionType;
}

/// Set the user-written type that redefines 'SEL'.
void setObjCSelRedefinitionType(QualType RedefType) {
  ObjCSelRedefinitionType = RedefType;
}

/// Retrieve the identifier 'NSObject'.
IdentifierInfo *getNSObjectName() const {
  if (!NSObjectName) {
    NSObjectName = &Idents.get("NSObject");
  }

  return NSObjectName;
}

/// Retrieve the identifier 'NSCopying'.
IdentifierInfo *getNSCopyingName() {
  if (!NSCopyingName) {
    NSCopyingName = &Idents.get("NSCopying");
  }

  return NSCopyingName;
}

CanQualType getNSUIntegerType() const;

CanQualType getNSIntegerType() const;

/// Retrieve the identifier 'bool'.
IdentifierInfo *getBoolName() const {
  if (!BoolName)
    BoolName = &Idents.get("bool");
  return BoolName;
}

IdentifierInfo *getMakeIntegerSeqName() const {
  if (!MakeIntegerSeqName)
    MakeIntegerSeqName = &Idents.get("__make_integer_seq");
  return MakeIntegerSeqName;
}

IdentifierInfo *getTypePackElementName() const {
  if (!TypePackElementName)
    TypePackElementName = &Idents.get("__type_pack_element");
  return TypePackElementName;
}

/// Retrieve the Objective-C "instancetype" type, if already known;
/// otherwise, returns a NULL type;
QualType getObjCInstanceType() {
  return getTypeDeclType(getObjCInstanceTypeDecl());
}

/// Retrieve the typedef declaration corresponding to the Objective-C
/// "instancetype" type.
TypedefDecl *getObjCInstanceTypeDecl();

/// Set the type for the C FILE type.
void setFILEDecl(TypeDecl *FILEDecl) { this->FILEDecl = FILEDecl; }

/// Retrieve the C FILE type.
QualType getFILEType() const {
  if (FILEDecl)
    return getTypeDeclType(FILEDecl);
  return QualType();
}

/// Set the type for the C jmp_buf type.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl) {
  this->jmp_bufDecl = jmp_bufDecl;
}

/// Retrieve the C jmp_buf type.
QualType getjmp_bufType() const {
  if (jmp_bufDecl)
    return getTypeDeclType(jmp_bufDecl);
  return QualType();
}

/// Set the type for the C sigjmp_buf type.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl) {
  this->sigjmp_bufDecl = sigjmp_bufDecl;
}

/// Retrieve the C sigjmp_buf type.
QualType getsigjmp_bufType() const {
  if (sigjmp_bufDecl)
    return getTypeDeclType(sigjmp_bufDecl);
  return QualType();
}

/// Set the type for the C ucontext_t type.
void setucontext_tDecl(TypeDecl *ucontext_tDecl) {
  this->ucontext_tDecl = ucontext_tDecl;
}

/// Retrieve the C ucontext_t type.
QualType getucontext_tType() const {
  if (ucontext_tDecl)
    return getTypeDeclType(ucontext_tDecl);
  return QualType();
}

/// The result type of logical operations, '<', '>', '!=', etc.
QualType getLogicalOperationType() const {
  return getLangOpts().CPlusPlus ? BoolTy : IntTy;
}

/// Emit the Objective-CC type encoding for the given type \p T into
/// \p S.
///
/// If \p Field is specified then record field names are also encoded.
void getObjCEncodingForType(QualType T, std::string &S,
                            const FieldDecl *Field=nullptr,
                            QualType *NotEncodedT=nullptr) const;

/// Emit the Objective-C property type encoding for the given
/// type \p T into \p S.
void getObjCEncodingForPropertyType(QualType T, std::string &S) const;

void getLegacyIntegralTypeEncoding(QualType &t) const;

/// Put the string version of the type qualifiers \p QT into \p S.
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
                                     std::string &S) const;

/// Emit the encoded type for the function \p Decl into \p S.
///
/// This is in the same format as Objective-C method encodings.
///
/// \returns true if an error occurred (e.g., because one of the parameter
/// types is incomplete), false otherwise.
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const;

/// Emit the encoded type for the method declaration \p Decl into
/// \p S.
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
                                         bool Extended = false) const;

/// Return the encoded type for this block declaration.
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const;

/// getObjCEncodingForPropertyDecl - Return the encoded type for
/// this method declaration. If non-NULL, Container must be either
/// an ObjCCategoryImplDecl or ObjCImplementationDecl; it should
/// only be NULL when getting encodings for protocol properties.
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
                                           const Decl *Container) const;

bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
                                    ObjCProtocolDecl *rProto) const;

ObjCPropertyImplDecl *getObjCPropertyImplDeclForPropertyDecl(
                                                const ObjCPropertyDecl *PD,
                                                const Decl *Container) const;

/// Return the size of type \p T for Objective-C encoding purpose,
/// in characters.
CharUnits getObjCEncodingTypeSize(QualType T) const;

/// Retrieve the typedef corresponding to the predefined \c id type
/// in Objective-C.
TypedefDecl *getObjCIdDecl() const;

/// Represents the Objective-CC \c id type.
///
/// This is set up lazily, by Sema.  \c id is always a (typedef for a)
/// pointer type, a pointer to a struct.
QualType getObjCIdType() const {
  return getTypeDeclType(getObjCIdDecl());
}

/// Retrieve the typedef corresponding to the predefined 'SEL' type
/// in Objective-C.
TypedefDecl *getObjCSelDecl() const;

/// Retrieve the type that corresponds to the predefined Objective-C
/// 'SEL' type.
QualType getObjCSelType() const {
  return getTypeDeclType(getObjCSelDecl());
}

/// Retrieve the typedef declaration corresponding to the predefined
/// Objective-C 'Class' type.
TypedefDecl *getObjCClassDecl() const;

/// Represents the Objective-C \c Class type.
///
/// This is set up lazily, by Sema.  \c Class is always a (typedef for a)
/// pointer type, a pointer to a struct.
QualType getObjCClassType() const {
  return getTypeDeclType(getObjCClassDecl());
}

/// Retrieve the Objective-C class declaration corresponding to
/// the predefined \c Protocol class.
ObjCInterfaceDecl *getObjCProtocolDecl() const;

/// Retrieve declaration of 'BOOL' typedef
TypedefDecl *getBOOLDecl() const {
  return BOOLDecl;
}

/// Save declaration of 'BOOL' typedef
void setBOOLDecl(TypedefDecl *TD) {
  BOOLDecl = TD;
}

/// type of 'BOOL' type.
QualType getBOOLType() const {
  return getTypeDeclType(getBOOLDecl());
}

/// Retrieve the type of the Objective-C \c Protocol class.
QualType getObjCProtoType() const {
  return getObjCInterfaceType(getObjCProtocolDecl());
}

/// Retrieve the C type declaration corresponding to the predefined
/// \c __builtin_va_list type.
TypedefDecl *getBuiltinVaListDecl() const;

/// Retrieve the type of the \c __builtin_va_list type.
QualType getBuiltinVaListType() const {
  return getTypeDeclType(getBuiltinVaListDecl());
}

/// Retrieve the C type declaration corresponding to the predefined
/// \c __va_list_tag type used to help define the \c __builtin_va_list type
/// for some targets.
Decl *getVaListTagDecl() const;

/// Retrieve the C type declaration corresponding to the predefined
/// \c __builtin_ms_va_list type.
TypedefDecl *getBuiltinMSVaListDecl() const;

/// Retrieve the type of the \c __builtin_ms_va_list type.
QualType getBuiltinMSVaListType() const {
  return getTypeDeclType(getBuiltinMSVaListDecl());
}

/// Retrieve the implicitly-predeclared 'struct _GUID' declaration.
TagDecl *getMSGuidTagDecl() const { return MSGuidTagDecl; }

/// Retrieve the implicitly-predeclared 'struct _GUID' type.
QualType getMSGuidType() const {
  assert(MSGuidTagDecl && "asked for GUID type but MS extensions disabled")((void)0);
  return getTagDeclType(MSGuidTagDecl);
}

/// Return whether a declaration to a builtin is allowed to be
/// overloaded/redeclared.
bool canBuiltinBeRedeclared(const FunctionDecl *) const;

/// Return a type with additional \c const, \c volatile, or
/// \c restrict qualifiers.
QualType getCVRQualifiedType(QualType T, unsigned CVR) const {
  return getQualifiedType(T, Qualifiers::fromCVRMask(CVR));
}

/// Un-split a SplitQualType.
QualType getQualifiedType(SplitQualType split) const {
  return getQualifiedType(split.Ty, split.Quals);
}

/// Return a type with additional qualifiers.
QualType getQualifiedType(QualType T, Qualifiers Qs) const {
  if (!Qs.hasNonFastQualifiers())
    return T.withFastQualifiers(Qs.getFastQualifiers());
  QualifierCollector Qc(Qs);
  const Type *Ptr = Qc.strip(T);
  return getExtQualType(Ptr, Qc);
}

/// Return a type with additional qualifiers.
QualType getQualifiedType(const Type *T, Qualifiers Qs) const {
  if (!Qs.hasNonFastQualifiers())
    return QualType(T, Qs.getFastQualifiers());
  return getExtQualType(T, Qs);
}

/// Return a type with the given lifetime qualifier.
///
/// \pre Neither type.ObjCLifetime() nor \p lifetime may be \c OCL_None.
QualType getLifetimeQualifiedType(QualType type,
                                  Qualifiers::ObjCLifetime lifetime) {
  assert(type.getObjCLifetime() == Qualifiers::OCL_None)((void)0);
  assert(lifetime != Qualifiers::OCL_None)((void)0);

  Qualifiers qs;
  qs.addObjCLifetime(lifetime);
  return getQualifiedType(type, qs);
}

/// getUnqualifiedObjCPointerType - Returns version of
/// Objective-C pointer type with lifetime qualifier removed.
QualType getUnqualifiedObjCPointerType(QualType type) const {
  if (!type.getTypePtr()->isObjCObjectPointerType() ||
      !type.getQualifiers().hasObjCLifetime())
    return type;
  Qualifiers Qs = type.getQualifiers();
  Qs.removeObjCLifetime();
  return getQualifiedType(type.getUnqualifiedType(), Qs);
}

unsigned char getFixedPointScale(QualType Ty) const;
unsigned char getFixedPointIBits(QualType Ty) const;
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const;
llvm::APFixedPoint getFixedPointMax(QualType Ty) const;
llvm::APFixedPoint getFixedPointMin(QualType Ty) const;

DeclarationNameInfo getNameForTemplate(TemplateName Name,
                                       SourceLocation NameLoc) const;

TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                       UnresolvedSetIterator End) const;
TemplateName getAssumedTemplateName(DeclarationName Name) const;

TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS,
                                      bool TemplateKeyword,
                                      TemplateDecl *Template) const;

TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                      const IdentifierInfo *Name) const;
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                      OverloadedOperatorKind Operator) const;
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
                                          TemplateName replacement) const;
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
                                      const TemplateArgument &ArgPack) const;

enum GetBuiltinTypeError {
  /// No error
  GE_None,

  /// Missing a type
  GE_Missing_type,

  /// Missing a type from <stdio.h>
  GE_Missing_stdio,

  /// Missing a type from <setjmp.h>
  GE_Missing_setjmp,

  /// Missing a type from <ucontext.h>
  GE_Missing_ucontext
};

QualType DecodeTypeStr(const char *&Str, const ASTContext &Context,
                       ASTContext::GetBuiltinTypeError &Error,
                       bool &RequireICE, bool AllowTypeModifiers) const;

/// Return the type for the specified builtin.
///
/// If \p IntegerConstantArgs is non-null, it is filled in with a bitmask of
/// arguments to the builtin that are required to be integer constant
/// expressions.
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error,
                        unsigned *IntegerConstantArgs = nullptr) const;

/// Types and expressions required to build C++2a three-way comparisons
/// using operator<=>, including the values return by builtin <=> operators.
ComparisonCategories CompCategories;

2153private:
CanQualType getFromTargetType(unsigned Type) const;
TypeInfo getTypeInfoImpl(const Type *T) const;

//===--------------------------------------------------------------------===//
//                         Type Predicates.
//===--------------------------------------------------------------------===//

2161public:
/// Return one of the GCNone, Weak or Strong Objective-C garbage
/// collection attributes.
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const;

/// Return true if the given vector types are of the same unqualified
/// type or if they are equivalent to the same GCC vector type.
///
/// \note This ignores whether they are target-specific (AltiVec or Neon)
/// types.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec);

/// Return true if the given types are an SVE builtin and a VectorType that
/// is a fixed-length representation of the SVE builtin for a specific
/// vector-length.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType);

/// Return true if the given vector types are lax-compatible SVE vector types,
/// false otherwise.
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType);

/// Return true if the type has been explicitly qualified with ObjC ownership.
/// A type may be implicitly qualified with ownership under ObjC ARC, and in
/// some cases the compiler treats these differently.
bool hasDirectOwnershipQualifier(QualType Ty) const;

/// Return true if this is an \c NSObject object with its \c NSObject
/// attribute set.
static bool isObjCNSObjectType(QualType Ty) {
  return Ty->isObjCNSObjectType();
}

//===--------------------------------------------------------------------===//
//                         Type Sizing and Analysis
//===--------------------------------------------------------------------===//

/// Return the APFloat 'semantics' for the specified scalar floating
/// point type.
const llvm::fltSemantics &getFloatTypeSemantics(QualType T) const;

/// Get the size and alignment of the specified complete type in bits.
TypeInfo getTypeInfo(const Type *T) const;
TypeInfo getTypeInfo(QualType T) const { return getTypeInfo(T.getTypePtr()); }

/// Get default simd alignment of the specified complete type in bits.
unsigned getOpenMPDefaultSimdAlign(QualType T) const;

/// Return the size of the specified (complete) type \p T, in bits.
uint64_t getTypeSize(QualType T) const { return getTypeInfo(T).Width; }
uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; }

/// Return the size of the character type, in bits.
uint64_t getCharWidth() const {
  return getTypeSize(CharTy);
}

/// Convert a size in bits to a size in characters.
CharUnits toCharUnitsFromBits(int64_t BitSize) const;

/// Convert a size in characters to a size in bits.
int64_t toBits(CharUnits CharSize) const;

/// Return the size of the specified (complete) type \p T, in
/// characters.
CharUnits getTypeSizeInChars(QualType T) const;
CharUnits getTypeSizeInChars(const Type *T) const;

Optional<CharUnits> getTypeSizeInCharsIfKnown(QualType Ty) const {
  if (Ty->isIncompleteType() || Ty->isDependentType())
    return None;
  return getTypeSizeInChars(Ty);
}

Optional<CharUnits> getTypeSizeInCharsIfKnown(const Type *Ty) const {
  return getTypeSizeInCharsIfKnown(QualType(Ty, 0));
}

/// Return the ABI-specified alignment of a (complete) type \p T, in
/// bits.
unsigned getTypeAlign(QualType T) const { return getTypeInfo(T).Align; }
unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }

/// Return the ABI-specified natural alignment of a (complete) type \p T,
/// before alignment adjustments, in bits.
///
/// This alignment is curently used only by ARM and AArch64 when passing
/// arguments of a composite type.
unsigned getTypeUnadjustedAlign(QualType T) const {
  return getTypeUnadjustedAlign(T.getTypePtr());
}
unsigned getTypeUnadjustedAlign(const Type *T) const;

/// Return the alignment of a type, in bits, or 0 if
/// the type is incomplete and we cannot determine the alignment (for
/// example, from alignment attributes). The returned alignment is the
/// Preferred alignment if NeedsPreferredAlignment is true, otherwise is the
/// ABI alignment.
unsigned getTypeAlignIfKnown(QualType T,
                             bool NeedsPreferredAlignment = false) const;

/// Return the ABI-specified alignment of a (complete) type \p T, in
/// characters.
CharUnits getTypeAlignInChars(QualType T) const;
CharUnits getTypeAlignInChars(const Type *T) const;

/// Return the PreferredAlignment of a (complete) type \p T, in
/// characters.
CharUnits getPreferredTypeAlignInChars(QualType T) const {
  return toCharUnitsFromBits(getPreferredTypeAlign(T));
}

/// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a type,
/// in characters, before alignment adjustments. This method does not work on
/// incomplete types.
CharUnits getTypeUnadjustedAlignInChars(QualType T) const;
CharUnits getTypeUnadjustedAlignInChars(const Type *T) const;

// getTypeInfoDataSizeInChars - Return the size of a type, in chars. If the
// type is a record, its data size is returned.
TypeInfoChars getTypeInfoDataSizeInChars(QualType T) const;

TypeInfoChars getTypeInfoInChars(const Type *T) const;
TypeInfoChars getTypeInfoInChars(QualType T) const;

/// Determine if the alignment the type has was required using an
/// alignment attribute.
bool isAlignmentRequired(const Type *T) const;
bool isAlignmentRequired(QualType T) const;

/// Return the "preferred" alignment of the specified type \p T for
/// the current target, in bits.
///
/// This can be different than the ABI alignment in cases where it is
/// beneficial for performance or backwards compatibility preserving to
/// overalign a data type. (Note: despite the name, the preferred alignment
/// is ABI-impacting, and not an optimization.)
unsigned getPreferredTypeAlign(QualType T) const {
  return getPreferredTypeAlign(T.getTypePtr());
}
unsigned getPreferredTypeAlign(const Type *T) const;

/// Return the default alignment for __attribute__((aligned)) on
/// this target, to be used if no alignment value is specified.
unsigned getTargetDefaultAlignForAttributeAligned() const;

/// Return the alignment in bits that should be given to a
/// global variable with type \p T.
unsigned getAlignOfGlobalVar(QualType T) const;

/// Return the alignment in characters that should be given to a
/// global variable with type \p T.
CharUnits getAlignOfGlobalVarInChars(QualType T) const;

/// Return a conservative estimate of the alignment of the specified
/// decl \p D.
///
/// \pre \p D must not be a bitfield type, as bitfields do not have a valid
/// alignment.
///
/// If \p ForAlignof, references are treated like their underlying type
/// and  large arrays don't get any special treatment. If not \p ForAlignof
/// it computes the value expected by CodeGen: references are treated like
/// pointers and large arrays get extra alignment.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof = false) const;

/// Return the alignment (in bytes) of the thrown exception object. This is
/// only meaningful for targets that allocate C++ exceptions in a system
/// runtime, such as those using the Itanium C++ ABI.
CharUnits getExnObjectAlignment() const;

/// Get or compute information about the layout of the specified
/// record (struct/union/class) \p D, which indicates its size and field
/// position information.
const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D) const;

/// Get or compute information about the layout of the specified
/// Objective-C interface.
const ASTRecordLayout &getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D)
  const;

void DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,
                      bool Simple = false) const;

/// Get or compute information about the layout of the specified
/// Objective-C implementation.
///
/// This may differ from the interface if synthesized ivars are present.
const ASTRecordLayout &
getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const;

/// Get our current best idea for the key function of the
/// given record decl, or nullptr if there isn't one.
///
/// The key function is, according to the Itanium C++ ABI section 5.2.3:
///   ...the first non-pure virtual function that is not inline at the
///   point of class definition.
///
/// Other ABIs use the same idea.  However, the ARM C++ ABI ignores
/// virtual functions that are defined 'inline', which means that
/// the result of this computation can change.
const CXXMethodDecl *getCurrentKeyFunction(const CXXRecordDecl *RD);

/// Observe that the given method cannot be a key function.
/// Checks the key-function cache for the method's class and clears it
/// if matches the given declaration.
///
/// This is used in ABIs where out-of-line definitions marked
/// inline are not considered to be key functions.
///
/// \param method should be the declaration from the class definition
void setNonKeyFunction(const CXXMethodDecl *method);

/// Loading virtual member pointers using the virtual inheritance model
/// always results in an adjustment using the vbtable even if the index is
/// zero.
///
/// This is usually OK because the first slot in the vbtable points
/// backwards to the top of the MDC.  However, the MDC might be reusing a
/// vbptr from an nv-base.  In this case, the first slot in the vbtable
/// points to the start of the nv-base which introduced the vbptr and *not*
/// the MDC.  Modify the NonVirtualBaseAdjustment to account for this.
CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const;

/// Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
uint64_t getFieldOffset(const ValueDecl *FD) const;

/// Get the offset of an ObjCIvarDecl in bits.
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID,
                              const ObjCImplementationDecl *ID,
                              const ObjCIvarDecl *Ivar) const;

/// Find the 'this' offset for the member path in a pointer-to-member
/// APValue.
CharUnits getMemberPointerPathAdjustment(const APValue &MP) const;

bool isNearlyEmpty(const CXXRecordDecl *RD) const;

VTableContextBase *getVTableContext();

/// If \p T is null pointer, assume the target in ASTContext.
MangleContext *createMangleContext(const TargetInfo *T = nullptr);

/// Creates a device mangle context to correctly mangle lambdas in a mixed
/// architecture compile by setting the lambda mangling number source to the
/// DeviceLambdaManglingNumber. Currently this asserts that the TargetInfo
/// (from the AuxTargetInfo) is a an itanium target.
MangleContext *createDeviceMangleContext(const TargetInfo &T);

void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass,
                          SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const;

unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const;
void CollectInheritedProtocols(const Decl *CDecl,
                        llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols);

/// Return true if the specified type has unique object representations
/// according to (C++17 [meta.unary.prop]p9)
bool hasUniqueObjectRepresentations(QualType Ty) const;

//===--------------------------------------------------------------------===//
//                            Type Operators
//===--------------------------------------------------------------------===//

/// Return the canonical (structural) type corresponding to the
/// specified potentially non-canonical type \p T.
///
/// The non-canonical version of a type may have many "decorated" versions of
/// types.  Decorators can include typedefs, 'typeof' operators, etc. The
/// returned type is guaranteed to be free of any of these, allowing two
/// canonical types to be compared for exact equality with a simple pointer
/// comparison.
CanQualType getCanonicalType(QualType T) const {
  return CanQualType::CreateUnsafe(T.getCanonicalType());
}

const Type *getCanonicalType(const Type *T) const {
  return T->getCanonicalTypeInternal().getTypePtr();
}

/// Return the canonical parameter type corresponding to the specific
/// potentially non-canonical one.
///
/// Qualifiers are stripped off, functions are turned into function
/// pointers, and arrays decay one level into pointers.
CanQualType getCanonicalParamType(QualType T) const;

/// Determine whether the given types \p T1 and \p T2 are equivalent.
bool hasSameType(QualType T1, QualType T2) const {
  return getCanonicalType(T1) == getCanonicalType(T2);
}
bool hasSameType(const Type *T1, const Type *T2) const {
  return getCanonicalType(T1) == getCanonicalType(T2);
}

/// Return this type as a completely-unqualified array type,
/// capturing the qualifiers in \p Quals.
///
/// This will remove the minimal amount of sugaring from the types, similar
/// to the behavior of QualType::getUnqualifiedType().
///
/// \param T is the qualified type, which may be an ArrayType
///
/// \param Quals will receive the full set of qualifiers that were
/// applied to the array.
///
/// \returns if this is an array type, the completely unqualified array type
/// that corresponds to it. Otherwise, returns T.getUnqualifiedType().
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals);

/// Determine whether the given types are equivalent after
/// cvr-qualifiers have been removed.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const {
  return getCanonicalType(T1).getTypePtr() ==
         getCanonicalType(T2).getTypePtr();
}

bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT,
                                     bool IsParam) const {
  auto SubTnullability = SubT->getNullability(*this);
  auto SuperTnullability = SuperT->getNullability(*this);
  if (SubTnullability.hasValue() == SuperTnullability.hasValue()) {
    // Neither has nullability; return true
    if (!SubTnullability)
      return true;
    // Both have nullability qualifier.
    if (*SubTnullability == *SuperTnullability ||
        *SubTnullability == NullabilityKind::Unspecified ||
        *SuperTnullability == NullabilityKind::Unspecified)
      return true;

    if (IsParam) {
      // Ok for the superclass method parameter to be "nonnull" and the subclass
      // method parameter to be "nullable"
      return (*SuperTnullability == NullabilityKind::NonNull &&
              *SubTnullability == NullabilityKind::Nullable);
    }
    // For the return type, it's okay for the superclass method to specify
    // "nullable" and the subclass method specify "nonnull"
    return (*SuperTnullability == NullabilityKind::Nullable &&
            *SubTnullability == NullabilityKind::NonNull);
  }
  return true;
}

bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
                         const ObjCMethodDecl *MethodImp);

bool UnwrapSimilarTypes(QualType &T1, QualType &T2);
void UnwrapSimilarArrayTypes(QualType &T1, QualType &T2);

/// Determine if two types are similar, according to the C++ rules. That is,
/// determine if they are the same other than qualifiers on the initial
/// sequence of pointer / pointer-to-member / array (and in Clang, object
/// pointer) types and their element types.
///
/// Clang offers a number of qualifiers in addition to the C++ qualifiers;
/// those qualifiers are also ignored in the 'similarity' check.
bool hasSimilarType(QualType T1, QualType T2);

/// Determine if two types are similar, ignoring only CVR qualifiers.
bool hasCvrSimilarType(QualType T1, QualType T2);

/// Retrieves the "canonical" nested name specifier for a
/// given nested name specifier.
///
/// The canonical nested name specifier is a nested name specifier
/// that uniquely identifies a type or namespace within the type
/// system. For example, given:
///
/// \code
/// namespace N {
///   struct S {
///     template<typename T> struct X { typename T* type; };
///   };
/// }
///
/// template<typename T> struct Y {
///   typename N::S::X<T>::type member;
/// };
/// \endcode
///
/// Here, the nested-name-specifier for N::S::X<T>:: will be
/// S::X<template-param-0-0>, since 'S' and 'X' are uniquely defined
/// by declarations in the type system and the canonical type for
/// the template type parameter 'T' is template-param-0-0.
NestedNameSpecifier *
getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const;

/// Retrieves the default calling convention for the current target.
CallingConv getDefaultCallingConvention(bool IsVariadic,
                                        bool IsCXXMethod,
                                        bool IsBuiltin = false) const;

/// Retrieves the "canonical" template name that refers to a
/// given template.
///
/// The canonical template name is the simplest expression that can
/// be used to refer to a given template. For most templates, this
/// expression is just the template declaration itself. For example,
/// the template std::vector can be referred to via a variety of
/// names---std::vector, \::std::vector, vector (if vector is in
/// scope), etc.---but all of these names map down to the same
/// TemplateDecl, which is used to form the canonical template name.
///
/// Dependent template names are more interesting. Here, the
/// template name could be something like T::template apply or
/// std::allocator<T>::template rebind, where the nested name
/// specifier itself is dependent. In this case, the canonical
/// template name uses the shortest form of the dependent
/// nested-name-specifier, which itself contains all canonical
/// types, values, and templates.
TemplateName getCanonicalTemplateName(TemplateName Name) const;

/// Determine whether the given template names refer to the same
/// template.
bool hasSameTemplateName(TemplateName X, TemplateName Y);

/// Retrieve the "canonical" template argument.
///
/// The canonical template argument is the simplest template argument
/// (which may be a type, value, expression, or declaration) that
/// expresses the value of the argument.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
  const;

/// Type Query functions.  If the type is an instance of the specified class,
/// return the Type pointer for the underlying maximally pretty type.  This
/// is a member of ASTContext because this may need to do some amount of
/// canonicalization, e.g. to move type qualifiers into the element type.
const ArrayType *getAsArrayType(QualType T) const;
const ConstantArrayType *getAsConstantArrayType(QualType T) const {
  return dyn_cast_or_null<ConstantArrayType>(getAsArrayType(T));
}
const VariableArrayType *getAsVariableArrayType(QualType T) const {
  return dyn_cast_or_null<VariableArrayType>(getAsArrayType(T));
20
←
Assuming null pointer is passed into cast→
21
←
Returning null pointer, which participates in a condition later→
}
const IncompleteArrayType *getAsIncompleteArrayType(QualType T) const {
  return dyn_cast_or_null<IncompleteArrayType>(getAsArrayType(T));
}
const DependentSizedArrayType *getAsDependentSizedArrayType(QualType T)
  const {
  return dyn_cast_or_null<DependentSizedArrayType>(getAsArrayType(T));
}

/// Return the innermost element type of an array type.
///
/// For example, will return "int" for int[m][n]
QualType getBaseElementType(const ArrayType *VAT) const;

/// Return the innermost element type of a type (which needn't
/// actually be an array type).
QualType getBaseElementType(QualType QT) const;

/// Return number of constant array elements.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const;

/// Perform adjustment on the parameter type of a function.
///
/// This routine adjusts the given parameter type @p T to the actual
/// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
/// C++ [dcl.fct]p3). The adjusted parameter type is returned.
QualType getAdjustedParameterType(QualType T) const;

/// Retrieve the parameter type as adjusted for use in the signature
/// of a function, decaying array and function types and removing top-level
/// cv-qualifiers.
QualType getSignatureParameterType(QualType T) const;

QualType getExceptionObjectType(QualType T) const;

/// Return the properly qualified result of decaying the specified
/// array type to a pointer.
///
/// This operation is non-trivial when handling typedefs etc.  The canonical
/// type of \p T must be an array type, this returns a pointer to a properly
/// qualified element of the array.
///
/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
QualType getArrayDecayedType(QualType T) const;

/// Return the type that \p PromotableType will promote to: C99
/// 6.3.1.1p2, assuming that \p PromotableType is a promotable integer type.
QualType getPromotedIntegerType(QualType PromotableType) const;

/// Recurses in pointer/array types until it finds an Objective-C
/// retainable type and returns its ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const;

/// Whether this is a promotable bitfield reference according
/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
///
/// \returns the type this bit-field will promote to, or NULL if no
/// promotion occurs.
QualType isPromotableBitField(Expr *E) const;

/// Return the highest ranked integer type, see C99 6.3.1.8p1.
///
/// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
/// \p LHS < \p RHS, return -1.
int getIntegerTypeOrder(QualType LHS, QualType RHS) const;

/// Compare the rank of the two specified floating point types,
/// ignoring the domain of the type (i.e. 'double' == '_Complex double').
///
/// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
/// \p LHS < \p RHS, return -1.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const;

/// Compare the rank of two floating point types as above, but compare equal
/// if both types have the same floating-point semantics on the target (i.e.
/// long double and double on AArch64 will return 0).
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const;

/// Return a real floating point or a complex type (based on
/// \p typeDomain/\p typeSize).
///
/// \param typeDomain a real floating point or complex type.
/// \param typeSize a real floating point or complex type.
QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize,
                                           QualType typeDomain) const;

unsigned getTargetAddressSpace(QualType T) const {
  return getTargetAddressSpace(T.getQualifiers());
}

unsigned getTargetAddressSpace(Qualifiers Q) const {
  return getTargetAddressSpace(Q.getAddressSpace());
}

unsigned getTargetAddressSpace(LangAS AS) const;

LangAS getLangASForBuiltinAddressSpace(unsigned AS) const;

/// Get target-dependent integer value for null pointer which is used for
/// constant folding.
uint64_t getTargetNullPointerValue(QualType QT) const;

bool addressSpaceMapManglingFor(LangAS AS) const {
  return AddrSpaceMapMangling || isTargetAddressSpace(AS);
}

2702private:
// Helper for integer ordering
unsigned getIntegerRank(const Type *T) const;

2706public:
//===--------------------------------------------------------------------===//
//                    Type Compatibility Predicates
//===--------------------------------------------------------------------===//

/// Compatibility predicates used to check assignment expressions.
bool typesAreCompatible(QualType T1, QualType T2,
                        bool CompareUnqualified = false); // C99 6.2.7p1

bool propertyTypesAreCompatible(QualType, QualType);
bool typesAreBlockPointerCompatible(QualType, QualType);

bool isObjCIdType(QualType T) const {
  return T == getObjCIdType();
}

bool isObjCClassType(QualType T) const {
  return T == getObjCClassType();
}

bool isObjCSelType(QualType T) const {
  return T == getObjCSelType();
}

bool ObjCQualifiedIdTypesAreCompatible(const ObjCObjectPointerType *LHS,
                                       const ObjCObjectPointerType *RHS,
                                       bool ForCompare);

bool ObjCQualifiedClassTypesAreCompatible(const ObjCObjectPointerType *LHS,
                                          const ObjCObjectPointerType *RHS);

// Check the safety of assignment from LHS to RHS
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
                             const ObjCObjectPointerType *RHSOPT);
bool canAssignObjCInterfaces(const ObjCObjectType *LHS,
                             const ObjCObjectType *RHS);
bool canAssignObjCInterfacesInBlockPointer(
                                        const ObjCObjectPointerType *LHSOPT,
                                        const ObjCObjectPointerType *RHSOPT,
                                        bool BlockReturnType);
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS);
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT,
                                 const ObjCObjectPointerType *RHSOPT);
bool canBindObjCObjectType(QualType To, QualType From);

// Functions for calculating composite types
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false,
                    bool Unqualified = false, bool BlockReturnType = false);
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false,
                            bool Unqualified = false, bool AllowCXX = false);
QualType mergeFunctionParameterTypes(QualType, QualType,
                                     bool OfBlockPointer = false,
                                     bool Unqualified = false);
QualType mergeTransparentUnionType(QualType, QualType,
                                   bool OfBlockPointer=false,
                                   bool Unqualified = false);

QualType mergeObjCGCQualifiers(QualType, QualType);

/// This function merges the ExtParameterInfo lists of two functions. It
/// returns true if the lists are compatible. The merged list is returned in
/// NewParamInfos.
///
/// \param FirstFnType The type of the first function.
///
/// \param SecondFnType The type of the second function.
///
/// \param CanUseFirst This flag is set to true if the first function's
/// ExtParameterInfo list can be used as the composite list of
/// ExtParameterInfo.
///
/// \param CanUseSecond This flag is set to true if the second function's
/// ExtParameterInfo list can be used as the composite list of
/// ExtParameterInfo.
///
/// \param NewParamInfos The composite list of ExtParameterInfo. The list is
/// empty if none of the flags are set.
///
bool mergeExtParameterInfo(
    const FunctionProtoType *FirstFnType,
    const FunctionProtoType *SecondFnType,
    bool &CanUseFirst, bool &CanUseSecond,
    SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos);

void ResetObjCLayout(const ObjCContainerDecl *CD);

//===--------------------------------------------------------------------===//
//                    Integer Predicates
//===--------------------------------------------------------------------===//

// The width of an integer, as defined in C99 6.2.6.2. This is the number
// of bits in an integer type excluding any padding bits.
unsigned getIntWidth(QualType T) const;

// Per C99 6.2.5p6, for every signed integer type, there is a corresponding
// unsigned integer type.  This method takes a signed type, and returns the
// corresponding unsigned integer type.
// With the introduction of fixed point types in ISO N1169, this method also
// accepts fixed point types and returns the corresponding unsigned type for
// a given fixed point type.
QualType getCorrespondingUnsignedType(QualType T) const;

// Per C99 6.2.5p6, for every signed integer type, there is a corresponding
// unsigned integer type.  This method takes an unsigned type, and returns the
// corresponding signed integer type.
// With the introduction of fixed point types in ISO N1169, this method also
// accepts fixed point types and returns the corresponding signed type for
// a given fixed point type.
QualType getCorrespondingSignedType(QualType T) const;

// Per ISO N1169, this method accepts fixed point types and returns the
// corresponding saturated type for a given fixed point type.
QualType getCorrespondingSaturatedType(QualType Ty) const;

// This method accepts fixed point types and returns the corresponding signed
// type. Unlike getCorrespondingUnsignedType(), this only accepts unsigned
// fixed point types because there are unsigned integer types like bool and
// char8_t that don't have signed equivalents.
QualType getCorrespondingSignedFixedPointType(QualType Ty) const;

//===--------------------------------------------------------------------===//
//                    Integer Values
//===--------------------------------------------------------------------===//

/// Make an APSInt of the appropriate width and signedness for the
/// given \p Value and integer \p Type.
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const {
  // If Type is a signed integer type larger than 64 bits, we need to be sure
  // to sign extend Res appropriately.
  llvm::APSInt Res(64, !Type->isSignedIntegerOrEnumerationType());
  Res = Value;
  unsigned Width = getIntWidth(Type);
  if (Width != Res.getBitWidth())
    return Res.extOrTrunc(Width);
  return Res;
}

bool isSentinelNullExpr(const Expr *E);

/// Get the implementation of the ObjCInterfaceDecl \p D, or nullptr if
/// none exists.
ObjCImplementationDecl *getObjCImplementation(ObjCInterfaceDecl *D);

/// Get the implementation of the ObjCCategoryDecl \p D, or nullptr if
/// none exists.
ObjCCategoryImplDecl *getObjCImplementation(ObjCCategoryDecl *D);

/// Return true if there is at least one \@implementation in the TU.
bool AnyObjCImplementation() {
  return !ObjCImpls.empty();
}

/// Set the implementation of ObjCInterfaceDecl.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD,
                           ObjCImplementationDecl *ImplD);

/// Set the implementation of ObjCCategoryDecl.
void setObjCImplementation(ObjCCategoryDecl *CatD,
                           ObjCCategoryImplDecl *ImplD);

/// Get the duplicate declaration of a ObjCMethod in the same
/// interface, or null if none exists.
const ObjCMethodDecl *
getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const;

void setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
                                const ObjCMethodDecl *Redecl);

/// Returns the Objective-C interface that \p ND belongs to if it is
/// an Objective-C method/property/ivar etc. that is part of an interface,
/// otherwise returns null.
const ObjCInterfaceDecl *getObjContainingInterface(const NamedDecl *ND) const;

/// Set the copy initialization expression of a block var decl. \p CanThrow
/// indicates whether the copy expression can throw or not.
void setBlockVarCopyInit(const VarDecl* VD, Expr *CopyExpr, bool CanThrow);

/// Get the copy initialization expression of the VarDecl \p VD, or
/// nullptr if none exists.
BlockVarCopyInit getBlockVarCopyInit(const VarDecl* VD) const;

/// Allocate an uninitialized TypeSourceInfo.
///
/// The caller should initialize the memory held by TypeSourceInfo using
/// the TypeLoc wrappers.
///
/// \param T the type that will be the basis for type source info. This type
/// should refer to how the declarator was written in source code, not to
/// what type semantic analysis resolved the declarator to.
///
/// \param Size the size of the type info to create, or 0 if the size
/// should be calculated based on the type.
TypeSourceInfo *CreateTypeSourceInfo(QualType T, unsigned Size = 0) const;

/// Allocate a TypeSourceInfo where all locations have been
/// initialized to a given location, which defaults to the empty
/// location.
TypeSourceInfo *
getTrivialTypeSourceInfo(QualType T,
                         SourceLocation Loc = SourceLocation()) const;

/// Add a deallocation callback that will be invoked when the
/// ASTContext is destroyed.
///
/// \param Callback A callback function that will be invoked on destruction.
///
/// \param Data Pointer data that will be provided to the callback function
/// when it is called.
void AddDeallocation(void (*Callback)(void *), void *Data) const;

/// If T isn't trivially destructible, calls AddDeallocation to register it
/// for destruction.
template <typename T> void addDestruction(T *Ptr) const {
  if (!std::is_trivially_destructible<T>::value) {
    auto DestroyPtr = [](void *V) { static_cast<T *>(V)->~T(); };
    AddDeallocation(DestroyPtr, Ptr);
  }
}

GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const;
GVALinkage GetGVALinkageForVariable(const VarDecl *VD);

/// Determines if the decl can be CodeGen'ed or deserialized from PCH
/// lazily, only when used; this is only relevant for function or file scoped
/// var definitions.
///
/// \returns true if the function/var must be CodeGen'ed/deserialized even if
/// it is not used.
bool DeclMustBeEmitted(const Decl *D);

/// Visits all versions of a multiversioned function with the passed
/// predicate.
void forEachMultiversionedFunctionVersion(
    const FunctionDecl *FD,
    llvm::function_ref<void(FunctionDecl *)> Pred) const;

const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl *RD);

void addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
                                          CXXConstructorDecl *CD);

void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND);

TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD);

void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD);

DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD);

void setManglingNumber(const NamedDecl *ND, unsigned Number);
unsigned getManglingNumber(const NamedDecl *ND) const;

void setStaticLocalNumber(const VarDecl *VD, unsigned Number);
unsigned getStaticLocalNumber(const VarDecl *VD) const;

/// Retrieve the context for computing mangling numbers in the given
/// DeclContext.
MangleNumberingContext &getManglingNumberContext(const DeclContext *DC);
enum NeedExtraManglingDecl_t { NeedExtraManglingDecl };
MangleNumberingContext &getManglingNumberContext(NeedExtraManglingDecl_t,
                                                 const Decl *D);

std::unique_ptr<MangleNumberingContext> createMangleNumberingContext() const;

/// Used by ParmVarDecl to store on the side the
/// index of the parameter when it exceeds the size of the normal bitfield.
void setParameterIndex(const ParmVarDecl *D, unsigned index);

/// Used by ParmVarDecl to retrieve on the side the
/// index of the parameter when it exceeds the size of the normal bitfield.
unsigned getParameterIndex(const ParmVarDecl *D) const;

/// Return a string representing the human readable name for the specified
/// function declaration or file name. Used by SourceLocExpr and
/// PredefinedExpr to cache evaluated results.
StringLiteral *getPredefinedStringLiteralFromCache(StringRef Key) const;

/// Return a declaration for the global GUID object representing the given
/// GUID value.
MSGuidDecl *getMSGuidDecl(MSGuidDeclParts Parts) const;

/// Return the template parameter object of the given type with the given
/// value.
TemplateParamObjectDecl *getTemplateParamObjectDecl(QualType T,
                                                    const APValue &V) const;

/// Parses the target attributes passed in, and returns only the ones that are
/// valid feature names.
ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD) const;

void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
                           const FunctionDecl *) const;
void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
                           GlobalDecl GD) const;

//===--------------------------------------------------------------------===//
//                    Statistics
//===--------------------------------------------------------------------===//

/// The number of implicitly-declared default constructors.
unsigned NumImplicitDefaultConstructors = 0;

/// The number of implicitly-declared default constructors for
/// which declarations were built.
unsigned NumImplicitDefaultConstructorsDeclared = 0;

/// The number of implicitly-declared copy constructors.
unsigned NumImplicitCopyConstructors = 0;

/// The number of implicitly-declared copy constructors for
/// which declarations were built.
unsigned NumImplicitCopyConstructorsDeclared = 0;

/// The number of implicitly-declared move constructors.
unsigned NumImplicitMoveConstructors = 0;

/// The number of implicitly-declared move constructors for
/// which declarations were built.
unsigned NumImplicitMoveConstructorsDeclared = 0;

/// The number of implicitly-declared copy assignment operators.
unsigned NumImplicitCopyAssignmentOperators = 0;

/// The number of implicitly-declared copy assignment operators for
/// which declarations were built.
unsigned NumImplicitCopyAssignmentOperatorsDeclared = 0;

/// The number of implicitly-declared move assignment operators.
unsigned NumImplicitMoveAssignmentOperators = 0;

/// The number of implicitly-declared move assignment operators for
/// which declarations were built.
unsigned NumImplicitMoveAssignmentOperatorsDeclared = 0;

/// The number of implicitly-declared destructors.
unsigned NumImplicitDestructors = 0;

/// The number of implicitly-declared destructors for which
/// declarations were built.
unsigned NumImplicitDestructorsDeclared = 0;

3048public:
/// Initialize built-in types.
///
/// This routine may only be invoked once for a given ASTContext object.
/// It is normally invoked after ASTContext construction.
///
/// \param Target The target
void InitBuiltinTypes(const TargetInfo &Target,
                      const TargetInfo *AuxTarget = nullptr);

3058private:
void InitBuiltinType(CanQualType &R, BuiltinType::Kind K);

class ObjCEncOptions {
  unsigned Bits;

  ObjCEncOptions(unsigned Bits) : Bits(Bits) {}

public:
  ObjCEncOptions() : Bits(0) {}
  ObjCEncOptions(const ObjCEncOptions &RHS) : Bits(RHS.Bits) {}

3070#define OPT_LIST(V)                                                            \
V(ExpandPointedToStructures, 0)                                              \
V(ExpandStructures, 1)                                                       \
V(IsOutermostType, 2)                                                        \
V(EncodingProperty, 3)                                                       \
V(IsStructField, 4)                                                          \
V(EncodeBlockParameters, 5)                                                  \
V(EncodeClassNames, 6)                                                       \

3079#define V(N,I) ObjCEncOptions& set##N() { Bits |= 1 << I; return *this; }
3080OPT_LIST(V)
3081#undef V

3083#define V(N,I) bool N() const { return Bits & 1 << I; }
3084OPT_LIST(V)
3085#undef V

3087#undef OPT_LIST

  LLVM_NODISCARD[[clang::warn_unused_result]] ObjCEncOptions keepingOnly(ObjCEncOptions Mask) const {
    return Bits & Mask.Bits;
  }

  LLVM_NODISCARD[[clang::warn_unused_result]] ObjCEncOptions forComponentType() const {
    ObjCEncOptions Mask = ObjCEncOptions()
                              .setIsOutermostType()
                              .setIsStructField();
    return Bits & ~Mask.Bits;
  }
};

// Return the Objective-C type encoding for a given type.
void getObjCEncodingForTypeImpl(QualType t, std::string &S,
                                ObjCEncOptions Options,
                                const FieldDecl *Field,
                                QualType *NotEncodedT = nullptr) const;

// Adds the encoding of the structure's members.
void getObjCEncodingForStructureImpl(RecordDecl *RD, std::string &S,
                                     const FieldDecl *Field,
                                     bool includeVBases = true,
                                     QualType *NotEncodedT=nullptr) const;

3113public:
// Adds the encoding of a method parameter or return type.
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
                                       QualType T, std::string& S,
                                       bool Extended) const;

/// Returns true if this is an inline-initialized static data member
/// which is treated as a definition for MSVC compatibility.
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const;

enum class InlineVariableDefinitionKind {
  /// Not an inline variable.
  None,

  /// Weak definition of inline variable.
  Weak,

  /// Weak for now, might become strong later in this TU.
  WeakUnknown,

  /// Strong definition.
  Strong
};

/// Determine whether a definition of this inline variable should
/// be treated as a weak or strong definition. For compatibility with
/// C++14 and before, for a constexpr static data member, if there is an
/// out-of-line declaration of the member, we may promote it from weak to
/// strong.
InlineVariableDefinitionKind
getInlineVariableDefinitionKind(const VarDecl *VD) const;

3145private:
friend class DeclarationNameTable;
friend class DeclContext;

const ASTRecordLayout &
getObjCLayout(const ObjCInterfaceDecl *D,
              const ObjCImplementationDecl *Impl) const;

/// A set of deallocations that should be performed when the
/// ASTContext is destroyed.
// FIXME: We really should have a better mechanism in the ASTContext to
// manage running destructors for types which do variable sized allocation
// within the AST. In some places we thread the AST bump pointer allocator
// into the datastructures which avoids this mess during deallocation but is
// wasteful of memory, and here we require a lot of error prone book keeping
// in order to track and run destructors while we're tearing things down.
using DeallocationFunctionsAndArguments =
    llvm::SmallVector<std::pair<void (*)(void *), void *>, 16>;
mutable DeallocationFunctionsAndArguments Deallocations;

// FIXME: This currently contains the set of StoredDeclMaps used
// by DeclContext objects.  This probably should not be in ASTContext,
// but we include it here so that ASTContext can quickly deallocate them.
llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM;

std::vector<Decl *> TraversalScope;

std::unique_ptr<VTableContextBase> VTContext;

void ReleaseDeclContextMaps();

3176public:
enum PragmaSectionFlag : unsigned {
  PSF_None = 0,
  PSF_Read = 0x1,
  PSF_Write = 0x2,
  PSF_Execute = 0x4,
  PSF_Implicit = 0x8,
  PSF_ZeroInit = 0x10,
  PSF_Invalid = 0x80000000U,
};

struct SectionInfo {
  NamedDecl *Decl;
  SourceLocation PragmaSectionLocation;
  int SectionFlags;

  SectionInfo() = default;
  SectionInfo(NamedDecl *Decl, SourceLocation PragmaSectionLocation,
              int SectionFlags)
      : Decl(Decl), PragmaSectionLocation(PragmaSectionLocation),
        SectionFlags(SectionFlags) {}
};

llvm::StringMap<SectionInfo> SectionInfos;

/// Return a new OMPTraitInfo object owned by this context.
OMPTraitInfo &getNewOMPTraitInfo();

/// Whether a C++ static variable may be externalized.
bool mayExternalizeStaticVar(const Decl *D) const;

/// Whether a C++ static variable should be externalized.
bool shouldExternalizeStaticVar(const Decl *D) const;

StringRef getCUIDHash() const;

void AddSYCLKernelNamingDecl(const CXXRecordDecl *RD);
bool IsSYCLKernelNamingDecl(const NamedDecl *RD) const;
unsigned GetSYCLKernelNamingIndex(const NamedDecl *RD);
/// A SourceLocation to store whether we have evaluated a kernel name already,
/// and where it happened.  If so, we need to diagnose an illegal use of the
/// builtin.
llvm::MapVector<const SYCLUniqueStableNameExpr *, std::string>
    SYCLUniqueStableNameEvaluatedValues;

3221private:
/// All OMPTraitInfo objects live in this collection, one per
/// `pragma omp [begin] declare variant` directive.
SmallVector<std::unique_ptr<OMPTraitInfo>, 4> OMPTraitInfoVector;

/// A list of the (right now just lambda decls) declarations required to
/// name all the SYCL kernels in the translation unit, so that we can get the
/// correct kernel name, as well as implement
/// __builtin_sycl_unique_stable_name.
llvm::DenseMap<const DeclContext *,
               llvm::SmallPtrSet<const CXXRecordDecl *, 4>>
    SYCLKernelNamingTypes;
std::unique_ptr<ItaniumMangleContext> SYCLKernelFilterContext;
void FilterSYCLKernelNamingDecls(
    const CXXRecordDecl *RD,
    llvm::SmallVectorImpl<const CXXRecordDecl *> &Decls);
3237};

3239/// Insertion operator for diagnostics.
3240const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                    const ASTContext::SectionInfo &Section);

3243/// Utility function for constructing a nullary selector.
3244inline Selector GetNullarySelector(StringRef name, ASTContext &Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(0, &II);
3247}

3249/// Utility function for constructing an unary selector.
3250inline Selector GetUnarySelector(StringRef name, ASTContext &Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(1, &II);
3253}

3255} // namespace clang

3257// operator new and delete aren't allowed inside namespaces.

3259/// Placement new for using the ASTContext's allocator.
3260///
3261/// This placement form of operator new uses the ASTContext's allocator for
3262/// obtaining memory.
3263///
3264/// IMPORTANT: These are also declared in clang/AST/ASTContextAllocate.h!
3265/// Any changes here need to also be made there.
3266///
3267/// We intentionally avoid using a nothrow specification here so that the calls
3268/// to this operator will not perform a null check on the result -- the
3269/// underlying allocator never returns null pointers.
3270///
3271/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
3272/// @code
3273/// // Default alignment (8)
3274/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
3275/// // Specific alignment
3276/// IntegerLiteral *Ex2 = new (Context, 4) IntegerLiteral(arguments);
3277/// @endcode
3278/// Memory allocated through this placement new operator does not need to be
3279/// explicitly freed, as ASTContext will free all of this memory when it gets
3280/// destroyed. Please note that you cannot use delete on the pointer.
3281///
3282/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
3283/// @param C The ASTContext that provides the allocator.
3284/// @param Alignment The alignment of the allocated memory (if the underlying
3285///                  allocator supports it).
3286/// @return The allocated memory. Could be nullptr.
3287inline void *operator new(size_t Bytes, const clang::ASTContext &C,
                        size_t Alignment /* = 8 */) {
return C.Allocate(Bytes, Alignment);
3290}

3292/// Placement delete companion to the new above.
3293///
3294/// This operator is just a companion to the new above. There is no way of
3295/// invoking it directly; see the new operator for more details. This operator
3296/// is called implicitly by the compiler if a placement new expression using
3297/// the ASTContext throws in the object constructor.
3298inline void operator delete(void *Ptr, const clang::ASTContext &C, size_t) {
C.Deallocate(Ptr);
3300}

3302/// This placement form of operator new[] uses the ASTContext's allocator for
3303/// obtaining memory.
3304///
3305/// We intentionally avoid using a nothrow specification here so that the calls
3306/// to this operator will not perform a null check on the result -- the
3307/// underlying allocator never returns null pointers.
3308///
3309/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
3310/// @code
3311/// // Default alignment (8)
3312/// char *data = new (Context) char[10];
3313/// // Specific alignment
3314/// char *data = new (Context, 4) char[10];
3315/// @endcode
3316/// Memory allocated through this placement new[] operator does not need to be
3317/// explicitly freed, as ASTContext will free all of this memory when it gets
3318/// destroyed. Please note that you cannot use delete on the pointer.
3319///
3320/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
3321/// @param C The ASTContext that provides the allocator.
3322/// @param Alignment The alignment of the allocated memory (if the underlying
3323///                  allocator supports it).
3324/// @return The allocated memory. Could be nullptr.
3325inline void *operator new[](size_t Bytes, const clang::ASTContext& C,
                          size_t Alignment /* = 8 */) {
return C.Allocate(Bytes, Alignment);
3328}

3330/// Placement delete[] companion to the new[] above.
3331///
3332/// This operator is just a companion to the new[] above. There is no way of
3333/// invoking it directly; see the new[] operator for more details. This operator
3334/// is called implicitly by the compiler if a placement new[] expression using
3335/// the ASTContext throws in the object constructor.
3336inline void operator delete[](void *Ptr, const clang::ASTContext &C, size_t) {
C.Deallocate(Ptr);
3338}

3340/// Create the representation of a LazyGenerationalUpdatePtr.
3341template <typename Owner, typename T,
        void (clang::ExternalASTSource::*Update)(Owner)>
3343typename clang::LazyGenerationalUpdatePtr<Owner, T, Update>::ValueType
  clang::LazyGenerationalUpdatePtr<Owner, T, Update>::makeValue(
      const clang::ASTContext &Ctx, T Value) {
// Note, this is implemented here so that ExternalASTSource.h doesn't need to
// include ASTContext.h. We explicitly instantiate it for all relevant types
// in ASTContext.cpp.
if (auto *Source = Ctx.getExternalSource())
  return new (Ctx) LazyData(Source, Value);
return Value;
3352}

3354#endif // LLVM_CLANG_AST_ASTCONTEXT_H

←

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

58namespace clang {

60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;

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

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

77} // namespace clang

79namespace 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);
  }

  static constexpr int 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);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

105} // namespace llvm

107namespace clang {

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

133using CanQualType = CanQual<Type>;

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

139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
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")((void)0);
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((void)0);
  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)((void)0);
  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)((void)0);
  assert(!hasObjCLifetime())((void)0);
  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())((void)0);
  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)((void)0);
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((void)0);
  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")((void)0);
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  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() ||((void)0)
         !hasAddressSpace() || !qs.hasAddressSpace())((void)0);
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((void)0)
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((void)0);
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((void)0)
         !hasObjCLifetime() || !qs.hasObjCLifetime())((void)0);
  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) ||
         // We also define global_device and global_host address spaces,
         // to distinguish global pointers allocated on host from pointers
         // allocated on device, which are a subset of __global.
         (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
                                         B == LangAS::opencl_global_host)) ||
         (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
                                       B == LangAS::sycl_global_host)) ||
         // Consider pointer size address spaces to be equivalent to default.
         ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
          (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
         // Default is a superset of SYCL address spaces.
         (A == LangAS::Default &&
          (B == LangAS::sycl_private || B == LangAS::sycl_local ||
           B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
           B == LangAS::sycl_global_host));
}

/// 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);
}

589private:
// 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;
603};

605/// A std::pair-like structure for storing a qualified type split
606/// into its local qualifiers and its locally-unqualified type.
607struct 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;
}
630};

632/// The kind of type we are substituting Objective-C type arguments into.
633///
634/// The kind of substitution affects the replacement of type parameters when
635/// no concrete type information is provided, e.g., when dealing with an
636/// unspecialized type.
637enum 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,
652};

654/// A (possibly-)qualified type.
655///
656/// For efficiency, we don't store CV-qualified types as nodes on their
657/// own: instead each reference to a type stores the qualifiers.  This
658/// greatly reduces the number of nodes we need to allocate for types (for
659/// example we only need one for 'int', 'const int', 'volatile int',
660/// 'const volatile int', etc).
661///
662/// As an added efficiency bonus, instead of making this a pair, we
663/// just store the two bits we care about in the low bits of the
664/// pointer.  To handle the packing/unpacking, we make QualType be a
665/// simple wrapper class that acts like a smart pointer.  A third bit
666/// indicates whether there are extended qualifiers present, in which
667/// case the pointer points to a special structure.
668class 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")((void)0);
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

690public:
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)((void)0)
         && "non-fast qualifier bits set in mask!")((void)0);
  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")((void)0);
  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;

/// Remove an outer pack expansion type (if any) from this type. Used as part
/// of converting the type of a declaration to the type of an expression that
/// references that expression. It's meaningless for an expression to have a
/// pack expansion type.
QualType getNonPackExpansionType() 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 ASTContext &Context) 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 true if address space qualifiers overlap with T address space
/// qualifiers.
/// OpenCL C defines conversion rules for pointers to different address spaces
/// and notion of overlapping address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// OpenCL C v2.0 s6.5.5 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(QualType T) const {
  Qualifiers Q = getQualifiers();
  Qualifiers TQ = T.getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
}

/// 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;

1289private:
// 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);
1306};

1308} // namespace clang

1310namespace llvm {

1312/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1313/// to a specific Type class.
1314template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1320};

1322// Teach SmallPtrSet that QualType is "basically a pointer".
1323template<>
1324struct 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.
static constexpr int NumLowBitsAvailable = 0;
1335};

1337} // namespace llvm

1339namespace clang {

1341/// Base class that is common to both the \c ExtQuals and \c Type
1342/// classes, which allows \c QualType to access the common fields between the
1343/// two.
1344class 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) {}
1361};

1363/// We can encode up to four bits in the low bits of a
1364/// type pointer, but there are many more type qualifiers that we want
1365/// to be able to apply to an arbitrary type.  Therefore we have this
1366/// struct, intended to be heap-allocated and used by QualType to
1367/// store qualifiers.
1368///
1369/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1370/// in three low bits on the QualType pointer; a fourth bit records whether
1371/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1372/// Objective-C GC attributes) are much more rare.
1373class 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; }

1393public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((void)0)
         && "ExtQuals created with no fast qualifiers")((void)0);
  assert(!Quals.hasFastQualifiers()((void)0)
         && "ExtQuals created with fast qualifiers")((void)0);
}

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; }

1419public:
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!")((void)0);
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1431};

1433/// The kind of C++11 ref-qualifier associated with a function type.
1434/// This determines whether a member function's "this" object can be an
1435/// lvalue, rvalue, or neither.
1436enum 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
1445};

1447/// Which keyword(s) were used to create an AutoType.
1448enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1457};

1459/// The base class of the type hierarchy.
1460///
1461/// A central concept with types is that each type always has a canonical
1462/// type.  A canonical type is the type with any typedef names stripped out
1463/// of it or the types it references.  For example, consider:
1464///
1465///  typedef int  foo;
1466///  typedef foo* bar;
1467///    'int *'    'foo *'    'bar'
1468///
1469/// There will be a Type object created for 'int'.  Since int is canonical, its
1470/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1471/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1472/// there is a PointerType that represents 'int*', which, like 'int', is
1473/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1474/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1475/// is also 'int*'.
1476///
1477/// Non-canonical types are useful for emitting diagnostics, without losing
1478/// information about typedefs being used.  Canonical types are useful for type
1479/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1480/// about whether something has a particular form (e.g. is a function type),
1481/// because they implicitly, recursively, strip all typedefs out of a type.
1482///
1483/// Types, once created, are immutable.
1484///
1485class alignas(8) Type : public ExtQualsTypeCommonBase {
1486public:
enum TypeClass {
1488#define TYPE(Class, Base) Class,
1489#define LAST_TYPE(Class) TypeLast = Class
1490#define ABSTRACT_TYPE(Class, Base)
1491#include "clang/AST/TypeNodes.inc"
};

1494private:
/// 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;

  /// Store information on the type dependency.
  unsigned Dependence : llvm::BitWidth<TypeDependence>;

  /// 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")((void)0);
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };

1535protected:
// 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 : 13;

  /// 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.
  uint32_t NumElements;
};

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;

  /// The number of template arguments in the type-constraints, 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 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;
};

1807private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1815protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, TypeDependence Dependence)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
                "changing bitfields changed sizeof(Type)!");
  static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
                "Insufficient alignment!");
  TypeBits.TC = tc;
  TypeBits.Dependence = static_cast<unsigned>(Dependence);
  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 setDependence(TypeDependence D) {
  TypeBits.Dependence = static_cast<unsigned>(D);
}

void addDependence(TypeDependence D) { setDependence(getDependence() | D); }

1842public:
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 getDependence() & TypeDependence::UnexpandedPack;
}

/// 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;

/// As an extension, we classify types as one of "sized" or "sizeless";
/// every type is one or the other.  Standard types are all sized;
/// sizeless types are purely an extension.
///
/// Sizeless types contain data with no specified size, alignment,
/// or layout.
bool isSizelessType() const;
bool isSizelessBuiltinType() const;

/// Determines if this is a sizeless type supported by the
/// 'arm_sve_vector_bits' type attribute, which can be applied to a single
/// SVE vector or predicate, excluding tuple types such as svint32x4_t.
bool isVLSTBuiltinType() const;

/// Returns the representative type for the element of an SVE builtin type.
/// This is used to represent fixed-length SVE vectors created with the
/// 'arm_sve_vector_bits' type attribute as VectorType.
QualType getSveEltType(const ASTContext &Ctx) 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;

/// Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isStructuralType() 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 isBFloat16Type() const;
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 isMatrixType() const;                    // Matrix type.
bool isConstantMatrixType() const;            // Constant matrix 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)
bool isTypedefNameType() const;               // typedef or alias template

2105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2107#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

2117#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2119#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 isExtIntType() const;                    // Extended Int 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;

/// Check if the type is the CUDA device builtin surface type.
bool isCUDADeviceBuiltinSurfaceType() const;
/// Check if the type is the CUDA device builtin texture type.
bool isCUDADeviceBuiltinTextureType() 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;

TypeDependence getDependence() const {
  return static_cast<TypeDependence>(TypeBits.Dependence);
}

/// Whether this type is an error type.
bool containsErrors() const {
  return getDependence() & TypeDependence::Error;
}

/// 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 getDependence() & TypeDependence::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 getDependence() & TypeDependence::Instantiation;
}

/// 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 getDependence() & TypeDependence::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 ASTContext &Context) const;
2458};

2460/// This will check for a TypedefType by removing any existing sugar
2461/// until it reaches a TypedefType or a non-sugared type.
2462template <> const TypedefType *Type::getAs() const;

2464/// This will check for a TemplateSpecializationType by removing any
2465/// existing sugar until it reaches a TemplateSpecializationType or a
2466/// non-sugared type.
2467template <> const TemplateSpecializationType *Type::getAs() const;

2469/// This will check for an AttributedType by removing any existing sugar
2470/// until it reaches an AttributedType or a non-sugared type.
2471template <> const AttributedType *Type::getAs() const;

2473// We can do canonical leaf types faster, because we don't have to
2474// worry about preserving child type decoration.
2475#define TYPE(Class, Base)
2476#define LEAF_TYPE(Class) \
2477template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2479} \
2480template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2482}
2483#include "clang/AST/TypeNodes.inc"

2485/// This class is used for builtin types like 'int'.  Builtin
2486/// types are always canonical and have a literal name field.
2487class BuiltinType : public Type {
2488public:
enum Kind {
2490// OpenCL image types
2491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2492#include "clang/Basic/OpenCLImageTypes.def"
2493// OpenCL extension types
2494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2495#include "clang/Basic/OpenCLExtensionTypes.def"
2496// SVE Types
2497#define SVE_TYPE(Name, Id, SingletonId) Id,
2498#include "clang/Basic/AArch64SVEACLETypes.def"
2499// PPC MMA Types
2500#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2501#include "clang/Basic/PPCTypes.def"
2502// RVV Types
2503#define RVV_TYPE(Name, Id, SingletonId) Id,
2504#include "clang/Basic/RISCVVTypes.def"
2505// All other builtin types
2506#define BUILTIN_TYPE(Id, SingletonId) Id,
2507#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2508#include "clang/AST/BuiltinTypes.def"
};

2511private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(),
           K == Dependent ? TypeDependence::DependentInstantiation
                          : TypeDependence::None) {
  BuiltinTypeBits.Kind = K;
}

2521public:
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')((void)0);
  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; }
2577};

2579/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2580/// types (_Complex float etc) as well as the GCC integer complex extensions.
2581class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->getDependence()),
      ElementType(Element) {}

2590public:
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; }
2605};

2607/// Sugar for parentheses used when specifying types.
2608class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}

2616public:
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; }
2631};

2633/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2634class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
      PointeeType(Pointee) {}

2643public:
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() == Pointer; }
2658};

2660/// Represents a type which was implicitly adjusted by the semantic
2661/// engine for arbitrary reasons.  For example, array and function types can
2662/// decay, and function types can have their calling conventions adjusted.
2663class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2667protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2675public:
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;
}
2694};

2696/// Represents a pointer type decayed from an array or function type.
2697class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2703public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2709};

2711/// Pointer to a block type.
2712/// This type is to represent types syntactically represented as
2713/// "void (^)(int)", etc. Pointee is required to always be a function type.
2714class 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->getDependence()),
      PointeeType(Pointee) {}

2724public:
// 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;
}
2742};

2744/// Base for LValueReferenceType and RValueReferenceType
2745class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2748protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->getDependence()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2757public:
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;
}
2786};

2788/// An lvalue reference type, per C++11 [dcl.ref].
2789class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2797public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2804};

2806/// An rvalue reference type, per C++11 [dcl.ref].
2807class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2813public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2820};

2822/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2823///
2824/// This includes both pointers to data members and pointer to member functions.
2825class 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->getDependence() & ~TypeDependence::VariablyModified) |
               Pointee->getDependence()),
      PointeeType(Pointee), Class(Cls) {}

2840public:
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;
}
2874};

2876/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2877class ArrayType : public Type, public llvm::FoldingSetNode {
2878public:
/// 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
};

2887private:
/// The element type of the array.
QualType ElementType;

2891protected:
friend class ASTContext; // ASTContext creates these.

ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
          unsigned tq, const Expr *sz = nullptr);

2897public:
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;
}
2918};

2920/// Represents the canonical version of C arrays with a specified constant size.
2921/// For example, the canonical type for 'int A[4 + 4*100]' is a
2922/// ConstantArrayType where the element type is 'int' and the size is 404.
2923class 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")((void)0);
    *getTrailingObjects<const Expr*>() = sz;
  }
}

unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
  return ConstantArrayTypeBits.HasStoredSizeExpr;
}

2945public:
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;
}
2978};

2980/// Represents a C array with an unspecified size.  For example 'int A[]' has
2981/// an IncompleteArrayType where the element type is 'int' and the size is
2982/// unspecified.
2983class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq) {}

2990public:
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);
}
3011};

3013/// Represents a C array with a specified size that is not an
3014/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3015/// Since the size expression is an arbitrary expression, we store it as such.
3016///
3017/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3018/// should not be: two lexically equivalent variable array types could mean
3019/// different things, for example, these variables do not have the same type
3020/// dynamically:
3021///
3022/// void foo(int x) {
3023///   int Y[x];
3024///   ++x;
3025///   int Z[x];
3026/// }
3027class 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) {}

3043public:
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.")__builtin_unreachable();
}
3066};

3068/// Represents an array type in C++ whose size is a value-dependent expression.
3069///
3070/// For example:
3071/// \code
3072/// template<typename T, int Size>
3073/// class array {
3074///   T data[Size];
3075/// };
3076/// \endcode
3077///
3078/// For these types, we won't actually know what the array bound is
3079/// until template instantiation occurs, at which point this will
3080/// become either a ConstantArrayType or a VariableArrayType.
3081class 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);

3100public:
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);
3128};

3130/// Represents an extended address space qualifier where the input address space
3131/// value is dependent. Non-dependent address spaces are not represented with a
3132/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3133///
3134/// For example:
3135/// \code
3136/// template<typename T, int AddrSpace>
3137/// class AddressSpace {
3138///   typedef T __attribute__((address_space(AddrSpace))) type;
3139/// }
3140/// \endcode
3141class 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);

3153public:
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);
3171};

3173/// Represents an extended vector type where either the type or size is
3174/// dependent.
3175///
3176/// For example:
3177/// \code
3178/// template<typename T, int Size>
3179/// class vector {
3180///   typedef T __attribute__((ext_vector_type(Size))) type;
3181/// }
3182/// \endcode
3183class 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);

3197public:
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);
3215};


3218/// Represents a GCC generic vector type. This type is created using
3219/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3220/// bytes; or from an Altivec __vector or vector declaration.
3221/// Since the constructor takes the number of vector elements, the
3222/// client is responsible for converting the size into the number of elements.
3223class VectorType : public Type, public llvm::FoldingSetNode {
3224public:
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,

  /// is AArch64 SVE fixed-length data vector
  SveFixedLengthDataVector,

  /// is AArch64 SVE fixed-length predicate vector
  SveFixedLengthPredicateVector
};

3251protected:
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);

3263public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

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/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3411/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3412/// number of rows and "columns" specifies the number of columns.
3413class MatrixType : public Type, public llvm::FoldingSetNode {
3414protected:
friend class ASTContext;

/// The element type of the matrix.
QualType ElementType;

MatrixType(QualType ElementTy, QualType CanonElementTy);

MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
           const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);

3425public:
/// Returns type of the elements being stored in the matrix
QualType getElementType() const { return ElementType; }

/// Valid elements types are the following:
/// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
///   and _Bool
/// * the standard floating types float or double
/// * a half-precision floating point type, if one is supported on the target
static bool isValidElementType(QualType T) {
  return T->isDependentType() ||
         (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix ||
         T->getTypeClass() == DependentSizedMatrix;
}
3446};

3448/// Represents a concrete matrix type with constant number of rows and columns
3449class ConstantMatrixType final : public MatrixType {
3450protected:
friend class ASTContext;

/// The element type of the matrix.
// FIXME: Appears to be unused? There is also MatrixType::ElementType...
QualType ElementType;

/// Number of rows and columns.
unsigned NumRows;
unsigned NumColumns;

static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;

ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

3469public:
/// Returns the number of rows in the matrix.
unsigned getNumRows() const { return NumRows; }

/// Returns the number of columns in the matrix.
unsigned getNumColumns() const { return NumColumns; }

/// Returns the number of elements required to embed the matrix into a vector.
unsigned getNumElementsFlattened() const {
  return getNumRows() * getNumColumns();
}

/// Returns true if \p NumElements is a valid matrix dimension.
static constexpr bool isDimensionValid(size_t NumElements) {
  return NumElements > 0 && NumElements <= MaxElementsPerDimension;
}

/// Returns the maximum number of elements per dimension.
static constexpr unsigned getMaxElementsPerDimension() {
  return MaxElementsPerDimension;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumRows(), getNumColumns(),
          getTypeClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumRows, unsigned NumColumns,
                    TypeClass TypeClass) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumRows);
  ID.AddInteger(NumColumns);
  ID.AddInteger(TypeClass);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix;
}
3508};

3510/// Represents a matrix type where the type and the number of rows and columns
3511/// is dependent on a template.
3512class DependentSizedMatrixType final : public MatrixType {
friend class ASTContext;

const ASTContext &Context;
Expr *RowExpr;
Expr *ColumnExpr;

SourceLocation loc;

DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
                         QualType CanonicalType, Expr *RowExpr,
                         Expr *ColumnExpr, SourceLocation loc);

3525public:
QualType getElementType() const { return ElementType; }
Expr *getRowExpr() const { return RowExpr; }
Expr *getColumnExpr() const { return ColumnExpr; }
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() == DependentSizedMatrix;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3544};

3546/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3547/// class of FunctionNoProtoType and FunctionProtoType.
3548class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3552public:
/// 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 16, you'll need to
  // adjust the Bits field below, and if you add bits, you'll need to adjust
  // Type::FunctionTypeBitfields::ExtInfo as well.

  // |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
  // |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |    12    |
  //
  // 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 {
    RegParmMask =  0x700,
    RegParmOffset = 8
  };
  enum { NoCfCheckMask = 0x800 };
  enum { CmseNSCallMask = 0x1000 };
  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,
          bool cmseNSCall) {
    assert((!hasRegParm || regParm < 7) && "Invalid regparm value")((void)0);
    Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
           (producesResult ? ProducesResultMask : 0) |
           (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
           (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
           (NoCfCheck ? NoCfCheckMask : 0) |
           (cmseNSCall ? CmseNSCallMask : 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 getCmseNSCall() const { return Bits & CmseNSCallMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return ((Bits & RegParmMask) >> 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 withCmseNSCall(bool cmseNSCall) const {
    if (cmseNSCall)
      return ExtInfo(Bits | CmseNSCallMask);
    else
      return ExtInfo(Bits & ~CmseNSCallMask);
  }

  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")((void)0);
    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;
};

3799protected:
FunctionType(TypeClass tc, QualType res, QualType Canonical,
             TypeDependence Dependence, ExtInfo Info)
    : Type(tc, Canonical, Dependence), ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3810public:
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(); }

bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
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;
}
3845};

3847/// Represents a K&R-style 'int foo()' function, which has
3848/// no information available about its arguments.
3849class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   Result->getDependence() &
                       ~(TypeDependence::DependentInstantiation |
                         TypeDependence::UnexpandedPack),
                   Info) {}

3859public:
// 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;
}
3878};

3880/// Represents a prototype with parameter type info, e.g.
3881/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3882/// parameters, not as having a single void parameter. Such a type can have
3883/// an exception specification, but this specification is not part of the
3884/// canonical type. FunctionProtoType has several trailing objects, some of
3885/// which optional. For more information about the trailing objects see
3886/// the first comment inside FunctionProtoType.
3887class 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.

3939public:
/// 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;
  }
};

3992private:
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")__builtin_unreachable();
}

/// 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;
}

4096public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((void)0);
  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!")((void)0);
  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())((void)0);
  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")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  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);
4336};

4338/// Represents the dependent type named by a dependently-scoped
4339/// typename using declaration, e.g.
4340///   using typename Base<T>::foo;
4341///
4342/// Template instantiation turns these into the underlying type.
4343class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}

4353public:
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);
}
4371};

4373class TypedefType : public Type {
TypedefNameDecl *Decl;

4376private:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
            QualType can);

4382public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4389};

4391/// Sugar type that represents a type that was qualified by a qualifier written
4392/// as a macro invocation.
4393class 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->getDependence()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&((void)0)
         "Expected a macro qualified type to only wrap attributed types.")((void)0);
}

4407public:
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;
}
4421};

4423/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4424class TypeOfExprType : public Type {
Expr *TOExpr;

4427protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4432public:
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; }
4442};

4444/// Internal representation of canonical, dependent
4445/// `typeof(expr)` types.
4446///
4447/// This class is used internally by the ASTContext to manage
4448/// canonical, dependent types, only. Clients will only see instances
4449/// of this class via TypeOfExprType nodes.
4450class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4454public:
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);
4464};

4466/// Represents `typeof(type)`, a GCC extension.
4467class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->getDependence()), TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((void)0);
}

4477public:
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; }
4487};

4489/// Represents the type `decltype(expr)` (C++11).
4490class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4494protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4499public:
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; }
4510};

4512/// Internal representation of canonical, dependent
4513/// decltype(expr) types.
4514///
4515/// This class is used internally by the ASTContext to manage
4516/// canonical, dependent types, only. Clients will only see instances
4517/// of this class via DecltypeType nodes.
4518class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4521public:
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);
4530};

4532/// A unary type transform, which is a type constructed from another.
4533class UnaryTransformType : public Type {
4534public:
enum UTTKind {
  EnumUnderlyingType
};

4539private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4548protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4554public:
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;
}
4566};

4568/// Internal representation of canonical, dependent
4569/// __underlying_type(type) types.
4570///
4571/// This class is used internally by the ASTContext to manage
4572/// canonical, dependent types, only. Clients will only see instances
4573/// of this class via UnaryTransformType nodes.
4574class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4576public:
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);
}
4589};

4591class 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;

4599protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4602public:
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;
}
4611};

4613/// A helper class that allows the use of isa/cast/dyncast
4614/// to detect TagType objects of structs/unions/classes.
4615class RecordType : public TagType {
4616protected:
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()) {}

4624public:
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; }
4637};

4639/// A helper class that allows the use of isa/cast/dyncast
4640/// to detect TagType objects of enums.
4641class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4647public:
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; }
4656};

4658/// An attributed type is a type to which a type attribute has been applied.
4659///
4660/// The "modified type" is the fully-sugared type to which the attributed
4661/// type was applied; generally it is not canonically equivalent to the
4662/// attributed type. The "equivalent type" is the minimally-desugared type
4663/// which the type is canonically equivalent to.
4664///
4665/// For example, in the following attributed type:
4666///     int32_t __attribute__((vector_size(16)))
4667///   - the modified type is the TypedefType for int32_t
4668///   - the equivalent type is VectorType(16, int32_t)
4669///   - the canonical type is VectorType(16, int)
4670class AttributedType : public Type, public llvm::FoldingSetNode {
4671public:
using Kind = attr::Kind;

4674private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->getDependence()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4687public:
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::NullableResult:
    return attr::TypeNullableResult;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
}

/// 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;
}
4765};

4767class 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,
           TypeDependence::DependentInstantiation |
               (Canon->getDependence() & TypeDependence::UnexpandedPack)),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           TypeDependence::DependentInstantiation |
               (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4807public:
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;
}
4837};

4839/// Represents the result of substituting a type for a template
4840/// type parameter.
4841///
4842/// Within an instantiated template, all template type parameters have
4843/// been replaced with these.  They are used solely to record that a
4844/// type was originally written as a template type parameter;
4845/// therefore they are never canonical.
4846class 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->getDependence()),
      Replaced(Param) {}

4856public:
/// 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;
}
4885};

4887/// Represents the result of substituting a set of types for a template
4888/// type parameter pack.
4889///
4890/// When a pack expansion in the source code contains multiple parameter packs
4891/// and those parameter packs correspond to different levels of template
4892/// parameter lists, this type node is used to represent a template type
4893/// parameter pack from an outer level, which has already had its argument pack
4894/// substituted but that still lives within a pack expansion that itself
4895/// could not be instantiated. When actually performing a substitution into
4896/// that pack expansion (e.g., when all template parameters have corresponding
4897/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4898/// at the current pack substitution index.
4899class 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);

4913public:
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;
}
4938};

4940/// Common base class for placeholders for types that get replaced by
4941/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4942/// class template types, and constrained type names.
4943///
4944/// These types are usually a placeholder for a deduced type. However, before
4945/// the initializer is attached, or (usually) if the initializer is
4946/// type-dependent, there is no deduced type and the type is canonical. In
4947/// the latter case, it is also a dependent type.
4948class DeducedType : public Type {
4949protected:
DeducedType(TypeClass TC, QualType DeducedAsType,
            TypeDependence ExtraDependence)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           ExtraDependence | (DeducedAsType.isNull()
                                  ? TypeDependence::None
                                  : DeducedAsType->getDependence() &
                                        ~TypeDependence::VariablyModified)) {}

4961public:
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;
}
4978};

4980/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4981/// by a type-constraint.
4982class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

ConceptDecl *TypeConstraintConcept;

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         TypeDependence ExtraDependence, ConceptDecl *CD,
         ArrayRef<TemplateArgument> TypeConstraintArgs);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

4999public:
/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return AutoTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
  return {getArgs(), getNumArgs()};
}

ConceptDecl *getTypeConstraintConcept() const {
  return TypeConstraintConcept;
}

bool isConstrained() const {
  return TypeConstraintConcept != nullptr;
}

bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
          getTypeConstraintConcept(), getTypeConstraintArguments());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType Deduced, AutoTypeKeyword Keyword,
                    bool IsDependent, ConceptDecl *CD,
                    ArrayRef<TemplateArgument> Arguments);

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
5045};

5047/// Represents a C++17 deduced template specialization type.
5048class 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,
                  toTypeDependence(Template.getDependence()) |
                      (IsDeducedAsDependent
                           ? TypeDependence::DependentInstantiation
                           : TypeDependence::None)),
      Template(Template) {}

5065public:
/// 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;
}
5083};

5085/// Represents a type template specialization; the template
5086/// must be a class template, a type alias template, or a template
5087/// template parameter.  A template which cannot be resolved to one of
5088/// these, e.g. because it is written with a dependent scope
5089/// specifier, is instead represented as a
5090/// @c DependentTemplateSpecializationType.
5091///
5092/// A non-dependent template specialization type is always "sugar",
5093/// typically for a \c RecordType.  For example, a class template
5094/// specialization type of \c vector<int> will refer to a tag type for
5095/// the instantiation \c std::vector<int, std::allocator<int>>
5096///
5097/// Template specializations are dependent if either the template or
5098/// any of the template arguments are dependent, in which case the
5099/// type may also be canonical.
5100///
5101/// Instances of this type are allocated with a trailing array of
5102/// TemplateArguments, followed by a QualType representing the
5103/// non-canonical aliased type when the template is a type alias
5104/// template.
5105class 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);

5124public:
/// Determine whether any of the given template arguments are dependent.
///
/// The converted arguments should be supplied when known; whether an
/// argument is dependent can depend on the conversions performed on it
/// (for example, a 'const int' passed as a template argument might be
/// dependent if the parameter is a reference but non-dependent if the
/// parameter is an int).
///
/// Note that the \p Args parameter is unused: this is intentional, to remind
/// the caller that they need to pass in the converted arguments, not the
/// specified arguments.
static bool
anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                              ArrayRef<TemplateArgument> Converted);
static bool
anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                              ArrayRef<TemplateArgument> Converted);
static bool anyInstantiationDependentTemplateArguments(
    ArrayRef<TemplateArgumentLoc> Args);

/// 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")((void)0);
  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;
}
5222};

5224/// Print a template argument list, including the '<' and '>'
5225/// enclosing the template arguments.
5226void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5231void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5236void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5241/// The injected class name of a C++ class template or class
5242/// template partial specialization.  Used to record that a type was
5243/// spelled with a bare identifier rather than as a template-id; the
5244/// equivalent for non-templated classes is just RecordType.
5245///
5246/// Injected class name types are always dependent.  Template
5247/// instantiation turns these into RecordTypes.
5248///
5249/// Injected class name types are always canonical.  This works
5250/// because it is impossible to compare an injected class name type
5251/// with the corresponding non-injected template type, for the same
5252/// reason that it is impossible to directly compare template
5253/// parameters from different dependent contexts: injected class name
5254/// types can only occur within the scope of a particular templated
5255/// declaration, and within that scope every template specialization
5256/// will canonicalize to the injected class name (when appropriate
5257/// according to the rules of the language).
5258class 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(),
           TypeDependence::DependentInstantiation),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))((void)0);
  assert(!TST.hasQualifiers())((void)0);
  assert(TST->isDependentType())((void)0);
}

5288public:
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;
}
5307};

5309/// The kind of a tag type.
5310enum 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
5325};

5327/// The elaboration keyword that precedes a qualified type name or
5328/// introduces an elaborated-type-specifier.
5329enum 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
5351};

5353/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5354/// The keyword in stored in the free bits of the base class.
5355/// Also provides a few static helpers for converting and printing
5356/// elaborated type keyword and tag type kind enumerations.
5357class TypeWithKeyword : public Type {
5358protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, TypeDependence Dependence)
    : Type(tc, Canonical, Dependence) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5365public:
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 *);
5395};

5397/// Represents a type that was referred to using an elaborated type
5398/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5399/// or both.
5400///
5401/// This type is used to keep track of a type name as written in the
5402/// source code, including tag keywords and any nested-name-specifiers.
5403/// The type itself is always "sugar", used to express what was written
5404/// in the source code but containing no additional semantic information.
5405class 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,
                      // Any semantic dependence on the qualifier will have
                      // been incorporated into NamedType. We still need to
                      // track syntactic (instantiation / error / pack)
                      // dependence on the qualifier.
                      NamedType->getDependence() |
                          (NNS ? toSyntacticDependence(
                                     toTypeDependence(NNS->getDependence()))
                               : TypeDependence::None)),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&((void)0)
         "ElaboratedType cannot have elaborated type keyword "((void)0)
         "and name qualifier both null.")((void)0);
}

5444public:
/// 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; }
5478};

5480/// Represents a qualified type name for which the type name is
5481/// dependent.
5482///
5483/// DependentNameType represents a class of dependent types that involve a
5484/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5485/// name of a type. The DependentNameType may start with a "typename" (for a
5486/// typename-specifier), "class", "struct", "union", or "enum" (for a
5487/// dependent elaborated-type-specifier), or nothing (in contexts where we
5488/// know that we must be referring to a type, e.g., in a base class specifier).
5489/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5490/// mode, this type is used with non-dependent names to delay name lookup until
5491/// instantiation.
5492class 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,
                      TypeDependence::DependentInstantiation |
                          toTypeDependence(NNS->getDependence())),
      NNS(NNS), Name(Name) {}

5508public:
/// 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;
}
5538};

5540/// Represents a template specialization type whose template cannot be
5541/// resolved, e.g.
5542///   A<T>::template B<T>
5543class 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);
}

5568public:
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;
}
5610};

5612/// Represents a pack expansion of types.
5613///
5614/// Pack expansions are part of C++11 variadic templates. A pack
5615/// expansion contains a pattern, which itself contains one or more
5616/// "unexpanded" parameter packs. When instantiated, a pack expansion
5617/// produces a series of types, each instantiated from the pattern of
5618/// the expansion, where the Ith instantiation of the pattern uses the
5619/// Ith arguments bound to each of the unexpanded parameter packs. The
5620/// pack expansion is considered to "expand" these unexpanded
5621/// parameter packs.
5622///
5623/// \code
5624/// template<typename ...Types> struct tuple;
5625///
5626/// template<typename ...Types>
5627/// struct tuple_of_references {
5628///   typedef tuple<Types&...> type;
5629/// };
5630/// \endcode
5631///
5632/// Here, the pack expansion \c Types&... is represented via a
5633/// PackExpansionType whose pattern is Types&.
5634class 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,
           (Pattern->getDependence() | TypeDependence::Dependent |
            TypeDependence::Instantiation) &
               ~TypeDependence::UnexpandedPack),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5651public:
/// 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 false; }
QualType desugar() const { return 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;
}
5683};

5685/// This class wraps the list of protocol qualifiers. For types that can
5686/// take ObjC protocol qualifers, they can subclass this class.
5687template <class T>
5688class ObjCProtocolQualifiers {
5689protected:
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() &&((void)0)
         "bitfield overflow in protocol count")((void)0);
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5713public:
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")((void)0);
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5739};

5741/// Represents a type parameter type in Objective C. It can take
5742/// a list of protocols.
5743class 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);

5773public:
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,
                    QualType CanonicalType,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5788};

5790/// Represents a class type in Objective C.
5791///
5792/// Every Objective C type is a combination of a base type, a set of
5793/// type arguments (optional, for parameterized classes) and a list of
5794/// protocols.
5795///
5796/// Given the following declarations:
5797/// \code
5798///   \@class C<T>;
5799///   \@protocol P;
5800/// \endcode
5801///
5802/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5803/// with base C and no protocols.
5804///
5805/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5806/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5807/// protocol list.
5808/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5809/// and protocol list [P].
5810///
5811/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5812/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5813/// and no protocols.
5814///
5815/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5816/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5817/// this should get its own sugar class to better represent the source.
5818class 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;
}

5856protected:
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(), TypeDependence::None),
      BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5874public:
/// 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?")((void)0);
  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;
}
5965};

5967/// A class providing a concrete implementation
5968/// of ObjCObjectType, so as to not increase the footprint of
5969/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5970/// system should not reference this type.
5971class 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) {}

5983public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5990};

5992inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5994}

5996inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5999}

6001inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
6004}

6006/// Interfaces are the core concept in Objective-C for object oriented design.
6007/// They basically correspond to C++ classes.  There are two kinds of interface
6008/// types: normal interfaces like `NSString`, and qualified interfaces, which
6009/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6010///
6011/// ObjCInterfaceType guarantees the following properties when considered
6012/// as a subtype of its superclass, ObjCObjectType:
6013///   - There are no protocol qualifiers.  To reinforce this, code which
6014///     tries to invoke the protocol methods via an ObjCInterfaceType will
6015///     fail to compile.
6016///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
6017///     T->getBaseType() == QualType(T, 0).
6018class 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)) {}

6030public:
/// 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
};
6052};

6054inline 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;
6064}

6066/// Represents a pointer to an Objective C object.
6067///
6068/// These are constructed from pointer declarators when the pointee type is
6069/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
6070/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6071/// and 'Class<P>' are translated into these.
6072///
6073/// Pointers to pointers to Objective C objects are still PointerTypes;
6074/// only the first level of pointer gets it own type implementation.
6075class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
      PointeeType(Pointee) {}

6084public:
/// 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;
}
6243};

6245class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}

6253public:
/// 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;
}
6272};

6274/// PipeType - OpenCL20.
6275class 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->getDependence()),
      ElementType(elemType), isRead(isRead) {}

6285public:
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; }
6306};

6308/// A fixed int type of a specified bitwidth.
6309class ExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
unsigned IsUnsigned : 1;
unsigned NumBits : 24;

6314protected:
ExtIntType(bool isUnsigned, unsigned NumBits);

6317public:
bool isUnsigned() const { return IsUnsigned; }
bool isSigned() const { return !IsUnsigned; }
unsigned getNumBits() const { return NumBits; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, isUnsigned(), getNumBits());
}

static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
                    unsigned NumBits) {
  ID.AddBoolean(IsUnsigned);
  ID.AddInteger(NumBits);
}

static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6336};

6338class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
const ASTContext &Context;
llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;

6343protected:
DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
                    Expr *NumBits);

6347public:
bool isUnsigned() const;
bool isSigned() const { return !isUnsigned(); }
Expr *getNumBitsExpr() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, isUnsigned(), getNumBitsExpr());
}
static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    bool IsUnsigned, Expr *NumBitsExpr);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentExtInt;
}
6364};

6366/// A qualifier set is used to build a set of qualifiers.
6367class QualifierCollector : public Qualifiers {
6368public:
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;
6389};

6391/// A container of type source information.
6392///
6393/// A client can read the relevant info using TypeLoc wrappers, e.g:
6394/// @code
6395/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6396/// TL.getBeginLoc().print(OS, SrcMgr);
6397/// @endcode
6398class 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) {}

6407public:
/// 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; }
6416};

6418// Inline function definitions.

6420inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6425}

6427inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6429}

6431inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6433}

6435inline 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);
6444}

6446inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6452}

6454inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6458}

6460inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6464}

6466inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6469}

6471inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6473}

6475inline 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);
6484}

6486inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6489}

6491inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6494}


6497inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6500}

6502inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6505}

6507inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6512}

6514inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6519}

6521inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6523}

6525inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6527}

6529inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6531}

6533inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((void)0);
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);
6540}

6542/// Check if this type has any address space qualifier.
6543inline bool QualType::hasAddressSpace() const {
return getQualifiers().hasAddressSpace();
6545}

6547/// Return the address space of this type.
6548inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6550}

6552/// Return the gc attribute of this type.
6553inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6555}

6557inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6561}

6563inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6567}

6569inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6573}

6575inline 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();
6583}

6585inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6587}

6589/// Determine whether this type is more
6590/// qualified than the Other type. For example, "const volatile int"
6591/// is more qualified than "const int", "volatile int", and
6592/// "int". However, it is not more qualified than "const volatile
6593/// int".
6594inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6598}

6600/// Determine whether this type is at last
6601/// as qualified as the Other type. For example, "const volatile
6602/// int" is at least as qualified as "const int", "volatile int",
6603/// "int", and "const volatile int".
6604inline 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);
6612}

6614/// If Type is a reference type (e.g., const
6615/// int&), returns the type that the reference refers to ("const
6616/// int"). Otherwise, returns the type itself. This routine is used
6617/// throughout Sema to implement C++ 5p6:
6618///
6619///   If an expression initially has the type "reference to T" (8.3.2,
6620///   8.5.3), the type is adjusted to "T" prior to any further
6621///   analysis, the expression designates the object or function
6622///   denoted by the reference, and the expression is an lvalue.
6623inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6628}

6630inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6633}

6635/// Tests whether the type is categorized as a fundamental type.
6636///
6637/// \returns True for types specified in C++0x [basic.fundamental].
6638inline 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());
6644}

6646/// Tests whether the type is categorized as a compound type.
6647///
6648/// \returns True for types specified in C++0x [basic.compound].
6649inline 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();
6669}

6671inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
33
←
Assuming field 'CanonicalType' is not a 'FunctionType'→
34
←
Returning zero, which participates in a condition later→
6673}

6675inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6677}

6679inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6681}

6683inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6685}

6687inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6689}

6691inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6693}

6695inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6697}

6699inline 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;
6707}

6709inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6714}

6716inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6721}

6723inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6725}

6727inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6732}

6734inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6739}

6741inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6743}

6745inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6747}

6749inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6751}

6753inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6755}

6757inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6759}

6761inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6763}

6765inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6767}

6769inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6771}

6773inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6775}

6777inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6779}

6781inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6783}

6785inline bool Type::isMatrixType() const {
return isa<MatrixType>(CanonicalType);
6787}

6789inline bool Type::isConstantMatrixType() const {
return isa<ConstantMatrixType>(CanonicalType);
6791}

6793inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6795}

6797inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6799}

6801inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6803}

6805inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6808}

6810inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6812}

6814inline bool Type::isUndeducedAutoType() const {
return isa<AutoType>(CanonicalType);
6816}

6818inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6822}

6824inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6828}

6830inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6834}

6836inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6840}

6842inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6846}

6848inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6850}

6852inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6854}

6856#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6860#include "clang/Basic/OpenCLImageTypes.def"

6862inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6864}

6866inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6868}

6870inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6872}

6874inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6876}

6878inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6880}

6882inline bool Type::isImageType() const {
6883#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6885#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6887}

6889inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6891}

6893inline bool Type::isExtIntType() const {
return isa<ExtIntType>(CanonicalType);
6895}

6897#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6901#include "clang/Basic/OpenCLExtensionTypes.def"

6903inline bool Type::isOCLIntelSubgroupAVCType() const {
6904#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6907#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6909}

6911inline bool Type::isOCLExtOpaqueType() const {
6912#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6914#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6916}

6918inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6921}

6923inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6925}

6927inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT26.1
'BT' is null
1
'BT' is null
1
'BT' is null
1
'BT' is null
1
'BT' is null
1
'BT' is null
 = getAs<BuiltinType>()) {
26
←
Assuming the object is not a 'BuiltinType'→
27
←
Taking false branch→
  return BT->getKind() == static_cast<BuiltinType::Kind>(K);
}
return false;
28
←
Returning zero, which participates in a condition later→
6932}

6934inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6938}

6940inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6945}

6947inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((void)0);
return isSpecificBuiltinType(K);
6950}

6952inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6956}

6958inline bool Type::isVoidType() const {
return isSpecificBuiltinType(BuiltinType::Void);
25
←
Calling 'Type::isSpecificBuiltinType'→
29
←
Returning from 'Type::isSpecificBuiltinType'→
30
←
Returning zero, which participates in a condition later→
6960}

6962inline bool Type::isHalfType() const {
// FIXME: Should we allow complex __fp16? Probably not.
return isSpecificBuiltinType(BuiltinType::Half);
6965}

6967inline bool Type::isFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::Float16);
6969}

6971inline bool Type::isBFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::BFloat16);
6973}

6975inline bool Type::isFloat128Type() const {
return isSpecificBuiltinType(BuiltinType::Float128);
6977}

6979inline bool Type::isNullPtrType() const {
return isSpecificBuiltinType(BuiltinType::NullPtr);
6981}

6983bool IsEnumDeclComplete(EnumDecl *);
6984bool IsEnumDeclScoped(EnumDecl *);

6986inline 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 isExtIntType();
6997}

6999inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7005}

7007inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
7009}

7011inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7017}

7019inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
7021}

7023inline 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;
7035}

7037inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
7039}

7041inline 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) ||
       isExtIntType();
7055}

7057inline 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 isExtIntType();
7068}

7070inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
7074}

7076inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
7079}

7081/// Determines whether this is a type for which one can define
7082/// an overloaded operator.
7083inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
7085}

7087/// Determines whether this type is written as a typedef-name.
7088inline bool Type::isTypedefNameType() const {
if (getAs<TypedefType>())
  return true;
if (auto *TST = getAs<TemplateSpecializationType>())
  return TST->isTypeAlias();
return false;
7094}

7096/// Determines whether this type can decay to a pointer type.
7097inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
7099}

7101inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
7104}

7106inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
7108}

7110inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
7115}

7117inline 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;
7124}
7125/// Insertion operator for partial diagnostics. This allows sending adress
7126/// spaces into a diagnostic with <<.
7127inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           LangAS AS) {
PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return PD;
7132}

7134/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7135/// into a diagnostic with <<.
7136inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
7141}

7143/// Insertion operator for partial diagnostics.  This allows sending QualType's
7144/// into a diagnostic with <<.
7145inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
7150}

7152// Helper class template that is used by Type::getAs to ensure that one does
7153// not try to look through a qualified type to get to an array type.
7154template <typename T>
7155using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

7159// Member-template getAs<specific type>'.
7160template <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());
7175}

7177template <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);
7209}

7211inline 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());
7223}

7225template <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))((void)0);
return cast<T>(getUnqualifiedDesugaredType());
7232}

7234inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((void)0);
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
7238}

7240DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7243#ifndef NDEBUG1
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((void)0);
7247#endif
7248}

7250QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
7254}

7256// Get the decimal string representation of a fixed point type, represented
7257// as a scaled integer.
7258// TODO: At some point, we should change the arguments to instead just accept an
7259// APFixedPoint instead of APSInt and scale.
7260void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

7263} // namespace clang

7265#endif // LLVM_CLANG_AST_TYPE_H

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include/clang/Basic/LangOptions.h

→

1//===- LangOptions.h - C Language Family Language Options -------*- 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/// Defines the clang::LangOptions interface.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_BASIC_LANGOPTIONS_H
15#define LLVM_CLANG_BASIC_LANGOPTIONS_H

17#include "clang/Basic/CommentOptions.h"
18#include "clang/Basic/LLVM.h"
19#include "clang/Basic/LangStandard.h"
20#include "clang/Basic/ObjCRuntime.h"
21#include "clang/Basic/Sanitizers.h"
22#include "clang/Basic/TargetCXXABI.h"
23#include "clang/Basic/Visibility.h"
24#include "llvm/ADT/FloatingPointMode.h"
25#include "llvm/ADT/StringRef.h"
26#include "llvm/ADT/Triple.h"
27#include <string>
28#include <vector>

30namespace clang {

32/// Bitfields of LangOptions, split out from LangOptions in order to ensure that
33/// this large collection of bitfields is a trivial class type.
34class LangOptionsBase {
friend class CompilerInvocation;

37public:
// Define simple language options (with no accessors).
39#define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
40#define ENUM_LANGOPT(Name, Type, Bits, Default, Description)
41#include "clang/Basic/LangOptions.def"

43protected:
// Define language options of enumeration type. These are private, and will
// have accessors (below).
46#define LANGOPT(Name, Bits, Default, Description)
47#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
unsigned Name : Bits;
49#include "clang/Basic/LangOptions.def"
50};

52/// In the Microsoft ABI, this controls the placement of virtual displacement
53/// members used to implement virtual inheritance.
54enum class MSVtorDispMode { Never, ForVBaseOverride, ForVFTable };

56/// Keeps track of the various options that can be
57/// enabled, which controls the dialect of C or C++ that is accepted.
58class LangOptions : public LangOptionsBase {
59public:
using Visibility = clang::Visibility;
using RoundingMode = llvm::RoundingMode;

enum GCMode { NonGC, GCOnly, HybridGC };
enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };

// Automatic variables live on the stack, and when trivial they're usually
// uninitialized because it's undefined behavior to use them without
// initializing them.
enum class TrivialAutoVarInitKind { Uninitialized, Zero, Pattern };

enum SignedOverflowBehaviorTy {
  // Default C standard behavior.
  SOB_Undefined,

  // -fwrapv
  SOB_Defined,

  // -ftrapv
  SOB_Trapping
};

// FIXME: Unify with TUKind.
enum CompilingModuleKind {
  /// Not compiling a module interface at all.
  CMK_None,

  /// Compiling a module from a module map.
  CMK_ModuleMap,

  /// Compiling a module from a list of header files.
  CMK_HeaderModule,

  /// Compiling a C++ modules TS module interface unit.
  CMK_ModuleInterface,
};

enum PragmaMSPointersToMembersKind {
  PPTMK_BestCase,
  PPTMK_FullGeneralitySingleInheritance,
  PPTMK_FullGeneralityMultipleInheritance,
  PPTMK_FullGeneralityVirtualInheritance
};

using MSVtorDispMode = clang::MSVtorDispMode;

enum DefaultCallingConvention {
  DCC_None,
  DCC_CDecl,
  DCC_FastCall,
  DCC_StdCall,
  DCC_VectorCall,
  DCC_RegCall
};

enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };

// Corresponds to _MSC_VER
enum MSVCMajorVersion {
  MSVC2010 = 1600,
  MSVC2012 = 1700,
  MSVC2013 = 1800,
  MSVC2015 = 1900,
  MSVC2017 = 1910,
  MSVC2017_5 = 1912,
  MSVC2017_7 = 1914,
  MSVC2019 = 1920,
  MSVC2019_8 = 1928,
};

enum SYCLMajorVersion {
  SYCL_None,
  SYCL_2017,
  SYCL_2020,
  // The "default" SYCL version to be used when none is specified on the
  // frontend command line.
  SYCL_Default = SYCL_2020
};

/// Clang versions with different platform ABI conformance.
enum class ClangABI {
  /// Attempt to be ABI-compatible with code generated by Clang 3.8.x
  /// (SVN r257626). This causes <1 x long long> to be passed in an
  /// integer register instead of an SSE register on x64_64.
  Ver3_8,

  /// Attempt to be ABI-compatible with code generated by Clang 4.0.x
  /// (SVN r291814). This causes move operations to be ignored when
  /// determining whether a class type can be passed or returned directly.
  Ver4,

  /// Attempt to be ABI-compatible with code generated by Clang 6.0.x
  /// (SVN r321711). This causes determination of whether a type is
  /// standard-layout to ignore collisions between empty base classes
  /// and between base classes and member subobjects, which affects
  /// whether we reuse base class tail padding in some ABIs.
  Ver6,

  /// Attempt to be ABI-compatible with code generated by Clang 7.0.x
  /// (SVN r338536). This causes alignof (C++) and _Alignof (C11) to be
  /// compatible with __alignof (i.e., return the preferred alignment)
  /// rather than returning the required alignment.
  Ver7,

  /// Attempt to be ABI-compatible with code generated by Clang 9.0.x
  /// (SVN r351319). This causes vectors of __int128 to be passed in memory
  /// instead of passing in multiple scalar registers on x86_64 on Linux and
  /// NetBSD.
  Ver9,

  /// Attempt to be ABI-compatible with code generated by Clang 11.0.x
  /// (git 2e10b7a39b93). This causes clang to pass unions with a 256-bit
  /// vector member on the stack instead of using registers, to not properly
  /// mangle substitutions for template names in some cases, and to mangle
  /// declaration template arguments without a cast to the parameter type
  /// even when that can lead to mangling collisions.
  Ver11,

  /// Attempt to be ABI-compatible with code generated by Clang 12.0.x
  /// (git 8e464dd76bef). This causes clang to mangle lambdas within
  /// global-scope inline variables incorrectly.
  Ver12,

  /// Conform to the underlying platform's C and C++ ABIs as closely
  /// as we can.
  Latest
};

enum class CoreFoundationABI {
  /// No interoperability ABI has been specified
  Unspecified,
  /// CoreFoundation does not have any language interoperability
  Standalone,
  /// Interoperability with the ObjectiveC runtime
  ObjectiveC,
  /// Interoperability with the latest known version of the Swift runtime
  Swift,
  /// Interoperability with the Swift 5.0 runtime
  Swift5_0,
  /// Interoperability with the Swift 4.2 runtime
  Swift4_2,
  /// Interoperability with the Swift 4.1 runtime
  Swift4_1,
};

enum FPModeKind {
  // Disable the floating point pragma
  FPM_Off,

  // Enable the floating point pragma
  FPM_On,

  // Aggressively fuse FP ops (E.g. FMA) disregarding pragmas.
  FPM_Fast,

  // Aggressively fuse FP ops and honor pragmas.
  FPM_FastHonorPragmas
};

/// Alias for RoundingMode::NearestTiesToEven.
static constexpr unsigned FPR_ToNearest =
    static_cast<unsigned>(llvm::RoundingMode::NearestTiesToEven);

/// Possible floating point exception behavior.
enum FPExceptionModeKind {
  /// Assume that floating-point exceptions are masked.
  FPE_Ignore,
  /// Transformations do not cause new exceptions but may hide some.
  FPE_MayTrap,
  /// Strictly preserve the floating-point exception semantics.
  FPE_Strict
};

/// Possible exception handling behavior.
enum class ExceptionHandlingKind { None, SjLj, WinEH, DwarfCFI, Wasm };

enum class LaxVectorConversionKind {
  /// Permit no implicit vector bitcasts.
  None,
  /// Permit vector bitcasts between integer vectors with different numbers
  /// of elements but the same total bit-width.
  Integer,
  /// Permit vector bitcasts between all vectors with the same total
  /// bit-width.
  All,
};

enum class AltivecSrcCompatKind {
  // All vector compares produce scalars except vector pixel and vector bool.
  // The types vector pixel and vector bool return vector results.
  Mixed,
  // All vector compares produce vector results as in GCC.
  GCC,
  // All vector compares produce scalars as in XL.
  XL,
  // Default clang behaviour.
  Default = Mixed,
};

enum class SignReturnAddressScopeKind {
  /// No signing for any function.
  None,
  /// Sign the return address of functions that spill LR.
  NonLeaf,
  /// Sign the return address of all functions,
  All
};

enum class SignReturnAddressKeyKind {
  /// Return address signing uses APIA key.
  AKey,
  /// Return address signing uses APIB key.
  BKey
};

enum class ThreadModelKind {
  /// POSIX Threads.
  POSIX,
  /// Single Threaded Environment.
  Single
};

enum class ExtendArgsKind {
  /// Integer arguments are sign or zero extended to 32/64 bits
  /// during default argument promotions.
  ExtendTo32,
  ExtendTo64
};

289public:
/// The used language standard.
LangStandard::Kind LangStd;

/// Set of enabled sanitizers.
SanitizerSet Sanitize;
/// Is at least one coverage instrumentation type enabled.
bool SanitizeCoverage = false;

/// Paths to files specifying which objects
/// (files, functions, variables) should not be instrumented.
std::vector<std::string> NoSanitizeFiles;

/// Paths to the XRay "always instrument" files specifying which
/// objects (files, functions, variables) should be imbued with the XRay
/// "always instrument" attribute.
/// WARNING: This is a deprecated field and will go away in the future.
std::vector<std::string> XRayAlwaysInstrumentFiles;

/// Paths to the XRay "never instrument" files specifying which
/// objects (files, functions, variables) should be imbued with the XRay
/// "never instrument" attribute.
/// WARNING: This is a deprecated field and will go away in the future.
std::vector<std::string> XRayNeverInstrumentFiles;

/// Paths to the XRay attribute list files, specifying which objects
/// (files, functions, variables) should be imbued with the appropriate XRay
/// attribute(s).
std::vector<std::string> XRayAttrListFiles;

/// Paths to special case list files specifying which entities
/// (files, functions) should or should not be instrumented.
std::vector<std::string> ProfileListFiles;

clang::ObjCRuntime ObjCRuntime;

CoreFoundationABI CFRuntime = CoreFoundationABI::Unspecified;

std::string ObjCConstantStringClass;

/// The name of the handler function to be called when -ftrapv is
/// specified.
///
/// If none is specified, abort (GCC-compatible behaviour).
std::string OverflowHandler;

/// The module currently being compiled as specified by -fmodule-name.
std::string ModuleName;

/// The name of the current module, of which the main source file
/// is a part. If CompilingModule is set, we are compiling the interface
/// of this module, otherwise we are compiling an implementation file of
/// it. This starts as ModuleName in case -fmodule-name is provided and
/// changes during compilation to reflect the current module.
std::string CurrentModule;

/// The names of any features to enable in module 'requires' decls
/// in addition to the hard-coded list in Module.cpp and the target features.
///
/// This list is sorted.
std::vector<std::string> ModuleFeatures;

/// Options for parsing comments.
CommentOptions CommentOpts;

/// A list of all -fno-builtin-* function names (e.g., memset).
std::vector<std::string> NoBuiltinFuncs;

/// A prefix map for __FILE__, __BASE_FILE__ and __builtin_FILE().
std::map<std::string, std::string, std::greater<std::string>> MacroPrefixMap;

/// Triples of the OpenMP targets that the host code codegen should
/// take into account in order to generate accurate offloading descriptors.
std::vector<llvm::Triple> OMPTargetTriples;

/// Name of the IR file that contains the result of the OpenMP target
/// host code generation.
std::string OMPHostIRFile;

/// The user provided compilation unit ID, if non-empty. This is used to
/// externalize static variables which is needed to support accessing static
/// device variables in host code for single source offloading languages
/// like CUDA/HIP.
std::string CUID;

/// C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
/// This overrides the default ABI used by the target.
llvm::Optional<TargetCXXABI::Kind> CXXABI;

/// Indicates whether the front-end is explicitly told that the
/// input is a header file (i.e. -x c-header).
bool IsHeaderFile = false;

LangOptions();

// Define accessors/mutators for language options of enumeration type.
385#define LANGOPT(Name, Bits, Default, Description)
386#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
Type get##Name() const { return static_cast<Type>(Name); } \
void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
389#include "clang/Basic/LangOptions.def"

/// Are we compiling a module interface (.cppm or module map)?
bool isCompilingModule() const {
  return getCompilingModule() != CMK_None;
}

/// Do we need to track the owning module for a local declaration?
bool trackLocalOwningModule() const {
  return isCompilingModule() || ModulesLocalVisibility;
}

bool isSignedOverflowDefined() const {
  return getSignedOverflowBehavior() == SOB_Defined;
38
←
Assuming the condition is false→
39
←
Returning zero, which participates in a condition later→
}

bool isSubscriptPointerArithmetic() const {
  return ObjCRuntime.isSubscriptPointerArithmetic() &&
         !ObjCSubscriptingLegacyRuntime;
}

bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
  return MSCompatibilityVersion >= MajorVersion * 100000U;
}

/// Reset all of the options that are not considered when building a
/// module.
void resetNonModularOptions();

/// Is this a libc/libm function that is no longer recognized as a
/// builtin because a -fno-builtin-* option has been specified?
bool isNoBuiltinFunc(StringRef Name) const;

/// True if any ObjC types may have non-trivial lifetime qualifiers.
bool allowsNonTrivialObjCLifetimeQualifiers() const {
  return ObjCAutoRefCount || ObjCWeak;
}

bool assumeFunctionsAreConvergent() const {
  return ConvergentFunctions;
}

/// Return the OpenCL C or C++ version as a VersionTuple.
VersionTuple getOpenCLVersionTuple() const;

/// Check if return address signing is enabled.
bool hasSignReturnAddress() const {
  return getSignReturnAddressScope() != SignReturnAddressScopeKind::None;
}

/// Check if return address signing uses AKey.
bool isSignReturnAddressWithAKey() const {
  return getSignReturnAddressKey() == SignReturnAddressKeyKind::AKey;
}

/// Check if leaf functions are also signed.
bool isSignReturnAddressScopeAll() const {
  return getSignReturnAddressScope() == SignReturnAddressScopeKind::All;
}

bool hasSjLjExceptions() const {
  return getExceptionHandling() == ExceptionHandlingKind::SjLj;
}

bool hasSEHExceptions() const {
  return getExceptionHandling() == ExceptionHandlingKind::WinEH;
}

bool hasDWARFExceptions() const {
  return getExceptionHandling() == ExceptionHandlingKind::DwarfCFI;
}

bool hasWasmExceptions() const {
  return getExceptionHandling() == ExceptionHandlingKind::Wasm;
}

bool isSYCL() const { return SYCLIsDevice || SYCLIsHost; }

/// Remap path prefix according to -fmacro-prefix-path option.
void remapPathPrefix(SmallString<256> &Path) const;
469};

471/// Floating point control options
472class FPOptionsOverride;
473class FPOptions {
474public:
// We start by defining the layout.
using storage_type = uint16_t;

using RoundingMode = llvm::RoundingMode;

static constexpr unsigned StorageBitSize = 8 * sizeof(storage_type);

// Define a fake option named "First" so that we have a PREVIOUS even for the
// real first option.
static constexpr storage_type FirstShift = 0, FirstWidth = 0;
485#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
static constexpr storage_type NAME##Shift =                                  \
    PREVIOUS##Shift + PREVIOUS##Width;                                       \
static constexpr storage_type NAME##Width = WIDTH;                           \
static constexpr storage_type NAME##Mask = ((1 << NAME##Width) - 1)          \
                                           << NAME##Shift;
491#include "clang/Basic/FPOptions.def"

static constexpr storage_type TotalWidth = 0
494#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) +WIDTH
495#include "clang/Basic/FPOptions.def"
    ;
static_assert(TotalWidth <= StorageBitSize, "Too short type for FPOptions");

499private:
storage_type Value;

502public:
FPOptions() : Value(0) {
  setFPContractMode(LangOptions::FPM_Off);
  setRoundingMode(static_cast<RoundingMode>(LangOptions::FPR_ToNearest));
  setFPExceptionMode(LangOptions::FPE_Ignore);
}
explicit FPOptions(const LangOptions &LO) {
  Value = 0;
  // The language fp contract option FPM_FastHonorPragmas has the same effect
  // as FPM_Fast in frontend. For simplicity, use FPM_Fast uniformly in
  // frontend.
  auto LangOptContractMode = LO.getDefaultFPContractMode();
  if (LangOptContractMode == LangOptions::FPM_FastHonorPragmas)
    LangOptContractMode = LangOptions::FPM_Fast;
  setFPContractMode(LangOptContractMode);
  setRoundingMode(LO.getFPRoundingMode());
  setFPExceptionMode(LO.getFPExceptionMode());
  setAllowFPReassociate(LO.AllowFPReassoc);
  setNoHonorNaNs(LO.NoHonorNaNs);
  setNoHonorInfs(LO.NoHonorInfs);
  setNoSignedZero(LO.NoSignedZero);
  setAllowReciprocal(LO.AllowRecip);
  setAllowApproxFunc(LO.ApproxFunc);
  if (getFPContractMode() == LangOptions::FPM_On &&
      getRoundingMode() == llvm::RoundingMode::Dynamic &&
      getFPExceptionMode() == LangOptions::FPE_Strict)
    // If the FP settings are set to the "strict" model, then
    // FENV access is set to true. (ffp-model=strict)
    setAllowFEnvAccess(true);
  else
    setAllowFEnvAccess(LangOptions::FPM_Off);
}

bool allowFPContractWithinStatement() const {
  return getFPContractMode() == LangOptions::FPM_On;
}
void setAllowFPContractWithinStatement() {
  setFPContractMode(LangOptions::FPM_On);
}

bool allowFPContractAcrossStatement() const {
  return getFPContractMode() == LangOptions::FPM_Fast;
}
void setAllowFPContractAcrossStatement() {
  setFPContractMode(LangOptions::FPM_Fast);
}

bool isFPConstrained() const {
  return getRoundingMode() != llvm::RoundingMode::NearestTiesToEven ||
         getFPExceptionMode() != LangOptions::FPE_Ignore ||
         getAllowFEnvAccess();
}

bool operator==(FPOptions other) const { return Value == other.Value; }

/// Return the default value of FPOptions that's used when trailing
/// storage isn't required.
static FPOptions defaultWithoutTrailingStorage(const LangOptions &LO);

storage_type getAsOpaqueInt() const { return Value; }
static FPOptions getFromOpaqueInt(storage_type Value) {
  FPOptions Opts;
  Opts.Value = Value;
  return Opts;
}

// We can define most of the accessors automatically:
569#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
TYPE get##NAME() const {                                                     \
  return static_cast<TYPE>((Value & NAME##Mask) >> NAME##Shift);             \
}                                                                            \
void set##NAME(TYPE value) {                                                 \
  Value = (Value & ~NAME##Mask) | (storage_type(value) << NAME##Shift);      \
}
576#include "clang/Basic/FPOptions.def"
LLVM_DUMP_METHOD__attribute__((noinline)) void dump();
578};

580/// Represents difference between two FPOptions values.
581///
582/// The effect of language constructs changing the set of floating point options
583/// is usually a change of some FP properties while leaving others intact. This
584/// class describes such changes by keeping information about what FP options
585/// are overridden.
586///
587/// The integral set of FP options, described by the class FPOptions, may be
588/// represented as a default FP option set, defined by language standard and
589/// command line options, with the overrides introduced by pragmas.
590///
591/// The is implemented as a value of the new FPOptions plus a mask showing which
592/// fields are actually set in it.
593class FPOptionsOverride {
FPOptions Options = FPOptions::getFromOpaqueInt(0);
FPOptions::storage_type OverrideMask = 0;

597public:
using RoundingMode = llvm::RoundingMode;

/// The type suitable for storing values of FPOptionsOverride. Must be twice
/// as wide as bit size of FPOption.
using storage_type = uint32_t;
static_assert(sizeof(storage_type) >= 2 * sizeof(FPOptions::storage_type),
              "Too short type for FPOptionsOverride");

/// Bit mask selecting bits of OverrideMask in serialized representation of
/// FPOptionsOverride.
static constexpr storage_type OverrideMaskBits =
    (static_cast<storage_type>(1) << FPOptions::StorageBitSize) - 1;

FPOptionsOverride() {}
FPOptionsOverride(const LangOptions &LO)
    : Options(LO), OverrideMask(OverrideMaskBits) {}
FPOptionsOverride(FPOptions FPO)
    : Options(FPO), OverrideMask(OverrideMaskBits) {}

bool requiresTrailingStorage() const { return OverrideMask != 0; }

void setAllowFPContractWithinStatement() {
  setFPContractModeOverride(LangOptions::FPM_On);
}

void setAllowFPContractAcrossStatement() {
  setFPContractModeOverride(LangOptions::FPM_Fast);
}

void setDisallowFPContract() {
  setFPContractModeOverride(LangOptions::FPM_Off);
}

void setFPPreciseEnabled(bool Value) {
  setAllowFPReassociateOverride(!Value);
  setNoHonorNaNsOverride(!Value);
  setNoHonorInfsOverride(!Value);
  setNoSignedZeroOverride(!Value);
  setAllowReciprocalOverride(!Value);
  setAllowApproxFuncOverride(!Value);
  if (Value)
    /* Precise mode implies fp_contract=on and disables ffast-math */
    setAllowFPContractWithinStatement();
  else
    /* Precise mode disabled sets fp_contract=fast and enables ffast-math */
    setAllowFPContractAcrossStatement();
}

storage_type getAsOpaqueInt() const {
  return (static_cast<storage_type>(Options.getAsOpaqueInt())
          << FPOptions::StorageBitSize) |
         OverrideMask;
}
static FPOptionsOverride getFromOpaqueInt(storage_type I) {
  FPOptionsOverride Opts;
  Opts.OverrideMask = I & OverrideMaskBits;
  Opts.Options = FPOptions::getFromOpaqueInt(I >> FPOptions::StorageBitSize);
  return Opts;
}

FPOptions applyOverrides(FPOptions Base) {
  FPOptions Result =
      FPOptions::getFromOpaqueInt((Base.getAsOpaqueInt() & ~OverrideMask) |
                                   (Options.getAsOpaqueInt() & OverrideMask));
  return Result;
}

FPOptions applyOverrides(const LangOptions &LO) {
  return applyOverrides(FPOptions(LO));
}

bool operator==(FPOptionsOverride other) const {
  return Options == other.Options && OverrideMask == other.OverrideMask;
}
bool operator!=(FPOptionsOverride other) const { return !(*this == other); }

674#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
bool has##NAME##Override() const {                                           \
  return OverrideMask & FPOptions::NAME##Mask;                               \
}                                                                            \
TYPE get##NAME##Override() const {                                           \
  assert(has##NAME##Override())((void)0);                                             \
  return Options.get##NAME();                                                \
}                                                                            \
void clear##NAME##Override() {                                               \
  /* Clear the actual value so that we don't have spurious differences when  \
   * testing equality. */                                                    \
  Options.set##NAME(TYPE(0));                                                \
  OverrideMask &= ~FPOptions::NAME##Mask;                                    \
}                                                                            \
void set##NAME##Override(TYPE value) {                                       \
  Options.set##NAME(value);                                                  \
  OverrideMask |= FPOptions::NAME##Mask;                                     \
}
692#include "clang/Basic/FPOptions.def"
LLVM_DUMP_METHOD__attribute__((noinline)) void dump();
694};

696/// Describes the kind of translation unit being processed.
697enum TranslationUnitKind {
/// The translation unit is a complete translation unit.
TU_Complete,

/// The translation unit is a prefix to a translation unit, and is
/// not complete.
TU_Prefix,

/// The translation unit is a module.
TU_Module,

/// The translation unit is a is a complete translation unit that we might
/// incrementally extend later.
TU_Incremental
711};

713} // namespace clang

715#endif // LLVM_CLANG_BASIC_LANGOPTIONS_H

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include/llvm/IR/IRBuilder.h

→

1//===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- 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// This file defines the IRBuilder class, which is used as a convenient way
10// to create LLVM instructions with a consistent and simplified interface.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_IR_IRBUILDER_H
15#define LLVM_IR_IRBUILDER_H

17#include "llvm-c/Types.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/Twine.h"
23#include "llvm/IR/BasicBlock.h"
24#include "llvm/IR/Constant.h"
25#include "llvm/IR/ConstantFolder.h"
26#include "llvm/IR/Constants.h"
27#include "llvm/IR/DataLayout.h"
28#include "llvm/IR/DebugInfoMetadata.h"
29#include "llvm/IR/DebugLoc.h"
30#include "llvm/IR/DerivedTypes.h"
31#include "llvm/IR/Function.h"
32#include "llvm/IR/GlobalVariable.h"
33#include "llvm/IR/InstrTypes.h"
34#include "llvm/IR/Instruction.h"
35#include "llvm/IR/Instructions.h"
36#include "llvm/IR/IntrinsicInst.h"
37#include "llvm/IR/LLVMContext.h"
38#include "llvm/IR/Module.h"
39#include "llvm/IR/Operator.h"
40#include "llvm/IR/Type.h"
41#include "llvm/IR/Value.h"
42#include "llvm/IR/ValueHandle.h"
43#include "llvm/Support/AtomicOrdering.h"
44#include "llvm/Support/CBindingWrapping.h"
45#include "llvm/Support/Casting.h"
46#include <cassert>
47#include <cstddef>
48#include <cstdint>
49#include <functional>
50#include <utility>

52namespace llvm {

54class APInt;
55class MDNode;
56class Use;

58/// This provides the default implementation of the IRBuilder
59/// 'InsertHelper' method that is called whenever an instruction is created by
60/// IRBuilder and needs to be inserted.
61///
62/// By default, this inserts the instruction at the insertion point.
63class IRBuilderDefaultInserter {
64public:
virtual ~IRBuilderDefaultInserter();

virtual void InsertHelper(Instruction *I, const Twine &Name,
                          BasicBlock *BB,
                          BasicBlock::iterator InsertPt) const {
  if (BB) BB->getInstList().insert(InsertPt, I);
  I->setName(Name);
}
73};

75/// Provides an 'InsertHelper' that calls a user-provided callback after
76/// performing the default insertion.
77class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
std::function<void(Instruction *)> Callback;

80public:
virtual ~IRBuilderCallbackInserter();

IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
    : Callback(std::move(Callback)) {}

void InsertHelper(Instruction *I, const Twine &Name,
                  BasicBlock *BB,
                  BasicBlock::iterator InsertPt) const override {
  IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
  Callback(I);
}
92};

94/// Common base class shared among various IRBuilders.
95class IRBuilderBase {
/// Pairs of (metadata kind, MDNode *) that should be added to all newly
/// created instructions, like !dbg metadata.
SmallVector<std::pair<unsigned, MDNode *>, 2> MetadataToCopy;

/// Add or update the an entry (Kind, MD) to MetadataToCopy, if \p MD is not
/// null. If \p MD is null, remove the entry with \p Kind.
void AddOrRemoveMetadataToCopy(unsigned Kind, MDNode *MD) {
  if (!MD) {
    erase_if(MetadataToCopy, [Kind](const std::pair<unsigned, MDNode *> &KV) {
      return KV.first == Kind;
    });
    return;
  }

  for (auto &KV : MetadataToCopy)
    if (KV.first == Kind) {
      KV.second = MD;
      return;
    }

  MetadataToCopy.emplace_back(Kind, MD);
}

119protected:
BasicBlock *BB;
BasicBlock::iterator InsertPt;
LLVMContext &Context;
const IRBuilderFolder &Folder;
const IRBuilderDefaultInserter &Inserter;

MDNode *DefaultFPMathTag;
FastMathFlags FMF;

bool IsFPConstrained;
fp::ExceptionBehavior DefaultConstrainedExcept;
RoundingMode DefaultConstrainedRounding;

ArrayRef<OperandBundleDef> DefaultOperandBundles;

135public:
IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder,
              const IRBuilderDefaultInserter &Inserter,
              MDNode *FPMathTag, ArrayRef<OperandBundleDef> OpBundles)
    : Context(context), Folder(Folder), Inserter(Inserter),
      DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
      DefaultConstrainedExcept(fp::ebStrict),
      DefaultConstrainedRounding(RoundingMode::Dynamic),
      DefaultOperandBundles(OpBundles) {
  ClearInsertionPoint();
}

/// Insert and return the specified instruction.
template<typename InstTy>
InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  Inserter.InsertHelper(I, Name, BB, InsertPt);
  AddMetadataToInst(I);
  return I;
}

/// No-op overload to handle constants.
Constant *Insert(Constant *C, const Twine& = "") const {
  return C;
}

Value *Insert(Value *V, const Twine &Name = "") const {
  if (Instruction *I = dyn_cast<Instruction>(V))
    return Insert(I, Name);
  assert(isa<Constant>(V))((void)0);
  return V;
}

//===--------------------------------------------------------------------===//
// Builder configuration methods
//===--------------------------------------------------------------------===//

/// Clear the insertion point: created instructions will not be
/// inserted into a block.
void ClearInsertionPoint() {
  BB = nullptr;
  InsertPt = BasicBlock::iterator();
}

BasicBlock *GetInsertBlock() const { return BB; }
BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
LLVMContext &getContext() const { return Context; }

/// This specifies that created instructions should be appended to the
/// end of the specified block.
void SetInsertPoint(BasicBlock *TheBB) {
  BB = TheBB;
  InsertPt = BB->end();
}

/// This specifies that created instructions should be inserted before
/// the specified instruction.
void SetInsertPoint(Instruction *I) {
  BB = I->getParent();
  InsertPt = I->getIterator();
  assert(InsertPt != BB->end() && "Can't read debug loc from end()")((void)0);
  SetCurrentDebugLocation(I->getDebugLoc());
}

/// This specifies that created instructions should be inserted at the
/// specified point.
void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
  BB = TheBB;
  InsertPt = IP;
  if (IP != TheBB->end())
    SetCurrentDebugLocation(IP->getDebugLoc());
}

/// Set location information used by debugging information.
void SetCurrentDebugLocation(DebugLoc L) {
  AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode());
}

/// Collect metadata with IDs \p MetadataKinds from \p Src which should be
/// added to all created instructions. Entries present in MedataDataToCopy but
/// not on \p Src will be dropped from MetadataToCopy.
void CollectMetadataToCopy(Instruction *Src,
                           ArrayRef<unsigned> MetadataKinds) {
  for (unsigned K : MetadataKinds)
    AddOrRemoveMetadataToCopy(K, Src->getMetadata(K));
}

/// Get location information used by debugging information.
DebugLoc getCurrentDebugLocation() const {
  for (auto &KV : MetadataToCopy)
    if (KV.first == LLVMContext::MD_dbg)
      return {cast<DILocation>(KV.second)};

  return {};
}

/// If this builder has a current debug location, set it on the
/// specified instruction.
void SetInstDebugLocation(Instruction *I) const {
  for (const auto &KV : MetadataToCopy)
    if (KV.first == LLVMContext::MD_dbg) {
      I->setDebugLoc(DebugLoc(KV.second));
      return;
    }
}

/// Add all entries in MetadataToCopy to \p I.
void AddMetadataToInst(Instruction *I) const {
  for (auto &KV : MetadataToCopy)
    I->setMetadata(KV.first, KV.second);
}

/// Get the return type of the current function that we're emitting
/// into.
Type *getCurrentFunctionReturnType() const;

/// InsertPoint - A saved insertion point.
class InsertPoint {
  BasicBlock *Block = nullptr;
  BasicBlock::iterator Point;

public:
  /// Creates a new insertion point which doesn't point to anything.
  InsertPoint() = default;

  /// Creates a new insertion point at the given location.
  InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
      : Block(InsertBlock), Point(InsertPoint) {}

  /// Returns true if this insert point is set.
  bool isSet() const { return (Block != nullptr); }

  BasicBlock *getBlock() const { return Block; }
  BasicBlock::iterator getPoint() const { return Point; }
};

/// Returns the current insert point.
InsertPoint saveIP() const {
  return InsertPoint(GetInsertBlock(), GetInsertPoint());
}

/// Returns the current insert point, clearing it in the process.
InsertPoint saveAndClearIP() {
  InsertPoint IP(GetInsertBlock(), GetInsertPoint());
  ClearInsertionPoint();
  return IP;
}

/// Sets the current insert point to a previously-saved location.
void restoreIP(InsertPoint IP) {
  if (IP.isSet())
    SetInsertPoint(IP.getBlock(), IP.getPoint());
  else
    ClearInsertionPoint();
}

/// Get the floating point math metadata being used.
MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }

/// Get the flags to be applied to created floating point ops
FastMathFlags getFastMathFlags() const { return FMF; }

FastMathFlags &getFastMathFlags() { return FMF; }

/// Clear the fast-math flags.
void clearFastMathFlags() { FMF.clear(); }

/// Set the floating point math metadata to be used.
void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }

/// Set the fast-math flags to be used with generated fp-math operators
void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }

/// Enable/Disable use of constrained floating point math. When
/// enabled the CreateF<op>() calls instead create constrained
/// floating point intrinsic calls. Fast math flags are unaffected
/// by this setting.
void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; }

/// Query for the use of constrained floating point math
bool getIsFPConstrained() { return IsFPConstrained; }

/// Set the exception handling to be used with constrained floating point
void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {
318#ifndef NDEBUG1
  Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(NewExcept);
  assert(ExceptStr.hasValue() && "Garbage strict exception behavior!")((void)0);
321#endif
  DefaultConstrainedExcept = NewExcept;
}

/// Set the rounding mode handling to be used with constrained floating point
void setDefaultConstrainedRounding(RoundingMode NewRounding) {
327#ifndef NDEBUG1
  Optional<StringRef> RoundingStr = RoundingModeToStr(NewRounding);
  assert(RoundingStr.hasValue() && "Garbage strict rounding mode!")((void)0);
330#endif
  DefaultConstrainedRounding = NewRounding;
}

/// Get the exception handling used with constrained floating point
fp::ExceptionBehavior getDefaultConstrainedExcept() {
  return DefaultConstrainedExcept;
}

/// Get the rounding mode handling used with constrained floating point
RoundingMode getDefaultConstrainedRounding() {
  return DefaultConstrainedRounding;
}

void setConstrainedFPFunctionAttr() {
  assert(BB && "Must have a basic block to set any function attributes!")((void)0);

  Function *F = BB->getParent();
  if (!F->hasFnAttribute(Attribute::StrictFP)) {
    F->addFnAttr(Attribute::StrictFP);
  }
}

void setConstrainedFPCallAttr(CallBase *I) {
  I->addAttribute(AttributeList::FunctionIndex, Attribute::StrictFP);
}

void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) {
  DefaultOperandBundles = OpBundles;
}

//===--------------------------------------------------------------------===//
// RAII helpers.
//===--------------------------------------------------------------------===//

// RAII object that stores the current insertion point and restores it
// when the object is destroyed. This includes the debug location.
class InsertPointGuard {
  IRBuilderBase &Builder;
  AssertingVH<BasicBlock> Block;
  BasicBlock::iterator Point;
  DebugLoc DbgLoc;

public:
  InsertPointGuard(IRBuilderBase &B)
      : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
        DbgLoc(B.getCurrentDebugLocation()) {}

  InsertPointGuard(const InsertPointGuard &) = delete;
  InsertPointGuard &operator=(const InsertPointGuard &) = delete;

  ~InsertPointGuard() {
    Builder.restoreIP(InsertPoint(Block, Point));
    Builder.SetCurrentDebugLocation(DbgLoc);
  }
};

// RAII object that stores the current fast math settings and restores
// them when the object is destroyed.
class FastMathFlagGuard {
  IRBuilderBase &Builder;
  FastMathFlags FMF;
  MDNode *FPMathTag;
  bool IsFPConstrained;
  fp::ExceptionBehavior DefaultConstrainedExcept;
  RoundingMode DefaultConstrainedRounding;

public:
  FastMathFlagGuard(IRBuilderBase &B)
      : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag),
        IsFPConstrained(B.IsFPConstrained),
        DefaultConstrainedExcept(B.DefaultConstrainedExcept),
        DefaultConstrainedRounding(B.DefaultConstrainedRounding) {}

  FastMathFlagGuard(const FastMathFlagGuard &) = delete;
  FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;

  ~FastMathFlagGuard() {
    Builder.FMF = FMF;
    Builder.DefaultFPMathTag = FPMathTag;
    Builder.IsFPConstrained = IsFPConstrained;
    Builder.DefaultConstrainedExcept = DefaultConstrainedExcept;
    Builder.DefaultConstrainedRounding = DefaultConstrainedRounding;
  }
};

// RAII object that stores the current default operand bundles and restores
// them when the object is destroyed.
class OperandBundlesGuard {
  IRBuilderBase &Builder;
  ArrayRef<OperandBundleDef> DefaultOperandBundles;

public:
  OperandBundlesGuard(IRBuilderBase &B)
      : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {}

  OperandBundlesGuard(const OperandBundlesGuard &) = delete;
  OperandBundlesGuard &operator=(const OperandBundlesGuard &) = delete;

  ~OperandBundlesGuard() {
    Builder.DefaultOperandBundles = DefaultOperandBundles;
  }
};


//===--------------------------------------------------------------------===//
// Miscellaneous creation methods.
//===--------------------------------------------------------------------===//

/// Make a new global variable with initializer type i8*
///
/// Make a new global variable with an initializer that has array of i8 type
/// filled in with the null terminated string value specified.  The new global
/// variable will be marked mergable with any others of the same contents.  If
/// Name is specified, it is the name of the global variable created.
///
/// If no module is given via \p M, it is take from the insertion point basic
/// block.
GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
                                   unsigned AddressSpace = 0,
                                   Module *M = nullptr);

/// Get a constant value representing either true or false.
ConstantInt *getInt1(bool V) {
  return ConstantInt::get(getInt1Ty(), V);
}

/// Get the constant value for i1 true.
ConstantInt *getTrue() {
  return ConstantInt::getTrue(Context);
}

/// Get the constant value for i1 false.
ConstantInt *getFalse() {
  return ConstantInt::getFalse(Context);
}

/// Get a constant 8-bit value.
ConstantInt *getInt8(uint8_t C) {
  return ConstantInt::get(getInt8Ty(), C);
}

/// Get a constant 16-bit value.
ConstantInt *getInt16(uint16_t C) {
  return ConstantInt::get(getInt16Ty(), C);
}

/// Get a constant 32-bit value.
ConstantInt *getInt32(uint32_t C) {
  return ConstantInt::get(getInt32Ty(), C);
}

/// Get a constant 64-bit value.
ConstantInt *getInt64(uint64_t C) {
  return ConstantInt::get(getInt64Ty(), C);
}

/// Get a constant N-bit value, zero extended or truncated from
/// a 64-bit value.
ConstantInt *getIntN(unsigned N, uint64_t C) {
  return ConstantInt::get(getIntNTy(N), C);
}

/// Get a constant integer value.
ConstantInt *getInt(const APInt &AI) {
  return ConstantInt::get(Context, AI);
}

//===--------------------------------------------------------------------===//
// Type creation methods
//===--------------------------------------------------------------------===//

/// Fetch the type representing a single bit
IntegerType *getInt1Ty() {
  return Type::getInt1Ty(Context);
}

/// Fetch the type representing an 8-bit integer.
IntegerType *getInt8Ty() {
  return Type::getInt8Ty(Context);
}

/// Fetch the type representing a 16-bit integer.
IntegerType *getInt16Ty() {
  return Type::getInt16Ty(Context);
}

/// Fetch the type representing a 32-bit integer.
IntegerType *getInt32Ty() {
  return Type::getInt32Ty(Context);
}

/// Fetch the type representing a 64-bit integer.
IntegerType *getInt64Ty() {
  return Type::getInt64Ty(Context);
}

/// Fetch the type representing a 128-bit integer.
IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }

/// Fetch the type representing an N-bit integer.
IntegerType *getIntNTy(unsigned N) {
  return Type::getIntNTy(Context, N);
}

/// Fetch the type representing a 16-bit floating point value.
Type *getHalfTy() {
  return Type::getHalfTy(Context);
}

/// Fetch the type representing a 16-bit brain floating point value.
Type *getBFloatTy() {
  return Type::getBFloatTy(Context);
}

/// Fetch the type representing a 32-bit floating point value.
Type *getFloatTy() {
  return Type::getFloatTy(Context);
}

/// Fetch the type representing a 64-bit floating point value.
Type *getDoubleTy() {
  return Type::getDoubleTy(Context);
}

/// Fetch the type representing void.
Type *getVoidTy() {
  return Type::getVoidTy(Context);
}

/// Fetch the type representing a pointer to an 8-bit integer value.
PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
  return Type::getInt8PtrTy(Context, AddrSpace);
}

/// Fetch the type representing a pointer to an integer value.
IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
  return DL.getIntPtrType(Context, AddrSpace);
}

//===--------------------------------------------------------------------===//
// Intrinsic creation methods
//===--------------------------------------------------------------------===//

/// Create and insert a memset to the specified pointer and the
/// specified value.
///
/// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
/// specified, it will be added to the instruction. Likewise with alias.scope
/// and noalias tags.
CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size,
                       MaybeAlign Align, bool isVolatile = false,
                       MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
                       MDNode *NoAliasTag = nullptr) {
  return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
                      TBAATag, ScopeTag, NoAliasTag);
}

CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align,
                       bool isVolatile = false, MDNode *TBAATag = nullptr,
                       MDNode *ScopeTag = nullptr,
                       MDNode *NoAliasTag = nullptr);

/// Create and insert an element unordered-atomic memset of the region of
/// memory starting at the given pointer to the given value.
///
/// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
/// specified, it will be added to the instruction. Likewise with alias.scope
/// and noalias tags.
CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
                                             uint64_t Size, Align Alignment,
                                             uint32_t ElementSize,
                                             MDNode *TBAATag = nullptr,
                                             MDNode *ScopeTag = nullptr,
                                             MDNode *NoAliasTag = nullptr) {
  return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size),
                                            Align(Alignment), ElementSize,
                                            TBAATag, ScopeTag, NoAliasTag);
}

CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
                                             Value *Size, Align Alignment,
                                             uint32_t ElementSize,
                                             MDNode *TBAATag = nullptr,
                                             MDNode *ScopeTag = nullptr,
                                             MDNode *NoAliasTag = nullptr);

/// Create and insert a memcpy between the specified pointers.
///
/// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
/// specified, it will be added to the instruction. Likewise with alias.scope
/// and noalias tags.
CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
                       MaybeAlign SrcAlign, uint64_t Size,
                       bool isVolatile = false, MDNode *TBAATag = nullptr,
                       MDNode *TBAAStructTag = nullptr,
                       MDNode *ScopeTag = nullptr,
                       MDNode *NoAliasTag = nullptr) {
  return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
                      isVolatile, TBAATag, TBAAStructTag, ScopeTag,
                      NoAliasTag);
}

CallInst *CreateMemTransferInst(
    Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src,
    MaybeAlign SrcAlign, Value *Size, bool isVolatile = false,
    MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,
    MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);

CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
                       MaybeAlign SrcAlign, Value *Size,
                       bool isVolatile = false, MDNode *TBAATag = nullptr,
                       MDNode *TBAAStructTag = nullptr,
                       MDNode *ScopeTag = nullptr,
                       MDNode *NoAliasTag = nullptr) {
  return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src,
                               SrcAlign, Size, isVolatile, TBAATag,
                               TBAAStructTag, ScopeTag, NoAliasTag);
}

CallInst *
CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,
                   MaybeAlign SrcAlign, Value *Size, bool IsVolatile = false,
                   MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,
                   MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);

/// Create and insert an element unordered-atomic memcpy between the
/// specified pointers.
///
/// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
///
/// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
/// specified, it will be added to the instruction. Likewise with alias.scope
/// and noalias tags.
CallInst *CreateElementUnorderedAtomicMemCpy(
    Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
    uint32_t ElementSize, MDNode *TBAATag = nullptr,
    MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
    MDNode *NoAliasTag = nullptr);

CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
                        MaybeAlign SrcAlign, uint64_t Size,
                        bool isVolatile = false, MDNode *TBAATag = nullptr,
                        MDNode *ScopeTag = nullptr,
                        MDNode *NoAliasTag = nullptr) {
  return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
                       isVolatile, TBAATag, ScopeTag, NoAliasTag);
}

CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
                        MaybeAlign SrcAlign, Value *Size,
                        bool isVolatile = false, MDNode *TBAATag = nullptr,
                        MDNode *ScopeTag = nullptr,
                        MDNode *NoAliasTag = nullptr);

/// \brief Create and insert an element unordered-atomic memmove between the
/// specified pointers.
///
/// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,
/// respectively.
///
/// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
/// specified, it will be added to the instruction. Likewise with alias.scope
/// and noalias tags.
CallInst *CreateElementUnorderedAtomicMemMove(
    Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
    uint32_t ElementSize, MDNode *TBAATag = nullptr,
    MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
    MDNode *NoAliasTag = nullptr);

/// Create a vector fadd reduction intrinsic of the source vector.
/// The first parameter is a scalar accumulator value for ordered reductions.
CallInst *CreateFAddReduce(Value *Acc, Value *Src);

/// Create a vector fmul reduction intrinsic of the source vector.
/// The first parameter is a scalar accumulator value for ordered reductions.
CallInst *CreateFMulReduce(Value *Acc, Value *Src);

/// Create a vector int add reduction intrinsic of the source vector.
CallInst *CreateAddReduce(Value *Src);

/// Create a vector int mul reduction intrinsic of the source vector.
CallInst *CreateMulReduce(Value *Src);

/// Create a vector int AND reduction intrinsic of the source vector.
CallInst *CreateAndReduce(Value *Src);

/// Create a vector int OR reduction intrinsic of the source vector.
CallInst *CreateOrReduce(Value *Src);

/// Create a vector int XOR reduction intrinsic of the source vector.
CallInst *CreateXorReduce(Value *Src);

/// Create a vector integer max reduction intrinsic of the source
/// vector.
CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);

/// Create a vector integer min reduction intrinsic of the source
/// vector.
CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);

/// Create a vector float max reduction intrinsic of the source
/// vector.
CallInst *CreateFPMaxReduce(Value *Src);

/// Create a vector float min reduction intrinsic of the source
/// vector.
CallInst *CreateFPMinReduce(Value *Src);

/// Create a lifetime.start intrinsic.
///
/// If the pointer isn't i8* it will be converted.
CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);

/// Create a lifetime.end intrinsic.
///
/// If the pointer isn't i8* it will be converted.
CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);

/// Create a call to invariant.start intrinsic.
///
/// If the pointer isn't i8* it will be converted.
CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);

/// Create a call to Masked Load intrinsic
CallInst *CreateMaskedLoad(Type *Ty, Value *Ptr, Align Alignment, Value *Mask,
                           Value *PassThru = nullptr, const Twine &Name = "");

/// Create a call to Masked Store intrinsic
CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
                            Value *Mask);

/// Create a call to Masked Gather intrinsic
CallInst *CreateMaskedGather(Type *Ty, Value *Ptrs, Align Alignment,
                             Value *Mask = nullptr, Value *PassThru = nullptr,
                             const Twine &Name = "");

/// Create a call to Masked Scatter intrinsic
CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,
                              Value *Mask = nullptr);

/// Create an assume intrinsic call that allows the optimizer to
/// assume that the provided condition will be true.
///
/// The optional argument \p OpBundles specifies operand bundles that are
/// added to the call instruction.
CallInst *CreateAssumption(Value *Cond,
                           ArrayRef<OperandBundleDef> OpBundles = llvm::None);

/// Create a llvm.experimental.noalias.scope.decl intrinsic call.
Instruction *CreateNoAliasScopeDeclaration(Value *Scope);
Instruction *CreateNoAliasScopeDeclaration(MDNode *ScopeTag) {
  return CreateNoAliasScopeDeclaration(
      MetadataAsValue::get(Context, ScopeTag));
}

/// Create a call to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.
CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                 Value *ActualCallee,
                                 ArrayRef<Value *> CallArgs,
                                 Optional<ArrayRef<Value *>> DeoptArgs,
                                 ArrayRef<Value *> GCArgs,
                                 const Twine &Name = "");

/// Create a call to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.
CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                 Value *ActualCallee, uint32_t Flags,
                                 ArrayRef<Value *> CallArgs,
                                 Optional<ArrayRef<Use>> TransitionArgs,
                                 Optional<ArrayRef<Use>> DeoptArgs,
                                 ArrayRef<Value *> GCArgs,
                                 const Twine &Name = "");

/// Conveninence function for the common case when CallArgs are filled
/// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
/// .get()'ed to get the Value pointer.
CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                 Value *ActualCallee, ArrayRef<Use> CallArgs,
                                 Optional<ArrayRef<Value *>> DeoptArgs,
                                 ArrayRef<Value *> GCArgs,
                                 const Twine &Name = "");

/// Create an invoke to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.
InvokeInst *
CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
                         Value *ActualInvokee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
                         Optional<ArrayRef<Value *>> DeoptArgs,
                         ArrayRef<Value *> GCArgs, const Twine &Name = "");

/// Create an invoke to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.
InvokeInst *CreateGCStatepointInvoke(
    uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
    BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
    ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs,
    Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs,
    const Twine &Name = "");

// Convenience function for the common case when CallArgs are filled in using
// makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
// get the Value *.
InvokeInst *
CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
                         Value *ActualInvokee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
                         Optional<ArrayRef<Value *>> DeoptArgs,
                         ArrayRef<Value *> GCArgs, const Twine &Name = "");

/// Create a call to the experimental.gc.result intrinsic to extract
/// the result from a call wrapped in a statepoint.
CallInst *CreateGCResult(Instruction *Statepoint,
                         Type *ResultType,
                         const Twine &Name = "");

/// Create a call to the experimental.gc.relocate intrinsics to
/// project the relocated value of one pointer from the statepoint.
CallInst *CreateGCRelocate(Instruction *Statepoint,
                           int BaseOffset,
                           int DerivedOffset,
                           Type *ResultType,
                           const Twine &Name = "");

/// Create a call to the experimental.gc.pointer.base intrinsic to get the
/// base pointer for the specified derived pointer.
CallInst *CreateGCGetPointerBase(Value *DerivedPtr, const Twine &Name = "");

/// Create a call to the experimental.gc.get.pointer.offset intrinsic to get
/// the offset of the specified derived pointer from its base.
CallInst *CreateGCGetPointerOffset(Value *DerivedPtr, const Twine &Name = "");

/// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
/// will be the same type as that of \p Scaling.
Value *CreateVScale(Constant *Scaling, const Twine &Name = "");

/// Creates a vector of type \p DstType with the linear sequence <0, 1, ...>
Value *CreateStepVector(Type *DstType, const Twine &Name = "");

/// Create a call to intrinsic \p ID with 1 operand which is mangled on its
/// type.
CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
                               Instruction *FMFSource = nullptr,
                               const Twine &Name = "");

/// Create a call to intrinsic \p ID with 2 operands which is mangled on the
/// first type.
CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
                                Instruction *FMFSource = nullptr,
                                const Twine &Name = "");

/// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If
/// \p FMFSource is provided, copy fast-math-flags from that instruction to
/// the intrinsic.
CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
                          ArrayRef<Value *> Args,
                          Instruction *FMFSource = nullptr,
                          const Twine &Name = "");

/// Create call to the minnum intrinsic.
CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
}

/// Create call to the maxnum intrinsic.
CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
}

/// Create call to the minimum intrinsic.
CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
}

/// Create call to the maximum intrinsic.
CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
}

/// Create a call to the arithmetic_fence intrinsic.
CallInst *CreateArithmeticFence(Value *Val, Type *DstType,
                                const Twine &Name = "") {
  return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
                         Name);
}

/// Create a call to the experimental.vector.extract intrinsic.
CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx,
                              const Twine &Name = "") {
  return CreateIntrinsic(Intrinsic::experimental_vector_extract,
                         {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
                         Name);
}

/// Create a call to the experimental.vector.insert intrinsic.
CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
                             Value *Idx, const Twine &Name = "") {
  return CreateIntrinsic(Intrinsic::experimental_vector_insert,
                         {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
                         nullptr, Name);
}

934private:
/// Create a call to a masked intrinsic with given Id.
CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
                                ArrayRef<Type *> OverloadedTypes,
                                const Twine &Name = "");

Value *getCastedInt8PtrValue(Value *Ptr);

//===--------------------------------------------------------------------===//
// Instruction creation methods: Terminators
//===--------------------------------------------------------------------===//

946private:
/// Helper to add branch weight and unpredictable metadata onto an
/// instruction.
/// \returns The annotated instruction.
template <typename InstTy>
InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
  if (Weights)
    I->setMetadata(LLVMContext::MD_prof, Weights);
  if (Unpredictable)
    I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
  return I;
}

959public:
/// Create a 'ret void' instruction.
ReturnInst *CreateRetVoid() {
  return Insert(ReturnInst::Create(Context));
}

/// Create a 'ret <val>' instruction.
ReturnInst *CreateRet(Value *V) {
  return Insert(ReturnInst::Create(Context, V));
}

/// Create a sequence of N insertvalue instructions,
/// with one Value from the retVals array each, that build a aggregate
/// return value one value at a time, and a ret instruction to return
/// the resulting aggregate value.
///
/// This is a convenience function for code that uses aggregate return values
/// as a vehicle for having multiple return values.
ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
  Value *V = UndefValue::get(getCurrentFunctionReturnType());
  for (unsigned i = 0; i != N; ++i)
    V = CreateInsertValue(V, retVals[i], i, "mrv");
  return Insert(ReturnInst::Create(Context, V));
}

/// Create an unconditional 'br label X' instruction.
BranchInst *CreateBr(BasicBlock *Dest) {
  return Insert(BranchInst::Create(Dest));
}

/// Create a conditional 'br Cond, TrueDest, FalseDest'
/// instruction.
BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
                         MDNode *BranchWeights = nullptr,
                         MDNode *Unpredictable = nullptr) {
  return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
                                  BranchWeights, Unpredictable));
}

/// Create a conditional 'br Cond, TrueDest, FalseDest'
/// instruction. Copy branch meta data if available.
BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
                         Instruction *MDSrc) {
  BranchInst *Br = BranchInst::Create(True, False, Cond);
  if (MDSrc) {
    unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
                      LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
    Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
  }
  return Insert(Br);
}

/// Create a switch instruction with the specified value, default dest,
/// and with a hint for the number of cases that will be added (for efficient
/// allocation).
SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
                         MDNode *BranchWeights = nullptr,
                         MDNode *Unpredictable = nullptr) {
  return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
                                  BranchWeights, Unpredictable));
}

/// Create an indirect branch instruction with the specified address
/// operand, with an optional hint for the number of destinations that will be
/// added (for efficient allocation).
IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
  return Insert(IndirectBrInst::Create(Addr, NumDests));
}

/// Create an invoke instruction.
InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
                         BasicBlock *NormalDest, BasicBlock *UnwindDest,
                         ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  InvokeInst *II =
      InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(II);
  return Insert(II, Name);
}
InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
                         BasicBlock *NormalDest, BasicBlock *UnwindDest,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  InvokeInst *II =
      InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(II);
  return Insert(II, Name);
}

InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest, ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
                      NormalDest, UnwindDest, Args, OpBundles, Name);
}

InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
                         BasicBlock *UnwindDest,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
                      NormalDest, UnwindDest, Args, Name);
}

/// \brief Create a callbr instruction.
CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
                         BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
                                   Args), Name);
}
CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
                         BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  return Insert(
      CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
                         OpBundles), Name);
}

CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args = None,
                         const Twine &Name = "") {
  return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
                      DefaultDest, IndirectDests, Args, Name);
}
CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
                         ArrayRef<BasicBlock *> IndirectDests,
                         ArrayRef<Value *> Args,
                         ArrayRef<OperandBundleDef> OpBundles,
                         const Twine &Name = "") {
  return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
                      DefaultDest, IndirectDests, Args, Name);
}

ResumeInst *CreateResume(Value *Exn) {
  return Insert(ResumeInst::Create(Exn));
}

CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
                                    BasicBlock *UnwindBB = nullptr) {
  return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
}

CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
                                   unsigned NumHandlers,
                                   const Twine &Name = "") {
  return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
                Name);
}

CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
                             const Twine &Name = "") {
  return Insert(CatchPadInst::Create(ParentPad, Args), Name);
}

CleanupPadInst *CreateCleanupPad(Value *ParentPad,
                                 ArrayRef<Value *> Args = None,
                                 const Twine &Name = "") {
  return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
}

CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
  return Insert(CatchReturnInst::Create(CatchPad, BB));
}

UnreachableInst *CreateUnreachable() {
  return Insert(new UnreachableInst(Context));
}

//===--------------------------------------------------------------------===//
// Instruction creation methods: Binary Operators
//===--------------------------------------------------------------------===//
1141private:
BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
                                        Value *LHS, Value *RHS,
                                        const Twine &Name,
                                        bool HasNUW, bool HasNSW) {
  BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
  if (HasNUW) BO->setHasNoUnsignedWrap();
  if (HasNSW) BO->setHasNoSignedWrap();
  return BO;
}

Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
                        FastMathFlags FMF) const {
  if (!FPMD)
    FPMD = DefaultFPMathTag;
  if (FPMD)
    I->setMetadata(LLVMContext::MD_fpmath, FPMD);
  I->setFastMathFlags(FMF);
  return I;
}

Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
                    Value *R, const Twine &Name) const {
  auto *LC = dyn_cast<Constant>(L);
  auto *RC = dyn_cast<Constant>(R);
  return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
}

Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) {
  RoundingMode UseRounding = DefaultConstrainedRounding;

  if (Rounding.hasValue())
    UseRounding = Rounding.getValue();

  Optional<StringRef> RoundingStr = RoundingModeToStr(UseRounding);
  assert(RoundingStr.hasValue() && "Garbage strict rounding mode!")((void)0);
  auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());

  return MetadataAsValue::get(Context, RoundingMDS);
}

Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) {
  fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept;

  if (Except.hasValue())
    UseExcept = Except.getValue();

  Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(UseExcept);
  assert(ExceptStr.hasValue() && "Garbage strict exception behavior!")((void)0);
  auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());

  return MetadataAsValue::get(Context, ExceptMDS);
}

Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
  assert(CmpInst::isFPPredicate(Predicate) &&((void)0)
         Predicate != CmpInst::FCMP_FALSE &&((void)0)
         Predicate != CmpInst::FCMP_TRUE &&((void)0)
         "Invalid constrained FP comparison predicate!")((void)0);

  StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
  auto *PredicateMDS = MDString::get(Context, PredicateStr);

  return MetadataAsValue::get(Context, PredicateMDS);
}

1207public:
Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
  return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
                                 HasNUW, HasNSW);
}

Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateAdd(LHS, RHS, Name, false, true);
}

Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateAdd(LHS, RHS, Name, true, false);
}

Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
  return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
                                 HasNUW, HasNSW);
}

Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateSub(LHS, RHS, Name, false, true);
}

Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateSub(LHS, RHS, Name, true, false);
}

Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
  return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
                                 HasNUW, HasNSW);
}

Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateMul(LHS, RHS, Name, false, true);
}

Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateMul(LHS, RHS, Name, true, false);
}

Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
  if (!isExact)
    return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
}

Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateUDiv(LHS, RHS, Name, true);
}

Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
  if (!isExact)
    return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
}

Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateSDiv(LHS, RHS, Name, true);
}

Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) return V;
  return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
}

Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) return V;
  return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
}

Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
  return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
                                 HasNUW, HasNSW);
}

Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
                   HasNUW, HasNSW);
}

Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
                   HasNUW, HasNSW);
}

Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
  if (!isExact)
    return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
}

Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
                  bool isExact = false) {
  if (auto *LC = dyn_cast<Constant>(LHS))
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
  if (!isExact)
    return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
  return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
}

Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
                  bool isExact = false) {
  return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
}

Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (auto *RC = dyn_cast<Constant>(RHS)) {
    if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
      return LHS;  // LHS & -1 -> LHS
    if (auto *LC = dyn_cast<Constant>(LHS))
      return Insert(Folder.CreateAnd(LC, RC), Name);
  }
  return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
}

Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
  return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
  return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateAnd(ArrayRef<Value*> Ops) {
  assert(!Ops.empty())((void)0);
  Value *Accum = Ops[0];
  for (unsigned i = 1; i < Ops.size(); i++)
    Accum = CreateAnd(Accum, Ops[i]);
  return Accum;
}

Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (auto *RC = dyn_cast<Constant>(RHS)) {
    if (RC->isNullValue())
      return LHS;  // LHS | 0 -> LHS
    if (auto *LC = dyn_cast<Constant>(LHS))
      return Insert(Folder.CreateOr(LC, RC), Name);
  }
  return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
}

Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
  return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
  return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateOr(ArrayRef<Value*> Ops) {
  assert(!Ops.empty())((void)0);
  Value *Accum = Ops[0];
  for (unsigned i = 1; i < Ops.size(); i++)
    Accum = CreateOr(Accum, Ops[i]);
  return Accum;
}

Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
  if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) return V;
  return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
}

Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
  return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
  return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
}

Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
                                    L, R, FMFSource, Name);

  if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
                              FMFSource->getFastMathFlags());
  return Insert(I, Name);
}

Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
                                    L, R, FMFSource, Name);

  if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
                              FMFSource->getFastMathFlags());
  return Insert(I, Name);
}

Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
                                    L, R, FMFSource, Name);

  if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
                              FMFSource->getFastMathFlags());
  return Insert(I, Name);
}

Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
                                    L, R, FMFSource, Name);

  if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr,
                              FMFSource->getFastMathFlags());
  return Insert(I, Name);
}

Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
                  MDNode *FPMD = nullptr) {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
                                    L, R, nullptr, Name, FPMD);

  if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
  return Insert(I, Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
                                    L, R, FMFSource, Name);

  if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
  Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
                              FMFSource->getFastMathFlags());
  return Insert(I, Name);
}

Value *CreateBinOp(Instruction::BinaryOps Opc,
                   Value *LHS, Value *RHS, const Twine &Name = "",
                   MDNode *FPMathTag = nullptr) {
  if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
  Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
  if (isa<FPMathOperator>(BinOp))
    setFPAttrs(BinOp, FPMathTag, FMF);
  return Insert(BinOp, Name);
}

Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
  assert(Cond2->getType()->isIntOrIntVectorTy(1))((void)0);
  return CreateSelect(Cond1, Cond2,
                      ConstantInt::getNullValue(Cond2->getType()), Name);
}

Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
  assert(Cond2->getType()->isIntOrIntVectorTy(1))((void)0);
  return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
                      Cond2, Name);
}

CallInst *CreateConstrainedFPBinOp(
    Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
    const Twine &Name = "", MDNode *FPMathTag = nullptr,
    Optional<RoundingMode> Rounding = None,
    Optional<fp::ExceptionBehavior> Except = None);

Value *CreateNeg(Value *V, const Twine &Name = "",
                 bool HasNUW = false, bool HasNSW = false) {
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
  BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
  if (HasNUW) BO->setHasNoUnsignedWrap();
  if (HasNSW) BO->setHasNoSignedWrap();
  return BO;
}

Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
  return CreateNeg(V, Name, false, true);
}

Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
  return CreateNeg(V, Name, true, false);
}

Value *CreateFNeg(Value *V, const Twine &Name = "",
                  MDNode *FPMathTag = nullptr) {
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateFNeg(VC), Name);
  return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
                Name);
}

/// Copy fast-math-flags from an instruction rather than using the builder's
/// default FMF.
Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
                     const Twine &Name = "") {
 if (auto *VC = dyn_cast<Constant>(V))
   return Insert(Folder.CreateFNeg(VC), Name);
 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
                          FMFSource->getFastMathFlags()),
               Name);
}

Value *CreateNot(Value *V, const Twine &Name = "") {
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateNot(VC), Name);
  return Insert(BinaryOperator::CreateNot(V), Name);
}

Value *CreateUnOp(Instruction::UnaryOps Opc,
                  Value *V, const Twine &Name = "",
                  MDNode *FPMathTag = nullptr) {
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateUnOp(Opc, VC), Name);
  Instruction *UnOp = UnaryOperator::Create(Opc, V);
  if (isa<FPMathOperator>(UnOp))
    setFPAttrs(UnOp, FPMathTag, FMF);
  return Insert(UnOp, Name);
}

/// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
/// Correct number of operands must be passed accordingly.
Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
                    const Twine &Name = "", MDNode *FPMathTag = nullptr);

//===--------------------------------------------------------------------===//
// Instruction creation methods: Memory Instructions
//===--------------------------------------------------------------------===//

AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
                         Value *ArraySize = nullptr, const Twine &Name = "") {
  const DataLayout &DL = BB->getModule()->getDataLayout();
  Align AllocaAlign = DL.getPrefTypeAlign(Ty);
  return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
}

AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
                         const Twine &Name = "") {
  const DataLayout &DL = BB->getModule()->getDataLayout();
  Align AllocaAlign = DL.getPrefTypeAlign(Ty);
  unsigned AddrSpace = DL.getAllocaAddrSpace();
  return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
}

/// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
/// converting the string to 'bool' for the isVolatile parameter.
LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
}

LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
}

LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
                     const Twine &Name = "") {
  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
}

// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 char *Name)
                                               const char *Name),[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 char *Name)
                          "Use the version that explicitly specifies the "[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 char *Name)
                          "loaded type instead")[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 char *Name) {
  return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
}

// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 Twine &Name = "")
                                               const Twine &Name = ""),[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 Twine &Name = "")
                          "Use the version that explicitly specifies the "[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 Twine &Name = "")
                          "loaded type instead")[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, const
 Twine &Name = "") {
  return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
}

// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, bool
 isVolatile, const Twine &Name = "")
                                               bool isVolatile,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, bool
 isVolatile, const Twine &Name = "")
                                               const Twine &Name = ""),[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, bool
 isVolatile, const Twine &Name = "")
                          "Use the version that explicitly specifies the "[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, bool
 isVolatile, const Twine &Name = "")
                          "loaded type instead")[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateLoad(Value *Ptr, bool
 isVolatile, const Twine &Name = "") {
  return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile,
                    Name);
}

StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
  return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
}

LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                            const char *Name) {
  return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
}

LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                            const Twine &Name = "") {
  return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
}

LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                            bool isVolatile, const Twine &Name = "") {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = DL.getABITypeAlign(Ty);
  }
  return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
}

// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const char *Name)
                                                      MaybeAlign Align,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const char *Name)
                                                      const char *Name),[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const char *Name)
                          "Use the version that explicitly specifies the "[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const char *Name)
                          "loaded type instead")[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const char *Name) {
  return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
                           Align, Name);
}
// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const Twine &Name = "")
                                                      MaybeAlign Align,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const Twine &Name = "")
                                                      const Twine &Name = ""),[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const Twine &Name = "")
                          "Use the version that explicitly specifies the "[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const Twine &Name = "")
                          "loaded type instead")[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, const Twine &Name = "") {
  return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
                           Align, Name);
}
// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name
 = "")
                                                      MaybeAlign Align,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name
 = "")
                                                      bool isVolatile,[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name
 = "")
                                                      const Twine &Name = ""),[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name
 = "")
                          "Use the version that explicitly specifies the "[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name
 = "")
                          "loaded type instead")[[deprecated("Use the version that explicitly specifies the "
 "loaded type instead")]] LoadInst *CreateAlignedLoad(Value *
Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name
 = "") {
  return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
                           Align, isVolatile, Name);
}

StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align,
                              bool isVolatile = false) {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = DL.getABITypeAlign(Val->getType());
  }
  return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
}
FenceInst *CreateFence(AtomicOrdering Ordering,
                       SyncScope::ID SSID = SyncScope::System,
                       const Twine &Name = "") {
  return Insert(new FenceInst(Context, Ordering, SSID), Name);
}

AtomicCmpXchgInst *
CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align,
                    AtomicOrdering SuccessOrdering,
                    AtomicOrdering FailureOrdering,
                    SyncScope::ID SSID = SyncScope::System) {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = llvm::Align(DL.getTypeStoreSize(New->getType()));
  }

  return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering,
                                      FailureOrdering, SSID));
}

AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr,
                               Value *Val, MaybeAlign Align,
                               AtomicOrdering Ordering,
                               SyncScope::ID SSID = SyncScope::System) {
  if (!Align) {
    const DataLayout &DL = BB->getModule()->getDataLayout();
    Align = llvm::Align(DL.getTypeStoreSize(Val->getType()));
  }

  return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID));
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList
, const Twine &Name = "")
    Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList
, const Twine &Name = "")
                     const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList
, const Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList
, const Twine &Name = "") {
  return CreateGEP(Ptr->getType()->getScalarType()->getPointerElementType(),
                   Ptr, IdxList, Name);
}

Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                 const Twine &Name = "") {
  if (auto *PC = dyn_cast<Constant>(Ptr)) {
    // Every index must be constant.
    size_t i, e;
    for (i = 0, e = IdxList.size(); i != e; ++i)
      if (!isa<Constant>(IdxList[i]))
        break;
    if (i == e)
      return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
  }
  return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *>
 IdxList, const Twine &Name = "")
    Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *>
 IdxList, const Twine &Name = "")
                             const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *>
 IdxList, const Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *>
 IdxList, const Twine &Name = "") {
  return CreateInBoundsGEP(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, IdxList,
      Name);
}

Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                         const Twine &Name = "") {
  if (auto *PC = dyn_cast<Constant>(Ptr)) {
    // Every index must be constant.
    size_t i, e;
    for (i = 0, e = IdxList.size(); i != e; ++i)
      if (!isa<Constant>(IdxList[i]))
        break;
    if (i == e)
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
                    Name);
  }
  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
}

Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
  if (auto *PC = dyn_cast<Constant>(Ptr))
    if (auto *IC = dyn_cast<Constant>(Idx))
      return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
}

Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
                         const Twine &Name = "") {
  if (auto *PC = dyn_cast<Constant>(Ptr))
    if (auto *IC = dyn_cast<Constant>(Idx))
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const
 Twine &Name = "")
    Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const
 Twine &Name = "")
                              const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const
 Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const
 Twine &Name = "") {
  return CreateConstGEP1_32(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, Idx0,
      Name);
}

Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
                          const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
}

Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
                                  const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
}

Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
                          const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt32Ty(Context), Idx0),
    ConstantInt::get(Type::getInt32Ty(Context), Idx1)
  };

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
}

Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
                                  unsigned Idx1, const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt32Ty(Context), Idx0),
    ConstantInt::get(Type::getInt32Ty(Context), Idx1)
  };

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
}

Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
                          const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const
 Twine &Name = "")
    Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const
 Twine &Name = "")
                              const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const
 Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const
 Twine &Name = "") {
  return CreateConstGEP1_64(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, Idx0,
      Name);
}

Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
                                  const Twine &Name = "") {
  Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0
, const Twine &Name = "")
    Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0
, const Twine &Name = "")
                                      const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0
, const Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0
, const Twine &Name = "") {
  return CreateConstInBoundsGEP1_64(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, Idx0,
      Name);
}

Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
                          const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt64Ty(Context), Idx0),
    ConstantInt::get(Type::getInt64Ty(Context), Idx1)
  };

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);

  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t
 Idx1, const Twine &Name = "")
    Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t
 Idx1, const Twine &Name = "")
                              const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t
 Idx1, const Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t
 Idx1, const Twine &Name = "") {
  return CreateConstGEP2_64(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, Idx0,
      Idx1, Name);
}

Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
                                  uint64_t Idx1, const Twine &Name = "") {
  Value *Idxs[] = {
    ConstantInt::get(Type::getInt64Ty(Context), Idx0),
    ConstantInt::get(Type::getInt64Ty(Context), Idx1)
  };

  if (auto *PC = dyn_cast<Constant>(Ptr))
    return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);

  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0
, uint64_t Idx1, const Twine &Name = "")
    Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0,[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0
, uint64_t Idx1, const Twine &Name = "")
                                      uint64_t Idx1, const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0
, uint64_t Idx1, const Twine &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0
, uint64_t Idx1, const Twine &Name = "") {
  return CreateConstInBoundsGEP2_64(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, Idx0,
      Idx1, Name);
}

Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
                       const Twine &Name = "") {
  return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
}

LLVM_ATTRIBUTE_DEPRECATED([[deprecated("Use the version with explicit element type instead"
)]] Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine
 &Name = "")
    Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = ""),[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine
 &Name = "")
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine
 &Name = "") {
  return CreateConstInBoundsGEP2_32(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, 0, Idx,
      Name);
}

/// Same as CreateGlobalString, but return a pointer with "i8*" type
/// instead of a pointer to array of i8.
///
/// If no module is given via \p M, it is take from the insertion point basic
/// block.
Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
                                unsigned AddressSpace = 0,
                                Module *M = nullptr) {
  GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace, M);
  Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
  Constant *Indices[] = {Zero, Zero};
  return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
                                                Indices);
}

//===--------------------------------------------------------------------===//
// Instruction creation methods: Cast/Conversion Operators
//===--------------------------------------------------------------------===//

Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
  return CreateCast(Instruction::Trunc, V, DestTy, Name);
}

Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
  return CreateCast(Instruction::ZExt, V, DestTy, Name);
}

Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
  return CreateCast(Instruction::SExt, V, DestTy, Name);
}

/// Create a ZExt or Trunc from the integer value V to DestTy. Return
/// the value untouched if the type of V is already DestTy.
Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
                         const Twine &Name = "") {
  assert(V->getType()->isIntOrIntVectorTy() &&((void)0)
         DestTy->isIntOrIntVectorTy() &&((void)0)
         "Can only zero extend/truncate integers!")((void)0);
  Type *VTy = V->getType();
  if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
    return CreateZExt(V, DestTy, Name);
  if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
    return CreateTrunc(V, DestTy, Name);
  return V;
}

/// Create a SExt or Trunc from the integer value V to DestTy. Return
/// the value untouched if the type of V is already DestTy.
Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
                         const Twine &Name = "") {
  assert(V->getType()->isIntOrIntVectorTy() &&((void)0)
         DestTy->isIntOrIntVectorTy() &&((void)0)
         "Can only sign extend/truncate integers!")((void)0);
  Type *VTy = V->getType();
  if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
    return CreateSExt(V, DestTy, Name);
  if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
    return CreateTrunc(V, DestTy, Name);
  return V;
}

Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::FPToUI, V, DestTy, Name);
}

Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::FPToSI, V, DestTy, Name);
}

Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::UIToFP, V, DestTy, Name);
}

Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::SIToFP, V, DestTy, Name);
}

Value *CreateFPTrunc(Value *V, Type *DestTy,
                     const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(
        Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
        Name);
  return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
}

Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
  if (IsFPConstrained)
    return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
                                   V, DestTy, nullptr, Name);
  return CreateCast(Instruction::FPExt, V, DestTy, Name);
}

Value *CreatePtrToInt(Value *V, Type *DestTy,
                      const Twine &Name = "") {
  return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
}

Value *CreateIntToPtr(Value *V, Type *DestTy,
                      const Twine &Name = "") {
  return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
}

Value *CreateBitCast(Value *V, Type *DestTy,
                     const Twine &Name = "") {
  return CreateCast(Instruction::BitCast, V, DestTy, Name);
}

Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
                           const Twine &Name = "") {
  return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
}

Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
                           const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
  return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
}

Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
                           const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
  return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
}

Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
                            const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
  return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
}

Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
                  const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
  return Insert(CastInst::Create(Op, V, DestTy), Name);
}

Value *CreatePointerCast(Value *V, Type *DestTy,
                         const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
  return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
}

Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
                                           const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;

  if (auto *VC = dyn_cast<Constant>(V)) {
    return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
                  Name);
  }

  return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
                Name);
}

Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
                     const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
  return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
}

Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
                              const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
    return CreatePtrToInt(V, DestTy, Name);
  if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
    return CreateIntToPtr(V, DestTy, Name);

  return CreateBitCast(V, DestTy, Name);
}

Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
  if (V->getType() == DestTy)
    return V;
  if (auto *VC = dyn_cast<Constant>(V))
    return Insert(Folder.CreateFPCast(VC, DestTy), Name);
  return Insert(CastInst::CreateFPCast(V, DestTy), Name);
}

CallInst *CreateConstrainedFPCast(
    Intrinsic::ID ID, Value *V, Type *DestTy,
    Instruction *FMFSource = nullptr, const Twine &Name = "",
    MDNode *FPMathTag = nullptr,
    Optional<RoundingMode> Rounding = None,
    Optional<fp::ExceptionBehavior> Except = None);

// Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
// compile time error, instead of converting the string to bool for the
// isSigned parameter.
Value *CreateIntCast(Value *, Type *, const char *) = delete;

//===--------------------------------------------------------------------===//
// Instruction creation methods: Compare Instructions
//===--------------------------------------------------------------------===//

Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
}

Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
}

Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
}

Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
}

Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
}

Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
}

Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
}

Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
57
←
Passing null pointer value via 2nd parameter 'LHS'→
58
←
Calling 'IRBuilderBase::CreateICmp'→
}

Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
}

Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
  return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
}

Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
}

Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
}

Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
                  const Twine &Name = "") {
  if (auto *LC = dyn_cast<Constant>(LHS))
59
←
Assuming 'LC' is null→
60
←
Taking false branch→
    if (auto *RC = dyn_cast<Constant>(RHS))
      return Insert(Folder.CreateICmp(P, LC, RC), Name);
  return Insert(new ICmpInst(P, LHS, RHS), Name);
61
←
Passing null pointer value via 2nd parameter 'LHS'→
62
←
Calling constructor for 'ICmpInst'→
}

// Create a quiet floating-point comparison (i.e. one that raises an FP
// exception only in the case where an input is a signaling NaN).
// Note that this differs from CreateFCmpS only if IsFPConstrained is true.
Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
                  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
}

Value *CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
                 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CmpInst::isFPPredicate(Pred)
             ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag)
             : CreateICmp(Pred, LHS, RHS, Name);
}

// Create a signaling floating-point comparison (i.e. one that raises an FP
// exception whenever an input is any NaN, signaling or quiet).
// Note that this differs from CreateFCmp only if IsFPConstrained is true.
Value *CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS,
                   const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
}

2368private:
// Helper routine to create either a signaling or a quiet FP comparison.
Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
                        const Twine &Name, MDNode *FPMathTag,
                        bool IsSignaling);

2374public:
CallInst *CreateConstrainedFPCmp(
    Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R,
    const Twine &Name = "", Optional<fp::ExceptionBehavior> Except = None);

//===--------------------------------------------------------------------===//
// Instruction creation methods: Other Instructions
//===--------------------------------------------------------------------===//

PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
                   const Twine &Name = "") {
  PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
  if (isa<FPMathOperator>(Phi))
    setFPAttrs(Phi, nullptr /* MDNode* */, FMF);
  return Insert(Phi, Name);
}

CallInst *CreateCall(FunctionType *FTy, Value *Callee,
                     ArrayRef<Value *> Args = None, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
  CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(CI);
  if (isa<FPMathOperator>(CI))
    setFPAttrs(CI, FPMathTag, FMF);
  return Insert(CI, Name);
}

CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> OpBundles,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
  if (IsFPConstrained)
    setConstrainedFPCallAttr(CI);
  if (isa<FPMathOperator>(CI))
    setFPAttrs(CI, FPMathTag, FMF);
  return Insert(CI, Name);
}

CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = None,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
                    FPMathTag);
}

CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> OpBundles,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
  return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
                    OpBundles, Name, FPMathTag);
}

CallInst *CreateConstrainedFPCall(
    Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
    Optional<RoundingMode> Rounding = None,
    Optional<fp::ExceptionBehavior> Except = None);

Value *CreateSelect(Value *C, Value *True, Value *False,
                    const Twine &Name = "", Instruction *MDFrom = nullptr);

VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
  return Insert(new VAArgInst(List, Ty), Name);
}

Value *CreateExtractElement(Value *Vec, Value *Idx,
                            const Twine &Name = "") {
  if (auto *VC = dyn_cast<Constant>(Vec))
    if (auto *IC = dyn_cast<Constant>(Idx))
      return Insert(Folder.CreateExtractElement(VC, IC), Name);
  return Insert(ExtractElementInst::Create(Vec, Idx), Name);
}

Value *CreateExtractElement(Value *Vec, uint64_t Idx,
                            const Twine &Name = "") {
  return CreateExtractElement(Vec, getInt64(Idx), Name);
}

Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
                           const Twine &Name = "") {
  if (auto *VC = dyn_cast<Constant>(Vec))
    if (auto *NC = dyn_cast<Constant>(NewElt))
      if (auto *IC = dyn_cast<Constant>(Idx))
        return Insert(Folder.CreateInsertElement(VC, NC, IC), Name);
  return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
}

Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
                           const Twine &Name = "") {
  return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
}

Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
                           const Twine &Name = "") {
  SmallVector<int, 16> IntMask;
  ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask);
  return CreateShuffleVector(V1, V2, IntMask, Name);
}

LLVM_ATTRIBUTE_DEPRECATED(Value *CreateShuffleVector(Value *V1, Value *V2,[[deprecated("Pass indices as 'int' instead")]] Value *CreateShuffleVector
(Value *V1, Value *V2, ArrayRef<uint32_t> Mask, const Twine
 &Name = "")
                                                     ArrayRef<uint32_t> Mask,[[deprecated("Pass indices as 'int' instead")]] Value *CreateShuffleVector
(Value *V1, Value *V2, ArrayRef<uint32_t> Mask, const Twine
 &Name = "")
                                                     const Twine &Name = ""),[[deprecated("Pass indices as 'int' instead")]] Value *CreateShuffleVector
(Value *V1, Value *V2, ArrayRef<uint32_t> Mask, const Twine
 &Name = "")
                          "Pass indices as 'int' instead")[[deprecated("Pass indices as 'int' instead")]] Value *CreateShuffleVector
(Value *V1, Value *V2, ArrayRef<uint32_t> Mask, const Twine
 &Name = "") {
  SmallVector<int, 16> IntMask;
  IntMask.assign(Mask.begin(), Mask.end());
  return CreateShuffleVector(V1, V2, IntMask, Name);
}

/// See class ShuffleVectorInst for a description of the mask representation.
Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<int> Mask,
                           const Twine &Name = "") {
  if (auto *V1C = dyn_cast<Constant>(V1))
    if (auto *V2C = dyn_cast<Constant>(V2))
      return Insert(Folder.CreateShuffleVector(V1C, V2C, Mask), Name);
  return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
}

/// Create a unary shuffle. The second vector operand of the IR instruction
/// is poison.
Value *CreateShuffleVector(Value *V, ArrayRef<int> Mask,
                           const Twine &Name = "") {
  return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name);
}

Value *CreateExtractValue(Value *Agg,
                          ArrayRef<unsigned> Idxs,
                          const Twine &Name = "") {
  if (auto *AggC = dyn_cast<Constant>(Agg))
    return Insert(Folder.CreateExtractValue(AggC, Idxs), Name);
  return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
}

Value *CreateInsertValue(Value *Agg, Value *Val,
                         ArrayRef<unsigned> Idxs,
                         const Twine &Name = "") {
  if (auto *AggC = dyn_cast<Constant>(Agg))
    if (auto *ValC = dyn_cast<Constant>(Val))
      return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
  return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
}

LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
                                 const Twine &Name = "") {
  return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
}

Value *CreateFreeze(Value *V, const Twine &Name = "") {
  return Insert(new FreezeInst(V), Name);
}

//===--------------------------------------------------------------------===//
// Utility creation methods
//===--------------------------------------------------------------------===//

/// Return an i1 value testing if \p Arg is null.
Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
  return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
                      Name);
}

/// Return an i1 value testing if \p Arg is not null.
Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
  return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
                      Name);
}

/// Return the i64 difference between two pointer values, dividing out
/// the size of the pointed-to objects.
///
/// This is intended to implement C-style pointer subtraction. As such, the
/// pointers must be appropriately aligned for their element types and
/// pointing into the same object.
Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "");

/// Create a launder.invariant.group intrinsic call. If Ptr type is
/// different from pointer to i8, it's casted to pointer to i8 in the same
/// address space before call and casted back to Ptr type after call.
Value *CreateLaunderInvariantGroup(Value *Ptr);

/// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
/// different from pointer to i8, it's casted to pointer to i8 in the same
/// address space before call and casted back to Ptr type after call.
Value *CreateStripInvariantGroup(Value *Ptr);

/// Return a vector value that contains the vector V reversed
Value *CreateVectorReverse(Value *V, const Twine &Name = "");

/// Return a vector splice intrinsic if using scalable vectors, otherwise
/// return a shufflevector. If the immediate is positive, a vector is
/// extracted from concat(V1, V2), starting at Imm. If the immediate
/// is negative, we extract -Imm elements from V1 and the remaining
/// elements from V2. Imm is a signed integer in the range
/// -VL <= Imm < VL (where VL is the runtime vector length of the
/// source/result vector)
Value *CreateVectorSplice(Value *V1, Value *V2, int64_t Imm,
                          const Twine &Name = "");

/// Return a vector value that contains \arg V broadcasted to \p
/// NumElts elements.
Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "");

/// Return a vector value that contains \arg V broadcasted to \p
/// EC elements.
Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = "");

/// Return a value that has been extracted from a larger integer type.
Value *CreateExtractInteger(const DataLayout &DL, Value *From,
                            IntegerType *ExtractedTy, uint64_t Offset,
                            const Twine &Name);

Value *CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base,
                                      unsigned Dimension, unsigned LastIndex,
                                      MDNode *DbgInfo);

Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
                                      MDNode *DbgInfo);

Value *CreatePreserveStructAccessIndex(Type *ElTy, Value *Base,
                                       unsigned Index, unsigned FieldIndex,
                                       MDNode *DbgInfo);

2594private:
/// Helper function that creates an assume intrinsic call that
/// represents an alignment assumption on the provided pointer \p PtrValue
/// with offset \p OffsetValue and alignment value \p AlignValue.
CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
                                          Value *PtrValue, Value *AlignValue,
                                          Value *OffsetValue);

2602public:
/// Create an assume intrinsic call that represents an alignment
/// assumption on the provided pointer.
///
/// An optional offset can be provided, and if it is provided, the offset
/// must be subtracted from the provided pointer to get the pointer with the
/// specified alignment.
CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                    unsigned Alignment,
                                    Value *OffsetValue = nullptr);

/// Create an assume intrinsic call that represents an alignment
/// assumption on the provided pointer.
///
/// An optional offset can be provided, and if it is provided, the offset
/// must be subtracted from the provided pointer to get the pointer with the
/// specified alignment.
///
/// This overload handles the condition where the Alignment is dependent
/// on an existing value rather than a static value.
CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                    Value *Alignment,
                                    Value *OffsetValue = nullptr);
2625};

2627/// This provides a uniform API for creating instructions and inserting
2628/// them into a basic block: either at the end of a BasicBlock, or at a specific
2629/// iterator location in a block.
2630///
2631/// Note that the builder does not expose the full generality of LLVM
2632/// instructions.  For access to extra instruction properties, use the mutators
2633/// (e.g. setVolatile) on the instructions after they have been
2634/// created. Convenience state exists to specify fast-math flags and fp-math
2635/// tags.
2636///
2637/// The first template argument specifies a class to use for creating constants.
2638/// This defaults to creating minimally folded constants.  The second template
2639/// argument allows clients to specify custom insertion hooks that are called on
2640/// every newly created insertion.
2641template <typename FolderTy = ConstantFolder,
        typename InserterTy = IRBuilderDefaultInserter>
2643class IRBuilder : public IRBuilderBase {
2644private:
FolderTy Folder;
InserterTy Inserter;

2648public:
IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
          MDNode *FPMathTag = nullptr,
          ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
      Folder(Folder), Inserter(Inserter) {}

explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}

explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
                   MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles), Folder(Folder) {
  SetInsertPoint(TheBB);
}

explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles) {
  SetInsertPoint(TheBB);
}

explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
                   ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles) {
  SetInsertPoint(IP);
}

IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
          MDNode *FPMathTag = nullptr,
          ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles), Folder(Folder) {
  SetInsertPoint(TheBB, IP);
}

IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
          MDNode *FPMathTag = nullptr,
          ArrayRef<OperandBundleDef> OpBundles = None)
    : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
                    FPMathTag, OpBundles) {
  SetInsertPoint(TheBB, IP);
}

/// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
/// or FastMathFlagGuard instead.
IRBuilder(const IRBuilder &) = delete;

InserterTy &getInserter() { return Inserter; }
2702};

2704// Create wrappers for C Binding types (see CBindingWrapping.h).
2705DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)inline IRBuilder<> *unwrap(LLVMBuilderRef P) { return reinterpret_cast
<IRBuilder<>*>(P); } inline LLVMBuilderRef wrap(const
 IRBuilder<> *P) { return reinterpret_cast<LLVMBuilderRef
>(const_cast<IRBuilder<>*>(P)); }

2707} // end namespace llvm

2709#endif // LLVM_IR_IRBUILDER_H

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include/llvm/IR/Instructions.h

1//===- llvm/Instructions.h - Instruction subclass definitions ---*- 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// This file exposes the class definitions of all of the subclasses of the
10// Instruction class.  This is meant to be an easy way to get access to all
11// instruction subclasses.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H

18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/Bitfields.h"
20#include "llvm/ADT/MapVector.h"
21#include "llvm/ADT/None.h"
22#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/Twine.h"
26#include "llvm/ADT/iterator.h"
27#include "llvm/ADT/iterator_range.h"
28#include "llvm/IR/Attributes.h"
29#include "llvm/IR/BasicBlock.h"
30#include "llvm/IR/CallingConv.h"
31#include "llvm/IR/CFG.h"
32#include "llvm/IR/Constant.h"
33#include "llvm/IR/DerivedTypes.h"
34#include "llvm/IR/Function.h"
35#include "llvm/IR/InstrTypes.h"
36#include "llvm/IR/Instruction.h"
37#include "llvm/IR/OperandTraits.h"
38#include "llvm/IR/Type.h"
39#include "llvm/IR/Use.h"
40#include "llvm/IR/User.h"
41#include "llvm/IR/Value.h"
42#include "llvm/Support/AtomicOrdering.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/ErrorHandling.h"
45#include <cassert>
46#include <cstddef>
47#include <cstdint>
48#include <iterator>

50namespace llvm {

52class APInt;
53class ConstantInt;
54class DataLayout;
55class LLVMContext;

57//===----------------------------------------------------------------------===//
58//                                AllocaInst Class
59//===----------------------------------------------------------------------===//

61/// an instruction to allocate memory on the stack
62class AllocaInst : public UnaryInstruction {
Type *AllocatedType;

using AlignmentField = AlignmentBitfieldElementT<0>;
using UsedWithInAllocaField = BoolBitfieldElementT<AlignmentField::NextBit>;
using SwiftErrorField = BoolBitfieldElementT<UsedWithInAllocaField::NextBit>;
static_assert(Bitfield::areContiguous<AlignmentField, UsedWithInAllocaField,
                                      SwiftErrorField>(),
              "Bitfields must be contiguous");

72protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AllocaInst *cloneImpl() const;

78public:
explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
                    const Twine &Name, Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
           const Twine &Name, BasicBlock *InsertAtEnd);

AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
           Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace,
           const Twine &Name, BasicBlock *InsertAtEnd);

AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
           const Twine &Name = "", Instruction *InsertBefore = nullptr);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
           const Twine &Name, BasicBlock *InsertAtEnd);

/// Return true if there is an allocation size parameter to the allocation
/// instruction that is not 1.
bool isArrayAllocation() const;

/// Get the number of elements allocated. For a simple allocation of a single
/// element, this will return a constant 1 value.
const Value *getArraySize() const { return getOperand(0); }
Value *getArraySize() { return getOperand(0); }

/// Overload to return most specific pointer type.
PointerType *getType() const {
  return cast<PointerType>(Instruction::getType());
}

/// Get allocation size in bits. Returns None if size can't be determined,
/// e.g. in case of a VLA.
Optional<TypeSize> getAllocationSizeInBits(const DataLayout &DL) const;

/// Return the type that is being allocated by the instruction.
Type *getAllocatedType() const { return AllocatedType; }
/// for use only in special circumstances that need to generically
/// transform a whole instruction (eg: IR linking and vectorization).
void setAllocatedType(Type *Ty) { AllocatedType = Ty; }

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

// FIXME: Remove this one transition to Align is over.
unsigned getAlignment() const { return getAlign().value(); }

/// Return true if this alloca is in the entry block of the function and is a
/// constant size. If so, the code generator will fold it into the
/// prolog/epilog code, so it is basically free.
bool isStaticAlloca() const;

/// Return true if this alloca is used as an inalloca argument to a call. Such
/// allocas are never considered static even if they are in the entry block.
bool isUsedWithInAlloca() const {
  return getSubclassData<UsedWithInAllocaField>();
}

/// Specify whether this alloca is used to represent the arguments to a call.
void setUsedWithInAlloca(bool V) {
  setSubclassData<UsedWithInAllocaField>(V);
}

/// Return true if this alloca is used as a swifterror argument to a call.
bool isSwiftError() const { return getSubclassData<SwiftErrorField>(); }
/// Specify whether this alloca is used to represent a swifterror.
void setSwiftError(bool V) { setSubclassData<SwiftErrorField>(V); }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Alloca);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

160private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
167};

169//===----------------------------------------------------------------------===//
170//                                LoadInst Class
171//===----------------------------------------------------------------------===//

173/// An instruction for reading from memory. This uses the SubclassData field in
174/// Value to store whether or not the load is volatile.
175class LoadInst : public UnaryInstruction {
using VolatileField = BoolBitfieldElementT<0>;
using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
    "Bitfields must be contiguous");

void AssertOK();

185protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

LoadInst *cloneImpl() const;

191public:
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
         Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, AtomicOrdering Order,
         SyncScope::ID SSID = SyncScope::System,
         Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, AtomicOrdering Order, SyncScope::ID SSID,
         BasicBlock *InsertAtEnd);

/// Return true if this is a load from a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile load or not.
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Return the alignment of the access that is being performed.
/// FIXME: Remove this function once transition to Align is over.
/// Use getAlign() instead.
unsigned getAlignment() const { return getAlign().value(); }

/// Return the alignment of the access that is being performed.
Align getAlign() const {
  return Align(1ULL << (getSubclassData<AlignmentField>()));
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Returns the ordering constraint of this load instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}
/// Sets the ordering constraint of this load instruction.  May not be Release
/// or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this load instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this load instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

/// Sets the ordering constraint and the synchronization scope ID of this load
/// instruction.
void setAtomic(AtomicOrdering Ordering,
               SyncScope::ID SSID = SyncScope::System) {
  setOrdering(Ordering);
  setSyncScopeID(SSID);
}

bool isSimple() const { return !isAtomic() && !isVolatile(); }

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }
Type *getPointerOperandType() const { return getPointerOperand()->getType(); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Load;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

285private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this load instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
297};

299//===----------------------------------------------------------------------===//
300//                                StoreInst Class
301//===----------------------------------------------------------------------===//

303/// An instruction for storing to memory.
304class StoreInst : public Instruction {
using VolatileField = BoolBitfieldElementT<0>;
using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
    "Bitfields must be contiguous");

void AssertOK();

314protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

StoreInst *cloneImpl() const;

320public:
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);

// allocate space for exactly two operands
void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

/// Return true if this is a store to a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile store or not.
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Return the alignment of the access that is being performed
/// FIXME: Remove this function once transition to Align is over.
/// Use getAlign() instead.
unsigned getAlignment() const { return getAlign().value(); }

Align getAlign() const {
  return Align(1ULL << (getSubclassData<AlignmentField>()));
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Returns the ordering constraint of this store instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}

/// Sets the ordering constraint of this store instruction.  May not be
/// Acquire or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this store instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this store instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

/// Sets the ordering constraint and the synchronization scope ID of this
/// store instruction.
void setAtomic(AtomicOrdering Ordering,
               SyncScope::ID SSID = SyncScope::System) {
  setOrdering(Ordering);
  setSyncScopeID(SSID);
}

bool isSimple() const { return !isAtomic() && !isVolatile(); }

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
}

Value *getValueOperand() { return getOperand(0); }
const Value *getValueOperand() const { return getOperand(0); }

Value *getPointerOperand() { return getOperand(1); }
const Value *getPointerOperand() const { return getOperand(1); }
static unsigned getPointerOperandIndex() { return 1U; }
Type *getPointerOperandType() const { return getPointerOperand()->getType(); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Store;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

419private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this store instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
431};

433template <>
434struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
435};

437DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)StoreInst::op_iterator StoreInst::op_begin() { return OperandTraits
<StoreInst>::op_begin(this); } StoreInst::const_op_iterator
 StoreInst::op_begin() const { return OperandTraits<StoreInst
>::op_begin(const_cast<StoreInst*>(this)); } StoreInst
::op_iterator StoreInst::op_end() { return OperandTraits<StoreInst
>::op_end(this); } StoreInst::const_op_iterator StoreInst::
op_end() const { return OperandTraits<StoreInst>::op_end
(const_cast<StoreInst*>(this)); } Value *StoreInst::getOperand
(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<StoreInst>::op_begin(const_cast
<StoreInst*>(this))[i_nocapture].get()); } void StoreInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<StoreInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned StoreInst::getNumOperands() const
 { return OperandTraits<StoreInst>::operands(this); } template
 <int Idx_nocapture> Use &StoreInst::Op() { return this
->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &StoreInst::Op() const { return this->OpFrom
<Idx_nocapture>(this); }

439//===----------------------------------------------------------------------===//
440//                                FenceInst Class
441//===----------------------------------------------------------------------===//

443/// An instruction for ordering other memory operations.
444class FenceInst : public Instruction {
using OrderingField = AtomicOrderingBitfieldElementT<0>;

void Init(AtomicOrdering Ordering, SyncScope::ID SSID);

449protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

FenceInst *cloneImpl() const;

455public:
// Ordering may only be Acquire, Release, AcquireRelease, or
// SequentiallyConsistent.
FenceInst(LLVMContext &C, AtomicOrdering Ordering,
          SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
          BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t S) { return User::operator new(S, 0); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

/// Returns the ordering constraint of this fence instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}

/// Sets the ordering constraint of this fence instruction.  May only be
/// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this fence instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this fence instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Fence;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

497private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this fence instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
509};

511//===----------------------------------------------------------------------===//
512//                                AtomicCmpXchgInst Class
513//===----------------------------------------------------------------------===//

515/// An instruction that atomically checks whether a
516/// specified value is in a memory location, and, if it is, stores a new value
517/// there. The value returned by this instruction is a pair containing the
518/// original value as first element, and an i1 indicating success (true) or
519/// failure (false) as second element.
520///
521class AtomicCmpXchgInst : public Instruction {
void Init(Value *Ptr, Value *Cmp, Value *NewVal, Align Align,
          AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
          SyncScope::ID SSID);

template <unsigned Offset>
using AtomicOrderingBitfieldElement =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

531protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicCmpXchgInst *cloneImpl() const;

537public:
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering, SyncScope::ID SSID,
                  Instruction *InsertBefore = nullptr);
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering, SyncScope::ID SSID,
                  BasicBlock *InsertAtEnd);

// allocate space for exactly three operands
void *operator new(size_t S) { return User::operator new(S, 3); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

using VolatileField = BoolBitfieldElementT<0>;
using WeakField = BoolBitfieldElementT<VolatileField::NextBit>;
using SuccessOrderingField =
    AtomicOrderingBitfieldElementT<WeakField::NextBit>;
using FailureOrderingField =
    AtomicOrderingBitfieldElementT<SuccessOrderingField::NextBit>;
using AlignmentField =
    AlignmentBitfieldElementT<FailureOrderingField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, WeakField, SuccessOrderingField,
                            FailureOrderingField, AlignmentField>(),
    "Bitfields must be contiguous");

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Return true if this is a cmpxchg from a volatile memory
/// location.
///
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile cmpxchg.
///
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Return true if this cmpxchg may spuriously fail.
bool isWeak() const { return getSubclassData<WeakField>(); }

void setWeak(bool IsWeak) { setSubclassData<WeakField>(IsWeak); }

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

static bool isValidSuccessOrdering(AtomicOrdering Ordering) {
  return Ordering != AtomicOrdering::NotAtomic &&
         Ordering != AtomicOrdering::Unordered;
}

static bool isValidFailureOrdering(AtomicOrdering Ordering) {
  return Ordering != AtomicOrdering::NotAtomic &&
         Ordering != AtomicOrdering::Unordered &&
         Ordering != AtomicOrdering::AcquireRelease &&
         Ordering != AtomicOrdering::Release;
}

/// Returns the success ordering constraint of this cmpxchg instruction.
AtomicOrdering getSuccessOrdering() const {
  return getSubclassData<SuccessOrderingField>();
}

/// Sets the success ordering constraint of this cmpxchg instruction.
void setSuccessOrdering(AtomicOrdering Ordering) {
  assert(isValidSuccessOrdering(Ordering) &&((void)0)
         "invalid CmpXchg success ordering")((void)0);
  setSubclassData<SuccessOrderingField>(Ordering);
}

/// Returns the failure ordering constraint of this cmpxchg instruction.
AtomicOrdering getFailureOrdering() const {
  return getSubclassData<FailureOrderingField>();
}

/// Sets the failure ordering constraint of this cmpxchg instruction.
void setFailureOrdering(AtomicOrdering Ordering) {
  assert(isValidFailureOrdering(Ordering) &&((void)0)
         "invalid CmpXchg failure ordering")((void)0);
  setSubclassData<FailureOrderingField>(Ordering);
}

/// Returns a single ordering which is at least as strong as both the
/// success and failure orderings for this cmpxchg.
AtomicOrdering getMergedOrdering() const {
  if (getFailureOrdering() == AtomicOrdering::SequentiallyConsistent)
    return AtomicOrdering::SequentiallyConsistent;
  if (getFailureOrdering() == AtomicOrdering::Acquire) {
    if (getSuccessOrdering() == AtomicOrdering::Monotonic)
      return AtomicOrdering::Acquire;
    if (getSuccessOrdering() == AtomicOrdering::Release)
      return AtomicOrdering::AcquireRelease;
  }
  return getSuccessOrdering();
}

/// Returns the synchronization scope ID of this cmpxchg instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this cmpxchg instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

Value *getCompareOperand() { return getOperand(1); }
const Value *getCompareOperand() const { return getOperand(1); }

Value *getNewValOperand() { return getOperand(2); }
const Value *getNewValOperand() const { return getOperand(2); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

/// Returns the strongest permitted ordering on failure, given the
/// desired ordering on success.
///
/// If the comparison in a cmpxchg operation fails, there is no atomic store
/// so release semantics cannot be provided. So this function drops explicit
/// Release requests from the AtomicOrdering. A SequentiallyConsistent
/// operation would remain SequentiallyConsistent.
static AtomicOrdering
getStrongestFailureOrdering(AtomicOrdering SuccessOrdering) {
  switch (SuccessOrdering) {
  default:
    llvm_unreachable("invalid cmpxchg success ordering")__builtin_unreachable();
  case AtomicOrdering::Release:
  case AtomicOrdering::Monotonic:
    return AtomicOrdering::Monotonic;
  case AtomicOrdering::AcquireRelease:
  case AtomicOrdering::Acquire:
    return AtomicOrdering::Acquire;
  case AtomicOrdering::SequentiallyConsistent:
    return AtomicOrdering::SequentiallyConsistent;
  }
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::AtomicCmpXchg;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

697private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this cmpxchg instruction.  Not quite
/// enough room in SubClassData for everything, so synchronization scope ID
/// gets its own field.
SyncScope::ID SSID;
709};

711template <>
712struct OperandTraits<AtomicCmpXchgInst> :
  public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
714};

716DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)AtomicCmpXchgInst::op_iterator AtomicCmpXchgInst::op_begin() {
 return OperandTraits<AtomicCmpXchgInst>::op_begin(this
); } AtomicCmpXchgInst::const_op_iterator AtomicCmpXchgInst::
op_begin() const { return OperandTraits<AtomicCmpXchgInst>
::op_begin(const_cast<AtomicCmpXchgInst*>(this)); } AtomicCmpXchgInst
::op_iterator AtomicCmpXchgInst::op_end() { return OperandTraits
<AtomicCmpXchgInst>::op_end(this); } AtomicCmpXchgInst::
const_op_iterator AtomicCmpXchgInst::op_end() const { return OperandTraits
<AtomicCmpXchgInst>::op_end(const_cast<AtomicCmpXchgInst
*>(this)); } Value *AtomicCmpXchgInst::getOperand(unsigned
 i_nocapture) const { ((void)0); return cast_or_null<Value
>( OperandTraits<AtomicCmpXchgInst>::op_begin(const_cast
<AtomicCmpXchgInst*>(this))[i_nocapture].get()); } void
 AtomicCmpXchgInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((void)0); OperandTraits<AtomicCmpXchgInst>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned AtomicCmpXchgInst
::getNumOperands() const { return OperandTraits<AtomicCmpXchgInst
>::operands(this); } template <int Idx_nocapture> Use
 &AtomicCmpXchgInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
AtomicCmpXchgInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

718//===----------------------------------------------------------------------===//
719//                                AtomicRMWInst Class
720//===----------------------------------------------------------------------===//

722/// an instruction that atomically reads a memory location,
723/// combines it with another value, and then stores the result back.  Returns
724/// the old value.
725///
726class AtomicRMWInst : public Instruction {
727protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicRMWInst *cloneImpl() const;

733public:
/// This enumeration lists the possible modifications atomicrmw can make.  In
/// the descriptions, 'p' is the pointer to the instruction's memory location,
/// 'old' is the initial value of *p, and 'v' is the other value passed to the
/// instruction.  These instructions always return 'old'.
enum BinOp : unsigned {
  /// *p = v
  Xchg,
  /// *p = old + v
  Add,
  /// *p = old - v
  Sub,
  /// *p = old & v
  And,
  /// *p = ~(old & v)
  Nand,
  /// *p = old | v
  Or,
  /// *p = old ^ v
  Xor,
  /// *p = old >signed v ? old : v
  Max,
  /// *p = old <signed v ? old : v
  Min,
  /// *p = old >unsigned v ? old : v
  UMax,
  /// *p = old <unsigned v ? old : v
  UMin,

  /// *p = old + v
  FAdd,

  /// *p = old - v
  FSub,

  FIRST_BINOP = Xchg,
  LAST_BINOP = FSub,
  BAD_BINOP
};

773private:
template <unsigned Offset>
using AtomicOrderingBitfieldElement =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

template <unsigned Offset>
using BinOpBitfieldElement =
    typename Bitfield::Element<BinOp, Offset, 4, BinOp::LAST_BINOP>;

783public:
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              Instruction *InsertBefore = nullptr);
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              BasicBlock *InsertAtEnd);

// allocate space for exactly two operands
void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

using VolatileField = BoolBitfieldElementT<0>;
using AtomicOrderingField =
    AtomicOrderingBitfieldElementT<VolatileField::NextBit>;
using OperationField = BinOpBitfieldElement<AtomicOrderingField::NextBit>;
using AlignmentField = AlignmentBitfieldElementT<OperationField::NextBit>;
static_assert(Bitfield::areContiguous<VolatileField, AtomicOrderingField,
                                      OperationField, AlignmentField>(),
              "Bitfields must be contiguous");

BinOp getOperation() const { return getSubclassData<OperationField>(); }

static StringRef getOperationName(BinOp Op);

static bool isFPOperation(BinOp Op) {
  switch (Op) {
  case AtomicRMWInst::FAdd:
  case AtomicRMWInst::FSub:
    return true;
  default:
    return false;
  }
}

void setOperation(BinOp Operation) {
  setSubclassData<OperationField>(Operation);
}

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Return true if this is a RMW on a volatile memory location.
///
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile RMW or not.
///
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Returns the ordering constraint of this rmw instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<AtomicOrderingField>();
}

/// Sets the ordering constraint of this rmw instruction.
void setOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((void)0)
         "atomicrmw instructions can only be atomic.")((void)0);
  setSubclassData<AtomicOrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this rmw instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this rmw instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

Value *getValOperand() { return getOperand(1); }
const Value *getValOperand() const { return getOperand(1); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

bool isFloatingPointOperation() const {
  return isFPOperation(getOperation());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::AtomicRMW;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

889private:
void Init(BinOp Operation, Value *Ptr, Value *Val, Align Align,
          AtomicOrdering Ordering, SyncScope::ID SSID);

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this rmw instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
904};

906template <>
907struct OperandTraits<AtomicRMWInst>
  : public FixedNumOperandTraits<AtomicRMWInst,2> {
909};

911DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)AtomicRMWInst::op_iterator AtomicRMWInst::op_begin() { return
 OperandTraits<AtomicRMWInst>::op_begin(this); } AtomicRMWInst
::const_op_iterator AtomicRMWInst::op_begin() const { return OperandTraits
<AtomicRMWInst>::op_begin(const_cast<AtomicRMWInst*>
(this)); } AtomicRMWInst::op_iterator AtomicRMWInst::op_end()
 { return OperandTraits<AtomicRMWInst>::op_end(this); }
 AtomicRMWInst::const_op_iterator AtomicRMWInst::op_end() const
 { return OperandTraits<AtomicRMWInst>::op_end(const_cast
<AtomicRMWInst*>(this)); } Value *AtomicRMWInst::getOperand
(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<AtomicRMWInst>::op_begin(const_cast
<AtomicRMWInst*>(this))[i_nocapture].get()); } void AtomicRMWInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<AtomicRMWInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned AtomicRMWInst::getNumOperands()
 const { return OperandTraits<AtomicRMWInst>::operands(
this); } template <int Idx_nocapture> Use &AtomicRMWInst
::Op() { return this->OpFrom<Idx_nocapture>(this); }
 template <int Idx_nocapture> const Use &AtomicRMWInst
::Op() const { return this->OpFrom<Idx_nocapture>(this
); }

913//===----------------------------------------------------------------------===//
914//                             GetElementPtrInst Class
915//===----------------------------------------------------------------------===//

917// checkGEPType - Simple wrapper function to give a better assertion failure
918// message on bad indexes for a gep instruction.
919//
920inline Type *checkGEPType(Type *Ty) {
assert(Ty && "Invalid GetElementPtrInst indices for type!")((void)0);
return Ty;
923}

925/// an instruction for type-safe pointer arithmetic to
926/// access elements of arrays and structs
927///
928class GetElementPtrInst : public Instruction {
Type *SourceElementType;
Type *ResultElementType;

GetElementPtrInst(const GetElementPtrInst &GEPI);

/// Constructors - Create a getelementptr instruction with a base pointer an
/// list of indices. The first ctor can optionally insert before an existing
/// instruction, the second appends the new instruction to the specified
/// BasicBlock.
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                         ArrayRef<Value *> IdxList, unsigned Values,
                         const Twine &NameStr, Instruction *InsertBefore);
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                         ArrayRef<Value *> IdxList, unsigned Values,
                         const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);

947protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

GetElementPtrInst *cloneImpl() const;

953public:
static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + unsigned(IdxList.size());
  assert(PointeeType && "Must specify element type")((void)0);
  assert(cast<PointerType>(Ptr->getType()->getScalarType())((void)0)
             ->isOpaqueOrPointeeTypeMatches(PointeeType))((void)0);
  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
                                        NameStr, InsertBefore);
}

static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + unsigned(IdxList.size());
  assert(PointeeType && "Must specify element type")((void)0);
  assert(cast<PointerType>(Ptr->getType()->getScalarType())((void)0)
             ->isOpaqueOrPointeeTypeMatches(PointeeType))((void)0);
  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
                                        NameStr, InsertAtEnd);
}

LLVM_ATTRIBUTE_DEPRECATED(static GetElementPtrInst *CreateInBounds([[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
 *InsertBefore = nullptr)
      Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr = "",[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
 *InsertBefore = nullptr)
      Instruction *InsertBefore = nullptr),[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
 *InsertBefore = nullptr)
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
 *InsertBefore = nullptr) {
  return CreateInBounds(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, IdxList,
      NameStr, InsertBefore);
}

/// Create an "inbounds" getelementptr. See the documentation for the
/// "inbounds" flag in LangRef.html for details.
static GetElementPtrInst *
CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
               const Twine &NameStr = "",
               Instruction *InsertBefore = nullptr) {
  GetElementPtrInst *GEP =
      Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
  GEP->setIsInBounds(true);
  return GEP;
}

LLVM_ATTRIBUTE_DEPRECATED(static GetElementPtrInst *CreateInBounds([[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
 *InsertAtEnd)
      Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr,[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
 *InsertAtEnd)
      BasicBlock *InsertAtEnd),[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
 *InsertAtEnd)
    "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
 *InsertAtEnd) {
  return CreateInBounds(
      Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, IdxList,
      NameStr, InsertAtEnd);
}

static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr,
                                         BasicBlock *InsertAtEnd) {
  GetElementPtrInst *GEP =
      Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
  GEP->setIsInBounds(true);
  return GEP;
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

Type *getSourceElementType() const { return SourceElementType; }

void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
void setResultElementType(Type *Ty) { ResultElementType = Ty; }

Type *getResultElementType() const {
  assert(cast<PointerType>(getType()->getScalarType())((void)0)
             ->isOpaqueOrPointeeTypeMatches(ResultElementType))((void)0);
  return ResultElementType;
}

/// Returns the address space of this instruction's pointer type.
unsigned getAddressSpace() const {
  // Note that this is always the same as the pointer operand's address space
  // and that is cheaper to compute, so cheat here.
  return getPointerAddressSpace();
}

/// Returns the result type of a getelementptr with the given source
/// element type and indexes.
///
/// Null is returned if the indices are invalid for the specified
/// source element type.
static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);

/// Return the type of the element at the given index of an indexable
/// type.  This is equivalent to "getIndexedType(Agg, {Zero, Idx})".
///
/// Returns null if the type can't be indexed, or the given index is not
/// legal for the given type.
static Type *getTypeAtIndex(Type *Ty, Value *Idx);
static Type *getTypeAtIndex(Type *Ty, uint64_t Idx);

inline op_iterator       idx_begin()       { return op_begin()+1; }
inline const_op_iterator idx_begin() const { return op_begin()+1; }
inline op_iterator       idx_end()         { return op_end(); }
inline const_op_iterator idx_end()   const { return op_end(); }

inline iterator_range<op_iterator> indices() {
  return make_range(idx_begin(), idx_end());
}

inline iterator_range<const_op_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getPointerOperand() {
  return getOperand(0);
}
const Value *getPointerOperand() const {
  return getOperand(0);
}
static unsigned getPointerOperandIndex() {
  return 0U;    // get index for modifying correct operand.
}

/// Method to return the pointer operand as a
/// PointerType.
Type *getPointerOperandType() const {
  return getPointerOperand()->getType();
}

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

/// Returns the pointer type returned by the GEP
/// instruction, which may be a vector of pointers.
static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
                              ArrayRef<Value *> IdxList) {
  PointerType *OrigPtrTy = cast<PointerType>(Ptr->getType()->getScalarType());
  unsigned AddrSpace = OrigPtrTy->getAddressSpace();
  Type *ResultElemTy = checkGEPType(getIndexedType(ElTy, IdxList));
  Type *PtrTy = OrigPtrTy->isOpaque()
    ? PointerType::get(OrigPtrTy->getContext(), AddrSpace)
    : PointerType::get(ResultElemTy, AddrSpace);
  // Vector GEP
  if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
    ElementCount EltCount = PtrVTy->getElementCount();
    return VectorType::get(PtrTy, EltCount);
  }
  for (Value *Index : IdxList)
    if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
      ElementCount EltCount = IndexVTy->getElementCount();
      return VectorType::get(PtrTy, EltCount);
    }
  // Scalar GEP
  return PtrTy;
}

unsigned getNumIndices() const {  // Note: always non-negative
  return getNumOperands() - 1;
}

bool hasIndices() const {
  return getNumOperands() > 1;
}

/// Return true if all of the indices of this GEP are
/// zeros.  If so, the result pointer and the first operand have the same
/// value, just potentially different types.
bool hasAllZeroIndices() const;

/// Return true if all of the indices of this GEP are
/// constant integers.  If so, the result pointer and the first operand have
/// a constant offset between them.
bool hasAllConstantIndices() const;

/// Set or clear the inbounds flag on this GEP instruction.
/// See LangRef.html for the meaning of inbounds on a getelementptr.
void setIsInBounds(bool b = true);

/// Determine whether the GEP has the inbounds flag.
bool isInBounds() const;

/// Accumulate the constant address offset of this GEP if possible.
///
/// This routine accepts an APInt into which it will accumulate the constant
/// offset of this GEP if the GEP is in fact constant. If the GEP is not
/// all-constant, it returns false and the value of the offset APInt is
/// undefined (it is *not* preserved!). The APInt passed into this routine
/// must be at least as wide as the IntPtr type for the address space of
/// the base GEP pointer.
bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
bool collectOffset(const DataLayout &DL, unsigned BitWidth,
                   MapVector<Value *, APInt> &VariableOffsets,
                   APInt &ConstantOffset) const;
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::GetElementPtr);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1158};

1160template <>
1161struct OperandTraits<GetElementPtrInst> :
public VariadicOperandTraits<GetElementPtrInst, 1> {
1163};

1165GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                   ArrayRef<Value *> IdxList, unsigned Values,
                                   const Twine &NameStr,
                                   Instruction *InsertBefore)
  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                Values, InsertBefore),
    SourceElementType(PointeeType),
    ResultElementType(getIndexedType(PointeeType, IdxList)) {
assert(cast<PointerType>(getType()->getScalarType())((void)0)
           ->isOpaqueOrPointeeTypeMatches(ResultElementType))((void)0);
init(Ptr, IdxList, NameStr);
1177}

1179GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                   ArrayRef<Value *> IdxList, unsigned Values,
                                   const Twine &NameStr,
                                   BasicBlock *InsertAtEnd)
  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                Values, InsertAtEnd),
    SourceElementType(PointeeType),
    ResultElementType(getIndexedType(PointeeType, IdxList)) {
assert(cast<PointerType>(getType()->getScalarType())((void)0)
           ->isOpaqueOrPointeeTypeMatches(ResultElementType))((void)0);
init(Ptr, IdxList, NameStr);
1191}

1193DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)GetElementPtrInst::op_iterator GetElementPtrInst::op_begin() {
 return OperandTraits<GetElementPtrInst>::op_begin(this
); } GetElementPtrInst::const_op_iterator GetElementPtrInst::
op_begin() const { return OperandTraits<GetElementPtrInst>
::op_begin(const_cast<GetElementPtrInst*>(this)); } GetElementPtrInst
::op_iterator GetElementPtrInst::op_end() { return OperandTraits
<GetElementPtrInst>::op_end(this); } GetElementPtrInst::
const_op_iterator GetElementPtrInst::op_end() const { return OperandTraits
<GetElementPtrInst>::op_end(const_cast<GetElementPtrInst
*>(this)); } Value *GetElementPtrInst::getOperand(unsigned
 i_nocapture) const { ((void)0); return cast_or_null<Value
>( OperandTraits<GetElementPtrInst>::op_begin(const_cast
<GetElementPtrInst*>(this))[i_nocapture].get()); } void
 GetElementPtrInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((void)0); OperandTraits<GetElementPtrInst>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned GetElementPtrInst
::getNumOperands() const { return OperandTraits<GetElementPtrInst
>::operands(this); } template <int Idx_nocapture> Use
 &GetElementPtrInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
GetElementPtrInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

1195//===----------------------------------------------------------------------===//
1196//                               ICmpInst Class
1197//===----------------------------------------------------------------------===//

1199/// This instruction compares its operands according to the predicate given
1200/// to the constructor. It only operates on integers or pointers. The operands
1201/// must be identical types.
1202/// Represent an integer comparison operator.
1203class ICmpInst: public CmpInst {
void AssertOK() {
  assert(isIntPredicate() &&((void)0)
         "Invalid ICmp predicate value")((void)0);
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&((void)0)
        "Both operands to ICmp instruction are not of the same type!")((void)0);
  // Check that the operands are the right type
  assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||((void)0)
          getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&((void)0)
         "Invalid operand types for ICmp instruction")((void)0);
}

1215protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical ICmpInst
ICmpInst *cloneImpl() const;

1222public:
/// Constructor with insert-before-instruction semantics.
ICmpInst(
  Instruction *InsertBefore,  ///< Where to insert
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr,
            InsertBefore) {
1233#ifndef NDEBUG1
AssertOK();
1235#endif
}

/// Constructor with insert-at-end semantics.
ICmpInst(
  BasicBlock &InsertAtEnd, ///< Block to insert into.
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr,
            &InsertAtEnd) {
1248#ifndef NDEBUG1
AssertOK();
1250#endif
}

/// Constructor with no-insertion semantics
ICmpInst(
  Predicate pred, ///< The predicate to use for the comparison
  Value *LHS,     ///< The left-hand-side of the expression
  Value *RHS,     ///< The right-hand-side of the expression
  const Twine &NameStr = "" ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
63
←
Called C++ object pointer is null
            Instruction::ICmp, pred, LHS, RHS, NameStr) {
1261#ifndef NDEBUG1
AssertOK();
1263#endif
}

/// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
/// @returns the predicate that would be the result if the operand were
/// regarded as signed.
/// Return the signed version of the predicate
Predicate getSignedPredicate() const {
  return getSignedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction.
/// Return the signed version of the predicate.
static Predicate getSignedPredicate(Predicate pred);

/// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
/// @returns the predicate that would be the result if the operand were
/// regarded as unsigned.
/// Return the unsigned version of the predicate
Predicate getUnsignedPredicate() const {
  return getUnsignedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction.
/// Return the unsigned version of the predicate.
static Predicate getUnsignedPredicate(Predicate pred);

/// Return true if this predicate is either EQ or NE.  This also
/// tests for commutativity.
static bool isEquality(Predicate P) {
  return P == ICMP_EQ || P == ICMP_NE;
}

/// Return true if this predicate is either EQ or NE.  This also
/// tests for commutativity.
bool isEquality() const {
  return isEquality(getPredicate());
}

/// @returns true if the predicate of this ICmpInst is commutative
/// Determine if this relation is commutative.
bool isCommutative() const { return isEquality(); }

/// Return true if the predicate is relational (not EQ or NE).
///
bool isRelational() const {
  return !isEquality();
}

/// Return true if the predicate is relational (not EQ or NE).
///
static bool isRelational(Predicate P) {
  return !isEquality(P);
}

/// Return true if the predicate is SGT or UGT.
///
static bool isGT(Predicate P) {
  return P == ICMP_SGT || P == ICMP_UGT;
}

/// Return true if the predicate is SLT or ULT.
///
static bool isLT(Predicate P) {
  return P == ICMP_SLT || P == ICMP_ULT;
}

/// Return true if the predicate is SGE or UGE.
///
static bool isGE(Predicate P) {
  return P == ICMP_SGE || P == ICMP_UGE;
}

/// Return true if the predicate is SLE or ULE.
///
static bool isLE(Predicate P) {
  return P == ICMP_SLE || P == ICMP_ULE;
}

/// Exchange the two operands to this instruction in such a way that it does
/// not modify the semantics of the instruction. The predicate value may be
/// changed to retain the same result if the predicate is order dependent
/// (e.g. ult).
/// Swap operands and adjust predicate.
void swapOperands() {
  setPredicate(getSwappedPredicate());
  Op<0>().swap(Op<1>());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ICmp;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1359};

1361//===----------------------------------------------------------------------===//
1362//                               FCmpInst Class
1363//===----------------------------------------------------------------------===//

1365/// This instruction compares its operands according to the predicate given
1366/// to the constructor. It only operates on floating point values or packed
1367/// vectors of floating point values. The operands must be identical types.
1368/// Represents a floating point comparison operator.
1369class FCmpInst: public CmpInst {
void AssertOK() {
  assert(isFPPredicate() && "Invalid FCmp predicate value")((void)0);
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&((void)0)
         "Both operands to FCmp instruction are not of the same type!")((void)0);
  // Check that the operands are the right type
  assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&((void)0)
         "Invalid operand types for FCmp instruction")((void)0);
}

1379protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FCmpInst
FCmpInst *cloneImpl() const;

1386public:
/// Constructor with insert-before-instruction semantics.
FCmpInst(
  Instruction *InsertBefore, ///< Where to insert
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr,
            InsertBefore) {
  AssertOK();
}

/// Constructor with insert-at-end semantics.
FCmpInst(
  BasicBlock &InsertAtEnd, ///< Block to insert into.
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr,
            &InsertAtEnd) {
  AssertOK();
}

/// Constructor with no-insertion semantics
FCmpInst(
  Predicate Pred, ///< The predicate to use for the comparison
  Value *LHS,     ///< The left-hand-side of the expression
  Value *RHS,     ///< The right-hand-side of the expression
  const Twine &NameStr = "", ///< Name of the instruction
  Instruction *FlagsSource = nullptr
) : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS,
            RHS, NameStr, nullptr, FlagsSource) {
  AssertOK();
}

/// @returns true if the predicate of this instruction is EQ or NE.
/// Determine if this is an equality predicate.
static bool isEquality(Predicate Pred) {
  return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
         Pred == FCMP_UNE;
}

/// @returns true if the predicate of this instruction is EQ or NE.
/// Determine if this is an equality predicate.
bool isEquality() const { return isEquality(getPredicate()); }

/// @returns true if the predicate of this instruction is commutative.
/// Determine if this is a commutative predicate.
bool isCommutative() const {
  return isEquality() ||
         getPredicate() == FCMP_FALSE ||
         getPredicate() == FCMP_TRUE ||
         getPredicate() == FCMP_ORD ||
         getPredicate() == FCMP_UNO;
}

/// @returns true if the predicate is relational (not EQ or NE).
/// Determine if this a relational predicate.
bool isRelational() const { return !isEquality(); }

/// Exchange the two operands to this instruction in such a way that it does
/// not modify the semantics of the instruction. The predicate value may be
/// changed to retain the same result if the predicate is order dependent
/// (e.g. ult).
/// Swap operands and adjust predicate.
void swapOperands() {
  setPredicate(getSwappedPredicate());
  Op<0>().swap(Op<1>());
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::FCmp;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1467};

1469//===----------------------------------------------------------------------===//
1470/// This class represents a function call, abstracting a target
1471/// machine's calling convention.  This class uses low bit of the SubClassData
1472/// field to indicate whether or not this is a tail call.  The rest of the bits
1473/// hold the calling convention of the call.
1474///
1475class CallInst : public CallBase {
CallInst(const CallInst &CI);

/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                Instruction *InsertBefore);

inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                const Twine &NameStr, Instruction *InsertBefore)
    : CallInst(Ty, Func, Args, None, NameStr, InsertBefore) {}

/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
                  Instruction *InsertBefore);

CallInst(FunctionType *ty, Value *F, const Twine &NameStr,
         BasicBlock *InsertAtEnd);

void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
void init(FunctionType *FTy, Value *Func, const Twine &NameStr);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
  // We need one operand for the called function, plus the input operand
  // counts provided.
  return 1 + NumArgs + NumBundleInputs;
}

1511protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

CallInst *cloneImpl() const;

1517public:
static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return new (ComputeNumOperands(Args.size()))
      CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  const int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return new (ComputeNumOperands(Args.size()))
      CallInst(Ty, Func, Args, None, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  const int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
                InsertBefore);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
                NameStr, InsertBefore);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
                InsertBefore);
}

static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
                InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
                InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
                NameStr, InsertAtEnd);
}

/// Create a clone of \p CI with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned call instruction is identical \p CI in every way except that
/// the operand bundles for the new instruction are set to the operand bundles
/// in \p Bundles.
static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
                        Instruction *InsertPt = nullptr);

/// Generate the IR for a call to malloc:
/// 1. Compute the malloc call's argument as the specified type's size,
///    possibly multiplied by the array size if the array size is not
///    constant 1.
/// 2. Call malloc with that argument.
/// 3. Bitcast the result of the malloc call to the specified type.
static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 ArrayRef<OperandBundleDef> Bundles = None,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 ArrayRef<OperandBundleDef> Bundles = None,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
/// Generate the IR for a call to the builtin free function.
static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               BasicBlock *InsertAtEnd);

// Note that 'musttail' implies 'tail'.
enum TailCallKind : unsigned {
  TCK_None = 0,
  TCK_Tail = 1,
  TCK_MustTail = 2,
  TCK_NoTail = 3,
  TCK_LAST = TCK_NoTail
};

using TailCallKindField = Bitfield::Element<TailCallKind, 0, 2, TCK_LAST>;
static_assert(
    Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
    "Bitfields must be contiguous");

TailCallKind getTailCallKind() const {
  return getSubclassData<TailCallKindField>();
}

bool isTailCall() const {
  TailCallKind Kind = getTailCallKind();
  return Kind == TCK_Tail || Kind == TCK_MustTail;
}

bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }

bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }

void setTailCallKind(TailCallKind TCK) {
  setSubclassData<TailCallKindField>(TCK);
}

void setTailCall(bool IsTc = true) {
  setTailCallKind(IsTc ? TCK_Tail : TCK_None);
}

/// Return true if the call can return twice
bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
void setCanReturnTwice() {
  addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Call;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

/// Updates profile metadata by scaling it by \p S / \p T.
void updateProfWeight(uint64_t S, uint64_t T);

1703private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
1710};

1712CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                 BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::Call,
             OperandTraits<CallBase>::op_end(this) -
                 (Args.size() + CountBundleInputs(Bundles) + 1),
             unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
             InsertAtEnd) {
init(Ty, Func, Args, Bundles, NameStr);
1721}

1723CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                 Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::Call,
             OperandTraits<CallBase>::op_end(this) -
                 (Args.size() + CountBundleInputs(Bundles) + 1),
             unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
             InsertBefore) {
init(Ty, Func, Args, Bundles, NameStr);
1732}

1734//===----------------------------------------------------------------------===//
1735//                               SelectInst Class
1736//===----------------------------------------------------------------------===//

1738/// This class represents the LLVM 'select' instruction.
1739///
1740class SelectInst : public Instruction {
SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
           Instruction *InsertBefore)
  : Instruction(S1->getType(), Instruction::Select,
                &Op<0>(), 3, InsertBefore) {
  init(C, S1, S2);
  setName(NameStr);
}

SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
           BasicBlock *InsertAtEnd)
  : Instruction(S1->getType(), Instruction::Select,
                &Op<0>(), 3, InsertAtEnd) {
  init(C, S1, S2);
  setName(NameStr);
}

void init(Value *C, Value *S1, Value *S2) {
  assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select")((void)0);
  Op<0>() = C;
  Op<1>() = S1;
  Op<2>() = S2;
}

1764protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

SelectInst *cloneImpl() const;

1770public:
static SelectInst *Create(Value *C, Value *S1, Value *S2,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr,
                          Instruction *MDFrom = nullptr) {
  SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
  if (MDFrom)
    Sel->copyMetadata(*MDFrom);
  return Sel;
}

static SelectInst *Create(Value *C, Value *S1, Value *S2,
                          const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
}

const Value *getCondition() const { return Op<0>(); }
const Value *getTrueValue() const { return Op<1>(); }
const Value *getFalseValue() const { return Op<2>(); }
Value *getCondition() { return Op<0>(); }
Value *getTrueValue() { return Op<1>(); }
Value *getFalseValue() { return Op<2>(); }

void setCondition(Value *V) { Op<0>() = V; }
void setTrueValue(Value *V) { Op<1>() = V; }
void setFalseValue(Value *V) { Op<2>() = V; }

/// Swap the true and false values of the select instruction.
/// This doesn't swap prof metadata.
void swapValues() { Op<1>().swap(Op<2>()); }

/// Return a string if the specified operands are invalid
/// for a select operation, otherwise return null.
static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

OtherOps getOpcode() const {
  return static_cast<OtherOps>(Instruction::getOpcode());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Select;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1820};

1822template <>
1823struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1824};

1826DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)SelectInst::op_iterator SelectInst::op_begin() { return OperandTraits
<SelectInst>::op_begin(this); } SelectInst::const_op_iterator
 SelectInst::op_begin() const { return OperandTraits<SelectInst
>::op_begin(const_cast<SelectInst*>(this)); } SelectInst
::op_iterator SelectInst::op_end() { return OperandTraits<
SelectInst>::op_end(this); } SelectInst::const_op_iterator
 SelectInst::op_end() const { return OperandTraits<SelectInst
>::op_end(const_cast<SelectInst*>(this)); } Value *SelectInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<SelectInst>::op_begin(const_cast
<SelectInst*>(this))[i_nocapture].get()); } void SelectInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<SelectInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned SelectInst::getNumOperands() const
 { return OperandTraits<SelectInst>::operands(this); } template
 <int Idx_nocapture> Use &SelectInst::Op() { return
 this->OpFrom<Idx_nocapture>(this); } template <int
 Idx_nocapture> const Use &SelectInst::Op() const { return
 this->OpFrom<Idx_nocapture>(this); }

1828//===----------------------------------------------------------------------===//
1829//                                VAArgInst Class
1830//===----------------------------------------------------------------------===//

1832/// This class represents the va_arg llvm instruction, which returns
1833/// an argument of the specified type given a va_list and increments that list
1834///
1835class VAArgInst : public UnaryInstruction {
1836protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

VAArgInst *cloneImpl() const;

1842public:
VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
           Instruction *InsertBefore = nullptr)
  : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
  setName(NameStr);
}

VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
          BasicBlock *InsertAtEnd)
  : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
  setName(NameStr);
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == VAArg;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1866};

1868//===----------------------------------------------------------------------===//
1869//                                ExtractElementInst Class
1870//===----------------------------------------------------------------------===//

1872/// This instruction extracts a single (scalar)
1873/// element from a VectorType value
1874///
1875class ExtractElementInst : public Instruction {
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
                   Instruction *InsertBefore = nullptr);
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
                   BasicBlock *InsertAtEnd);

1881protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ExtractElementInst *cloneImpl() const;

1887public:
static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
}

static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
}

/// Return true if an extractelement instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *Idx);

Value *getVectorOperand() { return Op<0>(); }
Value *getIndexOperand() { return Op<1>(); }
const Value *getVectorOperand() const { return Op<0>(); }
const Value *getIndexOperand() const { return Op<1>(); }

VectorType *getVectorOperandType() const {
  return cast<VectorType>(getVectorOperand()->getType());
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ExtractElement;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1923};

1925template <>
1926struct OperandTraits<ExtractElementInst> :
public FixedNumOperandTraits<ExtractElementInst, 2> {
1928};

1930DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)ExtractElementInst::op_iterator ExtractElementInst::op_begin(
) { return OperandTraits<ExtractElementInst>::op_begin(
this); } ExtractElementInst::const_op_iterator ExtractElementInst
::op_begin() const { return OperandTraits<ExtractElementInst
>::op_begin(const_cast<ExtractElementInst*>(this)); }
 ExtractElementInst::op_iterator ExtractElementInst::op_end()
 { return OperandTraits<ExtractElementInst>::op_end(this
); } ExtractElementInst::const_op_iterator ExtractElementInst
::op_end() const { return OperandTraits<ExtractElementInst
>::op_end(const_cast<ExtractElementInst*>(this)); } Value
 *ExtractElementInst::getOperand(unsigned i_nocapture) const {
 ((void)0); return cast_or_null<Value>( OperandTraits<
ExtractElementInst>::op_begin(const_cast<ExtractElementInst
*>(this))[i_nocapture].get()); } void ExtractElementInst::
setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((void
)0); OperandTraits<ExtractElementInst>::op_begin(this)[
i_nocapture] = Val_nocapture; } unsigned ExtractElementInst::
getNumOperands() const { return OperandTraits<ExtractElementInst
>::operands(this); } template <int Idx_nocapture> Use
 &ExtractElementInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
ExtractElementInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

1932//===----------------------------------------------------------------------===//
1933//                                InsertElementInst Class
1934//===----------------------------------------------------------------------===//

1936/// This instruction inserts a single (scalar)
1937/// element into a VectorType value
1938///
1939class InsertElementInst : public Instruction {
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
                  const Twine &NameStr = "",
                  Instruction *InsertBefore = nullptr);
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
                  BasicBlock *InsertAtEnd);

1946protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

InsertElementInst *cloneImpl() const;

1952public:
static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
}

static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
}

/// Return true if an insertelement instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *NewElt,
                            const Value *Idx);

/// Overload to return most specific vector type.
///
VectorType *getType() const {
  return cast<VectorType>(Instruction::getType());
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::InsertElement;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1986};

1988template <>
1989struct OperandTraits<InsertElementInst> :
public FixedNumOperandTraits<InsertElementInst, 3> {
1991};

1993DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)InsertElementInst::op_iterator InsertElementInst::op_begin() {
 return OperandTraits<InsertElementInst>::op_begin(this
); } InsertElementInst::const_op_iterator InsertElementInst::
op_begin() const { return OperandTraits<InsertElementInst>
::op_begin(const_cast<InsertElementInst*>(this)); } InsertElementInst
::op_iterator InsertElementInst::op_end() { return OperandTraits
<InsertElementInst>::op_end(this); } InsertElementInst::
const_op_iterator InsertElementInst::op_end() const { return OperandTraits
<InsertElementInst>::op_end(const_cast<InsertElementInst
*>(this)); } Value *InsertElementInst::getOperand(unsigned
 i_nocapture) const { ((void)0); return cast_or_null<Value
>( OperandTraits<InsertElementInst>::op_begin(const_cast
<InsertElementInst*>(this))[i_nocapture].get()); } void
 InsertElementInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((void)0); OperandTraits<InsertElementInst>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned InsertElementInst
::getNumOperands() const { return OperandTraits<InsertElementInst
>::operands(this); } template <int Idx_nocapture> Use
 &InsertElementInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
InsertElementInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

1995//===----------------------------------------------------------------------===//
1996//                           ShuffleVectorInst Class
1997//===----------------------------------------------------------------------===//

1999constexpr int UndefMaskElem = -1;

2001/// This instruction constructs a fixed permutation of two
2002/// input vectors.
2003///
2004/// For each element of the result vector, the shuffle mask selects an element
2005/// from one of the input vectors to copy to the result. Non-negative elements
2006/// in the mask represent an index into the concatenated pair of input vectors.
2007/// UndefMaskElem (-1) specifies that the result element is undefined.
2008///
2009/// For scalable vectors, all the elements of the mask must be 0 or -1. This
2010/// requirement may be relaxed in the future.
2011class ShuffleVectorInst : public Instruction {
SmallVector<int, 4> ShuffleMask;
Constant *ShuffleMaskForBitcode;

2015protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ShuffleVectorInst *cloneImpl() const;

2021public:
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                  const Twine &NameStr = "",
                  Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                  const Twine &NameStr = "",
                  Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { return User::operator delete(Ptr); }

/// Swap the operands and adjust the mask to preserve the semantics
/// of the instruction.
void commute();

/// Return true if a shufflevector instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *V1, const Value *V2,
                            const Value *Mask);
static bool isValidOperands(const Value *V1, const Value *V2,
                            ArrayRef<int> Mask);

/// Overload to return most specific vector type.
///
VectorType *getType() const {
  return cast<VectorType>(Instruction::getType());
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Return the shuffle mask value of this instruction for the given element
/// index. Return UndefMaskElem if the element is undef.
int getMaskValue(unsigned Elt) const { return ShuffleMask[Elt]; }

/// Convert the input shuffle mask operand to a vector of integers. Undefined
/// elements of the mask are returned as UndefMaskElem.
static void getShuffleMask(const Constant *Mask,
                           SmallVectorImpl<int> &Result);

/// Return the mask for this instruction as a vector of integers. Undefined
/// elements of the mask are returned as UndefMaskElem.
void getShuffleMask(SmallVectorImpl<int> &Result) const {
  Result.assign(ShuffleMask.begin(), ShuffleMask.end());
}

/// Return the mask for this instruction, for use in bitcode.
///
/// TODO: This is temporary until we decide a new bitcode encoding for
/// shufflevector.
Constant *getShuffleMaskForBitcode() const { return ShuffleMaskForBitcode; }

static Constant *convertShuffleMaskForBitcode(ArrayRef<int> Mask,
                                              Type *ResultTy);

void setShuffleMask(ArrayRef<int> Mask);

ArrayRef<int> getShuffleMask() const { return ShuffleMask; }

/// Return true if this shuffle returns a vector with a different number of
/// elements than its source vectors.
/// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
///           shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
bool changesLength() const {
  unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
                               ->getElementCount()
                               .getKnownMinValue();
  unsigned NumMaskElts = ShuffleMask.size();
  return NumSourceElts != NumMaskElts;
}

/// Return true if this shuffle returns a vector with a greater number of
/// elements than its source vectors.
/// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
bool increasesLength() const {
  unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
                               ->getElementCount()
                               .getKnownMinValue();
  unsigned NumMaskElts = ShuffleMask.size();
  return NumSourceElts < NumMaskElts;
}

/// Return true if this shuffle mask chooses elements from exactly one source
/// vector.
/// Example: <7,5,undef,7>
/// This assumes that vector operands are the same length as the mask.
static bool isSingleSourceMask(ArrayRef<int> Mask);
static bool isSingleSourceMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSingleSourceMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without changing the length of that vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
/// TODO: Optionally allow length-changing shuffles.
bool isSingleSource() const {
  return !changesLength() && isSingleSourceMask(ShuffleMask);
}

/// Return true if this shuffle mask chooses elements from exactly one source
/// vector without lane crossings. A shuffle using this mask is not
/// necessarily a no-op because it may change the number of elements from its
/// input vectors or it may provide demanded bits knowledge via undef lanes.
/// Example: <undef,undef,2,3>
static bool isIdentityMask(ArrayRef<int> Mask);
static bool isIdentityMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isIdentityMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without lane crossings and does not change the number of elements
/// from its input vectors.
/// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
bool isIdentity() const {
  return !changesLength() && isIdentityMask(ShuffleMask);
}

/// Return true if this shuffle lengthens exactly one source vector with
/// undefs in the high elements.
bool isIdentityWithPadding() const;

/// Return true if this shuffle extracts the first N elements of exactly one
/// source vector.
bool isIdentityWithExtract() const;

/// Return true if this shuffle concatenates its 2 source vectors. This
/// returns false if either input is undefined. In that case, the shuffle is
/// is better classified as an identity with padding operation.
bool isConcat() const;

/// Return true if this shuffle mask chooses elements from its source vectors
/// without lane crossings. A shuffle using this mask would be
/// equivalent to a vector select with a constant condition operand.
/// Example: <4,1,6,undef>
/// This returns false if the mask does not choose from both input vectors.
/// In that case, the shuffle is better classified as an identity shuffle.
/// This assumes that vector operands are the same length as the mask
/// (a length-changing shuffle can never be equivalent to a vector select).
static bool isSelectMask(ArrayRef<int> Mask);
static bool isSelectMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSelectMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from its source vectors
/// without lane crossings and all operands have the same number of elements.
/// In other words, this shuffle is equivalent to a vector select with a
/// constant condition operand.
/// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
/// This returns false if the mask does not choose from both input vectors.
/// In that case, the shuffle is better classified as an identity shuffle.
/// TODO: Optionally allow length-changing shuffles.
bool isSelect() const {
  return !changesLength() && isSelectMask(ShuffleMask);
}

/// Return true if this shuffle mask swaps the order of elements from exactly
/// one source vector.
/// Example: <7,6,undef,4>
/// This assumes that vector operands are the same length as the mask.
static bool isReverseMask(ArrayRef<int> Mask);
static bool isReverseMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isReverseMask(MaskAsInts);
}

/// Return true if this shuffle swaps the order of elements from exactly
/// one source vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
/// TODO: Optionally allow length-changing shuffles.
bool isReverse() const {
  return !changesLength() && isReverseMask(ShuffleMask);
}

/// Return true if this shuffle mask chooses all elements with the same value
/// as the first element of exactly one source vector.
/// Example: <4,undef,undef,4>
/// This assumes that vector operands are the same length as the mask.
static bool isZeroEltSplatMask(ArrayRef<int> Mask);
static bool isZeroEltSplatMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isZeroEltSplatMask(MaskAsInts);
}

/// Return true if all elements of this shuffle are the same value as the
/// first element of exactly one source vector without changing the length
/// of that vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
/// TODO: Optionally allow length-changing shuffles.
/// TODO: Optionally allow splats from other elements.
bool isZeroEltSplat() const {
  return !changesLength() && isZeroEltSplatMask(ShuffleMask);
}

/// Return true if this shuffle mask is a transpose mask.
/// Transpose vector masks transpose a 2xn matrix. They read corresponding
/// even- or odd-numbered vector elements from two n-dimensional source
/// vectors and write each result into consecutive elements of an
/// n-dimensional destination vector. Two shuffles are necessary to complete
/// the transpose, one for the even elements and another for the odd elements.
/// This description closely follows how the TRN1 and TRN2 AArch64
/// instructions operate.
///
/// For example, a simple 2x2 matrix can be transposed with:
///
///   ; Original matrix
///   m0 = < a, b >
///   m1 = < c, d >
///
///   ; Transposed matrix
///   t0 = < a, c > = shufflevector m0, m1, < 0, 2 >
///   t1 = < b, d > = shufflevector m0, m1, < 1, 3 >
///
/// For matrices having greater than n columns, the resulting nx2 transposed
/// matrix is stored in two result vectors such that one vector contains
/// interleaved elements from all the even-numbered rows and the other vector
/// contains interleaved elements from all the odd-numbered rows. For example,
/// a 2x4 matrix can be transposed with:
///
///   ; Original matrix
///   m0 = < a, b, c, d >
///   m1 = < e, f, g, h >
///
///   ; Transposed matrix
///   t0 = < a, e, c, g > = shufflevector m0, m1 < 0, 4, 2, 6 >
///   t1 = < b, f, d, h > = shufflevector m0, m1 < 1, 5, 3, 7 >
static bool isTransposeMask(ArrayRef<int> Mask);
static bool isTransposeMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isTransposeMask(MaskAsInts);
}

/// Return true if this shuffle transposes the elements of its inputs without
/// changing the length of the vectors. This operation may also be known as a
/// merge or interleave. See the description for isTransposeMask() for the
/// exact specification.
/// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
bool isTranspose() const {
  return !changesLength() && isTransposeMask(ShuffleMask);
}

/// Return true if this shuffle mask is an extract subvector mask.
/// A valid extract subvector mask returns a smaller vector from a single
/// source operand. The base extraction index is returned as well.
static bool isExtractSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
                                   int &Index);
static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
                                   int &Index) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((void)0);
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(Mask->getType()))
    return false;
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
}

/// Return true if this shuffle mask is an extract subvector mask.
bool isExtractSubvectorMask(int &Index) const {
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(getType()))
    return false;

  int NumSrcElts =
      cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
  return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
}

/// Change values in a shuffle permute mask assuming the two vector operands
/// of length InVecNumElts have swapped position.
static void commuteShuffleMask(MutableArrayRef<int> Mask,
                               unsigned InVecNumElts) {
  for (int &Idx : Mask) {
    if (Idx == -1)
      continue;
    Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
    assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&((void)0)
           "shufflevector mask index out of range")((void)0);
  }
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ShuffleVector;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2329};

2331template <>
2332struct OperandTraits<ShuffleVectorInst>
  : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};

2335DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)ShuffleVectorInst::op_iterator ShuffleVectorInst::op_begin() {
 return OperandTraits<ShuffleVectorInst>::op_begin(this
); } ShuffleVectorInst::const_op_iterator ShuffleVectorInst::
op_begin() const { return OperandTraits<ShuffleVectorInst>
::op_begin(const_cast<ShuffleVectorInst*>(this)); } ShuffleVectorInst
::op_iterator ShuffleVectorInst::op_end() { return OperandTraits
<ShuffleVectorInst>::op_end(this); } ShuffleVectorInst::
const_op_iterator ShuffleVectorInst::op_end() const { return OperandTraits
<ShuffleVectorInst>::op_end(const_cast<ShuffleVectorInst
*>(this)); } Value *ShuffleVectorInst::getOperand(unsigned
 i_nocapture) const { ((void)0); return cast_or_null<Value
>( OperandTraits<ShuffleVectorInst>::op_begin(const_cast
<ShuffleVectorInst*>(this))[i_nocapture].get()); } void
 ShuffleVectorInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((void)0); OperandTraits<ShuffleVectorInst>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned ShuffleVectorInst
::getNumOperands() const { return OperandTraits<ShuffleVectorInst
>::operands(this); } template <int Idx_nocapture> Use
 &ShuffleVectorInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
ShuffleVectorInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

2337//===----------------------------------------------------------------------===//
2338//                                ExtractValueInst Class
2339//===----------------------------------------------------------------------===//

2341/// This instruction extracts a struct member or array
2342/// element value from an aggregate value.
2343///
2344class ExtractValueInst : public UnaryInstruction {
SmallVector<unsigned, 4> Indices;

ExtractValueInst(const ExtractValueInst &EVI);

/// Constructors - Create a extractvalue instruction with a base aggregate
/// value and a list of indices.  The first ctor can optionally insert before
/// an existing instruction, the second appends the new instruction to the
/// specified BasicBlock.
inline ExtractValueInst(Value *Agg,
                        ArrayRef<unsigned> Idxs,
                        const Twine &NameStr,
                        Instruction *InsertBefore);
inline ExtractValueInst(Value *Agg,
                        ArrayRef<unsigned> Idxs,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);

2363protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ExtractValueInst *cloneImpl() const;

2369public:
static ExtractValueInst *Create(Value *Agg,
                                ArrayRef<unsigned> Idxs,
                                const Twine &NameStr = "",
                                Instruction *InsertBefore = nullptr) {
  return new
    ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
}

static ExtractValueInst *Create(Value *Agg,
                                ArrayRef<unsigned> Idxs,
                                const Twine &NameStr,
                                BasicBlock *InsertAtEnd) {
  return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
}

/// Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters.
///
/// Null is returned if the indices are invalid for the specified type.
static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);

using idx_iterator = const unsigned*;

inline idx_iterator idx_begin() const { return Indices.begin(); }
inline idx_iterator idx_end()   const { return Indices.end(); }
inline iterator_range<idx_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getAggregateOperand() {
  return getOperand(0);
}
const Value *getAggregateOperand() const {
  return getOperand(0);
}
static unsigned getAggregateOperandIndex() {
  return 0U;                      // get index for modifying correct operand
}

ArrayRef<unsigned> getIndices() const {
  return Indices;
}

unsigned getNumIndices() const {
  return (unsigned)Indices.size();
}

bool hasIndices() const {
  return true;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ExtractValue;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2428};

2430ExtractValueInst::ExtractValueInst(Value *Agg,
                                 ArrayRef<unsigned> Idxs,
                                 const Twine &NameStr,
                                 Instruction *InsertBefore)
: UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
                   ExtractValue, Agg, InsertBefore) {
init(Idxs, NameStr);
2437}

2439ExtractValueInst::ExtractValueInst(Value *Agg,
                                 ArrayRef<unsigned> Idxs,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd)
: UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
                   ExtractValue, Agg, InsertAtEnd) {
init(Idxs, NameStr);
2446}

2448//===----------------------------------------------------------------------===//
2449//                                InsertValueInst Class
2450//===----------------------------------------------------------------------===//

2452/// This instruction inserts a struct field of array element
2453/// value into an aggregate value.
2454///
2455class InsertValueInst : public Instruction {
SmallVector<unsigned, 4> Indices;

InsertValueInst(const InsertValueInst &IVI);

/// Constructors - Create a insertvalue instruction with a base aggregate
/// value, a value to insert, and a list of indices.  The first ctor can
/// optionally insert before an existing instruction, the second appends
/// the new instruction to the specified BasicBlock.
inline InsertValueInst(Value *Agg, Value *Val,
                       ArrayRef<unsigned> Idxs,
                       const Twine &NameStr,
                       Instruction *InsertBefore);
inline InsertValueInst(Value *Agg, Value *Val,
                       ArrayRef<unsigned> Idxs,
                       const Twine &NameStr, BasicBlock *InsertAtEnd);

/// Constructors - These two constructors are convenience methods because one
/// and two index insertvalue instructions are so common.
InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
                const Twine &NameStr = "",
                Instruction *InsertBefore = nullptr);
InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
          const Twine &NameStr);

2483protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

InsertValueInst *cloneImpl() const;

2489public:
// allocate space for exactly two operands
void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

static InsertValueInst *Create(Value *Agg, Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr = "",
                               Instruction *InsertBefore = nullptr) {
  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
}

static InsertValueInst *Create(Value *Agg, Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               BasicBlock *InsertAtEnd) {
  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

using idx_iterator = const unsigned*;

inline idx_iterator idx_begin() const { return Indices.begin(); }
inline idx_iterator idx_end()   const { return Indices.end(); }
inline iterator_range<idx_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getAggregateOperand() {
  return getOperand(0);
}
const Value *getAggregateOperand() const {
  return getOperand(0);
}
static unsigned getAggregateOperandIndex() {
  return 0U;                      // get index for modifying correct operand
}

Value *getInsertedValueOperand() {
  return getOperand(1);
}
const Value *getInsertedValueOperand() const {
  return getOperand(1);
}
static unsigned getInsertedValueOperandIndex() {
  return 1U;                      // get index for modifying correct operand
}

ArrayRef<unsigned> getIndices() const {
  return Indices;
}

unsigned getNumIndices() const {
  return (unsigned)Indices.size();
}

bool hasIndices() const {
  return true;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::InsertValue;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2558};

2560template <>
2561struct OperandTraits<InsertValueInst> :
public FixedNumOperandTraits<InsertValueInst, 2> {
2563};

2565InsertValueInst::InsertValueInst(Value *Agg,
                               Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               Instruction *InsertBefore)
: Instruction(Agg->getType(), InsertValue,
              OperandTraits<InsertValueInst>::op_begin(this),
              2, InsertBefore) {
init(Agg, Val, Idxs, NameStr);
2574}

2576InsertValueInst::InsertValueInst(Value *Agg,
                               Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               BasicBlock *InsertAtEnd)
: Instruction(Agg->getType(), InsertValue,
              OperandTraits<InsertValueInst>::op_begin(this),
              2, InsertAtEnd) {
init(Agg, Val, Idxs, NameStr);
2585}

2587DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)InsertValueInst::op_iterator InsertValueInst::op_begin() { return
 OperandTraits<InsertValueInst>::op_begin(this); } InsertValueInst
::const_op_iterator InsertValueInst::op_begin() const { return
 OperandTraits<InsertValueInst>::op_begin(const_cast<
InsertValueInst*>(this)); } InsertValueInst::op_iterator InsertValueInst
::op_end() { return OperandTraits<InsertValueInst>::op_end
(this); } InsertValueInst::const_op_iterator InsertValueInst::
op_end() const { return OperandTraits<InsertValueInst>::
op_end(const_cast<InsertValueInst*>(this)); } Value *InsertValueInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<InsertValueInst>::op_begin
(const_cast<InsertValueInst*>(this))[i_nocapture].get()
); } void InsertValueInst::setOperand(unsigned i_nocapture, Value
 *Val_nocapture) { ((void)0); OperandTraits<InsertValueInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 InsertValueInst::getNumOperands() const { return OperandTraits
<InsertValueInst>::operands(this); } template <int Idx_nocapture
> Use &InsertValueInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &InsertValueInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

2589//===----------------------------------------------------------------------===//
2590//                               PHINode Class
2591//===----------------------------------------------------------------------===//

2593// PHINode - The PHINode class is used to represent the magical mystical PHI
2594// node, that can not exist in nature, but can be synthesized in a computer
2595// scientist's overactive imagination.
2596//
2597class PHINode : public Instruction {
/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

PHINode(const PHINode &PN);

explicit PHINode(Type *Ty, unsigned NumReservedValues,
                 const Twine &NameStr = "",
                 Instruction *InsertBefore = nullptr)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
    ReservedSpace(NumReservedValues) {
  assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!")((void)0);
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
        BasicBlock *InsertAtEnd)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
    ReservedSpace(NumReservedValues) {
  assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!")((void)0);
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

2623protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

PHINode *cloneImpl() const;

// allocHungoffUses - this is more complicated than the generic
// User::allocHungoffUses, because we have to allocate Uses for the incoming
// values and pointers to the incoming blocks, all in one allocation.
void allocHungoffUses(unsigned N) {
  User::allocHungoffUses(N, /* IsPhi */ true);
}

2636public:
/// Constructors - NumReservedValues is a hint for the number of incoming
/// edges that this phi node will have (use 0 if you really have no idea).
static PHINode *Create(Type *Ty, unsigned NumReservedValues,
                       const Twine &NameStr = "",
                       Instruction *InsertBefore = nullptr) {
  return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
}

static PHINode *Create(Type *Ty, unsigned NumReservedValues,
                       const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Block iterator interface. This provides access to the list of incoming
// basic blocks, which parallels the list of incoming values.

using block_iterator = BasicBlock **;
using const_block_iterator = BasicBlock * const *;

block_iterator block_begin() {
  return reinterpret_cast<block_iterator>(op_begin() + ReservedSpace);
}

const_block_iterator block_begin() const {
  return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
}

block_iterator block_end() {
  return block_begin() + getNumOperands();
}

const_block_iterator block_end() const {
  return block_begin() + getNumOperands();
}

iterator_range<block_iterator> blocks() {
  return make_range(block_begin(), block_end());
}

iterator_range<const_block_iterator> blocks() const {
  return make_range(block_begin(), block_end());
}

op_range incoming_values() { return operands(); }

const_op_range incoming_values() const { return operands(); }

/// Return the number of incoming edges
///
unsigned getNumIncomingValues() const { return getNumOperands(); }

/// Return incoming value number x
///
Value *getIncomingValue(unsigned i) const {
  return getOperand(i);
}
void setIncomingValue(unsigned i, Value *V) {
  assert(V && "PHI node got a null value!")((void)0);
  assert(getType() == V->getType() &&((void)0)
         "All operands to PHI node must be the same type as the PHI node!")((void)0);
  setOperand(i, V);
}

static unsigned getOperandNumForIncomingValue(unsigned i) {
  return i;
}

static unsigned getIncomingValueNumForOperand(unsigned i) {
  return i;
}

/// Return incoming basic block number @p i.
///
BasicBlock *getIncomingBlock(unsigned i) const {
  return block_begin()[i];
}

/// Return incoming basic block corresponding
/// to an operand of the PHI.
///
BasicBlock *getIncomingBlock(const Use &U) const {
  assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?")((void)0);
  return getIncomingBlock(unsigned(&U - op_begin()));
}

/// Return incoming basic block corresponding
/// to value use iterator.
///
BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
  return getIncomingBlock(I.getUse());
}

void setIncomingBlock(unsigned i, BasicBlock *BB) {
  assert(BB && "PHI node got a null basic block!")((void)0);
  block_begin()[i] = BB;
}

/// Replace every incoming basic block \p Old to basic block \p New.
void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New) {
  assert(New && Old && "PHI node got a null basic block!")((void)0);
  for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
    if (getIncomingBlock(Op) == Old)
      setIncomingBlock(Op, New);
}

/// Add an incoming value to the end of the PHI list
///
void addIncoming(Value *V, BasicBlock *BB) {
  if (getNumOperands() == ReservedSpace)
    growOperands();  // Get more space!
  // Initialize some new operands.
  setNumHungOffUseOperands(getNumOperands() + 1);
  setIncomingValue(getNumOperands() - 1, V);
  setIncomingBlock(getNumOperands() - 1, BB);
}

/// Remove an incoming value.  This is useful if a
/// predecessor basic block is deleted.  The value removed is returned.
///
/// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
/// is true), the PHI node is destroyed and any uses of it are replaced with
/// dummy values.  The only time there should be zero incoming values to a PHI
/// node is when the block is dead, so this strategy is sound.
///
Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);

Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument to remove!")((void)0);
  return removeIncomingValue(Idx, DeletePHIIfEmpty);
}

/// Return the first index of the specified basic
/// block in the value list for this PHI.  Returns -1 if no instance.
///
int getBasicBlockIndex(const BasicBlock *BB) const {
  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
    if (block_begin()[i] == BB)
      return i;
  return -1;
}

Value *getIncomingValueForBlock(const BasicBlock *BB) const {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument!")((void)0);
  return getIncomingValue(Idx);
}

/// Set every incoming value(s) for block \p BB to \p V.
void setIncomingValueForBlock(const BasicBlock *BB, Value *V) {
  assert(BB && "PHI node got a null basic block!")((void)0);
  bool Found = false;
  for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
    if (getIncomingBlock(Op) == BB) {
      Found = true;
      setIncomingValue(Op, V);
    }
  (void)Found;
  assert(Found && "Invalid basic block argument to set!")((void)0);
}

/// If the specified PHI node always merges together the
/// same value, return the value, otherwise return null.
Value *hasConstantValue() const;

/// Whether the specified PHI node always merges
/// together the same value, assuming undefs are equal to a unique
/// non-undef value.
bool hasConstantOrUndefValue() const;

/// If the PHI node is complete which means all of its parent's predecessors
/// have incoming value in this PHI, return true, otherwise return false.
bool isComplete() const {
  return llvm::all_of(predecessors(getParent()),
                      [this](const BasicBlock *Pred) {
                        return getBasicBlockIndex(Pred) >= 0;
                      });
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::PHI;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

2827private:
void growOperands();
2829};

2831template <>
2832struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2833};

2835DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)PHINode::op_iterator PHINode::op_begin() { return OperandTraits
<PHINode>::op_begin(this); } PHINode::const_op_iterator
 PHINode::op_begin() const { return OperandTraits<PHINode>
::op_begin(const_cast<PHINode*>(this)); } PHINode::op_iterator
 PHINode::op_end() { return OperandTraits<PHINode>::op_end
(this); } PHINode::const_op_iterator PHINode::op_end() const {
 return OperandTraits<PHINode>::op_end(const_cast<PHINode
*>(this)); } Value *PHINode::getOperand(unsigned i_nocapture
) const { ((void)0); return cast_or_null<Value>( OperandTraits
<PHINode>::op_begin(const_cast<PHINode*>(this))[i_nocapture
].get()); } void PHINode::setOperand(unsigned i_nocapture, Value
 *Val_nocapture) { ((void)0); OperandTraits<PHINode>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned PHINode::getNumOperands
() const { return OperandTraits<PHINode>::operands(this
); } template <int Idx_nocapture> Use &PHINode::Op(
) { return this->OpFrom<Idx_nocapture>(this); } template
 <int Idx_nocapture> const Use &PHINode::Op() const
 { return this->OpFrom<Idx_nocapture>(this); }

2837//===----------------------------------------------------------------------===//
2838//                           LandingPadInst Class
2839//===----------------------------------------------------------------------===//

2841//===---------------------------------------------------------------------------
2842/// The landingpad instruction holds all of the information
2843/// necessary to generate correct exception handling. The landingpad instruction
2844/// cannot be moved from the top of a landing pad block, which itself is
2845/// accessible only from the 'unwind' edge of an invoke. This uses the
2846/// SubclassData field in Value to store whether or not the landingpad is a
2847/// cleanup.
2848///
2849class LandingPadInst : public Instruction {
using CleanupField = BoolBitfieldElementT<0>;

/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

LandingPadInst(const LandingPadInst &LP);

2858public:
enum ClauseType { Catch, Filter };

2861private:
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                        const Twine &NameStr, Instruction *InsertBefore);
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

// Allocate space for exactly zero operands.
void *operator new(size_t S) { return User::operator new(S); }

void growOperands(unsigned Size);
void init(unsigned NumReservedValues, const Twine &NameStr);

2873protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

LandingPadInst *cloneImpl() const;

2879public:
void operator delete(void *Ptr) { User::operator delete(Ptr); }

/// Constructors - NumReservedClauses is a hint for the number of incoming
/// clauses that this landingpad will have (use 0 if you really have no idea).
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                              const Twine &NameStr = "",
                              Instruction *InsertBefore = nullptr);
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                              const Twine &NameStr, BasicBlock *InsertAtEnd);

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Return 'true' if this landingpad instruction is a
/// cleanup. I.e., it should be run when unwinding even if its landing pad
/// doesn't catch the exception.
bool isCleanup() const { return getSubclassData<CleanupField>(); }

/// Indicate that this landingpad instruction is a cleanup.
void setCleanup(bool V) { setSubclassData<CleanupField>(V); }

/// Add a catch or filter clause to the landing pad.
void addClause(Constant *ClauseVal);

/// Get the value of the clause at index Idx. Use isCatch/isFilter to
/// determine what type of clause this is.
Constant *getClause(unsigned Idx) const {
  return cast<Constant>(getOperandList()[Idx]);
}

/// Return 'true' if the clause and index Idx is a catch clause.
bool isCatch(unsigned Idx) const {
  return !isa<ArrayType>(getOperandList()[Idx]->getType());
}

/// Return 'true' if the clause and index Idx is a filter clause.
bool isFilter(unsigned Idx) const {
  return isa<ArrayType>(getOperandList()[Idx]->getType());
}

/// Get the number of clauses for this landing pad.
unsigned getNumClauses() const { return getNumOperands(); }

/// Grow the size of the operand list to accommodate the new
/// number of clauses.
void reserveClauses(unsigned Size) { growOperands(Size); }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::LandingPad;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2934};

2936template <>
2937struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
2938};

2940DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)LandingPadInst::op_iterator LandingPadInst::op_begin() { return
 OperandTraits<LandingPadInst>::op_begin(this); } LandingPadInst
::const_op_iterator LandingPadInst::op_begin() const { return
 OperandTraits<LandingPadInst>::op_begin(const_cast<
LandingPadInst*>(this)); } LandingPadInst::op_iterator LandingPadInst
::op_end() { return OperandTraits<LandingPadInst>::op_end
(this); } LandingPadInst::const_op_iterator LandingPadInst::op_end
() const { return OperandTraits<LandingPadInst>::op_end
(const_cast<LandingPadInst*>(this)); } Value *LandingPadInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<LandingPadInst>::op_begin(
const_cast<LandingPadInst*>(this))[i_nocapture].get());
 } void LandingPadInst::setOperand(unsigned i_nocapture, Value
 *Val_nocapture) { ((void)0); OperandTraits<LandingPadInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 LandingPadInst::getNumOperands() const { return OperandTraits
<LandingPadInst>::operands(this); } template <int Idx_nocapture
> Use &LandingPadInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &LandingPadInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

2942//===----------------------------------------------------------------------===//
2943//                               ReturnInst Class
2944//===----------------------------------------------------------------------===//

2946//===---------------------------------------------------------------------------
2947/// Return a value (possibly void), from a function.  Execution
2948/// does not continue in this function any longer.
2949///
2950class ReturnInst : public Instruction {
ReturnInst(const ReturnInst &RI);

2953private:
// ReturnInst constructors:
// ReturnInst()                  - 'ret void' instruction
// ReturnInst(    null)          - 'ret void' instruction
// ReturnInst(Value* X)          - 'ret X'    instruction
// ReturnInst(    null, Inst *I) - 'ret void' instruction, insert before I
// ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
// ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of B
// ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of B
//
// NOTE: If the Value* passed is of type void then the constructor behaves as
// if it was passed NULL.
explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
                    Instruction *InsertBefore = nullptr);
ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);

2970protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ReturnInst *cloneImpl() const;

2976public:
static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
                          Instruction *InsertBefore = nullptr) {
  return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
}

static ReturnInst* Create(LLVMContext &C, Value *retVal,
                          BasicBlock *InsertAtEnd) {
  return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
}

static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
  return new(0) ReturnInst(C, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Convenience accessor. Returns null if there is no return value.
Value *getReturnValue() const {
  return getNumOperands() != 0 ? getOperand(0) : nullptr;
}

unsigned getNumSuccessors() const { return 0; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Ret);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

3009private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ReturnInst has no successors!")__builtin_unreachable();
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("ReturnInst has no successors!")__builtin_unreachable();
}
3017};

3019template <>
3020struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
3021};

3023DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)ReturnInst::op_iterator ReturnInst::op_begin() { return OperandTraits
<ReturnInst>::op_begin(this); } ReturnInst::const_op_iterator
 ReturnInst::op_begin() const { return OperandTraits<ReturnInst
>::op_begin(const_cast<ReturnInst*>(this)); } ReturnInst
::op_iterator ReturnInst::op_end() { return OperandTraits<
ReturnInst>::op_end(this); } ReturnInst::const_op_iterator
 ReturnInst::op_end() const { return OperandTraits<ReturnInst
>::op_end(const_cast<ReturnInst*>(this)); } Value *ReturnInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<ReturnInst>::op_begin(const_cast
<ReturnInst*>(this))[i_nocapture].get()); } void ReturnInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<ReturnInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned ReturnInst::getNumOperands() const
 { return OperandTraits<ReturnInst>::operands(this); } template
 <int Idx_nocapture> Use &ReturnInst::Op() { return
 this->OpFrom<Idx_nocapture>(this); } template <int
 Idx_nocapture> const Use &ReturnInst::Op() const { return
 this->OpFrom<Idx_nocapture>(this); }

3025//===----------------------------------------------------------------------===//
3026//                               BranchInst Class
3027//===----------------------------------------------------------------------===//

3029//===---------------------------------------------------------------------------
3030/// Conditional or Unconditional Branch instruction.
3031///
3032class BranchInst : public Instruction {
/// Ops list - Branches are strange.  The operands are ordered:
///  [Cond, FalseDest,] TrueDest.  This makes some accessors faster because
/// they don't have to check for cond/uncond branchness. These are mostly
/// accessed relative from op_end().
BranchInst(const BranchInst &BI);
// BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
// BranchInst(BB *B)                           - 'br B'
// BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
// BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
// BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
// BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
// BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
           Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
           BasicBlock *InsertAtEnd);

void AssertOK();

3054protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

BranchInst *cloneImpl() const;

3060public:
/// Iterator type that casts an operand to a basic block.
///
/// This only makes sense because the successors are stored as adjacent
/// operands for branch instructions.
struct succ_op_iterator
    : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                            std::random_access_iterator_tag, BasicBlock *,
                            ptrdiff_t, BasicBlock *, BasicBlock *> {
  explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}

  BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  BasicBlock *operator->() const { return operator*(); }
};

/// The const version of `succ_op_iterator`.
struct const_succ_op_iterator
    : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
                            std::random_access_iterator_tag,
                            const BasicBlock *, ptrdiff_t, const BasicBlock *,
                            const BasicBlock *> {
  explicit const_succ_op_iterator(const_value_op_iterator I)
      : iterator_adaptor_base(I) {}

  const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  const BasicBlock *operator->() const { return operator*(); }
};

static BranchInst *Create(BasicBlock *IfTrue,
                          Instruction *InsertBefore = nullptr) {
  return new(1) BranchInst(IfTrue, InsertBefore);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
                          Value *Cond, Instruction *InsertBefore = nullptr) {
  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
  return new(1) BranchInst(IfTrue, InsertAtEnd);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
                          Value *Cond, BasicBlock *InsertAtEnd) {
  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

bool isUnconditional() const { return getNumOperands() == 1; }
bool isConditional()   const { return getNumOperands() == 3; }

Value *getCondition() const {
  assert(isConditional() && "Cannot get condition of an uncond branch!")((void)0);
  return Op<-3>();
}

void setCondition(Value *V) {
  assert(isConditional() && "Cannot set condition of unconditional branch!")((void)0);
  Op<-3>() = V;
}

unsigned getNumSuccessors() const { return 1+isConditional(); }

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < getNumSuccessors() && "Successor # out of range for Branch!")((void)0);
  return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for Branch!")((void)0);
  *(&Op<-1>() - idx) = NewSucc;
}

/// Swap the successors of this branch instruction.
///
/// Swaps the successors of the branch instruction. This also swaps any
/// branch weight metadata associated with the instruction so that it
/// continues to map correctly to each operand.
void swapSuccessors();

iterator_range<succ_op_iterator> successors() {
  return make_range(
      succ_op_iterator(std::next(value_op_begin(), isConditional() ? 1 : 0)),
      succ_op_iterator(value_op_end()));
}

iterator_range<const_succ_op_iterator> successors() const {
  return make_range(const_succ_op_iterator(
                        std::next(value_op_begin(), isConditional() ? 1 : 0)),
                    const_succ_op_iterator(value_op_end()));
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Br);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
3161};

3163template <>
3164struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3165};

3167DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)BranchInst::op_iterator BranchInst::op_begin() { return OperandTraits
<BranchInst>::op_begin(this); } BranchInst::const_op_iterator
 BranchInst::op_begin() const { return OperandTraits<BranchInst
>::op_begin(const_cast<BranchInst*>(this)); } BranchInst
::op_iterator BranchInst::op_end() { return OperandTraits<
BranchInst>::op_end(this); } BranchInst::const_op_iterator
 BranchInst::op_end() const { return OperandTraits<BranchInst
>::op_end(const_cast<BranchInst*>(this)); } Value *BranchInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<BranchInst>::op_begin(const_cast
<BranchInst*>(this))[i_nocapture].get()); } void BranchInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<BranchInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned BranchInst::getNumOperands() const
 { return OperandTraits<BranchInst>::operands(this); } template
 <int Idx_nocapture> Use &BranchInst::Op() { return
 this->OpFrom<Idx_nocapture>(this); } template <int
 Idx_nocapture> const Use &BranchInst::Op() const { return
 this->OpFrom<Idx_nocapture>(this); }

3169//===----------------------------------------------------------------------===//
3170//                               SwitchInst Class
3171//===----------------------------------------------------------------------===//

3173//===---------------------------------------------------------------------------
3174/// Multiway switch
3175///
3176class SwitchInst : public Instruction {
unsigned ReservedSpace;

// Operand[0]    = Value to switch on
// Operand[1]    = Default basic block destination
// Operand[2n  ] = Value to match
// Operand[2n+1] = BasicBlock to go to on match
SwitchInst(const SwitchInst &SI);

/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor can also
/// auto-insert before another instruction.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
           Instruction *InsertBefore);

/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor also
/// auto-inserts at the end of the specified BasicBlock.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
           BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t S) { return User::operator new(S); }

void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
void growOperands();

3205protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

SwitchInst *cloneImpl() const;

3211public:
void operator delete(void *Ptr) { User::operator delete(Ptr); }

// -2
static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);

template <typename CaseHandleT> class CaseIteratorImpl;

/// A handle to a particular switch case. It exposes a convenient interface
/// to both the case value and the successor block.
///
/// We define this as a template and instantiate it to form both a const and
/// non-const handle.
template <typename SwitchInstT, typename ConstantIntT, typename BasicBlockT>
class CaseHandleImpl {
  // Directly befriend both const and non-const iterators.
  friend class SwitchInst::CaseIteratorImpl<
      CaseHandleImpl<SwitchInstT, ConstantIntT, BasicBlockT>>;

protected:
  // Expose the switch type we're parameterized with to the iterator.
  using SwitchInstType = SwitchInstT;

  SwitchInstT *SI;
  ptrdiff_t Index;

  CaseHandleImpl() = default;
  CaseHandleImpl(SwitchInstT *SI, ptrdiff_t Index) : SI(SI), Index(Index) {}

public:
  /// Resolves case value for current case.
  ConstantIntT *getCaseValue() const {
    assert((unsigned)Index < SI->getNumCases() &&((void)0)
           "Index out the number of cases.")((void)0);
    return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
  }

  /// Resolves successor for current case.
  BasicBlockT *getCaseSuccessor() const {
    assert(((unsigned)Index < SI->getNumCases() ||((void)0)
            (unsigned)Index == DefaultPseudoIndex) &&((void)0)
           "Index out the number of cases.")((void)0);
    return SI->getSuccessor(getSuccessorIndex());
  }

  /// Returns number of current case.
  unsigned getCaseIndex() const { return Index; }

  /// Returns successor index for current case successor.
  unsigned getSuccessorIndex() const {
    assert(((unsigned)Index == DefaultPseudoIndex ||((void)0)
            (unsigned)Index < SI->getNumCases()) &&((void)0)
           "Index out the number of cases.")((void)0);
    return (unsigned)Index != DefaultPseudoIndex ? Index + 1 : 0;
  }

  bool operator==(const CaseHandleImpl &RHS) const {
    assert(SI == RHS.SI && "Incompatible operators.")((void)0);
    return Index == RHS.Index;
  }
};

using ConstCaseHandle =
    CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>;

class CaseHandle
    : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
  friend class SwitchInst::CaseIteratorImpl<CaseHandle>;

public:
  CaseHandle(SwitchInst *SI, ptrdiff_t Index) : CaseHandleImpl(SI, Index) {}

  /// Sets the new value for current case.
  void setValue(ConstantInt *V) {
    assert((unsigned)Index < SI->getNumCases() &&((void)0)
           "Index out the number of cases.")((void)0);
    SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
  }

  /// Sets the new successor for current case.
  void setSuccessor(BasicBlock *S) {
    SI->setSuccessor(getSuccessorIndex(), S);
  }
};

template <typename CaseHandleT>
class CaseIteratorImpl
    : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
                                  std::random_access_iterator_tag,
                                  CaseHandleT> {
  using SwitchInstT = typename CaseHandleT::SwitchInstType;

  CaseHandleT Case;

public:
  /// Default constructed iterator is in an invalid state until assigned to
  /// a case for a particular switch.
  CaseIteratorImpl() = default;

  /// Initializes case iterator for given SwitchInst and for given
  /// case number.
  CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}

  /// Initializes case iterator for given SwitchInst and for given
  /// successor index.
  static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
                                             unsigned SuccessorIndex) {
    assert(SuccessorIndex < SI->getNumSuccessors() &&((void)0)
           "Successor index # out of range!")((void)0);
    return SuccessorIndex != 0 ? CaseIteratorImpl(SI, SuccessorIndex - 1)
                               : CaseIteratorImpl(SI, DefaultPseudoIndex);
  }

  /// Support converting to the const variant. This will be a no-op for const
  /// variant.
  operator CaseIteratorImpl<ConstCaseHandle>() const {
    return CaseIteratorImpl<ConstCaseHandle>(Case.SI, Case.Index);
  }

  CaseIteratorImpl &operator+=(ptrdiff_t N) {
    // Check index correctness after addition.
    // Note: Index == getNumCases() means end().
    assert(Case.Index + N >= 0 &&((void)0)
           (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&((void)0)
           "Case.Index out the number of cases.")((void)0);
    Case.Index += N;
    return *this;
  }
  CaseIteratorImpl &operator-=(ptrdiff_t N) {
    // Check index correctness after subtraction.
    // Note: Case.Index == getNumCases() means end().
    assert(Case.Index - N >= 0 &&((void)0)
           (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&((void)0)
           "Case.Index out the number of cases.")((void)0);
    Case.Index -= N;
    return *this;
  }
  ptrdiff_t operator-(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")((void)0);
    return Case.Index - RHS.Case.Index;
  }
  bool operator==(const CaseIteratorImpl &RHS) const {
    return Case == RHS.Case;
  }
  bool operator<(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")((void)0);
    return Case.Index < RHS.Case.Index;
  }
  CaseHandleT &operator*() { return Case; }
  const CaseHandleT &operator*() const { return Case; }
};

using CaseIt = CaseIteratorImpl<CaseHandle>;
using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;

static SwitchInst *Create(Value *Value, BasicBlock *Default,
                          unsigned NumCases,
                          Instruction *InsertBefore = nullptr) {
  return new SwitchInst(Value, Default, NumCases, InsertBefore);
}

static SwitchInst *Create(Value *Value, BasicBlock *Default,
                          unsigned NumCases, BasicBlock *InsertAtEnd) {
  return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Accessor Methods for Switch stmt
Value *getCondition() const { return getOperand(0); }
void setCondition(Value *V) { setOperand(0, V); }

BasicBlock *getDefaultDest() const {
  return cast<BasicBlock>(getOperand(1));
}

void setDefaultDest(BasicBlock *DefaultCase) {
  setOperand(1, reinterpret_cast<Value*>(DefaultCase));
}

/// Return the number of 'cases' in this switch instruction, excluding the
/// default case.
unsigned getNumCases() const {
  return getNumOperands()/2 - 1;
}

/// Returns a read/write iterator that points to the first case in the
/// SwitchInst.
CaseIt case_begin() {
  return CaseIt(this, 0);
}

/// Returns a read-only iterator that points to the first case in the
/// SwitchInst.
ConstCaseIt case_begin() const {
  return ConstCaseIt(this, 0);
}

/// Returns a read/write iterator that points one past the last in the
/// SwitchInst.
CaseIt case_end() {
  return CaseIt(this, getNumCases());
}

/// Returns a read-only iterator that points one past the last in the
/// SwitchInst.
ConstCaseIt case_end() const {
  return ConstCaseIt(this, getNumCases());
}

/// Iteration adapter for range-for loops.
iterator_range<CaseIt> cases() {
  return make_range(case_begin(), case_end());
}

/// Constant iteration adapter for range-for loops.
iterator_range<ConstCaseIt> cases() const {
  return make_range(case_begin(), case_end());
}

/// Returns an iterator that points to the default case.
/// Note: this iterator allows to resolve successor only. Attempt
/// to resolve case value causes an assertion.
/// Also note, that increment and decrement also causes an assertion and
/// makes iterator invalid.
CaseIt case_default() {
  return CaseIt(this, DefaultPseudoIndex);
}
ConstCaseIt case_default() const {
  return ConstCaseIt(this, DefaultPseudoIndex);
}

/// Search all of the case values for the specified constant. If it is
/// explicitly handled, return the case iterator of it, otherwise return
/// default case iterator to indicate that it is handled by the default
/// handler.
CaseIt findCaseValue(const ConstantInt *C) {
  CaseIt I = llvm::find_if(
      cases(), [C](CaseHandle &Case) { return Case.getCaseValue() == C; });
  if (I != case_end())
    return I;

  return case_default();
}
ConstCaseIt findCaseValue(const ConstantInt *C) const {
  ConstCaseIt I = llvm::find_if(cases(), [C](ConstCaseHandle &Case) {
    return Case.getCaseValue() == C;
  });
  if (I != case_end())
    return I;

  return case_default();
}

/// Finds the unique case value for a given successor. Returns null if the
/// successor is not found, not unique, or is the default case.
ConstantInt *findCaseDest(BasicBlock *BB) {
  if (BB == getDefaultDest())
    return nullptr;

  ConstantInt *CI = nullptr;
  for (auto Case : cases()) {
    if (Case.getCaseSuccessor() != BB)
      continue;

    if (CI)
      return nullptr; // Multiple cases lead to BB.

    CI = Case.getCaseValue();
  }

  return CI;
}

/// Add an entry to the switch instruction.
/// Note:
/// This action invalidates case_end(). Old case_end() iterator will
/// point to the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest);

/// This method removes the specified case and its successor from the switch
/// instruction. Note that this operation may reorder the remaining cases at
/// index idx and above.
/// Note:
/// This action invalidates iterators for all cases following the one removed,
/// including the case_end() iterator. It returns an iterator for the next
/// case.
CaseIt removeCase(CaseIt I);

unsigned getNumSuccessors() const { return getNumOperands()/2; }
BasicBlock *getSuccessor(unsigned idx) const {
  assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!")((void)0);
  return cast<BasicBlock>(getOperand(idx*2+1));
}
void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for switch!")((void)0);
  setOperand(idx * 2 + 1, NewSucc);
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Switch;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
3518};

3520/// A wrapper class to simplify modification of SwitchInst cases along with
3521/// their prof branch_weights metadata.
3522class SwitchInstProfUpdateWrapper {
SwitchInst &SI;
Optional<SmallVector<uint32_t, 8> > Weights = None;
bool Changed = false;

3527protected:
static MDNode *getProfBranchWeightsMD(const SwitchInst &SI);

MDNode *buildProfBranchWeightsMD();

void init();

3534public:
using CaseWeightOpt = Optional<uint32_t>;
SwitchInst *operator->() { return &SI; }
SwitchInst &operator*() { return SI; }
operator SwitchInst *() { return &SI; }

SwitchInstProfUpdateWrapper(SwitchInst &SI) : SI(SI) { init(); }

~SwitchInstProfUpdateWrapper() {
  if (Changed)
    SI.setMetadata(LLVMContext::MD_prof, buildProfBranchWeightsMD());
}

/// Delegate the call to the underlying SwitchInst::removeCase() and remove
/// correspondent branch weight.
SwitchInst::CaseIt removeCase(SwitchInst::CaseIt I);

/// Delegate the call to the underlying SwitchInst::addCase() and set the
/// specified branch weight for the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest, CaseWeightOpt W);

/// Delegate the call to the underlying SwitchInst::eraseFromParent() and mark
/// this object to not touch the underlying SwitchInst in destructor.
SymbolTableList<Instruction>::iterator eraseFromParent();

void setSuccessorWeight(unsigned idx, CaseWeightOpt W);
CaseWeightOpt getSuccessorWeight(unsigned idx);

static CaseWeightOpt getSuccessorWeight(const SwitchInst &SI, unsigned idx);
3563};

3565template <>
3566struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
3567};

3569DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)SwitchInst::op_iterator SwitchInst::op_begin() { return OperandTraits
<SwitchInst>::op_begin(this); } SwitchInst::const_op_iterator
 SwitchInst::op_begin() const { return OperandTraits<SwitchInst
>::op_begin(const_cast<SwitchInst*>(this)); } SwitchInst
::op_iterator SwitchInst::op_end() { return OperandTraits<
SwitchInst>::op_end(this); } SwitchInst::const_op_iterator
 SwitchInst::op_end() const { return OperandTraits<SwitchInst
>::op_end(const_cast<SwitchInst*>(this)); } Value *SwitchInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<SwitchInst>::op_begin(const_cast
<SwitchInst*>(this))[i_nocapture].get()); } void SwitchInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<SwitchInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned SwitchInst::getNumOperands() const
 { return OperandTraits<SwitchInst>::operands(this); } template
 <int Idx_nocapture> Use &SwitchInst::Op() { return
 this->OpFrom<Idx_nocapture>(this); } template <int
 Idx_nocapture> const Use &SwitchInst::Op() const { return
 this->OpFrom<Idx_nocapture>(this); }

3571//===----------------------------------------------------------------------===//
3572//                             IndirectBrInst Class
3573//===----------------------------------------------------------------------===//

3575//===---------------------------------------------------------------------------
3576/// Indirect Branch Instruction.
3577///
3578class IndirectBrInst : public Instruction {
unsigned ReservedSpace;

// Operand[0]   = Address to jump to
// Operand[n+1] = n-th destination
IndirectBrInst(const IndirectBrInst &IBI);

/// Create a new indirectbr instruction, specifying an
/// Address to jump to.  The number of expected destinations can be specified
/// here to make memory allocation more efficient.  This constructor can also
/// autoinsert before another instruction.
IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);

/// Create a new indirectbr instruction, specifying an
/// Address to jump to.  The number of expected destinations can be specified
/// here to make memory allocation more efficient.  This constructor also
/// autoinserts at the end of the specified BasicBlock.
IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t S) { return User::operator new(S); }

void init(Value *Address, unsigned NumDests);
void growOperands();

3603protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

IndirectBrInst *cloneImpl() const;

3609public:
void operator delete(void *Ptr) { User::operator delete(Ptr); }

/// Iterator type that casts an operand to a basic block.
///
/// This only makes sense because the successors are stored as adjacent
/// operands for indirectbr instructions.
struct succ_op_iterator
    : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                            std::random_access_iterator_tag, BasicBlock *,
                            ptrdiff_t, BasicBlock *, BasicBlock *> {
  explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}

  BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  BasicBlock *operator->() const { return operator*(); }
};

/// The const version of `succ_op_iterator`.
struct const_succ_op_iterator
    : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
                            std::random_access_iterator_tag,
                            const BasicBlock *, ptrdiff_t, const BasicBlock *,
                            const BasicBlock *> {
  explicit const_succ_op_iterator(const_value_op_iterator I)
      : iterator_adaptor_base(I) {}

  const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  const BasicBlock *operator->() const { return operator*(); }
};

static IndirectBrInst *Create(Value *Address, unsigned NumDests,
                              Instruction *InsertBefore = nullptr) {
  return new IndirectBrInst(Address, NumDests, InsertBefore);
}

static IndirectBrInst *Create(Value *Address, unsigned NumDests,
                              BasicBlock *InsertAtEnd) {
  return new IndirectBrInst(Address, NumDests, InsertAtEnd);
}

/// Provide fast operand accessors.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Accessor Methods for IndirectBrInst instruction.
Value *getAddress() { return getOperand(0); }
const Value *getAddress() const { return getOperand(0); }
void setAddress(Value *V) { setOperand(0, V); }

/// return the number of possible destinations in this
/// indirectbr instruction.
unsigned getNumDestinations() const { return getNumOperands()-1; }

/// Return the specified destination.
BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }

/// Add a destination.
///
void addDestination(BasicBlock *Dest);

/// This method removes the specified successor from the
/// indirectbr instruction.
void removeDestination(unsigned i);

unsigned getNumSuccessors() const { return getNumOperands()-1; }
BasicBlock *getSuccessor(unsigned i) const {
  return cast<BasicBlock>(getOperand(i+1));
}
void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  setOperand(i + 1, NewSucc);
}

iterator_range<succ_op_iterator> successors() {
  return make_range(succ_op_iterator(std::next(value_op_begin())),
                    succ_op_iterator(value_op_end()));
}

iterator_range<const_succ_op_iterator> successors() const {
  return make_range(const_succ_op_iterator(std::next(value_op_begin())),
                    const_succ_op_iterator(value_op_end()));
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::IndirectBr;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
3698};

3700template <>
3701struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
3702};

3704DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)IndirectBrInst::op_iterator IndirectBrInst::op_begin() { return
 OperandTraits<IndirectBrInst>::op_begin(this); } IndirectBrInst
::const_op_iterator IndirectBrInst::op_begin() const { return
 OperandTraits<IndirectBrInst>::op_begin(const_cast<
IndirectBrInst*>(this)); } IndirectBrInst::op_iterator IndirectBrInst
::op_end() { return OperandTraits<IndirectBrInst>::op_end
(this); } IndirectBrInst::const_op_iterator IndirectBrInst::op_end
() const { return OperandTraits<IndirectBrInst>::op_end
(const_cast<IndirectBrInst*>(this)); } Value *IndirectBrInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<IndirectBrInst>::op_begin(
const_cast<IndirectBrInst*>(this))[i_nocapture].get());
 } void IndirectBrInst::setOperand(unsigned i_nocapture, Value
 *Val_nocapture) { ((void)0); OperandTraits<IndirectBrInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 IndirectBrInst::getNumOperands() const { return OperandTraits
<IndirectBrInst>::operands(this); } template <int Idx_nocapture
> Use &IndirectBrInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &IndirectBrInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

3706//===----------------------------------------------------------------------===//
3707//                               InvokeInst Class
3708//===----------------------------------------------------------------------===//

3710/// Invoke instruction.  The SubclassData field is used to hold the
3711/// calling convention of the call.
3712///
3713class InvokeInst : public CallBase {
/// The number of operands for this call beyond the called function,
/// arguments, and operand bundles.
static constexpr int NumExtraOperands = 2;

/// The index from the end of the operand array to the normal destination.
static constexpr int NormalDestOpEndIdx = -3;

/// The index from the end of the operand array to the unwind destination.
static constexpr int UnwindDestOpEndIdx = -2;

InvokeInst(const InvokeInst &BI);

/// Construct an InvokeInst given a range of arguments.
///
/// Construct an InvokeInst from a range of arguments
inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                  BasicBlock *IfException, ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, Instruction *InsertBefore);

inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                  BasicBlock *IfException, ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
          BasicBlock *IfException, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
  // We need one operand for the called function, plus our extra operands and
  // the input operand counts provided.
  return 1 + NumExtraOperands + NumArgs + NumBundleInputs;
}

3750protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

InvokeInst *cloneImpl() const;

3756public:
static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  int NumOperands = ComputeNumOperands(Args.size());
  return new (NumOperands)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
                 NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
                 NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  int NumOperands = ComputeNumOperands(Args.size());
  return new (NumOperands)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
                 NameStr, InsertAtEnd);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
                 NameStr, InsertAtEnd);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, None, NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, Bundles, NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, NameStr, InsertAtEnd);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, Bundles, NameStr, InsertAtEnd);
}

/// Create a clone of \p II with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned invoke instruction is identical to \p II in every way except
/// that the operand bundles for the new instruction are set to the operand
/// bundles in \p Bundles.
static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
                          Instruction *InsertPt = nullptr);

// get*Dest - Return the destination basic blocks...
BasicBlock *getNormalDest() const {
  return cast<BasicBlock>(Op<NormalDestOpEndIdx>());
}
BasicBlock *getUnwindDest() const {
  return cast<BasicBlock>(Op<UnwindDestOpEndIdx>());
}
void setNormalDest(BasicBlock *B) {
  Op<NormalDestOpEndIdx>() = reinterpret_cast<Value *>(B);
}
void setUnwindDest(BasicBlock *B) {
  Op<UnwindDestOpEndIdx>() = reinterpret_cast<Value *>(B);
}

/// Get the landingpad instruction from the landing pad
/// block (the unwind destination).
LandingPadInst *getLandingPadInst() const;

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < 2 && "Successor # out of range for invoke!")((void)0);
  return i == 0 ? getNormalDest() : getUnwindDest();
}

void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  assert(i < 2 && "Successor # out of range for invoke!")((void)0);
  if (i == 0)
    setNormalDest(NewSucc);
  else
    setUnwindDest(NewSucc);
}

unsigned getNumSuccessors() const { return 2; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::Invoke);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

3885private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
3892};

3894InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                     BasicBlock *IfException, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::Invoke,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertBefore) {
init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
3902}

3904InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                     BasicBlock *IfException, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::Invoke,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertAtEnd) {
init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
3912}

3914//===----------------------------------------------------------------------===//
3915//                              CallBrInst Class
3916//===----------------------------------------------------------------------===//

3918/// CallBr instruction, tracking function calls that may not return control but
3919/// instead transfer it to a third location. The SubclassData field is used to
3920/// hold the calling convention of the call.
3921///
3922class CallBrInst : public CallBase {

unsigned NumIndirectDests;

CallBrInst(const CallBrInst &BI);

/// Construct a CallBrInst given a range of arguments.
///
/// Construct a CallBrInst from a range of arguments
inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                  ArrayRef<BasicBlock *> IndirectDests,
                  ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, Instruction *InsertBefore);

inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                  ArrayRef<BasicBlock *> IndirectDests,
                  ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(FunctionType *FTy, Value *Func, BasicBlock *DefaultDest,
          ArrayRef<BasicBlock *> IndirectDests, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);

/// Should the Indirect Destinations change, scan + update the Arg list.
void updateArgBlockAddresses(unsigned i, BasicBlock *B);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumIndirectDests,
                              int NumBundleInputs = 0) {
  // We need one operand for the called function, plus our extra operands and
  // the input operand counts provided.
  return 2 + NumIndirectDests + NumArgs + NumBundleInputs;
}

3958protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

CallBrInst *cloneImpl() const;

3964public:
static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
  return new (NumOperands)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, None,
                 NumOperands, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
                                       CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
                 NumOperands, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
  return new (NumOperands)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, None,
                 NumOperands, NameStr, InsertAtEnd);
}

static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
                                       CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
                 NumOperands, NameStr, InsertAtEnd);
}

static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, Bundles, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, NameStr, InsertAtEnd);
}

static CallBrInst *Create(FunctionCallee Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, Bundles, NameStr, InsertAtEnd);
}

/// Create a clone of \p CBI with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned callbr instruction is identical to \p CBI in every way
/// except that the operand bundles for the new instruction are set to the
/// operand bundles in \p Bundles.
static CallBrInst *Create(CallBrInst *CBI,
                          ArrayRef<OperandBundleDef> Bundles,
                          Instruction *InsertPt = nullptr);

/// Return the number of callbr indirect dest labels.
///
unsigned getNumIndirectDests() const { return NumIndirectDests; }

/// getIndirectDestLabel - Return the i-th indirect dest label.
///
Value *getIndirectDestLabel(unsigned i) const {
  assert(i < getNumIndirectDests() && "Out of bounds!")((void)0);
  return getOperand(i + getNumArgOperands() + getNumTotalBundleOperands() +
                    1);
}

Value *getIndirectDestLabelUse(unsigned i) const {
  assert(i < getNumIndirectDests() && "Out of bounds!")((void)0);
  return getOperandUse(i + getNumArgOperands() + getNumTotalBundleOperands() +
                       1);
}

// Return the destination basic blocks...
BasicBlock *getDefaultDest() const {
  return cast<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() - 1));
}
BasicBlock *getIndirectDest(unsigned i) const {
  return cast_or_null<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() + i));
}
SmallVector<BasicBlock *, 16> getIndirectDests() const {
  SmallVector<BasicBlock *, 16> IndirectDests;
  for (unsigned i = 0, e = getNumIndirectDests(); i < e; ++i)
    IndirectDests.push_back(getIndirectDest(i));
  return IndirectDests;
}
void setDefaultDest(BasicBlock *B) {
  *(&Op<-1>() - getNumIndirectDests() - 1) = reinterpret_cast<Value *>(B);
}
void setIndirectDest(unsigned i, BasicBlock *B) {
  updateArgBlockAddresses(i, B);
  *(&Op<-1>() - getNumIndirectDests() + i) = reinterpret_cast<Value *>(B);
}

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < getNumSuccessors() + 1 &&((void)0)
         "Successor # out of range for callbr!")((void)0);
  return i == 0 ? getDefaultDest() : getIndirectDest(i - 1);
}

void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  assert(i < getNumIndirectDests() + 1 &&((void)0)
         "Successor # out of range for callbr!")((void)0);
  return i == 0 ? setDefaultDest(NewSucc) : setIndirectDest(i - 1, NewSucc);
}

unsigned getNumSuccessors() const { return getNumIndirectDests() + 1; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::CallBr);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

4125private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
4132};

4134CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                     ArrayRef<BasicBlock *> IndirectDests,
                     ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::CallBr,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertBefore) {
init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4143}

4145CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                     ArrayRef<BasicBlock *> IndirectDests,
                     ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::CallBr,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertAtEnd) {
init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4154}

4156//===----------------------------------------------------------------------===//
4157//                              ResumeInst Class
4158//===----------------------------------------------------------------------===//

4160//===---------------------------------------------------------------------------
4161/// Resume the propagation of an exception.
4162///
4163class ResumeInst : public Instruction {
ResumeInst(const ResumeInst &RI);

explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);

4169protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ResumeInst *cloneImpl() const;

4175public:
static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
  return new(1) ResumeInst(Exn, InsertBefore);
}

static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
  return new(1) ResumeInst(Exn, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Convenience accessor.
Value *getValue() const { return Op<0>(); }

unsigned getNumSuccessors() const { return 0; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Resume;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

4200private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ResumeInst has no successors!")__builtin_unreachable();
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  llvm_unreachable("ResumeInst has no successors!")__builtin_unreachable();
}
4208};

4210template <>
4211struct OperandTraits<ResumeInst> :
  public FixedNumOperandTraits<ResumeInst, 1> {
4213};

4215DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)ResumeInst::op_iterator ResumeInst::op_begin() { return OperandTraits
<ResumeInst>::op_begin(this); } ResumeInst::const_op_iterator
 ResumeInst::op_begin() const { return OperandTraits<ResumeInst
>::op_begin(const_cast<ResumeInst*>(this)); } ResumeInst
::op_iterator ResumeInst::op_end() { return OperandTraits<
ResumeInst>::op_end(this); } ResumeInst::const_op_iterator
 ResumeInst::op_end() const { return OperandTraits<ResumeInst
>::op_end(const_cast<ResumeInst*>(this)); } Value *ResumeInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<ResumeInst>::op_begin(const_cast
<ResumeInst*>(this))[i_nocapture].get()); } void ResumeInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
void)0); OperandTraits<ResumeInst>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned ResumeInst::getNumOperands() const
 { return OperandTraits<ResumeInst>::operands(this); } template
 <int Idx_nocapture> Use &ResumeInst::Op() { return
 this->OpFrom<Idx_nocapture>(this); } template <int
 Idx_nocapture> const Use &ResumeInst::Op() const { return
 this->OpFrom<Idx_nocapture>(this); }

4217//===----------------------------------------------------------------------===//
4218//                         CatchSwitchInst Class
4219//===----------------------------------------------------------------------===//
4220class CatchSwitchInst : public Instruction {
using UnwindDestField = BoolBitfieldElementT<0>;

/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

// Operand[0] = Outer scope
// Operand[1] = Unwind block destination
// Operand[n] = BasicBlock to go to on match
CatchSwitchInst(const CatchSwitchInst &CSI);

/// Create a new switch instruction, specifying a
/// default destination.  The number of additional handlers can be specified
/// here to make memory allocation more efficient.
/// This constructor can also autoinsert before another instruction.
CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
                unsigned NumHandlers, const Twine &NameStr,
                Instruction *InsertBefore);

/// Create a new switch instruction, specifying a
/// default destination.  The number of additional handlers can be specified
/// here to make memory allocation more efficient.
/// This constructor also autoinserts at the end of the specified BasicBlock.
CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
                unsigned NumHandlers, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t S) { return User::operator new(S); }

void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
void growOperands(unsigned Size);

4254protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

CatchSwitchInst *cloneImpl() const;

4260public:
void operator delete(void *Ptr) { return User::operator delete(Ptr); }

static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
                               unsigned NumHandlers,
                               const Twine &NameStr = "",
                               Instruction *InsertBefore = nullptr) {
  return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
                             InsertBefore);
}

static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
                               unsigned NumHandlers, const Twine &NameStr,
                               BasicBlock *InsertAtEnd) {
  return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
                             InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Accessor Methods for CatchSwitch stmt
Value *getParentPad() const { return getOperand(0); }
void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }

// Accessor Methods for CatchSwitch stmt
bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
bool unwindsToCaller() const { return !hasUnwindDest(); }
BasicBlock *getUnwindDest() const {
  if (hasUnwindDest())
    return cast<BasicBlock>(getOperand(1));
  return nullptr;
}
void setUnwindDest(BasicBlock *UnwindDest) {
  assert(UnwindDest)((void)0);
  assert(hasUnwindDest())((void)0);
  setOperand(1, UnwindDest);
}

/// return the number of 'handlers' in this catchswitch
/// instruction, except the default handler
unsigned getNumHandlers() const {
  if (hasUnwindDest())
    return getNumOperands() - 2;
  return getNumOperands() - 1;
}

4307private:
static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
static const BasicBlock *handler_helper(const Value *V) {
  return cast<BasicBlock>(V);
}

4313public:
using DerefFnTy = BasicBlock *(*)(Value *);
using handler_iterator = mapped_iterator<op_iterator, DerefFnTy>;
using handler_range = iterator_range<handler_iterator>;
using ConstDerefFnTy = const BasicBlock *(*)(const Value *);
using const_handler_iterator =
    mapped_iterator<const_op_iterator, ConstDerefFnTy>;
using const_handler_range = iterator_range<const_handler_iterator>;

/// Returns an iterator that points to the first handler in CatchSwitchInst.
handler_iterator handler_begin() {
  op_iterator It = op_begin() + 1;
  if (hasUnwindDest())
    ++It;
  return handler_iterator(It, DerefFnTy(handler_helper));
}

/// Returns an iterator that points to the first handler in the
/// CatchSwitchInst.
const_handler_iterator handler_begin() const {
  const_op_iterator It = op_begin() + 1;
  if (hasUnwindDest())
    ++It;
  return const_handler_iterator(It, ConstDerefFnTy(handler_helper));
}

/// Returns a read-only iterator that points one past the last
/// handler in the CatchSwitchInst.
handler_iterator handler_end() {
  return handler_iterator(op_end(), DerefFnTy(handler_helper));
}

/// Returns an iterator that points one past the last handler in the
/// CatchSwitchInst.
const_handler_iterator handler_end() const {
  return const_handler_iterator(op_end(), ConstDerefFnTy(handler_helper));
}

/// iteration adapter for range-for loops.
handler_range handlers() {
  return make_range(handler_begin(), handler_end());
}

/// iteration adapter for range-for loops.
const_handler_range handlers() const {
  return make_range(handler_begin(), handler_end());
}

/// Add an entry to the switch instruction...
/// Note:
/// This action invalidates handler_end(). Old handler_end() iterator will
/// point to the added handler.
void addHandler(BasicBlock *Dest);

void removeHandler(handler_iterator HI);

unsigned getNumSuccessors() const { return getNumOperands() - 1; }
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx < getNumSuccessors() &&((void)0)
         "Successor # out of range for catchswitch!")((void)0);
  return cast<BasicBlock>(getOperand(Idx + 1));
}
void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
  assert(Idx < getNumSuccessors() &&((void)0)
         "Successor # out of range for catchswitch!")((void)0);
  setOperand(Idx + 1, NewSucc);
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::CatchSwitch;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4388};

4390template <>
4391struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};

4393DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchSwitchInst, Value)CatchSwitchInst::op_iterator CatchSwitchInst::op_begin() { return
 OperandTraits<CatchSwitchInst>::op_begin(this); } CatchSwitchInst
::const_op_iterator CatchSwitchInst::op_begin() const { return
 OperandTraits<CatchSwitchInst>::op_begin(const_cast<
CatchSwitchInst*>(this)); } CatchSwitchInst::op_iterator CatchSwitchInst
::op_end() { return OperandTraits<CatchSwitchInst>::op_end
(this); } CatchSwitchInst::const_op_iterator CatchSwitchInst::
op_end() const { return OperandTraits<CatchSwitchInst>::
op_end(const_cast<CatchSwitchInst*>(this)); } Value *CatchSwitchInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<CatchSwitchInst>::op_begin
(const_cast<CatchSwitchInst*>(this))[i_nocapture].get()
); } void CatchSwitchInst::setOperand(unsigned i_nocapture, Value
 *Val_nocapture) { ((void)0); OperandTraits<CatchSwitchInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 CatchSwitchInst::getNumOperands() const { return OperandTraits
<CatchSwitchInst>::operands(this); } template <int Idx_nocapture
> Use &CatchSwitchInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &CatchSwitchInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

4395//===----------------------------------------------------------------------===//
4396//                               CleanupPadInst Class
4397//===----------------------------------------------------------------------===//
4398class CleanupPadInst : public FuncletPadInst {
4399private:
explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
                        unsigned Values, const Twine &NameStr,
                        Instruction *InsertBefore)
    : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
                     NameStr, InsertBefore) {}
explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
                        unsigned Values, const Twine &NameStr,
                        BasicBlock *InsertAtEnd)
    : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
                     NameStr, InsertAtEnd) {}

4411public:
static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args = None,
                              const Twine &NameStr = "",
                              Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore);
}

static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
                              const Twine &NameStr, BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd);
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::CleanupPad;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4434};

4436//===----------------------------------------------------------------------===//
4437//                               CatchPadInst Class
4438//===----------------------------------------------------------------------===//
4439class CatchPadInst : public FuncletPadInst {
4440private:
explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
                      unsigned Values, const Twine &NameStr,
                      Instruction *InsertBefore)
    : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
                     NameStr, InsertBefore) {}
explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
                      unsigned Values, const Twine &NameStr,
                      BasicBlock *InsertAtEnd)
    : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
                     NameStr, InsertAtEnd) {}

4452public:
static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
                            const Twine &NameStr = "",
                            Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
}

static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
                            const Twine &NameStr, BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertAtEnd);
}

/// Convenience accessors
CatchSwitchInst *getCatchSwitch() const {
  return cast<CatchSwitchInst>(Op<-1>());
}
void setCatchSwitch(Value *CatchSwitch) {
  assert(CatchSwitch)((void)0);
  Op<-1>() = CatchSwitch;
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::CatchPad;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4484};

4486//===----------------------------------------------------------------------===//
4487//                               CatchReturnInst Class
4488//===----------------------------------------------------------------------===//

4490class CatchReturnInst : public Instruction {
CatchReturnInst(const CatchReturnInst &RI);
CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);

void init(Value *CatchPad, BasicBlock *BB);

4497protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

CatchReturnInst *cloneImpl() const;

4503public:
static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               Instruction *InsertBefore = nullptr) {
  assert(CatchPad)((void)0);
  assert(BB)((void)0);
  return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
}

static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               BasicBlock *InsertAtEnd) {
  assert(CatchPad)((void)0);
  assert(BB)((void)0);
  return new (2) CatchReturnInst(CatchPad, BB, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Convenience accessors.
CatchPadInst *getCatchPad() const { return cast<CatchPadInst>(Op<0>()); }
void setCatchPad(CatchPadInst *CatchPad) {
  assert(CatchPad)((void)0);
  Op<0>() = CatchPad;
}

BasicBlock *getSuccessor() const { return cast<BasicBlock>(Op<1>()); }
void setSuccessor(BasicBlock *NewSucc) {
  assert(NewSucc)((void)0);
  Op<1>() = NewSucc;
}
unsigned getNumSuccessors() const { return 1; }

/// Get the parentPad of this catchret's catchpad's catchswitch.
/// The successor block is implicitly a member of this funclet.
Value *getCatchSwitchParentPad() const {
  return getCatchPad()->getCatchSwitch()->getParentPad();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::CatchRet);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

4549private:
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!")((void)0);
  return getSuccessor();
}

void setSuccessor(unsigned Idx, BasicBlock *B) {
  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!")((void)0);
  setSuccessor(B);
}
4559};

4561template <>
4562struct OperandTraits<CatchReturnInst>
  : public FixedNumOperandTraits<CatchReturnInst, 2> {};

4565DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value)CatchReturnInst::op_iterator CatchReturnInst::op_begin() { return
 OperandTraits<CatchReturnInst>::op_begin(this); } CatchReturnInst
::const_op_iterator CatchReturnInst::op_begin() const { return
 OperandTraits<CatchReturnInst>::op_begin(const_cast<
CatchReturnInst*>(this)); } CatchReturnInst::op_iterator CatchReturnInst
::op_end() { return OperandTraits<CatchReturnInst>::op_end
(this); } CatchReturnInst::const_op_iterator CatchReturnInst::
op_end() const { return OperandTraits<CatchReturnInst>::
op_end(const_cast<CatchReturnInst*>(this)); } Value *CatchReturnInst
::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null
<Value>( OperandTraits<CatchReturnInst>::op_begin
(const_cast<CatchReturnInst*>(this))[i_nocapture].get()
); } void CatchReturnInst::setOperand(unsigned i_nocapture, Value
 *Val_nocapture) { ((void)0); OperandTraits<CatchReturnInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 CatchReturnInst::getNumOperands() const { return OperandTraits
<CatchReturnInst>::operands(this); } template <int Idx_nocapture
> Use &CatchReturnInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &CatchReturnInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

4567//===----------------------------------------------------------------------===//
4568//                               CleanupReturnInst Class
4569//===----------------------------------------------------------------------===//

4571class CleanupReturnInst : public Instruction {
using UnwindDestField = BoolBitfieldElementT<0>;

4574private:
CleanupReturnInst(const CleanupReturnInst &RI);
CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                  Instruction *InsertBefore = nullptr);
CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                  BasicBlock *InsertAtEnd);

void init(Value *CleanupPad, BasicBlock *UnwindBB);

4583protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

CleanupReturnInst *cloneImpl() const;

4589public:
static CleanupReturnInst *Create(Value *CleanupPad,
                                 BasicBlock *UnwindBB = nullptr,
                                 Instruction *InsertBefore = nullptr) {
  assert(CleanupPad)((void)0);
  unsigned Values = 1;
  if (UnwindBB)
    ++Values;
  return new (Values)
      CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore);
}

static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB,
                                 BasicBlock *InsertAtEnd) {
  assert(CleanupPad)((void)0);
  unsigned Values = 1;
  if (UnwindBB)
    ++Values;
  return new (Values)
      CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
}

/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
bool unwindsToCaller() const { return !hasUnwindDest(); }

/// Convenience accessor.
CleanupPadInst *getCleanupPad() const {
  return cast<CleanupPadInst>(Op<0>());
}
void setCleanupPad(CleanupPadInst *CleanupPad) {
  assert(CleanupPad)((void)0);
  Op<0>() = CleanupPad;
}

unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }

BasicBlock *getUnwindDest() const {
  return hasUnwindDest() ? cast<BasicBlock>(Op<1>()) : nullptr;
}
void setUnwindDest(BasicBlock *NewDest) {
  assert(NewDest)((void)0);
  assert(hasUnwindDest())((void)0);
  Op<1>() = NewDest;
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return (I->getOpcode() == Instruction::CleanupRet);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

4645private:
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx == 0)((void)0);
  return getUnwindDest();
}

void setSuccessor(unsigned Idx, BasicBlock *B) {
  assert(Idx == 0)((void)0);
  setUnwindDest(B);
}

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
4662};

4664template <>
4665struct OperandTraits<CleanupReturnInst>
  : public VariadicOperandTraits<CleanupReturnInst, /*MINARITY=*/1> {};

4668DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupReturnInst, Value)CleanupReturnInst::op_iterator CleanupReturnInst::op_begin() {
 return OperandTraits<CleanupReturnInst>::op_begin(this
); } CleanupReturnInst::const_op_iterator CleanupReturnInst::
op_begin() const { return OperandTraits<CleanupReturnInst>
::op_begin(const_cast<CleanupReturnInst*>(this)); } CleanupReturnInst
::op_iterator CleanupReturnInst::op_end() { return OperandTraits
<CleanupReturnInst>::op_end(this); } CleanupReturnInst::
const_op_iterator CleanupReturnInst::op_end() const { return OperandTraits
<CleanupReturnInst>::op_end(const_cast<CleanupReturnInst
*>(this)); } Value *CleanupReturnInst::getOperand(unsigned
 i_nocapture) const { ((void)0); return cast_or_null<Value
>( OperandTraits<CleanupReturnInst>::op_begin(const_cast
<CleanupReturnInst*>(this))[i_nocapture].get()); } void
 CleanupReturnInst::setOperand(unsigned i_nocapture, Value *Val_nocapture
) { ((void)0); OperandTraits<CleanupReturnInst>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned CleanupReturnInst
::getNumOperands() const { return OperandTraits<CleanupReturnInst
>::operands(this); } template <int Idx_nocapture> Use
 &CleanupReturnInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
CleanupReturnInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }

4670//===----------------------------------------------------------------------===//
4671//                           UnreachableInst Class
4672//===----------------------------------------------------------------------===//

4674//===---------------------------------------------------------------------------
4675/// This function has undefined behavior.  In particular, the
4676/// presence of this instruction indicates some higher level knowledge that the
4677/// end of the block cannot be reached.
4678///
4679class UnreachableInst : public Instruction {
4680protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

UnreachableInst *cloneImpl() const;

4686public:
explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = nullptr);
explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t S) { return User::operator new(S, 0); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

unsigned getNumSuccessors() const { return 0; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Unreachable;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

4704private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("UnreachableInst has no successors!")__builtin_unreachable();
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("UnreachableInst has no successors!")__builtin_unreachable();
}
4712};

4714//===----------------------------------------------------------------------===//
4715//                                 TruncInst Class
4716//===----------------------------------------------------------------------===//

4718/// This class represents a truncation of integer types.
4719class TruncInst : public CastInst {
4720protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical TruncInst
TruncInst *cloneImpl() const;

4727public:
/// Constructor with insert-before-instruction semantics
TruncInst(
  Value *S,                           ///< The value to be truncated
  Type *Ty,                           ///< The (smaller) type to truncate to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
TruncInst(
  Value *S,                     ///< The value to be truncated
  Type *Ty,                     ///< The (smaller) type to truncate to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Trunc;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4751};

4753//===----------------------------------------------------------------------===//
4754//                                 ZExtInst Class
4755//===----------------------------------------------------------------------===//

4757/// This class represents zero extension of integer types.
4758class ZExtInst : public CastInst {
4759protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical ZExtInst
ZExtInst *cloneImpl() const;

4766public:
/// Constructor with insert-before-instruction semantics
ZExtInst(
  Value *S,                           ///< The value to be zero extended
  Type *Ty,                           ///< The type to zero extend to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end semantics.
ZExtInst(
  Value *S,                     ///< The value to be zero extended
  Type *Ty,                     ///< The type to zero extend to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == ZExt;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4790};

4792//===----------------------------------------------------------------------===//
4793//                                 SExtInst Class
4794//===----------------------------------------------------------------------===//

4796/// This class represents a sign extension of integer types.
4797class SExtInst : public CastInst {
4798protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical SExtInst
SExtInst *cloneImpl() const;

4805public:
/// Constructor with insert-before-instruction semantics
SExtInst(
  Value *S,                           ///< The value to be sign extended
  Type *Ty,                           ///< The type to sign extend to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
SExtInst(
  Value *S,                     ///< The value to be sign extended
  Type *Ty,                     ///< The type to sign extend to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == SExt;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4829};

4831//===----------------------------------------------------------------------===//
4832//                                 FPTruncInst Class
4833//===----------------------------------------------------------------------===//

4835/// This class represents a truncation of floating point types.
4836class FPTruncInst : public CastInst {
4837protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPTruncInst
FPTruncInst *cloneImpl() const;

4844public:
/// Constructor with insert-before-instruction semantics
FPTruncInst(
  Value *S,                           ///< The value to be truncated
  Type *Ty,                           ///< The type to truncate to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-before-instruction semantics
FPTruncInst(
  Value *S,                     ///< The value to be truncated
  Type *Ty,                     ///< The type to truncate to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == FPTrunc;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4868};

4870//===----------------------------------------------------------------------===//
4871//                                 FPExtInst Class
4872//===----------------------------------------------------------------------===//

4874/// This class represents an extension of floating point types.
4875class FPExtInst : public CastInst {
4876protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPExtInst
FPExtInst *cloneImpl() const;

4883public:
/// Constructor with insert-before-instruction semantics
FPExtInst(
  Value *S,                           ///< The value to be extended
  Type *Ty,                           ///< The type to extend to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
FPExtInst(
  Value *S,                     ///< The value to be extended
  Type *Ty,                     ///< The type to extend to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == FPExt;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4907};

4909//===----------------------------------------------------------------------===//
4910//                                 UIToFPInst Class
4911//===----------------------------------------------------------------------===//

4913/// This class represents a cast unsigned integer to floating point.
4914class UIToFPInst : public CastInst {
4915protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical UIToFPInst
UIToFPInst *cloneImpl() const;

4922public:
/// Constructor with insert-before-instruction semantics
UIToFPInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
UIToFPInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == UIToFP;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4946};

4948//===----------------------------------------------------------------------===//
4949//                                 SIToFPInst Class
4950//===----------------------------------------------------------------------===//

4952/// This class represents a cast from signed integer to floating point.
4953class SIToFPInst : public CastInst {
4954protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical SIToFPInst
SIToFPInst *cloneImpl() const;

4961public:
/// Constructor with insert-before-instruction semantics
SIToFPInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
SIToFPInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == SIToFP;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
4985};

4987//===----------------------------------------------------------------------===//
4988//                                 FPToUIInst Class
4989//===----------------------------------------------------------------------===//

4991/// This class represents a cast from floating point to unsigned integer
4992class FPToUIInst  : public CastInst {
4993protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPToUIInst
FPToUIInst *cloneImpl() const;

5000public:
/// Constructor with insert-before-instruction semantics
FPToUIInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
FPToUIInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< Where to insert the new instruction
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == FPToUI;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
5024};

5026//===----------------------------------------------------------------------===//
5027//                                 FPToSIInst Class
5028//===----------------------------------------------------------------------===//

5030/// This class represents a cast from floating point to signed integer.
5031class FPToSIInst  : public CastInst {
5032protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPToSIInst
FPToSIInst *cloneImpl() const;

5039public:
/// Constructor with insert-before-instruction semantics
FPToSIInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
FPToSIInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == FPToSI;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
5063};

5065//===----------------------------------------------------------------------===//
5066//                                 IntToPtrInst Class
5067//===----------------------------------------------------------------------===//

5069/// This class represents a cast from an integer to a pointer.
5070class IntToPtrInst : public CastInst {
5071public:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Constructor with insert-before-instruction semantics
IntToPtrInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
IntToPtrInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Clone an identical IntToPtrInst.
IntToPtrInst *cloneImpl() const;

/// Returns the address space of this instruction's pointer type.
unsigned getAddressSpace() const {
  return getType()->getPointerAddressSpace();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == IntToPtr;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
5106};

5108//===----------------------------------------------------------------------===//
5109//                                 PtrToIntInst Class
5110//===----------------------------------------------------------------------===//

5112/// This class represents a cast from a pointer to an integer.
5113class PtrToIntInst : public CastInst {
5114protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical PtrToIntInst.
PtrToIntInst *cloneImpl() const;

5121public:
/// Constructor with insert-before-instruction semantics
PtrToIntInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
PtrToIntInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Gets the pointer operand.
Value *getPointerOperand() { return getOperand(0); }
/// Gets the pointer operand.
const Value *getPointerOperand() const { return getOperand(0); }
/// Gets the operand index of the pointer operand.
static unsigned getPointerOperandIndex() { return 0U; }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == PtrToInt;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
5157};

5159//===----------------------------------------------------------------------===//
5160//                             BitCastInst Class
5161//===----------------------------------------------------------------------===//

5163/// This class represents a no-op cast from one type to another.
5164class BitCastInst : public CastInst {
5165protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical BitCastInst.
BitCastInst *cloneImpl() const;

5172public:
/// Constructor with insert-before-instruction semantics
BitCastInst(
  Value *S,                           ///< The value to be casted
  Type *Ty,                           ///< The type to casted to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
BitCastInst(
  Value *S,                     ///< The value to be casted
  Type *Ty,                     ///< The type to casted to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == BitCast;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
5196};

5198//===----------------------------------------------------------------------===//
5199//                          AddrSpaceCastInst Class
5200//===----------------------------------------------------------------------===//

5202/// This class represents a conversion between pointers from one address space
5203/// to another.
5204class AddrSpaceCastInst : public CastInst {
5205protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical AddrSpaceCastInst.
AddrSpaceCastInst *cloneImpl() const;

5212public:
/// Constructor with insert-before-instruction semantics
AddrSpaceCastInst(
  Value *S,                           ///< The value to be casted
  Type *Ty,                           ///< The type to casted to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
AddrSpaceCastInst(
  Value *S,                     ///< The value to be casted
  Type *Ty,                     ///< The type to casted to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == AddrSpaceCast;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

/// Gets the pointer operand.
Value *getPointerOperand() {
  return getOperand(0);
}

/// Gets the pointer operand.
const Value *getPointerOperand() const {
  return getOperand(0);
}

/// Gets the operand index of the pointer operand.
static unsigned getPointerOperandIndex() {
  return 0U;
}

/// Returns the address space of the pointer operand.
unsigned getSrcAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

/// Returns the address space of the result.
unsigned getDestAddressSpace() const {
  return getType()->getPointerAddressSpace();
}
5261};

5263/// A helper function that returns the pointer operand of a load or store
5264/// instruction. Returns nullptr if not load or store.
5265inline const Value *getLoadStorePointerOperand(const Value *V) {
if (auto *Load = dyn_cast<LoadInst>(V))
  return Load->getPointerOperand();
if (auto *Store = dyn_cast<StoreInst>(V))
  return Store->getPointerOperand();
return nullptr;
5271}
5272inline Value *getLoadStorePointerOperand(Value *V) {
return const_cast<Value *>(
    getLoadStorePointerOperand(static_cast<const Value *>(V)));
5275}

5277/// A helper function that returns the pointer operand of a load, store
5278/// or GEP instruction. Returns nullptr if not load, store, or GEP.
5279inline const Value *getPointerOperand(const Value *V) {
if (auto *Ptr = getLoadStorePointerOperand(V))
  return Ptr;
if (auto *Gep = dyn_cast<GetElementPtrInst>(V))
  return Gep->getPointerOperand();
return nullptr;
5285}
5286inline Value *getPointerOperand(Value *V) {
return const_cast<Value *>(getPointerOperand(static_cast<const Value *>(V)));
5288}

5290/// A helper function that returns the alignment of load or store instruction.
5291inline Align getLoadStoreAlignment(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&((void)0)
       "Expected Load or Store instruction")((void)0);
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getAlign();
return cast<StoreInst>(I)->getAlign();
5297}

5299/// A helper function that returns the address space of the pointer operand of
5300/// load or store instruction.
5301inline unsigned getLoadStoreAddressSpace(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&((void)0)
       "Expected Load or Store instruction")((void)0);
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getPointerAddressSpace();
return cast<StoreInst>(I)->getPointerAddressSpace();
5307}

5309/// A helper function that returns the type of a load or store instruction.
5310inline Type *getLoadStoreType(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&((void)0)
       "Expected Load or Store instruction")((void)0);
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getType();
return cast<StoreInst>(I)->getValueOperand()->getType();
5316}

5318//===----------------------------------------------------------------------===//
5319//                              FreezeInst Class
5320//===----------------------------------------------------------------------===//

5322/// This class represents a freeze function that returns random concrete
5323/// value if an operand is either a poison value or an undef value
5324class FreezeInst : public UnaryInstruction {
5325protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FreezeInst
FreezeInst *cloneImpl() const;

5332public:
explicit FreezeInst(Value *S,
                    const Twine &NameStr = "",
                    Instruction *InsertBefore = nullptr);
FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd);

// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Instruction *I) {
  return I->getOpcode() == Freeze;
}
static inline bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
5345};

5347} // end namespace llvm

5349#endif // LLVM_IR_INSTRUCTIONS_H