/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	//===----------------------------------------------------------------------===//
13
14	#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
15	#define LLVM_CLANG_AST_ASTCONTEXT_H
16
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>
76
77	namespace llvm {
78
79	class APFixedPoint;
80	class FixedPointSemantics;
81	struct fltSemantics;
82	template <typename T, unsigned N> class SmallPtrSet;
83
84	} // namespace llvm
85
86	namespace clang {
87
88	class APValue;
89	class ASTMutationListener;
90	class ASTRecordLayout;
91	class AtomicExpr;
92	class BlockExpr;
93	class BuiltinTemplateDecl;
94	class CharUnits;
95	class ConceptDecl;
96	class CXXABI;
97	class CXXConstructorDecl;
98	class CXXMethodDecl;
99	class CXXRecordDecl;
100	class DiagnosticsEngine;
101	class ParentMapContext;
102	class DynTypedNode;
103	class DynTypedNodeList;
104	class Expr;
105	class GlobalDecl;
106	class ItaniumMangleContext;
107	class MangleContext;
108	class MangleNumberingContext;
109	class MaterializeTemporaryExpr;
110	class MemberSpecializationInfo;
111	class Module;
112	struct MSGuidDeclParts;
113	class ObjCCategoryDecl;
114	class ObjCCategoryImplDecl;
115	class ObjCContainerDecl;
116	class ObjCImplDecl;
117	class ObjCImplementationDecl;
118	class ObjCInterfaceDecl;
119	class ObjCIvarDecl;
120	class ObjCMethodDecl;
121	class ObjCPropertyDecl;
122	class ObjCPropertyImplDecl;
123	class ObjCProtocolDecl;
124	class ObjCTypeParamDecl;
125	class OMPTraitInfo;
126	struct ParsedTargetAttr;
127	class Preprocessor;
128	class Stmt;
129	class StoredDeclsMap;
130	class TargetAttr;
131	class TargetInfo;
132	class TemplateDecl;
133	class TemplateParameterList;
134	class TemplateTemplateParmDecl;
135	class TemplateTypeParmDecl;
136	class UnresolvedSetIterator;
137	class UsingShadowDecl;
138	class VarTemplateDecl;
139	class VTableContextBase;
140	struct BlockVarCopyInit;
141
142	namespace Builtin {
143
144	class Context;
145
146	} // namespace Builtin
147
148	enum BuiltinTemplateKind : int;
149	enum OpenCLTypeKind : uint8_t;
150
151	namespace comments {
152
153	class FullComment;
154
155	} // namespace comments
156
157	namespace interp {
158
159	class Context;
160
161	} // namespace interp
162
163	namespace serialization {
164	template <class> class AbstractTypeReader;
165	} // namespace serialization
166
167	struct TypeInfo {
168	uint64_t Width = 0;
169	unsigned Align = 0;
170	bool AlignIsRequired : 1;
171
172	TypeInfo() : AlignIsRequired(false) {}
173	TypeInfo(uint64_t Width, unsigned Align, bool AlignIsRequired)
174	: Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
175	};
176
177	struct TypeInfoChars {
178	CharUnits Width;
179	CharUnits Align;
180	bool AlignIsRequired : 1;
181
182	TypeInfoChars() : AlignIsRequired(false) {}
183	TypeInfoChars(CharUnits Width, CharUnits Align, bool AlignIsRequired)
184	: Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
185	};
186
187	/// Holds long-lived AST nodes (such as types and decls) that can be
188	/// referred to throughout the semantic analysis of a file.
189	class ASTContext : public RefCountedBase<ASTContext> {
190	friend class NestedNameSpecifier;
191
192	mutable SmallVector<Type *, 0> Types;
193	mutable llvm::FoldingSet<ExtQuals> ExtQualNodes;
194	mutable llvm::FoldingSet<ComplexType> ComplexTypes;
195	mutable llvm::FoldingSet<PointerType> PointerTypes;
196	mutable llvm::FoldingSet<AdjustedType> AdjustedTypes;
197	mutable llvm::FoldingSet<BlockPointerType> BlockPointerTypes;
198	mutable llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;
199	mutable llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;
200	mutable llvm::FoldingSet<MemberPointerType> MemberPointerTypes;
201	mutable llvm::ContextualFoldingSet<ConstantArrayType, ASTContext &>
202	ConstantArrayTypes;
203	mutable llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;
204	mutable std::vector<VariableArrayType*> VariableArrayTypes;
205	mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;
206	mutable llvm::FoldingSet<DependentSizedExtVectorType>
207	DependentSizedExtVectorTypes;
208	mutable llvm::FoldingSet<DependentAddressSpaceType>
209	DependentAddressSpaceTypes;
210	mutable llvm::FoldingSet<VectorType> VectorTypes;
211	mutable llvm::FoldingSet<DependentVectorType> DependentVectorTypes;
212	mutable llvm::FoldingSet<ConstantMatrixType> MatrixTypes;
213	mutable llvm::FoldingSet<DependentSizedMatrixType> DependentSizedMatrixTypes;
214	mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
215	mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>
216	FunctionProtoTypes;
217	mutable llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;
218	mutable llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;
219	mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
220	mutable llvm::FoldingSet<ObjCTypeParamType> ObjCTypeParamTypes;
221	mutable llvm::FoldingSet<SubstTemplateTypeParmType>
222	SubstTemplateTypeParmTypes;
223	mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>
224	SubstTemplateTypeParmPackTypes;
225	mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>
226	TemplateSpecializationTypes;
227	mutable llvm::FoldingSet<ParenType> ParenTypes;
228	mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes;
229	mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;
230	mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,
231	ASTContext&>
232	DependentTemplateSpecializationTypes;
233	llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
234	mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;
235	mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
236	mutable llvm::FoldingSet<DependentUnaryTransformType>
237	DependentUnaryTransformTypes;
238	mutable llvm::ContextualFoldingSet<AutoType, ASTContext&> AutoTypes;
239	mutable llvm::FoldingSet<DeducedTemplateSpecializationType>
240	DeducedTemplateSpecializationTypes;
241	mutable llvm::FoldingSet<AtomicType> AtomicTypes;
242	llvm::FoldingSet<AttributedType> AttributedTypes;
243	mutable llvm::FoldingSet<PipeType> PipeTypes;
244	mutable llvm::FoldingSet<ExtIntType> ExtIntTypes;
245	mutable llvm::FoldingSet<DependentExtIntType> DependentExtIntTypes;
246
247	mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
248	mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
249	mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
250	SubstTemplateTemplateParms;
251	mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
252	ASTContext&>
253	SubstTemplateTemplateParmPacks;
254
255	/// The set of nested name specifiers.
256	///
257	/// This set is managed by the NestedNameSpecifier class.
258	mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
259	mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;
260
261	/// A cache mapping from RecordDecls to ASTRecordLayouts.
262	///
263	/// This is lazily created. This is intentionally not serialized.
264	mutable llvm::DenseMap<const RecordDecl, const ASTRecordLayout>
265	ASTRecordLayouts;
266	mutable llvm::DenseMap<const ObjCContainerDecl, const ASTRecordLayout>
267	ObjCLayouts;
268
269	/// A cache from types to size and alignment information.
270	using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
271	mutable TypeInfoMap MemoizedTypeInfo;
272
273	/// A cache from types to unadjusted alignment information. Only ARM and
274	/// AArch64 targets need this information, keeping it separate prevents
275	/// imposing overhead on TypeInfo size.
276	using UnadjustedAlignMap = llvm::DenseMap<const Type *, unsigned>;
277	mutable UnadjustedAlignMap MemoizedUnadjustedAlign;
278
279	/// A cache mapping from CXXRecordDecls to key functions.
280	llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;
281
282	/// Mapping from ObjCContainers to their ObjCImplementations.
283	llvm::DenseMap<ObjCContainerDecl, ObjCImplDecl> ObjCImpls;
284
285	/// Mapping from ObjCMethod to its duplicate declaration in the same
286	/// interface.
287	llvm::DenseMap<const ObjCMethodDecl,const ObjCMethodDecl> ObjCMethodRedecls;
288
289	/// Mapping from __block VarDecls to BlockVarCopyInit.
290	llvm::DenseMap<const VarDecl *, BlockVarCopyInit> BlockVarCopyInits;
291
292	/// Mapping from GUIDs to the corresponding MSGuidDecl.
293	mutable llvm::FoldingSet<MSGuidDecl> MSGuidDecls;
294
295	/// Mapping from APValues to the corresponding TemplateParamObjects.
296	mutable llvm::FoldingSet<TemplateParamObjectDecl> TemplateParamObjectDecls;
297
298	/// A cache mapping a string value to a StringLiteral object with the same
299	/// value.
300	///
301	/// This is lazily created. This is intentionally not serialized.
302	mutable llvm::StringMap<StringLiteral *> StringLiteralCache;
303
304	/// MD5 hash of CUID. It is calculated when first used and cached by this
305	/// data member.
306	mutable std::string CUIDHash;
307
308	/// Representation of a "canonical" template template parameter that
309	/// is used in canonical template names.
310	class CanonicalTemplateTemplateParm : public llvm::FoldingSetNode {
311	TemplateTemplateParmDecl *Parm;
312
313	public:
314	CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm)
315	: Parm(Parm) {}
316
317	TemplateTemplateParmDecl *getParam() const { return Parm; }
318
319	void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) {
320	Profile(ID, C, Parm);
321	}
322
323	static void Profile(llvm::FoldingSetNodeID &ID,
324	const ASTContext &C,
325	TemplateTemplateParmDecl *Parm);
326	};
327	mutable llvm::ContextualFoldingSet<CanonicalTemplateTemplateParm,
328	const ASTContext&>
329	CanonTemplateTemplateParms;
330
331	TemplateTemplateParmDecl *
332	getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const;
333
334	/// The typedef for the __int128_t type.
335	mutable TypedefDecl *Int128Decl = nullptr;
336
337	/// The typedef for the __uint128_t type.
338	mutable TypedefDecl *UInt128Decl = nullptr;
339
340	/// The typedef for the target specific predefined
341	/// __builtin_va_list type.
342	mutable TypedefDecl *BuiltinVaListDecl = nullptr;
343
344	/// The typedef for the predefined \c __builtin_ms_va_list type.
345	mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;
346
347	/// The typedef for the predefined \c id type.
348	mutable TypedefDecl *ObjCIdDecl = nullptr;
349
350	/// The typedef for the predefined \c SEL type.
351	mutable TypedefDecl *ObjCSelDecl = nullptr;
352
353	/// The typedef for the predefined \c Class type.
354	mutable TypedefDecl *ObjCClassDecl = nullptr;
355
356	/// The typedef for the predefined \c Protocol class in Objective-C.
357	mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;
358
359	/// The typedef for the predefined 'BOOL' type.
360	mutable TypedefDecl *BOOLDecl = nullptr;
361
362	// Typedefs which may be provided defining the structure of Objective-C
363	// pseudo-builtins
364	QualType ObjCIdRedefinitionType;
365	QualType ObjCClassRedefinitionType;
366	QualType ObjCSelRedefinitionType;
367
368	/// The identifier 'bool'.
369	mutable IdentifierInfo *BoolName = nullptr;
370
371	/// The identifier 'NSObject'.
372	mutable IdentifierInfo *NSObjectName = nullptr;
373
374	/// The identifier 'NSCopying'.
375	IdentifierInfo *NSCopyingName = nullptr;
376
377	/// The identifier '__make_integer_seq'.
378	mutable IdentifierInfo *MakeIntegerSeqName = nullptr;
379
380	/// The identifier '__type_pack_element'.
381	mutable IdentifierInfo *TypePackElementName = nullptr;
382
383	QualType ObjCConstantStringType;
384	mutable RecordDecl *CFConstantStringTagDecl = nullptr;
385	mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;
386
387	mutable QualType ObjCSuperType;
388
389	QualType ObjCNSStringType;
390
391	/// The typedef declaration for the Objective-C "instancetype" type.
392	TypedefDecl *ObjCInstanceTypeDecl = nullptr;
393
394	/// The type for the C FILE type.
395	TypeDecl *FILEDecl = nullptr;
396
397	/// The type for the C jmp_buf type.
398	TypeDecl *jmp_bufDecl = nullptr;
399
400	/// The type for the C sigjmp_buf type.
401	TypeDecl *sigjmp_bufDecl = nullptr;
402
403	/// The type for the C ucontext_t type.
404	TypeDecl *ucontext_tDecl = nullptr;
405
406	/// Type for the Block descriptor for Blocks CodeGen.
407	///
408	/// Since this is only used for generation of debug info, it is not
409	/// serialized.
410	mutable RecordDecl *BlockDescriptorType = nullptr;
411
412	/// Type for the Block descriptor for Blocks CodeGen.
413	///
414	/// Since this is only used for generation of debug info, it is not
415	/// serialized.
416	mutable RecordDecl *BlockDescriptorExtendedType = nullptr;
417
418	/// Declaration for the CUDA cudaConfigureCall function.
419	FunctionDecl *cudaConfigureCallDecl = nullptr;
420
421	/// Keeps track of all declaration attributes.
422	///
423	/// Since so few decls have attrs, we keep them in a hash map instead of
424	/// wasting space in the Decl class.
425	llvm::DenseMap<const Decl, AttrVec> DeclAttrs;
426
427	/// A mapping from non-redeclarable declarations in modules that were
428	/// merged with other declarations to the canonical declaration that they were
429	/// merged into.
430	llvm::DenseMap<Decl, Decl> MergedDecls;
431
432	/// A mapping from a defining declaration to a list of modules (other
433	/// than the owning module of the declaration) that contain merged
434	/// definitions of that entity.
435	llvm::DenseMap<NamedDecl, llvm::TinyPtrVector<Module>> MergedDefModules;
436
437	/// Initializers for a module, in order. Each Decl will be either
438	/// something that has a semantic effect on startup (such as a variable with
439	/// a non-constant initializer), or an ImportDecl (which recursively triggers
440	/// initialization of another module).
441	struct PerModuleInitializers {
442	llvm::SmallVector<Decl*, 4> Initializers;
443	llvm::SmallVector<uint32_t, 4> LazyInitializers;
444
445	void resolve(ASTContext &Ctx);
446	};
447	llvm::DenseMap<Module, PerModuleInitializers> ModuleInitializers;
448
449	ASTContext &this_() { return *this; }
450
451	public:
452	/// A type synonym for the TemplateOrInstantiation mapping.
453	using TemplateOrSpecializationInfo =
454	llvm::PointerUnion<VarTemplateDecl , MemberSpecializationInfo >;
455
456	private:
457	friend class ASTDeclReader;
458	friend class ASTReader;
459	friend class ASTWriter;
460	template <class> friend class serialization::AbstractTypeReader;
461	friend class CXXRecordDecl;
462	friend class IncrementalParser;
463
464	/// A mapping to contain the template or declaration that
465	/// a variable declaration describes or was instantiated from,
466	/// respectively.
467	///
468	/// For non-templates, this value will be NULL. For variable
469	/// declarations that describe a variable template, this will be a
470	/// pointer to a VarTemplateDecl. For static data members
471	/// of class template specializations, this will be the
472	/// MemberSpecializationInfo referring to the member variable that was
473	/// instantiated or specialized. Thus, the mapping will keep track of
474	/// the static data member templates from which static data members of
475	/// class template specializations were instantiated.
476	///
477	/// Given the following example:
478	///
479	/// \code
480	/// template<typename T>
481	/// struct X {
482	/// static T value;
483	/// };
484	///
485	/// template<typename T>
486	/// T X<T>::value = T(17);
487	///
488	/// int *x = &X<int>::value;
489	/// \endcode
490	///
491	/// This mapping will contain an entry that maps from the VarDecl for
492	/// X<int>::value to the corresponding VarDecl for X<T>::value (within the
493	/// class template X) and will be marked TSK_ImplicitInstantiation.
494	llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
495	TemplateOrInstantiation;
496
497	/// Keeps track of the declaration from which a using declaration was
498	/// created during instantiation.
499	///
500	/// The source and target declarations are always a UsingDecl, an
501	/// UnresolvedUsingValueDecl, or an UnresolvedUsingTypenameDecl.
502	///
503	/// For example:
504	/// \code
505	/// template<typename T>
506	/// struct A {
507	/// void f();
508	/// };
509	///
510	/// template<typename T>
511	/// struct B : A<T> {
512	/// using A<T>::f;
513	/// };
514	///
515	/// template struct B<int>;
516	/// \endcode
517	///
518	/// This mapping will contain an entry that maps from the UsingDecl in
519	/// B<int> to the UnresolvedUsingDecl in B<T>.
520	llvm::DenseMap<NamedDecl , NamedDecl > InstantiatedFromUsingDecl;
521
522	/// Like InstantiatedFromUsingDecl, but for using-enum-declarations. Maps
523	/// from the instantiated using-enum to the templated decl from whence it
524	/// came.
525	/// Note that using-enum-declarations cannot be dependent and
526	/// thus will never be instantiated from an "unresolved"
527	/// version thereof (as with using-declarations), so each mapping is from
528	/// a (resolved) UsingEnumDecl to a (resolved) UsingEnumDecl.
529	llvm::DenseMap<UsingEnumDecl , UsingEnumDecl >
530	InstantiatedFromUsingEnumDecl;
531
532	/// Simlarly maps instantiated UsingShadowDecls to their origin.
533	llvm::DenseMap<UsingShadowDecl, UsingShadowDecl>
534	InstantiatedFromUsingShadowDecl;
535
536	llvm::DenseMap<FieldDecl , FieldDecl > InstantiatedFromUnnamedFieldDecl;
537
538	/// Mapping that stores the methods overridden by a given C++
539	/// member function.
540	///
541	/// Since most C++ member functions aren't virtual and therefore
542	/// don't override anything, we store the overridden functions in
543	/// this map on the side rather than within the CXXMethodDecl structure.
544	using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>;
545	llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;
546
547	/// Mapping from each declaration context to its corresponding
548	/// mangling numbering context (used for constructs like lambdas which
549	/// need to be consistently numbered for the mangler).
550	llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>
551	MangleNumberingContexts;
552	llvm::DenseMap<const Decl *, std::unique_ptr<MangleNumberingContext>>
553	ExtraMangleNumberingContexts;
554
555	/// Side-table of mangling numbers for declarations which rarely
556	/// need them (like static local vars).
557	llvm::MapVector<const NamedDecl *, unsigned> MangleNumbers;
558	llvm::MapVector<const VarDecl *, unsigned> StaticLocalNumbers;
559	/// Mapping the associated device lambda mangling number if present.
560	mutable llvm::DenseMap<const CXXRecordDecl *, unsigned>
561	DeviceLambdaManglingNumbers;
562
563	/// Mapping that stores parameterIndex values for ParmVarDecls when
564	/// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex.
565	using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;
566	ParameterIndexTable ParamIndices;
567
568	ImportDecl *FirstLocalImport = nullptr;
569	ImportDecl *LastLocalImport = nullptr;
570
571	TranslationUnitDecl *TUDecl = nullptr;
572	mutable ExternCContextDecl *ExternCContext = nullptr;
573	mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
574	mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;
575
576	/// The associated SourceManager object.
577	SourceManager &SourceMgr;
578
579	/// The language options used to create the AST associated with
580	/// this ASTContext object.
581	LangOptions &LangOpts;
582
583	/// NoSanitizeList object that is used by sanitizers to decide which
584	/// entities should not be instrumented.
585	std::unique_ptr<NoSanitizeList> NoSanitizeL;
586
587	/// Function filtering mechanism to determine whether a given function
588	/// should be imbued with the XRay "always" or "never" attributes.
589	std::unique_ptr<XRayFunctionFilter> XRayFilter;
590
591	/// ProfileList object that is used by the profile instrumentation
592	/// to decide which entities should be instrumented.
593	std::unique_ptr<ProfileList> ProfList;
594
595	/// The allocator used to create AST objects.
596	///
597	/// AST objects are never destructed; rather, all memory associated with the
598	/// AST objects will be released when the ASTContext itself is destroyed.
599	mutable llvm::BumpPtrAllocator BumpAlloc;
600
601	/// Allocator for partial diagnostics.
602	PartialDiagnostic::DiagStorageAllocator DiagAllocator;
603
604	/// The current C++ ABI.
605	std::unique_ptr<CXXABI> ABI;
606	CXXABI *createCXXABI(const TargetInfo &T);
607
608	/// The logical -> physical address space map.
609	const LangASMap *AddrSpaceMap = nullptr;
610
611	/// Address space map mangling must be used with language specific
612	/// address spaces (e.g. OpenCL/CUDA)
613	bool AddrSpaceMapMangling;
614
615	const TargetInfo *Target = nullptr;
616	const TargetInfo *AuxTarget = nullptr;
617	clang::PrintingPolicy PrintingPolicy;
618	std::unique_ptr<interp::Context> InterpContext;
619	std::unique_ptr<ParentMapContext> ParentMapCtx;
620
621	/// Keeps track of the deallocated DeclListNodes for future reuse.
622	DeclListNode *ListNodeFreeList = nullptr;
623
624	public:
625	IdentifierTable &Idents;
626	SelectorTable &Selectors;
627	Builtin::Context &BuiltinInfo;
628	const TranslationUnitKind TUKind;
629	mutable DeclarationNameTable DeclarationNames;
630	IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;
631	ASTMutationListener *Listener = nullptr;
632
633	/// Returns the clang bytecode interpreter context.
634	interp::Context &getInterpContext();
635
636	/// Returns the dynamic AST node parent map context.
637	ParentMapContext &getParentMapContext();
638
639	// A traversal scope limits the parts of the AST visible to certain analyses.
640	// RecursiveASTVisitor only visits specified children of TranslationUnitDecl.
641	// getParents() will only observe reachable parent edges.
642	//
643	// The scope is defined by a set of "top-level" declarations which will be
644	// visible under the TranslationUnitDecl.
645	// Initially, it is the entire TU, represented by {getTranslationUnitDecl()}.
646	//
647	// After setTraversalScope({foo, bar}), the exposed AST looks like:
648	// TranslationUnitDecl
649	// - foo
650	// - ...
651	// - bar
652	// - ...
653	// All other siblings of foo and bar are pruned from the tree.
654	// (However they are still accessible via TranslationUnitDecl->decls())
655	//
656	// Changing the scope clears the parent cache, which is expensive to rebuild.
657	std::vector<Decl *> getTraversalScope() const { return TraversalScope; }
658	void setTraversalScope(const std::vector<Decl *> &);
659
660	/// Forwards to get node parents from the ParentMapContext. New callers should
661	/// use ParentMapContext::getParents() directly.
662	template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);
663
664	const clang::PrintingPolicy &getPrintingPolicy() const {
665	return PrintingPolicy;
666	}
667
668	void setPrintingPolicy(const clang::PrintingPolicy &Policy) {
669	PrintingPolicy = Policy;
670	}
671
672	SourceManager& getSourceManager() { return SourceMgr; }
673	const SourceManager& getSourceManager() const { return SourceMgr; }
674
675	llvm::BumpPtrAllocator &getAllocator() const {
676	return BumpAlloc;
677	}
678
679	void *Allocate(size_t Size, unsigned Align = 8) const {
680	return BumpAlloc.Allocate(Size, Align);
681	}
682	template <typename T> T *Allocate(size_t Num = 1) const {
683	return static_cast<T >(Allocate(Num sizeof(T), alignof(T)));
684	}
685	void Deallocate(void *Ptr) const {}
686
687	/// Allocates a \c DeclListNode or returns one from the \c ListNodeFreeList
688	/// pool.
689	DeclListNode AllocateDeclListNode(clang::NamedDecl ND) {
690	if (DeclListNode *Alloc = ListNodeFreeList) {
691	ListNodeFreeList = Alloc->Rest.dyn_cast<DeclListNode*>();
692	Alloc->D = ND;
693	Alloc->Rest = nullptr;
694	return Alloc;
695	}
696	return new (*this) DeclListNode(ND);
697	}
698	/// Deallcates a \c DeclListNode by returning it to the \c ListNodeFreeList
699	/// pool.
700	void DeallocateDeclListNode(DeclListNode *N) {
701	N->Rest = ListNodeFreeList;
702	ListNodeFreeList = N;
703	}
704
705	/// Return the total amount of physical memory allocated for representing
706	/// AST nodes and type information.
707	size_t getASTAllocatedMemory() const {
708	return BumpAlloc.getTotalMemory();
709	}
710
711	/// Return the total memory used for various side tables.
712	size_t getSideTableAllocatedMemory() const;
713
714	PartialDiagnostic::DiagStorageAllocator &getDiagAllocator() {
715	return DiagAllocator;
716	}
717
718	const TargetInfo &getTargetInfo() const { return *Target; }
719	const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }
720
721	/// getIntTypeForBitwidth -
722	/// sets integer QualTy according to specified details:
723	/// bitwidth, signed/unsigned.
724	/// Returns empty type if there is no appropriate target types.
725	QualType getIntTypeForBitwidth(unsigned DestWidth,
726	unsigned Signed) const;
727
728	/// getRealTypeForBitwidth -
729	/// sets floating point QualTy according to specified bitwidth.
730	/// Returns empty type if there is no appropriate target types.
731	QualType getRealTypeForBitwidth(unsigned DestWidth, bool ExplicitIEEE) const;
732
733	bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const;
734
735	const LangOptions& getLangOpts() const { return LangOpts; }
736
737	// If this condition is false, typo correction must be performed eagerly
738	// rather than delayed in many places, as it makes use of dependent types.
739	// the condition is false for clang's C-only codepath, as it doesn't support
740	// dependent types yet.
741	bool isDependenceAllowed() const {
742	return LangOpts.CPlusPlus \|\| LangOpts.RecoveryAST;
743	}
744
745	const NoSanitizeList &getNoSanitizeList() const { return *NoSanitizeL; }
746
747	const XRayFunctionFilter &getXRayFilter() const {
748	return *XRayFilter;
749	}
750
751	const ProfileList &getProfileList() const { return *ProfList; }
752
753	DiagnosticsEngine &getDiagnostics() const;
754
755	FullSourceLoc getFullLoc(SourceLocation Loc) const {
756	return FullSourceLoc(Loc,SourceMgr);
757	}
758
759	/// Return the C++ ABI kind that should be used. The C++ ABI can be overriden
760	/// at compile time with `-fc++-abi=`. If this is not provided, we instead use
761	/// the default ABI set by the target.
762	TargetCXXABI::Kind getCXXABIKind() const;
763
764	/// All comments in this translation unit.
765	RawCommentList Comments;
766
767	/// True if comments are already loaded from ExternalASTSource.
768	mutable bool CommentsLoaded = false;
769
770	/// Mapping from declaration to directly attached comment.
771	///
772	/// Raw comments are owned by Comments list. This mapping is populated
773	/// lazily.
774	mutable llvm::DenseMap<const Decl , const RawComment > DeclRawComments;
775
776	/// Mapping from canonical declaration to the first redeclaration in chain
777	/// that has a comment attached.
778	///
779	/// Raw comments are owned by Comments list. This mapping is populated
780	/// lazily.
781	mutable llvm::DenseMap<const Decl , const Decl > RedeclChainComments;
782
783	/// Keeps track of redeclaration chains that don't have any comment attached.
784	/// Mapping from canonical declaration to redeclaration chain that has no
785	/// comments attached to any redeclaration. Specifically it's mapping to
786	/// the last redeclaration we've checked.
787	///
788	/// Shall not contain declarations that have comments attached to any
789	/// redeclaration in their chain.
790	mutable llvm::DenseMap<const Decl , const Decl > CommentlessRedeclChains;
791
792	/// Mapping from declarations to parsed comments attached to any
793	/// redeclaration.
794	mutable llvm::DenseMap<const Decl , comments::FullComment > ParsedComments;
795
796	/// Attaches \p Comment to \p OriginalD and to its redeclaration chain
797	/// and removes the redeclaration chain from the set of commentless chains.
798	///
799	/// Don't do anything if a comment has already been attached to \p OriginalD
800	/// or its redeclaration chain.
801	void cacheRawCommentForDecl(const Decl &OriginalD,
802	const RawComment &Comment) const;
803
804	/// \returns searches \p CommentsInFile for doc comment for \p D.
805	///
806	/// \p RepresentativeLocForDecl is used as a location for searching doc
807	/// comments. \p CommentsInFile is a mapping offset -> comment of files in the
808	/// same file where \p RepresentativeLocForDecl is.
809	RawComment *getRawCommentForDeclNoCacheImpl(
810	const Decl *D, const SourceLocation RepresentativeLocForDecl,
811	const std::map<unsigned, RawComment *> &CommentsInFile) const;
812
813	/// Return the documentation comment attached to a given declaration,
814	/// without looking into cache.
815	RawComment getRawCommentForDeclNoCache(const Decl D) const;
816
817	public:
818	void addComment(const RawComment &RC);
819
820	/// Return the documentation comment attached to a given declaration.
821	/// Returns nullptr if no comment is attached.
822	///
823	/// \param OriginalDecl if not nullptr, is set to declaration AST node that
824	/// had the comment, if the comment we found comes from a redeclaration.
825	const RawComment *
826	getRawCommentForAnyRedecl(const Decl *D,
827	const Decl **OriginalDecl = nullptr) const;
828
829	/// Searches existing comments for doc comments that should be attached to \p
830	/// Decls. If any doc comment is found, it is parsed.
831	///
832	/// Requirement: All \p Decls are in the same file.
833	///
834	/// If the last comment in the file is already attached we assume
835	/// there are not comments left to be attached to \p Decls.
836	void attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls,
837	const Preprocessor *PP);
838
839	/// Return parsed documentation comment attached to a given declaration.
840	/// Returns nullptr if no comment is attached.
841	///
842	/// \param PP the Preprocessor used with this TU. Could be nullptr if
843	/// preprocessor is not available.
844	comments::FullComment getCommentForDecl(const Decl D,
845	const Preprocessor *PP) const;
846
847	/// Return parsed documentation comment attached to a given declaration.
848	/// Returns nullptr if no comment is attached. Does not look at any
849	/// redeclarations of the declaration.
850	comments::FullComment getLocalCommentForDeclUncached(const Decl D) const;
851
852	comments::FullComment cloneFullComment(comments::FullComment FC,
853	const Decl *D) const;
854
855	private: