/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp

Bug Summary

File:	tools/clang/lib/CodeGen/CGAtomic.cpp
Warning:	line 972, column 17 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

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

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp

→

1//===--- CGAtomic.cpp - Emit LLVM IR for atomic operations ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the code for emitting atomic operations.
10//
11//===----------------------------------------------------------------------===//

13#include "CGCall.h"
14#include "CGRecordLayout.h"
15#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
17#include "TargetInfo.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/CodeGen/CGFunctionInfo.h"
20#include "clang/Frontend/FrontendDiagnostic.h"
21#include "llvm/ADT/DenseMap.h"
22#include "llvm/IR/DataLayout.h"
23#include "llvm/IR/Intrinsics.h"
24#include "llvm/IR/Operator.h"

26using namespace clang;
27using namespace CodeGen;

29namespace {
class AtomicInfo {
  CodeGenFunction &CGF;
  QualType AtomicTy;
  QualType ValueTy;
  uint64_t AtomicSizeInBits;
  uint64_t ValueSizeInBits;
  CharUnits AtomicAlign;
  CharUnits ValueAlign;
  TypeEvaluationKind EvaluationKind;
  bool UseLibcall;
  LValue LVal;
  CGBitFieldInfo BFI;
public:
  AtomicInfo(CodeGenFunction &CGF, LValue &lvalue)
      : CGF(CGF), AtomicSizeInBits(0), ValueSizeInBits(0),
        EvaluationKind(TEK_Scalar), UseLibcall(true) {
    assert(!lvalue.isGlobalReg())((!lvalue.isGlobalReg()) ? static_cast<void> (0) : __assert_fail
 ("!lvalue.isGlobalReg()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 46, __PRETTY_FUNCTION__));
    ASTContext &C = CGF.getContext();
    if (lvalue.isSimple()) {
      AtomicTy = lvalue.getType();
      if (auto *ATy = AtomicTy->getAs<AtomicType>())
        ValueTy = ATy->getValueType();
      else
        ValueTy = AtomicTy;
      EvaluationKind = CGF.getEvaluationKind(ValueTy);

      uint64_t ValueAlignInBits;
      uint64_t AtomicAlignInBits;
      TypeInfo ValueTI = C.getTypeInfo(ValueTy);
      ValueSizeInBits = ValueTI.Width;
      ValueAlignInBits = ValueTI.Align;

      TypeInfo AtomicTI = C.getTypeInfo(AtomicTy);
      AtomicSizeInBits = AtomicTI.Width;
      AtomicAlignInBits = AtomicTI.Align;

      assert(ValueSizeInBits <= AtomicSizeInBits)((ValueSizeInBits <= AtomicSizeInBits) ? static_cast<void
> (0) : __assert_fail ("ValueSizeInBits <= AtomicSizeInBits"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 66, __PRETTY_FUNCTION__));
      assert(ValueAlignInBits <= AtomicAlignInBits)((ValueAlignInBits <= AtomicAlignInBits) ? static_cast<
void> (0) : __assert_fail ("ValueAlignInBits <= AtomicAlignInBits"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 67, __PRETTY_FUNCTION__));

      AtomicAlign = C.toCharUnitsFromBits(AtomicAlignInBits);
      ValueAlign = C.toCharUnitsFromBits(ValueAlignInBits);
      if (lvalue.getAlignment().isZero())
        lvalue.setAlignment(AtomicAlign);

      LVal = lvalue;
    } else if (lvalue.isBitField()) {
      ValueTy = lvalue.getType();
      ValueSizeInBits = C.getTypeSize(ValueTy);
      auto &OrigBFI = lvalue.getBitFieldInfo();
      auto Offset = OrigBFI.Offset % C.toBits(lvalue.getAlignment());
      AtomicSizeInBits = C.toBits(
          C.toCharUnitsFromBits(Offset + OrigBFI.Size + C.getCharWidth() - 1)
              .alignTo(lvalue.getAlignment()));
      auto VoidPtrAddr = CGF.EmitCastToVoidPtr(lvalue.getBitFieldPointer());
      auto OffsetInChars =
          (C.toCharUnitsFromBits(OrigBFI.Offset) / lvalue.getAlignment()) *
          lvalue.getAlignment();
      VoidPtrAddr = CGF.Builder.CreateConstGEP1_64(
          VoidPtrAddr, OffsetInChars.getQuantity());
      auto Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
          VoidPtrAddr,
          CGF.Builder.getIntNTy(AtomicSizeInBits)->getPointerTo(),
          "atomic_bitfield_base");
      BFI = OrigBFI;
      BFI.Offset = Offset;
      BFI.StorageSize = AtomicSizeInBits;
      BFI.StorageOffset += OffsetInChars;
      LVal = LValue::MakeBitfield(Address(Addr, lvalue.getAlignment()),
                                  BFI, lvalue.getType(), lvalue.getBaseInfo(),
                                  lvalue.getTBAAInfo());
      AtomicTy = C.getIntTypeForBitwidth(AtomicSizeInBits, OrigBFI.IsSigned);
      if (AtomicTy.isNull()) {
        llvm::APInt Size(
            /*numBits=*/32,
            C.toCharUnitsFromBits(AtomicSizeInBits).getQuantity());
        AtomicTy = C.getConstantArrayType(C.CharTy, Size, ArrayType::Normal,
                                          /*IndexTypeQuals=*/0);
      }
      AtomicAlign = ValueAlign = lvalue.getAlignment();
    } else if (lvalue.isVectorElt()) {
      ValueTy = lvalue.getType()->castAs<VectorType>()->getElementType();
      ValueSizeInBits = C.getTypeSize(ValueTy);
      AtomicTy = lvalue.getType();
      AtomicSizeInBits = C.getTypeSize(AtomicTy);
      AtomicAlign = ValueAlign = lvalue.getAlignment();
      LVal = lvalue;
    } else {
      assert(lvalue.isExtVectorElt())((lvalue.isExtVectorElt()) ? static_cast<void> (0) : __assert_fail
 ("lvalue.isExtVectorElt()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 117, __PRETTY_FUNCTION__));
      ValueTy = lvalue.getType();
      ValueSizeInBits = C.getTypeSize(ValueTy);
      AtomicTy = ValueTy = CGF.getContext().getExtVectorType(
          lvalue.getType(), lvalue.getExtVectorAddress()
                                .getElementType()->getVectorNumElements());
      AtomicSizeInBits = C.getTypeSize(AtomicTy);
      AtomicAlign = ValueAlign = lvalue.getAlignment();
      LVal = lvalue;
    }
    UseLibcall = !C.getTargetInfo().hasBuiltinAtomic(
        AtomicSizeInBits, C.toBits(lvalue.getAlignment()));
  }

  QualType getAtomicType() const { return AtomicTy; }
  QualType getValueType() const { return ValueTy; }
  CharUnits getAtomicAlignment() const { return AtomicAlign; }
  uint64_t getAtomicSizeInBits() const { return AtomicSizeInBits; }
  uint64_t getValueSizeInBits() const { return ValueSizeInBits; }
  TypeEvaluationKind getEvaluationKind() const { return EvaluationKind; }
  bool shouldUseLibcall() const { return UseLibcall; }
  const LValue &getAtomicLValue() const { return LVal; }
  llvm::Value *getAtomicPointer() const {
    if (LVal.isSimple())
      return LVal.getPointer();
    else if (LVal.isBitField())
      return LVal.getBitFieldPointer();
    else if (LVal.isVectorElt())
      return LVal.getVectorPointer();
    assert(LVal.isExtVectorElt())((LVal.isExtVectorElt()) ? static_cast<void> (0) : __assert_fail
 ("LVal.isExtVectorElt()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 146, __PRETTY_FUNCTION__));
    return LVal.getExtVectorPointer();
  }
  Address getAtomicAddress() const {
    return Address(getAtomicPointer(), getAtomicAlignment());
  }

  Address getAtomicAddressAsAtomicIntPointer() const {
    return emitCastToAtomicIntPointer(getAtomicAddress());
  }

  /// Is the atomic size larger than the underlying value type?
  ///
  /// Note that the absence of padding does not mean that atomic
  /// objects are completely interchangeable with non-atomic
  /// objects: we might have promoted the alignment of a type
  /// without making it bigger.
  bool hasPadding() const {
    return (ValueSizeInBits != AtomicSizeInBits);
  }

  bool emitMemSetZeroIfNecessary() const;

  llvm::Value *getAtomicSizeValue() const {
    CharUnits size = CGF.getContext().toCharUnitsFromBits(AtomicSizeInBits);
    return CGF.CGM.getSize(size);
  }

  /// Cast the given pointer to an integer pointer suitable for atomic
  /// operations if the source.
  Address emitCastToAtomicIntPointer(Address Addr) const;

  /// If Addr is compatible with the iN that will be used for an atomic
  /// operation, bitcast it. Otherwise, create a temporary that is suitable
  /// and copy the value across.
  Address convertToAtomicIntPointer(Address Addr) const;

  /// Turn an atomic-layout object into an r-value.
  RValue convertAtomicTempToRValue(Address addr, AggValueSlot resultSlot,
                                   SourceLocation loc, bool AsValue) const;

  /// Converts a rvalue to integer value.
  llvm::Value *convertRValueToInt(RValue RVal) const;

  RValue ConvertIntToValueOrAtomic(llvm::Value *IntVal,
                                   AggValueSlot ResultSlot,
                                   SourceLocation Loc, bool AsValue) const;

  /// Copy an atomic r-value into atomic-layout memory.
  void emitCopyIntoMemory(RValue rvalue) const;

  /// Project an l-value down to the value field.
  LValue projectValue() const {
    assert(LVal.isSimple())((LVal.isSimple()) ? static_cast<void> (0) : __assert_fail
 ("LVal.isSimple()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 199, __PRETTY_FUNCTION__));
    Address addr = getAtomicAddress();
    if (hasPadding())
      addr = CGF.Builder.CreateStructGEP(addr, 0);

    return LValue::MakeAddr(addr, getValueType(), CGF.getContext(),
                            LVal.getBaseInfo(), LVal.getTBAAInfo());
  }

  /// Emits atomic load.
  /// \returns Loaded value.
  RValue EmitAtomicLoad(AggValueSlot ResultSlot, SourceLocation Loc,
                        bool AsValue, llvm::AtomicOrdering AO,
                        bool IsVolatile);

  /// Emits atomic compare-and-exchange sequence.
  /// \param Expected Expected value.
  /// \param Desired Desired value.
  /// \param Success Atomic ordering for success operation.
  /// \param Failure Atomic ordering for failed operation.
  /// \param IsWeak true if atomic operation is weak, false otherwise.
  /// \returns Pair of values: previous value from storage (value type) and
  /// boolean flag (i1 type) with true if success and false otherwise.
  std::pair<RValue, llvm::Value *>
  EmitAtomicCompareExchange(RValue Expected, RValue Desired,
                            llvm::AtomicOrdering Success =
                                llvm::AtomicOrdering::SequentiallyConsistent,
                            llvm::AtomicOrdering Failure =
                                llvm::AtomicOrdering::SequentiallyConsistent,
                            bool IsWeak = false);

  /// Emits atomic update.
  /// \param AO Atomic ordering.
  /// \param UpdateOp Update operation for the current lvalue.
  void EmitAtomicUpdate(llvm::AtomicOrdering AO,
                        const llvm::function_ref<RValue(RValue)> &UpdateOp,
                        bool IsVolatile);
  /// Emits atomic update.
  /// \param AO Atomic ordering.
  void EmitAtomicUpdate(llvm::AtomicOrdering AO, RValue UpdateRVal,
                        bool IsVolatile);

  /// Materialize an atomic r-value in atomic-layout memory.
  Address materializeRValue(RValue rvalue) const;

  /// Creates temp alloca for intermediate operations on atomic value.
  Address CreateTempAlloca() const;
private:
  bool requiresMemSetZero(llvm::Type *type) const;


  /// Emits atomic load as a libcall.
  void EmitAtomicLoadLibcall(llvm::Value *AddForLoaded,
                             llvm::AtomicOrdering AO, bool IsVolatile);
  /// Emits atomic load as LLVM instruction.
  llvm::Value *EmitAtomicLoadOp(llvm::AtomicOrdering AO, bool IsVolatile);
  /// Emits atomic compare-and-exchange op as a libcall.
  llvm::Value *EmitAtomicCompareExchangeLibcall(
      llvm::Value *ExpectedAddr, llvm::Value *DesiredAddr,
      llvm::AtomicOrdering Success =
          llvm::AtomicOrdering::SequentiallyConsistent,
      llvm::AtomicOrdering Failure =
          llvm::AtomicOrdering::SequentiallyConsistent);
  /// Emits atomic compare-and-exchange op as LLVM instruction.
  std::pair<llvm::Value *, llvm::Value *> EmitAtomicCompareExchangeOp(
      llvm::Value *ExpectedVal, llvm::Value *DesiredVal,
      llvm::AtomicOrdering Success =
          llvm::AtomicOrdering::SequentiallyConsistent,
      llvm::AtomicOrdering Failure =
          llvm::AtomicOrdering::SequentiallyConsistent,
      bool IsWeak = false);
  /// Emit atomic update as libcalls.
  void
  EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO,
                          const llvm::function_ref<RValue(RValue)> &UpdateOp,
                          bool IsVolatile);
  /// Emit atomic update as LLVM instructions.
  void EmitAtomicUpdateOp(llvm::AtomicOrdering AO,
                          const llvm::function_ref<RValue(RValue)> &UpdateOp,
                          bool IsVolatile);
  /// Emit atomic update as libcalls.
  void EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO, RValue UpdateRVal,
                               bool IsVolatile);
  /// Emit atomic update as LLVM instructions.
  void EmitAtomicUpdateOp(llvm::AtomicOrdering AO, RValue UpdateRal,
                          bool IsVolatile);
};
286}

288Address AtomicInfo::CreateTempAlloca() const {
Address TempAlloca = CGF.CreateMemTemp(
    (LVal.isBitField() && ValueSizeInBits > AtomicSizeInBits) ? ValueTy
                                                              : AtomicTy,
    getAtomicAlignment(),
    "atomic-temp");
// Cast to pointer to value type for bitfields.
if (LVal.isBitField())
  return CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
      TempAlloca, getAtomicAddress().getType());
return TempAlloca;
299}

301static RValue emitAtomicLibcall(CodeGenFunction &CGF,
                              StringRef fnName,
                              QualType resultType,
                              CallArgList &args) {
const CGFunctionInfo &fnInfo =
  CGF.CGM.getTypes().arrangeBuiltinFunctionCall(resultType, args);
llvm::FunctionType *fnTy = CGF.CGM.getTypes().GetFunctionType(fnInfo);
llvm::FunctionCallee fn = CGF.CGM.CreateRuntimeFunction(fnTy, fnName);
auto callee = CGCallee::forDirect(fn);
return CGF.EmitCall(fnInfo, callee, ReturnValueSlot(), args);
311}

313/// Does a store of the given IR type modify the full expected width?
314static bool isFullSizeType(CodeGenModule &CGM, llvm::Type *type,
                         uint64_t expectedSize) {
return (CGM.getDataLayout().getTypeStoreSize(type) * 8 == expectedSize);
317}

319/// Does the atomic type require memsetting to zero before initialization?
320///
321/// The IR type is provided as a way of making certain queries faster.
322bool AtomicInfo::requiresMemSetZero(llvm::Type *type) const {
// If the atomic type has size padding, we definitely need a memset.
if (hasPadding()) return true;

// Otherwise, do some simple heuristics to try to avoid it:
switch (getEvaluationKind()) {
// For scalars and complexes, check whether the store size of the
// type uses the full size.
case TEK_Scalar:
  return !isFullSizeType(CGF.CGM, type, AtomicSizeInBits);
case TEK_Complex:
  return !isFullSizeType(CGF.CGM, type->getStructElementType(0),
                         AtomicSizeInBits / 2);

// Padding in structs has an undefined bit pattern.  User beware.
case TEK_Aggregate:
  return false;
}
llvm_unreachable("bad evaluation kind")::llvm::llvm_unreachable_internal("bad evaluation kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 340);
341}

343bool AtomicInfo::emitMemSetZeroIfNecessary() const {
assert(LVal.isSimple())((LVal.isSimple()) ? static_cast<void> (0) : __assert_fail
 ("LVal.isSimple()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 344, __PRETTY_FUNCTION__));
llvm::Value *addr = LVal.getPointer();
if (!requiresMemSetZero(addr->getType()->getPointerElementType()))
  return false;

CGF.Builder.CreateMemSet(
    addr, llvm::ConstantInt::get(CGF.Int8Ty, 0),
    CGF.getContext().toCharUnitsFromBits(AtomicSizeInBits).getQuantity(),
    LVal.getAlignment().getQuantity());
return true;
354}

356static void emitAtomicCmpXchg(CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak,
                            Address Dest, Address Ptr,
                            Address Val1, Address Val2,
                            uint64_t Size,
                            llvm::AtomicOrdering SuccessOrder,
                            llvm::AtomicOrdering FailureOrder,
                            llvm::SyncScope::ID Scope) {
// Note that cmpxchg doesn't support weak cmpxchg, at least at the moment.
llvm::Value *Expected = CGF.Builder.CreateLoad(Val1);
llvm::Value *Desired = CGF.Builder.CreateLoad(Val2);

llvm::AtomicCmpXchgInst *Pair = CGF.Builder.CreateAtomicCmpXchg(
    Ptr.getPointer(), Expected, Desired, SuccessOrder, FailureOrder,
    Scope);
Pair->setVolatile(E->isVolatile());
Pair->setWeak(IsWeak);

// Cmp holds the result of the compare-exchange operation: true on success,
// false on failure.
llvm::Value *Old = CGF.Builder.CreateExtractValue(Pair, 0);
llvm::Value *Cmp = CGF.Builder.CreateExtractValue(Pair, 1);

// This basic block is used to hold the store instruction if the operation
// failed.
llvm::BasicBlock *StoreExpectedBB =
    CGF.createBasicBlock("cmpxchg.store_expected", CGF.CurFn);

// This basic block is the exit point of the operation, we should end up
// here regardless of whether or not the operation succeeded.
llvm::BasicBlock *ContinueBB =
    CGF.createBasicBlock("cmpxchg.continue", CGF.CurFn);

// Update Expected if Expected isn't equal to Old, otherwise branch to the
// exit point.
CGF.Builder.CreateCondBr(Cmp, ContinueBB, StoreExpectedBB);

CGF.Builder.SetInsertPoint(StoreExpectedBB);
// Update the memory at Expected with Old's value.
CGF.Builder.CreateStore(Old, Val1);
// Finally, branch to the exit point.
CGF.Builder.CreateBr(ContinueBB);

CGF.Builder.SetInsertPoint(ContinueBB);
// Update the memory at Dest with Cmp's value.
CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
401}

403/// Given an ordering required on success, emit all possible cmpxchg
404/// instructions to cope with the provided (but possibly only dynamically known)
405/// FailureOrder.
406static void emitAtomicCmpXchgFailureSet(CodeGenFunction &CGF, AtomicExpr *E,
                                      bool IsWeak, Address Dest, Address Ptr,
                                      Address Val1, Address Val2,
                                      llvm::Value *FailureOrderVal,
                                      uint64_t Size,
                                      llvm::AtomicOrdering SuccessOrder,
                                      llvm::SyncScope::ID Scope) {
llvm::AtomicOrdering FailureOrder;
if (llvm::ConstantInt *FO = dyn_cast<llvm::ConstantInt>(FailureOrderVal)) {
  auto FOS = FO->getSExtValue();
  if (!llvm::isValidAtomicOrderingCABI(FOS))
    FailureOrder = llvm::AtomicOrdering::Monotonic;
  else
    switch ((llvm::AtomicOrderingCABI)FOS) {
    case llvm::AtomicOrderingCABI::relaxed:
    case llvm::AtomicOrderingCABI::release:
    case llvm::AtomicOrderingCABI::acq_rel:
      FailureOrder = llvm::AtomicOrdering::Monotonic;
      break;
    case llvm::AtomicOrderingCABI::consume:
    case llvm::AtomicOrderingCABI::acquire:
      FailureOrder = llvm::AtomicOrdering::Acquire;
      break;
    case llvm::AtomicOrderingCABI::seq_cst:
      FailureOrder = llvm::AtomicOrdering::SequentiallyConsistent;
      break;
    }
  if (isStrongerThan(FailureOrder, SuccessOrder)) {
    // Don't assert on undefined behavior "failure argument shall be no
    // stronger than the success argument".
    FailureOrder =
        llvm::AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrder);
  }
  emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2, Size, SuccessOrder,
                    FailureOrder, Scope);
  return;
}

// Create all the relevant BB's
llvm::BasicBlock *MonotonicBB = nullptr, *AcquireBB = nullptr,
                 *SeqCstBB = nullptr;
MonotonicBB = CGF.createBasicBlock("monotonic_fail", CGF.CurFn);
if (SuccessOrder != llvm::AtomicOrdering::Monotonic &&
    SuccessOrder != llvm::AtomicOrdering::Release)
  AcquireBB = CGF.createBasicBlock("acquire_fail", CGF.CurFn);
if (SuccessOrder == llvm::AtomicOrdering::SequentiallyConsistent)
  SeqCstBB = CGF.createBasicBlock("seqcst_fail", CGF.CurFn);

llvm::BasicBlock *ContBB = CGF.createBasicBlock("atomic.continue", CGF.CurFn);

llvm::SwitchInst *SI = CGF.Builder.CreateSwitch(FailureOrderVal, MonotonicBB);

// Emit all the different atomics

// MonotonicBB is arbitrarily chosen as the default case; in practice, this
// doesn't matter unless someone is crazy enough to use something that
// doesn't fold to a constant for the ordering.
CGF.Builder.SetInsertPoint(MonotonicBB);
emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
                  Size, SuccessOrder, llvm::AtomicOrdering::Monotonic, Scope);
CGF.Builder.CreateBr(ContBB);

if (AcquireBB) {
  CGF.Builder.SetInsertPoint(AcquireBB);
  emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
                    Size, SuccessOrder, llvm::AtomicOrdering::Acquire, Scope);
  CGF.Builder.CreateBr(ContBB);
  SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::consume),
              AcquireBB);
  SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::acquire),
              AcquireBB);
}
if (SeqCstBB) {
  CGF.Builder.SetInsertPoint(SeqCstBB);
  emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2, Size, SuccessOrder,
                    llvm::AtomicOrdering::SequentiallyConsistent, Scope);
  CGF.Builder.CreateBr(ContBB);
  SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::seq_cst),
              SeqCstBB);
}

CGF.Builder.SetInsertPoint(ContBB);
488}

490static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, Address Dest,
                       Address Ptr, Address Val1, Address Val2,
                       llvm::Value *IsWeak, llvm::Value *FailureOrder,
                       uint64_t Size, llvm::AtomicOrdering Order,
                       llvm::SyncScope::ID Scope) {
llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0;

switch (E->getOp()) {
case AtomicExpr::AO__c11_atomic_init:
case AtomicExpr::AO__opencl_atomic_init:
  llvm_unreachable("Already handled!")::llvm::llvm_unreachable_internal("Already handled!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 501);

case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
  emitAtomicCmpXchgFailureSet(CGF, E, false, Dest, Ptr, Val1, Val2,
                              FailureOrder, Size, Order, Scope);
  return;
case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
  emitAtomicCmpXchgFailureSet(CGF, E, true, Dest, Ptr, Val1, Val2,
                              FailureOrder, Size, Order, Scope);
  return;
case AtomicExpr::AO__atomic_compare_exchange:
case AtomicExpr::AO__atomic_compare_exchange_n: {
  if (llvm::ConstantInt *IsWeakC = dyn_cast<llvm::ConstantInt>(IsWeak)) {
    emitAtomicCmpXchgFailureSet(CGF, E, IsWeakC->getZExtValue(), Dest, Ptr,
                                Val1, Val2, FailureOrder, Size, Order, Scope);
  } else {
    // Create all the relevant BB's
    llvm::BasicBlock *StrongBB =
        CGF.createBasicBlock("cmpxchg.strong", CGF.CurFn);
    llvm::BasicBlock *WeakBB = CGF.createBasicBlock("cmxchg.weak", CGF.CurFn);
    llvm::BasicBlock *ContBB =
        CGF.createBasicBlock("cmpxchg.continue", CGF.CurFn);

    llvm::SwitchInst *SI = CGF.Builder.CreateSwitch(IsWeak, WeakBB);
    SI->addCase(CGF.Builder.getInt1(false), StrongBB);

    CGF.Builder.SetInsertPoint(StrongBB);
    emitAtomicCmpXchgFailureSet(CGF, E, false, Dest, Ptr, Val1, Val2,
                                FailureOrder, Size, Order, Scope);
    CGF.Builder.CreateBr(ContBB);

    CGF.Builder.SetInsertPoint(WeakBB);
    emitAtomicCmpXchgFailureSet(CGF, E, true, Dest, Ptr, Val1, Val2,
                                FailureOrder, Size, Order, Scope);
    CGF.Builder.CreateBr(ContBB);

    CGF.Builder.SetInsertPoint(ContBB);
  }
  return;
}
case AtomicExpr::AO__c11_atomic_load:
case AtomicExpr::AO__opencl_atomic_load:
case AtomicExpr::AO__atomic_load_n:
case AtomicExpr::AO__atomic_load: {
  llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
  Load->setAtomic(Order, Scope);
  Load->setVolatile(E->isVolatile());
  CGF.Builder.CreateStore(Load, Dest);
  return;
}

case AtomicExpr::AO__c11_atomic_store:
case AtomicExpr::AO__opencl_atomic_store:
case AtomicExpr::AO__atomic_store:
case AtomicExpr::AO__atomic_store_n: {
  llvm::Value *LoadVal1 = CGF.Builder.CreateLoad(Val1);
  llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
  Store->setAtomic(Order, Scope);
  Store->setVolatile(E->isVolatile());
  return;
}

case AtomicExpr::AO__c11_atomic_exchange:
case AtomicExpr::AO__opencl_atomic_exchange:
case AtomicExpr::AO__atomic_exchange_n:
case AtomicExpr::AO__atomic_exchange:
  Op = llvm::AtomicRMWInst::Xchg;
  break;

case AtomicExpr::AO__atomic_add_fetch:
  PostOp = llvm::Instruction::Add;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__c11_atomic_fetch_add:
case AtomicExpr::AO__opencl_atomic_fetch_add:
case AtomicExpr::AO__atomic_fetch_add:
  Op = llvm::AtomicRMWInst::Add;
  break;

case AtomicExpr::AO__atomic_sub_fetch:
  PostOp = llvm::Instruction::Sub;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__c11_atomic_fetch_sub:
case AtomicExpr::AO__opencl_atomic_fetch_sub:
case AtomicExpr::AO__atomic_fetch_sub:
  Op = llvm::AtomicRMWInst::Sub;
  break;

case AtomicExpr::AO__opencl_atomic_fetch_min:
case AtomicExpr::AO__atomic_fetch_min:
  Op = E->getValueType()->isSignedIntegerType() ? llvm::AtomicRMWInst::Min
                                                : llvm::AtomicRMWInst::UMin;
  break;

case AtomicExpr::AO__opencl_atomic_fetch_max:
case AtomicExpr::AO__atomic_fetch_max:
  Op = E->getValueType()->isSignedIntegerType() ? llvm::AtomicRMWInst::Max
                                                : llvm::AtomicRMWInst::UMax;
  break;

case AtomicExpr::AO__atomic_and_fetch:
  PostOp = llvm::Instruction::And;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__c11_atomic_fetch_and:
case AtomicExpr::AO__opencl_atomic_fetch_and:
case AtomicExpr::AO__atomic_fetch_and:
  Op = llvm::AtomicRMWInst::And;
  break;

case AtomicExpr::AO__atomic_or_fetch:
  PostOp = llvm::Instruction::Or;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__c11_atomic_fetch_or:
case AtomicExpr::AO__opencl_atomic_fetch_or:
case AtomicExpr::AO__atomic_fetch_or:
  Op = llvm::AtomicRMWInst::Or;
  break;

case AtomicExpr::AO__atomic_xor_fetch:
  PostOp = llvm::Instruction::Xor;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__c11_atomic_fetch_xor:
case AtomicExpr::AO__opencl_atomic_fetch_xor:
case AtomicExpr::AO__atomic_fetch_xor:
  Op = llvm::AtomicRMWInst::Xor;
  break;

case AtomicExpr::AO__atomic_nand_fetch:
  PostOp = llvm::Instruction::And; // the NOT is special cased below
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__atomic_fetch_nand:
  Op = llvm::AtomicRMWInst::Nand;
  break;
}

llvm::Value *LoadVal1 = CGF.Builder.CreateLoad(Val1);
llvm::AtomicRMWInst *RMWI =
    CGF.Builder.CreateAtomicRMW(Op, Ptr.getPointer(), LoadVal1, Order, Scope);
RMWI->setVolatile(E->isVolatile());

// For __atomic_*_fetch operations, perform the operation again to
// determine the value which was written.
llvm::Value *Result = RMWI;
if (PostOp)
  Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch)
  Result = CGF.Builder.CreateNot(Result);
CGF.Builder.CreateStore(Result, Dest);
650}

652// This function emits any expression (scalar, complex, or aggregate)
653// into a temporary alloca.
654static Address
655EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
Address DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
                     /*Init*/ true);
return DeclPtr;
660}

662static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *Expr, Address Dest,
                       Address Ptr, Address Val1, Address Val2,
                       llvm::Value *IsWeak, llvm::Value *FailureOrder,
                       uint64_t Size, llvm::AtomicOrdering Order,
                       llvm::Value *Scope) {
auto ScopeModel = Expr->getScopeModel();

// LLVM atomic instructions always have synch scope. If clang atomic
// expression has no scope operand, use default LLVM synch scope.
if (!ScopeModel) {
  EmitAtomicOp(CGF, Expr, Dest, Ptr, Val1, Val2, IsWeak, FailureOrder, Size,
               Order, CGF.CGM.getLLVMContext().getOrInsertSyncScopeID(""));
  return;
}

// Handle constant scope.
if (auto SC = dyn_cast<llvm::ConstantInt>(Scope)) {
  auto SCID = CGF.getTargetHooks().getLLVMSyncScopeID(
      CGF.CGM.getLangOpts(), ScopeModel->map(SC->getZExtValue()),
      Order, CGF.CGM.getLLVMContext());
  EmitAtomicOp(CGF, Expr, Dest, Ptr, Val1, Val2, IsWeak, FailureOrder, Size,
               Order, SCID);
  return;
}

// Handle non-constant scope.
auto &Builder = CGF.Builder;
auto Scopes = ScopeModel->getRuntimeValues();
llvm::DenseMap<unsigned, llvm::BasicBlock *> BB;
for (auto S : Scopes)
  BB[S] = CGF.createBasicBlock(getAsString(ScopeModel->map(S)), CGF.CurFn);

llvm::BasicBlock *ContBB =
    CGF.createBasicBlock("atomic.scope.continue", CGF.CurFn);

auto *SC = Builder.CreateIntCast(Scope, Builder.getInt32Ty(), false);
// If unsupported synch scope is encountered at run time, assume a fallback
// synch scope value.
auto FallBack = ScopeModel->getFallBackValue();
llvm::SwitchInst *SI = Builder.CreateSwitch(SC, BB[FallBack]);
for (auto S : Scopes) {
  auto *B = BB[S];
  if (S != FallBack)
    SI->addCase(Builder.getInt32(S), B);

  Builder.SetInsertPoint(B);
  EmitAtomicOp(CGF, Expr, Dest, Ptr, Val1, Val2, IsWeak, FailureOrder, Size,
               Order,
               CGF.getTargetHooks().getLLVMSyncScopeID(CGF.CGM.getLangOpts(),
                                                       ScopeModel->map(S),
                                                       Order,
                                                       CGF.getLLVMContext()));
  Builder.CreateBr(ContBB);
}

Builder.SetInsertPoint(ContBB);
718}

720static void
721AddDirectArgument(CodeGenFunction &CGF, CallArgList &Args,
                bool UseOptimizedLibcall, llvm::Value *Val, QualType ValTy,
                SourceLocation Loc, CharUnits SizeInChars) {
if (UseOptimizedLibcall) {
  // Load value and pass it to the function directly.
  CharUnits Align = CGF.getContext().getTypeAlignInChars(ValTy);
  int64_t SizeInBits = CGF.getContext().toBits(SizeInChars);
  ValTy =
      CGF.getContext().getIntTypeForBitwidth(SizeInBits, /*Signed=*/false);
  llvm::Type *IPtrTy = llvm::IntegerType::get(CGF.getLLVMContext(),
                                              SizeInBits)->getPointerTo();
  Address Ptr = Address(CGF.Builder.CreateBitCast(Val, IPtrTy), Align);
  Val = CGF.EmitLoadOfScalar(Ptr, false,
                             CGF.getContext().getPointerType(ValTy),
                             Loc);
  // Coerce the value into an appropriately sized integer type.
  Args.add(RValue::get(Val), ValTy);
} else {
  // Non-optimized functions always take a reference.
  Args.add(RValue::get(CGF.EmitCastToVoidPtr(Val)),
                       CGF.getContext().VoidPtrTy);
}
743}

745RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
QualType MemTy = AtomicTy;
if (const AtomicType *AT = AtomicTy->getAs<AtomicType>())
  MemTy = AT->getValueType();
llvm::Value *IsWeak = nullptr, *OrderFail = nullptr;

Address Val1 = Address::invalid();
Address Val2 = Address::invalid();
Address Dest = Address::invalid();
Address Ptr = EmitPointerWithAlignment(E->getPtr());

if (E->getOp() == AtomicExpr::AO__c11_atomic_init ||
    E->getOp() == AtomicExpr::AO__opencl_atomic_init) {
  LValue lvalue = MakeAddrLValue(Ptr, AtomicTy);
  EmitAtomicInit(E->getVal1(), lvalue);
  return RValue::get(nullptr);
}

CharUnits sizeChars, alignChars;
std::tie(sizeChars, alignChars) = getContext().getTypeInfoInChars(AtomicTy);
uint64_t Size = sizeChars.getQuantity();
unsigned MaxInlineWidthInBits = getTarget().getMaxAtomicInlineWidth();

bool Oversized = getContext().toBits(sizeChars) > MaxInlineWidthInBits;
bool Misaligned = (Ptr.getAlignment() % sizeChars) != 0;
bool UseLibcall = Misaligned | Oversized;

if (UseLibcall) {
  CGM.getDiags().Report(E->getBeginLoc(), diag::warn_atomic_op_misaligned)
      << !Oversized;
}

llvm::Value *Order = EmitScalarExpr(E->getOrder());
llvm::Value *Scope =
    E->getScopeModel() ? EmitScalarExpr(E->getScope()) : nullptr;

switch (E->getOp()) {
case AtomicExpr::AO__c11_atomic_init:
case AtomicExpr::AO__opencl_atomic_init:
  llvm_unreachable("Already handled above with EmitAtomicInit!")::llvm::llvm_unreachable_internal("Already handled above with EmitAtomicInit!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 785);

case AtomicExpr::AO__c11_atomic_load:
case AtomicExpr::AO__opencl_atomic_load:
case AtomicExpr::AO__atomic_load_n:
  break;

case AtomicExpr::AO__atomic_load:
  Dest = EmitPointerWithAlignment(E->getVal1());
  break;

case AtomicExpr::AO__atomic_store:
  Val1 = EmitPointerWithAlignment(E->getVal1());
  break;

case AtomicExpr::AO__atomic_exchange:
  Val1 = EmitPointerWithAlignment(E->getVal1());
  Dest = EmitPointerWithAlignment(E->getVal2());
  break;

case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
case AtomicExpr::AO__atomic_compare_exchange_n:
case AtomicExpr::AO__atomic_compare_exchange:
  Val1 = EmitPointerWithAlignment(E->getVal1());
  if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange)
    Val2 = EmitPointerWithAlignment(E->getVal2());
  else
    Val2 = EmitValToTemp(*this, E->getVal2());
  OrderFail = EmitScalarExpr(E->getOrderFail());
  if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange_n ||
      E->getOp() == AtomicExpr::AO__atomic_compare_exchange)
    IsWeak = EmitScalarExpr(E->getWeak());
  break;

case AtomicExpr::AO__c11_atomic_fetch_add:
case AtomicExpr::AO__c11_atomic_fetch_sub:
case AtomicExpr::AO__opencl_atomic_fetch_add:
case AtomicExpr::AO__opencl_atomic_fetch_sub:
  if (MemTy->isPointerType()) {
    // For pointer arithmetic, we're required to do a bit of math:
    // adding 1 to an int* is not the same as adding 1 to a uintptr_t.
    // ... but only for the C11 builtins. The GNU builtins expect the
    // user to multiply by sizeof(T).
    QualType Val1Ty = E->getVal1()->getType();
    llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1());
    CharUnits PointeeIncAmt =
        getContext().getTypeSizeInChars(MemTy->getPointeeType());
    Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
    auto Temp = CreateMemTemp(Val1Ty, ".atomictmp");
    Val1 = Temp;
    EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Temp, Val1Ty));
    break;
  }
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
case AtomicExpr::AO__atomic_fetch_add:
case AtomicExpr::AO__atomic_fetch_sub:
case AtomicExpr::AO__atomic_add_fetch:
case AtomicExpr::AO__atomic_sub_fetch:
case AtomicExpr::AO__c11_atomic_store:
case AtomicExpr::AO__c11_atomic_exchange:
case AtomicExpr::AO__opencl_atomic_store:
case AtomicExpr::AO__opencl_atomic_exchange:
case AtomicExpr::AO__atomic_store_n:
case AtomicExpr::AO__atomic_exchange_n:
case AtomicExpr::AO__c11_atomic_fetch_and:
case AtomicExpr::AO__c11_atomic_fetch_or:
case AtomicExpr::AO__c11_atomic_fetch_xor:
case AtomicExpr::AO__opencl_atomic_fetch_and:
case AtomicExpr::AO__opencl_atomic_fetch_or:
case AtomicExpr::AO__opencl_atomic_fetch_xor:
case AtomicExpr::AO__opencl_atomic_fetch_min:
case AtomicExpr::AO__opencl_atomic_fetch_max:
case AtomicExpr::AO__atomic_fetch_and:
case AtomicExpr::AO__atomic_fetch_or:
case AtomicExpr::AO__atomic_fetch_xor:
case AtomicExpr::AO__atomic_fetch_nand:
case AtomicExpr::AO__atomic_and_fetch:
case AtomicExpr::AO__atomic_or_fetch:
case AtomicExpr::AO__atomic_xor_fetch:
case AtomicExpr::AO__atomic_nand_fetch:
case AtomicExpr::AO__atomic_fetch_min:
case AtomicExpr::AO__atomic_fetch_max:
  Val1 = EmitValToTemp(*this, E->getVal1());
  break;
}

QualType RValTy = E->getType().getUnqualifiedType();

// The inlined atomics only function on iN types, where N is a power of 2. We
// need to make sure (via temporaries if necessary) that all incoming values
// are compatible.
LValue AtomicVal = MakeAddrLValue(Ptr, AtomicTy);
AtomicInfo Atomics(*this, AtomicVal);

Ptr = Atomics.emitCastToAtomicIntPointer(Ptr);
if (Val1.isValid()) Val1 = Atomics.convertToAtomicIntPointer(Val1);
if (Val2.isValid()) Val2 = Atomics.convertToAtomicIntPointer(Val2);
if (Dest.isValid())
  Dest = Atomics.emitCastToAtomicIntPointer(Dest);
else if (E->isCmpXChg())
  Dest = CreateMemTemp(RValTy, "cmpxchg.bool");
else if (!RValTy->isVoidType())
  Dest = Atomics.emitCastToAtomicIntPointer(Atomics.CreateTempAlloca());

// Use a library call.  See: http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary .
if (UseLibcall) {
  bool UseOptimizedLibcall = false;
  switch (E->getOp()) {
  case AtomicExpr::AO__c11_atomic_init:
  case AtomicExpr::AO__opencl_atomic_init:
    llvm_unreachable("Already handled above with EmitAtomicInit!")::llvm::llvm_unreachable_internal("Already handled above with EmitAtomicInit!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 898);

  case AtomicExpr::AO__c11_atomic_fetch_add:
  case AtomicExpr::AO__opencl_atomic_fetch_add:
  case AtomicExpr::AO__atomic_fetch_add:
  case AtomicExpr::AO__c11_atomic_fetch_and:
  case AtomicExpr::AO__opencl_atomic_fetch_and:
  case AtomicExpr::AO__atomic_fetch_and:
  case AtomicExpr::AO__c11_atomic_fetch_or:
  case AtomicExpr::AO__opencl_atomic_fetch_or:
  case AtomicExpr::AO__atomic_fetch_or:
  case AtomicExpr::AO__atomic_fetch_nand:
  case AtomicExpr::AO__c11_atomic_fetch_sub:
  case AtomicExpr::AO__opencl_atomic_fetch_sub:
  case AtomicExpr::AO__atomic_fetch_sub:
  case AtomicExpr::AO__c11_atomic_fetch_xor:
  case AtomicExpr::AO__opencl_atomic_fetch_xor:
  case AtomicExpr::AO__opencl_atomic_fetch_min:
  case AtomicExpr::AO__opencl_atomic_fetch_max:
  case AtomicExpr::AO__atomic_fetch_xor:
  case AtomicExpr::AO__atomic_add_fetch:
  case AtomicExpr::AO__atomic_and_fetch:
  case AtomicExpr::AO__atomic_nand_fetch:
  case AtomicExpr::AO__atomic_or_fetch:
  case AtomicExpr::AO__atomic_sub_fetch:
  case AtomicExpr::AO__atomic_xor_fetch:
  case AtomicExpr::AO__atomic_fetch_min:
  case AtomicExpr::AO__atomic_fetch_max:
    // For these, only library calls for certain sizes exist.
    UseOptimizedLibcall = true;
    break;

  case AtomicExpr::AO__atomic_load:
  case AtomicExpr::AO__atomic_store:
  case AtomicExpr::AO__atomic_exchange:
  case AtomicExpr::AO__atomic_compare_exchange:
    // Use the generic version if we don't know that the operand will be
    // suitably aligned for the optimized version.
    if (Misaligned)
      break;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__c11_atomic_load:
  case AtomicExpr::AO__c11_atomic_store:
  case AtomicExpr::AO__c11_atomic_exchange:
  case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
  case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
  case AtomicExpr::AO__opencl_atomic_load:
  case AtomicExpr::AO__opencl_atomic_store:
  case AtomicExpr::AO__opencl_atomic_exchange:
  case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
  case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
  case AtomicExpr::AO__atomic_load_n:
  case AtomicExpr::AO__atomic_store_n:
  case AtomicExpr::AO__atomic_exchange_n:
  case AtomicExpr::AO__atomic_compare_exchange_n:
    // Only use optimized library calls for sizes for which they exist.
    // FIXME: Size == 16 optimized library functions exist too.
    if (Size == 1 || Size == 2 || Size == 4 || Size == 8)
      UseOptimizedLibcall = true;
    break;
  }

  CallArgList Args;
  if (!UseOptimizedLibcall) {
    // For non-optimized library calls, the size is the first parameter
    Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
             getContext().getSizeType());
  }
  // Atomic address is the first or second parameter
  // The OpenCL atomic library functions only accept pointer arguments to
  // generic address space.
  auto CastToGenericAddrSpace = [&](llvm::Value *V, QualType PT) {
    if (!E->isOpenCL())
1
Calling 'AtomicExpr::isOpenCL'→
5
←
Returning from 'AtomicExpr::isOpenCL'→
6
←
Taking false branch→
      return V;
    auto AS = PT->getAs<PointerType>()->getPointeeType().getAddressSpace();
7
←
Assuming the object is not a 'PointerType'→
8
←
Called C++ object pointer is null
    if (AS == LangAS::opencl_generic)
      return V;
    auto DestAS = getContext().getTargetAddressSpace(LangAS::opencl_generic);
    auto T = V->getType();
    auto *DestType = T->getPointerElementType()->getPointerTo(DestAS);

    return getTargetHooks().performAddrSpaceCast(
        *this, V, AS, LangAS::opencl_generic, DestType, false);
  };

  Args.add(RValue::get(CastToGenericAddrSpace(
               EmitCastToVoidPtr(Ptr.getPointer()), E->getPtr()->getType())),
           getContext().VoidPtrTy);

  std::string LibCallName;
  QualType LoweredMemTy =
    MemTy->isPointerType() ? getContext().getIntPtrType() : MemTy;
  QualType RetTy;
  bool HaveRetTy = false;
  llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0;
  switch (E->getOp()) {
  case AtomicExpr::AO__c11_atomic_init:
  case AtomicExpr::AO__opencl_atomic_init:
    llvm_unreachable("Already handled!")::llvm::llvm_unreachable_internal("Already handled!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 996);

  // There is only one libcall for compare an exchange, because there is no
  // optimisation benefit possible from a libcall version of a weak compare
  // and exchange.
  // bool __atomic_compare_exchange(size_t size, void *mem, void *expected,
  //                                void *desired, int success, int failure)
  // bool __atomic_compare_exchange_N(T *mem, T *expected, T desired,
  //                                  int success, int failure)
  case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
  case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
  case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
  case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
  case AtomicExpr::AO__atomic_compare_exchange:
  case AtomicExpr::AO__atomic_compare_exchange_n:
    LibCallName = "__atomic_compare_exchange";
    RetTy = getContext().BoolTy;
    HaveRetTy = true;
    Args.add(
        RValue::get(CastToGenericAddrSpace(
            EmitCastToVoidPtr(Val1.getPointer()), E->getVal1()->getType())),
        getContext().VoidPtrTy);
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val2.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    Args.add(RValue::get(Order), getContext().IntTy);
    Order = OrderFail;
    break;
  // void __atomic_exchange(size_t size, void *mem, void *val, void *return,
  //                        int order)
  // T __atomic_exchange_N(T *mem, T val, int order)
  case AtomicExpr::AO__c11_atomic_exchange:
  case AtomicExpr::AO__opencl_atomic_exchange:
  case AtomicExpr::AO__atomic_exchange_n:
  case AtomicExpr::AO__atomic_exchange:
    LibCallName = "__atomic_exchange";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    break;
  // void __atomic_store(size_t size, void *mem, void *val, int order)
  // void __atomic_store_N(T *mem, T val, int order)
  case AtomicExpr::AO__c11_atomic_store:
  case AtomicExpr::AO__opencl_atomic_store:
  case AtomicExpr::AO__atomic_store:
  case AtomicExpr::AO__atomic_store_n:
    LibCallName = "__atomic_store";
    RetTy = getContext().VoidTy;
    HaveRetTy = true;
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    break;
  // void __atomic_load(size_t size, void *mem, void *return, int order)
  // T __atomic_load_N(T *mem, int order)
  case AtomicExpr::AO__c11_atomic_load:
  case AtomicExpr::AO__opencl_atomic_load:
  case AtomicExpr::AO__atomic_load:
  case AtomicExpr::AO__atomic_load_n:
    LibCallName = "__atomic_load";
    break;
  // T __atomic_add_fetch_N(T *mem, T val, int order)
  // T __atomic_fetch_add_N(T *mem, T val, int order)
  case AtomicExpr::AO__atomic_add_fetch:
    PostOp = llvm::Instruction::Add;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__c11_atomic_fetch_add:
  case AtomicExpr::AO__opencl_atomic_fetch_add:
  case AtomicExpr::AO__atomic_fetch_add:
    LibCallName = "__atomic_fetch_add";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      LoweredMemTy, E->getExprLoc(), sizeChars);
    break;
  // T __atomic_and_fetch_N(T *mem, T val, int order)
  // T __atomic_fetch_and_N(T *mem, T val, int order)
  case AtomicExpr::AO__atomic_and_fetch:
    PostOp = llvm::Instruction::And;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__c11_atomic_fetch_and:
  case AtomicExpr::AO__opencl_atomic_fetch_and:
  case AtomicExpr::AO__atomic_fetch_and:
    LibCallName = "__atomic_fetch_and";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    break;
  // T __atomic_or_fetch_N(T *mem, T val, int order)
  // T __atomic_fetch_or_N(T *mem, T val, int order)
  case AtomicExpr::AO__atomic_or_fetch:
    PostOp = llvm::Instruction::Or;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__c11_atomic_fetch_or:
  case AtomicExpr::AO__opencl_atomic_fetch_or:
  case AtomicExpr::AO__atomic_fetch_or:
    LibCallName = "__atomic_fetch_or";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    break;
  // T __atomic_sub_fetch_N(T *mem, T val, int order)
  // T __atomic_fetch_sub_N(T *mem, T val, int order)
  case AtomicExpr::AO__atomic_sub_fetch:
    PostOp = llvm::Instruction::Sub;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__c11_atomic_fetch_sub:
  case AtomicExpr::AO__opencl_atomic_fetch_sub:
  case AtomicExpr::AO__atomic_fetch_sub:
    LibCallName = "__atomic_fetch_sub";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      LoweredMemTy, E->getExprLoc(), sizeChars);
    break;
  // T __atomic_xor_fetch_N(T *mem, T val, int order)
  // T __atomic_fetch_xor_N(T *mem, T val, int order)
  case AtomicExpr::AO__atomic_xor_fetch:
    PostOp = llvm::Instruction::Xor;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__c11_atomic_fetch_xor:
  case AtomicExpr::AO__opencl_atomic_fetch_xor:
  case AtomicExpr::AO__atomic_fetch_xor:
    LibCallName = "__atomic_fetch_xor";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    break;
  case AtomicExpr::AO__atomic_fetch_min:
  case AtomicExpr::AO__opencl_atomic_fetch_min:
    LibCallName = E->getValueType()->isSignedIntegerType()
                      ? "__atomic_fetch_min"
                      : "__atomic_fetch_umin";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      LoweredMemTy, E->getExprLoc(), sizeChars);
    break;
  case AtomicExpr::AO__atomic_fetch_max:
  case AtomicExpr::AO__opencl_atomic_fetch_max:
    LibCallName = E->getValueType()->isSignedIntegerType()
                      ? "__atomic_fetch_max"
                      : "__atomic_fetch_umax";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      LoweredMemTy, E->getExprLoc(), sizeChars);
    break;
  // T __atomic_nand_fetch_N(T *mem, T val, int order)
  // T __atomic_fetch_nand_N(T *mem, T val, int order)
  case AtomicExpr::AO__atomic_nand_fetch:
    PostOp = llvm::Instruction::And; // the NOT is special cased below
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AtomicExpr::AO__atomic_fetch_nand:
    LibCallName = "__atomic_fetch_nand";
    AddDirectArgument(*this, Args, UseOptimizedLibcall, Val1.getPointer(),
                      MemTy, E->getExprLoc(), sizeChars);
    break;
  }

  if (E->isOpenCL()) {
    LibCallName = std::string("__opencl") +
        StringRef(LibCallName).drop_front(1).str();

  }
  // Optimized functions have the size in their name.
  if (UseOptimizedLibcall)
    LibCallName += "_" + llvm::utostr(Size);
  // By default, assume we return a value of the atomic type.
  if (!HaveRetTy) {
    if (UseOptimizedLibcall) {
      // Value is returned directly.
      // The function returns an appropriately sized integer type.
      RetTy = getContext().getIntTypeForBitwidth(
          getContext().toBits(sizeChars), /*Signed=*/false);
    } else {
      // Value is returned through parameter before the order.
      RetTy = getContext().VoidTy;
      Args.add(RValue::get(EmitCastToVoidPtr(Dest.getPointer())),
               getContext().VoidPtrTy);
    }
  }
  // order is always the last parameter
  Args.add(RValue::get(Order),
           getContext().IntTy);
  if (E->isOpenCL())
    Args.add(RValue::get(Scope), getContext().IntTy);

  // PostOp is only needed for the atomic_*_fetch operations, and
  // thus is only needed for and implemented in the
  // UseOptimizedLibcall codepath.
  assert(UseOptimizedLibcall || !PostOp)((UseOptimizedLibcall || !PostOp) ? static_cast<void> (
0) : __assert_fail ("UseOptimizedLibcall || !PostOp", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1173, __PRETTY_FUNCTION__));

  RValue Res = emitAtomicLibcall(*this, LibCallName, RetTy, Args);
  // The value is returned directly from the libcall.
  if (E->isCmpXChg())
    return Res;

  // The value is returned directly for optimized libcalls but the expr
  // provided an out-param.
  if (UseOptimizedLibcall && Res.getScalarVal()) {
    llvm::Value *ResVal = Res.getScalarVal();
    if (PostOp) {
      llvm::Value *LoadVal1 = Args[1].getRValue(*this).getScalarVal();
      ResVal = Builder.CreateBinOp(PostOp, ResVal, LoadVal1);
    }
    if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch)
      ResVal = Builder.CreateNot(ResVal);

    Builder.CreateStore(
        ResVal,
        Builder.CreateBitCast(Dest, ResVal->getType()->getPointerTo()));
  }

  if (RValTy->isVoidType())
    return RValue::get(nullptr);

  return convertTempToRValue(
      Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo()),
      RValTy, E->getExprLoc());
}

bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store ||
               E->getOp() == AtomicExpr::AO__opencl_atomic_store ||
               E->getOp() == AtomicExpr::AO__atomic_store ||
               E->getOp() == AtomicExpr::AO__atomic_store_n;
bool IsLoad = E->getOp() == AtomicExpr::AO__c11_atomic_load ||
              E->getOp() == AtomicExpr::AO__opencl_atomic_load ||
              E->getOp() == AtomicExpr::AO__atomic_load ||
              E->getOp() == AtomicExpr::AO__atomic_load_n;

if (isa<llvm::ConstantInt>(Order)) {
  auto ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
  // We should not ever get to a case where the ordering isn't a valid C ABI
  // value, but it's hard to enforce that in general.
  if (llvm::isValidAtomicOrderingCABI(ord))
    switch ((llvm::AtomicOrderingCABI)ord) {
    case llvm::AtomicOrderingCABI::relaxed:
      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
                   llvm::AtomicOrdering::Monotonic, Scope);
      break;
    case llvm::AtomicOrderingCABI::consume:
    case llvm::AtomicOrderingCABI::acquire:
      if (IsStore)
        break; // Avoid crashing on code with undefined behavior
      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
                   llvm::AtomicOrdering::Acquire, Scope);
      break;
    case llvm::AtomicOrderingCABI::release:
      if (IsLoad)
        break; // Avoid crashing on code with undefined behavior
      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
                   llvm::AtomicOrdering::Release, Scope);
      break;
    case llvm::AtomicOrderingCABI::acq_rel:
      if (IsLoad || IsStore)
        break; // Avoid crashing on code with undefined behavior
      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
                   llvm::AtomicOrdering::AcquireRelease, Scope);
      break;
    case llvm::AtomicOrderingCABI::seq_cst:
      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
                   llvm::AtomicOrdering::SequentiallyConsistent, Scope);
      break;
    }
  if (RValTy->isVoidType())
    return RValue::get(nullptr);

  return convertTempToRValue(
      Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo(
                                      Dest.getAddressSpace())),
      RValTy, E->getExprLoc());
}

// Long case, when Order isn't obviously constant.

// Create all the relevant BB's
llvm::BasicBlock *MonotonicBB = nullptr, *AcquireBB = nullptr,
                 *ReleaseBB = nullptr, *AcqRelBB = nullptr,
                 *SeqCstBB = nullptr;
MonotonicBB = createBasicBlock("monotonic", CurFn);
if (!IsStore)
  AcquireBB = createBasicBlock("acquire", CurFn);
if (!IsLoad)
  ReleaseBB = createBasicBlock("release", CurFn);
if (!IsLoad && !IsStore)
  AcqRelBB = createBasicBlock("acqrel", CurFn);
SeqCstBB = createBasicBlock("seqcst", CurFn);
llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);

// Create the switch for the split
// MonotonicBB is arbitrarily chosen as the default case; in practice, this
// doesn't matter unless someone is crazy enough to use something that
// doesn't fold to a constant for the ordering.
Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);

// Emit all the different atomics
Builder.SetInsertPoint(MonotonicBB);
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
             llvm::AtomicOrdering::Monotonic, Scope);
Builder.CreateBr(ContBB);
if (!IsStore) {
  Builder.SetInsertPoint(AcquireBB);
  EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
               llvm::AtomicOrdering::Acquire, Scope);
  Builder.CreateBr(ContBB);
  SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::consume),
              AcquireBB);
  SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::acquire),
              AcquireBB);
}
if (!IsLoad) {
  Builder.SetInsertPoint(ReleaseBB);
  EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
               llvm::AtomicOrdering::Release, Scope);
  Builder.CreateBr(ContBB);
  SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::release),
              ReleaseBB);
}
if (!IsLoad && !IsStore) {
  Builder.SetInsertPoint(AcqRelBB);
  EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
               llvm::AtomicOrdering::AcquireRelease, Scope);
  Builder.CreateBr(ContBB);
  SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::acq_rel),
              AcqRelBB);
}
Builder.SetInsertPoint(SeqCstBB);
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail, Size,
             llvm::AtomicOrdering::SequentiallyConsistent, Scope);
Builder.CreateBr(ContBB);
SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::seq_cst),
            SeqCstBB);

// Cleanup and return
Builder.SetInsertPoint(ContBB);
if (RValTy->isVoidType())
  return RValue::get(nullptr);

assert(Atomics.getValueSizeInBits() <= Atomics.getAtomicSizeInBits())((Atomics.getValueSizeInBits() <= Atomics.getAtomicSizeInBits
()) ? static_cast<void> (0) : __assert_fail ("Atomics.getValueSizeInBits() <= Atomics.getAtomicSizeInBits()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1322, __PRETTY_FUNCTION__));
return convertTempToRValue(
    Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo(
                                    Dest.getAddressSpace())),
    RValTy, E->getExprLoc());
1327}

1329Address AtomicInfo::emitCastToAtomicIntPointer(Address addr) const {
unsigned addrspace =
  cast<llvm::PointerType>(addr.getPointer()->getType())->getAddressSpace();
llvm::IntegerType *ty =
  llvm::IntegerType::get(CGF.getLLVMContext(), AtomicSizeInBits);
return CGF.Builder.CreateBitCast(addr, ty->getPointerTo(addrspace));
1335}

1337Address AtomicInfo::convertToAtomicIntPointer(Address Addr) const {
llvm::Type *Ty = Addr.getElementType();
uint64_t SourceSizeInBits = CGF.CGM.getDataLayout().getTypeSizeInBits(Ty);
if (SourceSizeInBits != AtomicSizeInBits) {
  Address Tmp = CreateTempAlloca();
  CGF.Builder.CreateMemCpy(Tmp, Addr,
                           std::min(AtomicSizeInBits, SourceSizeInBits) / 8);
  Addr = Tmp;
}

return emitCastToAtomicIntPointer(Addr);
1348}

1350RValue AtomicInfo::convertAtomicTempToRValue(Address addr,
                                           AggValueSlot resultSlot,
                                           SourceLocation loc,
                                           bool asValue) const {
if (LVal.isSimple()) {
  if (EvaluationKind == TEK_Aggregate)
    return resultSlot.asRValue();

  // Drill into the padding structure if we have one.
  if (hasPadding())
    addr = CGF.Builder.CreateStructGEP(addr, 0);

  // Otherwise, just convert the temporary to an r-value using the
  // normal conversion routine.
  return CGF.convertTempToRValue(addr, getValueType(), loc);
}
if (!asValue)
  // Get RValue from temp memory as atomic for non-simple lvalues
  return RValue::get(CGF.Builder.CreateLoad(addr));
if (LVal.isBitField())
  return CGF.EmitLoadOfBitfieldLValue(
      LValue::MakeBitfield(addr, LVal.getBitFieldInfo(), LVal.getType(),
                           LVal.getBaseInfo(), TBAAAccessInfo()), loc);
if (LVal.isVectorElt())
  return CGF.EmitLoadOfLValue(
      LValue::MakeVectorElt(addr, LVal.getVectorIdx(), LVal.getType(),
                            LVal.getBaseInfo(), TBAAAccessInfo()), loc);
assert(LVal.isExtVectorElt())((LVal.isExtVectorElt()) ? static_cast<void> (0) : __assert_fail
 ("LVal.isExtVectorElt()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1377, __PRETTY_FUNCTION__));
return CGF.EmitLoadOfExtVectorElementLValue(LValue::MakeExtVectorElt(
    addr, LVal.getExtVectorElts(), LVal.getType(),
    LVal.getBaseInfo(), TBAAAccessInfo()));
1381}

1383RValue AtomicInfo::ConvertIntToValueOrAtomic(llvm::Value *IntVal,
                                           AggValueSlot ResultSlot,
                                           SourceLocation Loc,
                                           bool AsValue) const {
// Try not to in some easy cases.
assert(IntVal->getType()->isIntegerTy() && "Expected integer value")((IntVal->getType()->isIntegerTy() && "Expected integer value"
) ? static_cast<void> (0) : __assert_fail ("IntVal->getType()->isIntegerTy() && \"Expected integer value\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1388, __PRETTY_FUNCTION__));
if (getEvaluationKind() == TEK_Scalar &&
    (((!LVal.isBitField() ||
       LVal.getBitFieldInfo().Size == ValueSizeInBits) &&
      !hasPadding()) ||
     !AsValue)) {
  auto *ValTy = AsValue
                    ? CGF.ConvertTypeForMem(ValueTy)
                    : getAtomicAddress().getType()->getPointerElementType();
  if (ValTy->isIntegerTy()) {
    assert(IntVal->getType() == ValTy && "Different integer types.")((IntVal->getType() == ValTy && "Different integer types."
) ? static_cast<void> (0) : __assert_fail ("IntVal->getType() == ValTy && \"Different integer types.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1398, __PRETTY_FUNCTION__));
    return RValue::get(CGF.EmitFromMemory(IntVal, ValueTy));
  } else if (ValTy->isPointerTy())
    return RValue::get(CGF.Builder.CreateIntToPtr(IntVal, ValTy));
  else if (llvm::CastInst::isBitCastable(IntVal->getType(), ValTy))
    return RValue::get(CGF.Builder.CreateBitCast(IntVal, ValTy));
}

// Create a temporary.  This needs to be big enough to hold the
// atomic integer.
Address Temp = Address::invalid();
bool TempIsVolatile = false;
if (AsValue && getEvaluationKind() == TEK_Aggregate) {
  assert(!ResultSlot.isIgnored())((!ResultSlot.isIgnored()) ? static_cast<void> (0) : __assert_fail
 ("!ResultSlot.isIgnored()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1411, __PRETTY_FUNCTION__));
  Temp = ResultSlot.getAddress();
  TempIsVolatile = ResultSlot.isVolatile();
} else {
  Temp = CreateTempAlloca();
}

// Slam the integer into the temporary.
Address CastTemp = emitCastToAtomicIntPointer(Temp);
CGF.Builder.CreateStore(IntVal, CastTemp)
    ->setVolatile(TempIsVolatile);

return convertAtomicTempToRValue(Temp, ResultSlot, Loc, AsValue);
1424}

1426void AtomicInfo::EmitAtomicLoadLibcall(llvm::Value *AddForLoaded,
                                     llvm::AtomicOrdering AO, bool) {
// void __atomic_load(size_t size, void *mem, void *return, int order);
CallArgList Args;
Args.add(RValue::get(getAtomicSizeValue()), CGF.getContext().getSizeType());
Args.add(RValue::get(CGF.EmitCastToVoidPtr(getAtomicPointer())),
         CGF.getContext().VoidPtrTy);
Args.add(RValue::get(CGF.EmitCastToVoidPtr(AddForLoaded)),
         CGF.getContext().VoidPtrTy);
Args.add(
    RValue::get(llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(AO))),
    CGF.getContext().IntTy);
emitAtomicLibcall(CGF, "__atomic_load", CGF.getContext().VoidTy, Args);
1439}

1441llvm::Value *AtomicInfo::EmitAtomicLoadOp(llvm::AtomicOrdering AO,
                                        bool IsVolatile) {
// Okay, we're doing this natively.
Address Addr = getAtomicAddressAsAtomicIntPointer();
llvm::LoadInst *Load = CGF.Builder.CreateLoad(Addr, "atomic-load");
Load->setAtomic(AO);

// Other decoration.
if (IsVolatile)
  Load->setVolatile(true);
CGF.CGM.DecorateInstructionWithTBAA(Load, LVal.getTBAAInfo());
return Load;
1453}

1455/// An LValue is a candidate for having its loads and stores be made atomic if
1456/// we are operating under /volatile:ms *and* the LValue itself is volatile and
1457/// performing such an operation can be performed without a libcall.
1458bool CodeGenFunction::LValueIsSuitableForInlineAtomic(LValue LV) {
if (!CGM.getCodeGenOpts().MSVolatile) return false;
AtomicInfo AI(*this, LV);
bool IsVolatile = LV.isVolatile() || hasVolatileMember(LV.getType());
// An atomic is inline if we don't need to use a libcall.
bool AtomicIsInline = !AI.shouldUseLibcall();
// MSVC doesn't seem to do this for types wider than a pointer.
if (getContext().getTypeSize(LV.getType()) >
    getContext().getTypeSize(getContext().getIntPtrType()))
  return false;
return IsVolatile && AtomicIsInline;
1469}

1471RValue CodeGenFunction::EmitAtomicLoad(LValue LV, SourceLocation SL,
                                     AggValueSlot Slot) {
llvm::AtomicOrdering AO;
bool IsVolatile = LV.isVolatileQualified();
if (LV.getType()->isAtomicType()) {
  AO = llvm::AtomicOrdering::SequentiallyConsistent;
} else {
  AO = llvm::AtomicOrdering::Acquire;
  IsVolatile = true;
}
return EmitAtomicLoad(LV, SL, AO, IsVolatile, Slot);
1482}

1484RValue AtomicInfo::EmitAtomicLoad(AggValueSlot ResultSlot, SourceLocation Loc,
                                bool AsValue, llvm::AtomicOrdering AO,
                                bool IsVolatile) {
// Check whether we should use a library call.
if (shouldUseLibcall()) {
  Address TempAddr = Address::invalid();
  if (LVal.isSimple() && !ResultSlot.isIgnored()) {
    assert(getEvaluationKind() == TEK_Aggregate)((getEvaluationKind() == TEK_Aggregate) ? static_cast<void
> (0) : __assert_fail ("getEvaluationKind() == TEK_Aggregate"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1491, __PRETTY_FUNCTION__));
    TempAddr = ResultSlot.getAddress();
  } else
    TempAddr = CreateTempAlloca();

  EmitAtomicLoadLibcall(TempAddr.getPointer(), AO, IsVolatile);

  // Okay, turn that back into the original value or whole atomic (for
  // non-simple lvalues) type.
  return convertAtomicTempToRValue(TempAddr, ResultSlot, Loc, AsValue);
}

// Okay, we're doing this natively.
auto *Load = EmitAtomicLoadOp(AO, IsVolatile);

// If we're ignoring an aggregate return, don't do anything.
if (getEvaluationKind() == TEK_Aggregate && ResultSlot.isIgnored())
  return RValue::getAggregate(Address::invalid(), false);

// Okay, turn that back into the original value or atomic (for non-simple
// lvalues) type.
return ConvertIntToValueOrAtomic(Load, ResultSlot, Loc, AsValue);
1513}

1515/// Emit a load from an l-value of atomic type.  Note that the r-value
1516/// we produce is an r-value of the atomic *value* type.
1517RValue CodeGenFunction::EmitAtomicLoad(LValue src, SourceLocation loc,
                                     llvm::AtomicOrdering AO, bool IsVolatile,
                                     AggValueSlot resultSlot) {
AtomicInfo Atomics(*this, src);
return Atomics.EmitAtomicLoad(resultSlot, loc, /*AsValue=*/true, AO,
                              IsVolatile);
1523}

1525/// Copy an r-value into memory as part of storing to an atomic type.
1526/// This needs to create a bit-pattern suitable for atomic operations.
1527void AtomicInfo::emitCopyIntoMemory(RValue rvalue) const {
assert(LVal.isSimple())((LVal.isSimple()) ? static_cast<void> (0) : __assert_fail
 ("LVal.isSimple()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1528, __PRETTY_FUNCTION__));
// If we have an r-value, the rvalue should be of the atomic type,
// which means that the caller is responsible for having zeroed
// any padding.  Just do an aggregate copy of that type.
if (rvalue.isAggregate()) {
  LValue Dest = CGF.MakeAddrLValue(getAtomicAddress(), getAtomicType());
  LValue Src = CGF.MakeAddrLValue(rvalue.getAggregateAddress(),
                                  getAtomicType());
  bool IsVolatile = rvalue.isVolatileQualified() ||
                    LVal.isVolatileQualified();
  CGF.EmitAggregateCopy(Dest, Src, getAtomicType(),
                        AggValueSlot::DoesNotOverlap, IsVolatile);
  return;
}

// Okay, otherwise we're copying stuff.

// Zero out the buffer if necessary.
emitMemSetZeroIfNecessary();

// Drill past the padding if present.
LValue TempLVal = projectValue();

// Okay, store the rvalue in.
if (rvalue.isScalar()) {
  CGF.EmitStoreOfScalar(rvalue.getScalarVal(), TempLVal, /*init*/ true);
} else {
  CGF.EmitStoreOfComplex(rvalue.getComplexVal(), TempLVal, /*init*/ true);
}
1557}


1560/// Materialize an r-value into memory for the purposes of storing it
1561/// to an atomic type.
1562Address AtomicInfo::materializeRValue(RValue rvalue) const {
// Aggregate r-values are already in memory, and EmitAtomicStore
// requires them to be values of the atomic type.
if (rvalue.isAggregate())
  return rvalue.getAggregateAddress();

// Otherwise, make a temporary and materialize into it.
LValue TempLV = CGF.MakeAddrLValue(CreateTempAlloca(), getAtomicType());
AtomicInfo Atomics(CGF, TempLV);
Atomics.emitCopyIntoMemory(rvalue);
return TempLV.getAddress();
1573}

1575llvm::Value *AtomicInfo::convertRValueToInt(RValue RVal) const {
// If we've got a scalar value of the right size, try to avoid going
// through memory.
if (RVal.isScalar() && (!hasPadding() || !LVal.isSimple())) {
  llvm::Value *Value = RVal.getScalarVal();
  if (isa<llvm::IntegerType>(Value->getType()))
    return CGF.EmitToMemory(Value, ValueTy);
  else {
    llvm::IntegerType *InputIntTy = llvm::IntegerType::get(
        CGF.getLLVMContext(),
        LVal.isSimple() ? getValueSizeInBits() : getAtomicSizeInBits());
    if (isa<llvm::PointerType>(Value->getType()))
      return CGF.Builder.CreatePtrToInt(Value, InputIntTy);
    else if (llvm::BitCastInst::isBitCastable(Value->getType(), InputIntTy))
      return CGF.Builder.CreateBitCast(Value, InputIntTy);
  }
}
// Otherwise, we need to go through memory.
// Put the r-value in memory.
Address Addr = materializeRValue(RVal);

// Cast the temporary to the atomic int type and pull a value out.
Addr = emitCastToAtomicIntPointer(Addr);
return CGF.Builder.CreateLoad(Addr);
1599}

1601std::pair<llvm::Value *, llvm::Value *> AtomicInfo::EmitAtomicCompareExchangeOp(
  llvm::Value *ExpectedVal, llvm::Value *DesiredVal,
  llvm::AtomicOrdering Success, llvm::AtomicOrdering Failure, bool IsWeak) {
// Do the atomic store.
Address Addr = getAtomicAddressAsAtomicIntPointer();
auto *Inst = CGF.Builder.CreateAtomicCmpXchg(Addr.getPointer(),
                                             ExpectedVal, DesiredVal,
                                             Success, Failure);
// Other decoration.
Inst->setVolatile(LVal.isVolatileQualified());
Inst->setWeak(IsWeak);

// Okay, turn that back into the original value type.
auto *PreviousVal = CGF.Builder.CreateExtractValue(Inst, /*Idxs=*/0);
auto *SuccessFailureVal = CGF.Builder.CreateExtractValue(Inst, /*Idxs=*/1);
return std::make_pair(PreviousVal, SuccessFailureVal);
1617}

1619llvm::Value *
1620AtomicInfo::EmitAtomicCompareExchangeLibcall(llvm::Value *ExpectedAddr,
                                           llvm::Value *DesiredAddr,
                                           llvm::AtomicOrdering Success,
                                           llvm::AtomicOrdering Failure) {
// bool __atomic_compare_exchange(size_t size, void *obj, void *expected,
// void *desired, int success, int failure);
CallArgList Args;
Args.add(RValue::get(getAtomicSizeValue()), CGF.getContext().getSizeType());
Args.add(RValue::get(CGF.EmitCastToVoidPtr(getAtomicPointer())),
         CGF.getContext().VoidPtrTy);
Args.add(RValue::get(CGF.EmitCastToVoidPtr(ExpectedAddr)),
         CGF.getContext().VoidPtrTy);
Args.add(RValue::get(CGF.EmitCastToVoidPtr(DesiredAddr)),
         CGF.getContext().VoidPtrTy);
Args.add(RValue::get(
             llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(Success))),
         CGF.getContext().IntTy);
Args.add(RValue::get(
             llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(Failure))),
         CGF.getContext().IntTy);
auto SuccessFailureRVal = emitAtomicLibcall(CGF, "__atomic_compare_exchange",
                                            CGF.getContext().BoolTy, Args);

return SuccessFailureRVal.getScalarVal();
1644}

1646std::pair<RValue, llvm::Value *> AtomicInfo::EmitAtomicCompareExchange(
  RValue Expected, RValue Desired, llvm::AtomicOrdering Success,
  llvm::AtomicOrdering Failure, bool IsWeak) {
if (isStrongerThan(Failure, Success))
  // Don't assert on undefined behavior "failure argument shall be no stronger
  // than the success argument".
  Failure = llvm::AtomicCmpXchgInst::getStrongestFailureOrdering(Success);

// Check whether we should use a library call.
if (shouldUseLibcall()) {
  // Produce a source address.
  Address ExpectedAddr = materializeRValue(Expected);
  Address DesiredAddr = materializeRValue(Desired);
  auto *Res = EmitAtomicCompareExchangeLibcall(ExpectedAddr.getPointer(),
                                               DesiredAddr.getPointer(),
                                               Success, Failure);
  return std::make_pair(
      convertAtomicTempToRValue(ExpectedAddr, AggValueSlot::ignored(),
                                SourceLocation(), /*AsValue=*/false),
      Res);
}

// If we've got a scalar value of the right size, try to avoid going
// through memory.
auto *ExpectedVal = convertRValueToInt(Expected);
auto *DesiredVal = convertRValueToInt(Desired);
auto Res = EmitAtomicCompareExchangeOp(ExpectedVal, DesiredVal, Success,
                                       Failure, IsWeak);
return std::make_pair(
    ConvertIntToValueOrAtomic(Res.first, AggValueSlot::ignored(),
                              SourceLocation(), /*AsValue=*/false),
    Res.second);
1678}

1680static void
1681EmitAtomicUpdateValue(CodeGenFunction &CGF, AtomicInfo &Atomics, RValue OldRVal,
                    const llvm::function_ref<RValue(RValue)> &UpdateOp,
                    Address DesiredAddr) {
RValue UpRVal;
LValue AtomicLVal = Atomics.getAtomicLValue();
LValue DesiredLVal;
if (AtomicLVal.isSimple()) {
  UpRVal = OldRVal;
  DesiredLVal = CGF.MakeAddrLValue(DesiredAddr, AtomicLVal.getType());
} else {
  // Build new lvalue for temp address.
  Address Ptr = Atomics.materializeRValue(OldRVal);
  LValue UpdateLVal;
  if (AtomicLVal.isBitField()) {
    UpdateLVal =
        LValue::MakeBitfield(Ptr, AtomicLVal.getBitFieldInfo(),
                             AtomicLVal.getType(),
                             AtomicLVal.getBaseInfo(),
                             AtomicLVal.getTBAAInfo());
    DesiredLVal =
        LValue::MakeBitfield(DesiredAddr, AtomicLVal.getBitFieldInfo(),
                             AtomicLVal.getType(), AtomicLVal.getBaseInfo(),
                             AtomicLVal.getTBAAInfo());
  } else if (AtomicLVal.isVectorElt()) {
    UpdateLVal = LValue::MakeVectorElt(Ptr, AtomicLVal.getVectorIdx(),
                                       AtomicLVal.getType(),
                                       AtomicLVal.getBaseInfo(),
                                       AtomicLVal.getTBAAInfo());
    DesiredLVal = LValue::MakeVectorElt(
        DesiredAddr, AtomicLVal.getVectorIdx(), AtomicLVal.getType(),
        AtomicLVal.getBaseInfo(), AtomicLVal.getTBAAInfo());
  } else {
    assert(AtomicLVal.isExtVectorElt())((AtomicLVal.isExtVectorElt()) ? static_cast<void> (0) :
 __assert_fail ("AtomicLVal.isExtVectorElt()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1713, __PRETTY_FUNCTION__));
    UpdateLVal = LValue::MakeExtVectorElt(Ptr, AtomicLVal.getExtVectorElts(),
                                          AtomicLVal.getType(),
                                          AtomicLVal.getBaseInfo(),
                                          AtomicLVal.getTBAAInfo());
    DesiredLVal = LValue::MakeExtVectorElt(
        DesiredAddr, AtomicLVal.getExtVectorElts(), AtomicLVal.getType(),
        AtomicLVal.getBaseInfo(), AtomicLVal.getTBAAInfo());
  }
  UpRVal = CGF.EmitLoadOfLValue(UpdateLVal, SourceLocation());
}
// Store new value in the corresponding memory area.
RValue NewRVal = UpdateOp(UpRVal);
if (NewRVal.isScalar()) {
  CGF.EmitStoreThroughLValue(NewRVal, DesiredLVal);
} else {
  assert(NewRVal.isComplex())((NewRVal.isComplex()) ? static_cast<void> (0) : __assert_fail
 ("NewRVal.isComplex()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1729, __PRETTY_FUNCTION__));
  CGF.EmitStoreOfComplex(NewRVal.getComplexVal(), DesiredLVal,
                         /*isInit=*/false);
}
1733}

1735void AtomicInfo::EmitAtomicUpdateLibcall(
  llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
  bool IsVolatile) {
auto Failure = llvm::AtomicCmpXchgInst::getStrongestFailureOrdering(AO);

Address ExpectedAddr = CreateTempAlloca();

EmitAtomicLoadLibcall(ExpectedAddr.getPointer(), AO, IsVolatile);
auto *ContBB = CGF.createBasicBlock("atomic_cont");
auto *ExitBB = CGF.createBasicBlock("atomic_exit");
CGF.EmitBlock(ContBB);
Address DesiredAddr = CreateTempAlloca();
if ((LVal.isBitField() && BFI.Size != ValueSizeInBits) ||
    requiresMemSetZero(getAtomicAddress().getElementType())) {
  auto *OldVal = CGF.Builder.CreateLoad(ExpectedAddr);
  CGF.Builder.CreateStore(OldVal, DesiredAddr);
}
auto OldRVal = convertAtomicTempToRValue(ExpectedAddr,
                                         AggValueSlot::ignored(),
                                         SourceLocation(), /*AsValue=*/false);
EmitAtomicUpdateValue(CGF, *this, OldRVal, UpdateOp, DesiredAddr);
auto *Res =
    EmitAtomicCompareExchangeLibcall(ExpectedAddr.getPointer(),
                                     DesiredAddr.getPointer(),
                                     AO, Failure);
CGF.Builder.CreateCondBr(Res, ExitBB, ContBB);
CGF.EmitBlock(ExitBB, /*IsFinished=*/true);
1762}

1764void AtomicInfo::EmitAtomicUpdateOp(
  llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
  bool IsVolatile) {
auto Failure = llvm::AtomicCmpXchgInst::getStrongestFailureOrdering(AO);

// Do the atomic load.
auto *OldVal = EmitAtomicLoadOp(AO, IsVolatile);
// For non-simple lvalues perform compare-and-swap procedure.
auto *ContBB = CGF.createBasicBlock("atomic_cont");
auto *ExitBB = CGF.createBasicBlock("atomic_exit");
auto *CurBB = CGF.Builder.GetInsertBlock();
CGF.EmitBlock(ContBB);
llvm::PHINode *PHI = CGF.Builder.CreatePHI(OldVal->getType(),
                                           /*NumReservedValues=*/2);
PHI->addIncoming(OldVal, CurBB);
Address NewAtomicAddr = CreateTempAlloca();
Address NewAtomicIntAddr = emitCastToAtomicIntPointer(NewAtomicAddr);
if ((LVal.isBitField() && BFI.Size != ValueSizeInBits) ||
    requiresMemSetZero(getAtomicAddress().getElementType())) {
  CGF.Builder.CreateStore(PHI, NewAtomicIntAddr);
}
auto OldRVal = ConvertIntToValueOrAtomic(PHI, AggValueSlot::ignored(),
                                         SourceLocation(), /*AsValue=*/false);
EmitAtomicUpdateValue(CGF, *this, OldRVal, UpdateOp, NewAtomicAddr);
auto *DesiredVal = CGF.Builder.CreateLoad(NewAtomicIntAddr);
// Try to write new value using cmpxchg operation.
auto Res = EmitAtomicCompareExchangeOp(PHI, DesiredVal, AO, Failure);
PHI->addIncoming(Res.first, CGF.Builder.GetInsertBlock());
CGF.Builder.CreateCondBr(Res.second, ExitBB, ContBB);
CGF.EmitBlock(ExitBB, /*IsFinished=*/true);
1794}

1796static void EmitAtomicUpdateValue(CodeGenFunction &CGF, AtomicInfo &Atomics,
                                RValue UpdateRVal, Address DesiredAddr) {
LValue AtomicLVal = Atomics.getAtomicLValue();
LValue DesiredLVal;
// Build new lvalue for temp address.
if (AtomicLVal.isBitField()) {
  DesiredLVal =
      LValue::MakeBitfield(DesiredAddr, AtomicLVal.getBitFieldInfo(),
                           AtomicLVal.getType(), AtomicLVal.getBaseInfo(),
                           AtomicLVal.getTBAAInfo());
} else if (AtomicLVal.isVectorElt()) {
  DesiredLVal =
      LValue::MakeVectorElt(DesiredAddr, AtomicLVal.getVectorIdx(),
                            AtomicLVal.getType(), AtomicLVal.getBaseInfo(),
                            AtomicLVal.getTBAAInfo());
} else {
  assert(AtomicLVal.isExtVectorElt())((AtomicLVal.isExtVectorElt()) ? static_cast<void> (0) :
 __assert_fail ("AtomicLVal.isExtVectorElt()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1812, __PRETTY_FUNCTION__));
  DesiredLVal = LValue::MakeExtVectorElt(
      DesiredAddr, AtomicLVal.getExtVectorElts(), AtomicLVal.getType(),
      AtomicLVal.getBaseInfo(), AtomicLVal.getTBAAInfo());
}
// Store new value in the corresponding memory area.
assert(UpdateRVal.isScalar())((UpdateRVal.isScalar()) ? static_cast<void> (0) : __assert_fail
 ("UpdateRVal.isScalar()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1818, __PRETTY_FUNCTION__));
CGF.EmitStoreThroughLValue(UpdateRVal, DesiredLVal);
1820}

1822void AtomicInfo::EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO,
                                       RValue UpdateRVal, bool IsVolatile) {
auto Failure = llvm::AtomicCmpXchgInst::getStrongestFailureOrdering(AO);

Address ExpectedAddr = CreateTempAlloca();

EmitAtomicLoadLibcall(ExpectedAddr.getPointer(), AO, IsVolatile);
auto *ContBB = CGF.createBasicBlock("atomic_cont");
auto *ExitBB = CGF.createBasicBlock("atomic_exit");
CGF.EmitBlock(ContBB);
Address DesiredAddr = CreateTempAlloca();
if ((LVal.isBitField() && BFI.Size != ValueSizeInBits) ||
    requiresMemSetZero(getAtomicAddress().getElementType())) {
  auto *OldVal = CGF.Builder.CreateLoad(ExpectedAddr);
  CGF.Builder.CreateStore(OldVal, DesiredAddr);
}
EmitAtomicUpdateValue(CGF, *this, UpdateRVal, DesiredAddr);
auto *Res =
    EmitAtomicCompareExchangeLibcall(ExpectedAddr.getPointer(),
                                     DesiredAddr.getPointer(),
                                     AO, Failure);
CGF.Builder.CreateCondBr(Res, ExitBB, ContBB);
CGF.EmitBlock(ExitBB, /*IsFinished=*/true);
1845}

1847void AtomicInfo::EmitAtomicUpdateOp(llvm::AtomicOrdering AO, RValue UpdateRVal,
                                  bool IsVolatile) {
auto Failure = llvm::AtomicCmpXchgInst::getStrongestFailureOrdering(AO);

// Do the atomic load.
auto *OldVal = EmitAtomicLoadOp(AO, IsVolatile);
// For non-simple lvalues perform compare-and-swap procedure.
auto *ContBB = CGF.createBasicBlock("atomic_cont");
auto *ExitBB = CGF.createBasicBlock("atomic_exit");
auto *CurBB = CGF.Builder.GetInsertBlock();
CGF.EmitBlock(ContBB);
llvm::PHINode *PHI = CGF.Builder.CreatePHI(OldVal->getType(),
                                           /*NumReservedValues=*/2);
PHI->addIncoming(OldVal, CurBB);
Address NewAtomicAddr = CreateTempAlloca();
Address NewAtomicIntAddr = emitCastToAtomicIntPointer(NewAtomicAddr);
if ((LVal.isBitField() && BFI.Size != ValueSizeInBits) ||
    requiresMemSetZero(getAtomicAddress().getElementType())) {
  CGF.Builder.CreateStore(PHI, NewAtomicIntAddr);
}
EmitAtomicUpdateValue(CGF, *this, UpdateRVal, NewAtomicAddr);
auto *DesiredVal = CGF.Builder.CreateLoad(NewAtomicIntAddr);
// Try to write new value using cmpxchg operation.
auto Res = EmitAtomicCompareExchangeOp(PHI, DesiredVal, AO, Failure);
PHI->addIncoming(Res.first, CGF.Builder.GetInsertBlock());
CGF.Builder.CreateCondBr(Res.second, ExitBB, ContBB);
CGF.EmitBlock(ExitBB, /*IsFinished=*/true);
1874}

1876void AtomicInfo::EmitAtomicUpdate(
  llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
  bool IsVolatile) {
if (shouldUseLibcall()) {
  EmitAtomicUpdateLibcall(AO, UpdateOp, IsVolatile);
} else {
  EmitAtomicUpdateOp(AO, UpdateOp, IsVolatile);
}
1884}

1886void AtomicInfo::EmitAtomicUpdate(llvm::AtomicOrdering AO, RValue UpdateRVal,
                                bool IsVolatile) {
if (shouldUseLibcall()) {
  EmitAtomicUpdateLibcall(AO, UpdateRVal, IsVolatile);
} else {
  EmitAtomicUpdateOp(AO, UpdateRVal, IsVolatile);
}
1893}

1895void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue lvalue,
                                    bool isInit) {
bool IsVolatile = lvalue.isVolatileQualified();
llvm::AtomicOrdering AO;
if (lvalue.getType()->isAtomicType()) {
  AO = llvm::AtomicOrdering::SequentiallyConsistent;
} else {
  AO = llvm::AtomicOrdering::Release;
  IsVolatile = true;
}
return EmitAtomicStore(rvalue, lvalue, AO, IsVolatile, isInit);
1906}

1908/// Emit a store to an l-value of atomic type.
1909///
1910/// Note that the r-value is expected to be an r-value *of the atomic
1911/// type*; this means that for aggregate r-values, it should include
1912/// storage for any padding that was necessary.
1913void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue dest,
                                    llvm::AtomicOrdering AO, bool IsVolatile,
                                    bool isInit) {
// If this is an aggregate r-value, it should agree in type except
// maybe for address-space qualification.
assert(!rvalue.isAggregate() ||((!rvalue.isAggregate() || rvalue.getAggregateAddress().getElementType
() == dest.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!rvalue.isAggregate() || rvalue.getAggregateAddress().getElementType() == dest.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1920, __PRETTY_FUNCTION__))
       rvalue.getAggregateAddress().getElementType()((!rvalue.isAggregate() || rvalue.getAggregateAddress().getElementType
() == dest.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!rvalue.isAggregate() || rvalue.getAggregateAddress().getElementType() == dest.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1920, __PRETTY_FUNCTION__))
         == dest.getAddress().getElementType())((!rvalue.isAggregate() || rvalue.getAggregateAddress().getElementType
() == dest.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!rvalue.isAggregate() || rvalue.getAggregateAddress().getElementType() == dest.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1920, __PRETTY_FUNCTION__));

AtomicInfo atomics(*this, dest);
LValue LVal = atomics.getAtomicLValue();

// If this is an initialization, just put the value there normally.
if (LVal.isSimple()) {
  if (isInit) {
    atomics.emitCopyIntoMemory(rvalue);
    return;
  }

  // Check whether we should use a library call.
  if (atomics.shouldUseLibcall()) {
    // Produce a source address.
    Address srcAddr = atomics.materializeRValue(rvalue);

    // void __atomic_store(size_t size, void *mem, void *val, int order)
    CallArgList args;
    args.add(RValue::get(atomics.getAtomicSizeValue()),
             getContext().getSizeType());
    args.add(RValue::get(EmitCastToVoidPtr(atomics.getAtomicPointer())),
             getContext().VoidPtrTy);
    args.add(RValue::get(EmitCastToVoidPtr(srcAddr.getPointer())),
             getContext().VoidPtrTy);
    args.add(
        RValue::get(llvm::ConstantInt::get(IntTy, (int)llvm::toCABI(AO))),
        getContext().IntTy);
    emitAtomicLibcall(*this, "__atomic_store", getContext().VoidTy, args);
    return;
  }

  // Okay, we're doing this natively.
  llvm::Value *intValue = atomics.convertRValueToInt(rvalue);

  // Do the atomic store.
  Address addr =
      atomics.emitCastToAtomicIntPointer(atomics.getAtomicAddress());
  intValue = Builder.CreateIntCast(
      intValue, addr.getElementType(), /*isSigned=*/false);
  llvm::StoreInst *store = Builder.CreateStore(intValue, addr);

  // Initializations don't need to be atomic.
  if (!isInit)
    store->setAtomic(AO);

  // Other decoration.
  if (IsVolatile)
    store->setVolatile(true);
  CGM.DecorateInstructionWithTBAA(store, dest.getTBAAInfo());
  return;
}

// Emit simple atomic update operation.
atomics.EmitAtomicUpdate(AO, rvalue, IsVolatile);
1975}

1977/// Emit a compare-and-exchange op for atomic type.
1978///
1979std::pair<RValue, llvm::Value *> CodeGenFunction::EmitAtomicCompareExchange(
  LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
  llvm::AtomicOrdering Success, llvm::AtomicOrdering Failure, bool IsWeak,
  AggValueSlot Slot) {
// If this is an aggregate r-value, it should agree in type except
// maybe for address-space qualification.
assert(!Expected.isAggregate() ||((!Expected.isAggregate() || Expected.getAggregateAddress().getElementType
() == Obj.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!Expected.isAggregate() || Expected.getAggregateAddress().getElementType() == Obj.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1987, __PRETTY_FUNCTION__))
       Expected.getAggregateAddress().getElementType() ==((!Expected.isAggregate() || Expected.getAggregateAddress().getElementType
() == Obj.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!Expected.isAggregate() || Expected.getAggregateAddress().getElementType() == Obj.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1987, __PRETTY_FUNCTION__))
           Obj.getAddress().getElementType())((!Expected.isAggregate() || Expected.getAggregateAddress().getElementType
() == Obj.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!Expected.isAggregate() || Expected.getAggregateAddress().getElementType() == Obj.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1987, __PRETTY_FUNCTION__));
assert(!Desired.isAggregate() ||((!Desired.isAggregate() || Desired.getAggregateAddress().getElementType
() == Obj.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!Desired.isAggregate() || Desired.getAggregateAddress().getElementType() == Obj.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1990, __PRETTY_FUNCTION__))
       Desired.getAggregateAddress().getElementType() ==((!Desired.isAggregate() || Desired.getAggregateAddress().getElementType
() == Obj.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!Desired.isAggregate() || Desired.getAggregateAddress().getElementType() == Obj.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1990, __PRETTY_FUNCTION__))
           Obj.getAddress().getElementType())((!Desired.isAggregate() || Desired.getAggregateAddress().getElementType
() == Obj.getAddress().getElementType()) ? static_cast<void
> (0) : __assert_fail ("!Desired.isAggregate() || Desired.getAggregateAddress().getElementType() == Obj.getAddress().getElementType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 1990, __PRETTY_FUNCTION__));
AtomicInfo Atomics(*this, Obj);

return Atomics.EmitAtomicCompareExchange(Expected, Desired, Success, Failure,
                                         IsWeak);
1995}

1997void CodeGenFunction::EmitAtomicUpdate(
  LValue LVal, llvm::AtomicOrdering AO,
  const llvm::function_ref<RValue(RValue)> &UpdateOp, bool IsVolatile) {
AtomicInfo Atomics(*this, LVal);
Atomics.EmitAtomicUpdate(AO, UpdateOp, IsVolatile);
2002}

2004void CodeGenFunction::EmitAtomicInit(Expr *init, LValue dest) {
AtomicInfo atomics(*this, dest);

switch (atomics.getEvaluationKind()) {
case TEK_Scalar: {
  llvm::Value *value = EmitScalarExpr(init);
  atomics.emitCopyIntoMemory(RValue::get(value));
  return;
}

case TEK_Complex: {
  ComplexPairTy value = EmitComplexExpr(init);
  atomics.emitCopyIntoMemory(RValue::getComplex(value));
  return;
}

case TEK_Aggregate: {
  // Fix up the destination if the initializer isn't an expression
  // of atomic type.
  bool Zeroed = false;
  if (!init->getType()->isAtomicType()) {
    Zeroed = atomics.emitMemSetZeroIfNecessary();
    dest = atomics.projectValue();
  }

  // Evaluate the expression directly into the destination.
  AggValueSlot slot = AggValueSlot::forLValue(dest,
                                      AggValueSlot::IsNotDestructed,
                                      AggValueSlot::DoesNotNeedGCBarriers,
                                      AggValueSlot::IsNotAliased,
                                      AggValueSlot::DoesNotOverlap,
                                      Zeroed ? AggValueSlot::IsZeroed :
                                               AggValueSlot::IsNotZeroed);

  EmitAggExpr(init, slot);
  return;
}
}
llvm_unreachable("bad evaluation kind")::llvm::llvm_unreachable_internal("bad evaluation kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGAtomic.cpp"
, 2042);
2043}

←

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h

1//===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines the Expr interface and subclasses.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_EXPR_H
14#define LLVM_CLANG_AST_EXPR_H

16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTVector.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclAccessPair.h"
20#include "clang/AST/OperationKinds.h"
21#include "clang/AST/Stmt.h"
22#include "clang/AST/TemplateBase.h"
23#include "clang/AST/Type.h"
24#include "clang/Basic/CharInfo.h"
25#include "clang/Basic/FixedPoint.h"
26#include "clang/Basic/LangOptions.h"
27#include "clang/Basic/SyncScope.h"
28#include "clang/Basic/TypeTraits.h"
29#include "llvm/ADT/APFloat.h"
30#include "llvm/ADT/APSInt.h"
31#include "llvm/ADT/iterator.h"
32#include "llvm/ADT/iterator_range.h"
33#include "llvm/ADT/SmallVector.h"
34#include "llvm/ADT/StringRef.h"
35#include "llvm/Support/AtomicOrdering.h"
36#include "llvm/Support/Compiler.h"
37#include "llvm/Support/TrailingObjects.h"

39namespace clang {
class APValue;
class ASTContext;
class BlockDecl;
class CXXBaseSpecifier;
class CXXMemberCallExpr;
class CXXOperatorCallExpr;
class CastExpr;
class Decl;
class IdentifierInfo;
class MaterializeTemporaryExpr;
class NamedDecl;
class ObjCPropertyRefExpr;
class OpaqueValueExpr;
class ParmVarDecl;
class StringLiteral;
class TargetInfo;
class ValueDecl;

58/// A simple array of base specifiers.
59typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;

61/// An adjustment to be made to the temporary created when emitting a
62/// reference binding, which accesses a particular subobject of that temporary.
63struct SubobjectAdjustment {
enum {
  DerivedToBaseAdjustment,
  FieldAdjustment,
  MemberPointerAdjustment
} Kind;

struct DTB {
  const CastExpr *BasePath;
  const CXXRecordDecl *DerivedClass;
};

struct P {
  const MemberPointerType *MPT;
  Expr *RHS;
};

union {
  struct DTB DerivedToBase;
  FieldDecl *Field;
  struct P Ptr;
};

SubobjectAdjustment(const CastExpr *BasePath,
                    const CXXRecordDecl *DerivedClass)
  : Kind(DerivedToBaseAdjustment) {
  DerivedToBase.BasePath = BasePath;
  DerivedToBase.DerivedClass = DerivedClass;
}

SubobjectAdjustment(FieldDecl *Field)
  : Kind(FieldAdjustment) {
  this->Field = Field;
}

SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)
  : Kind(MemberPointerAdjustment) {
  this->Ptr.MPT = MPT;
  this->Ptr.RHS = RHS;
}
103};

105/// This represents one expression.  Note that Expr's are subclasses of Stmt.
106/// This allows an expression to be transparently used any place a Stmt is
107/// required.
108class Expr : public ValueStmt {
QualType TR;

111public:
Expr() = delete;
Expr(const Expr&) = delete;
Expr(Expr &&) = delete;
Expr &operator=(const Expr&) = delete;
Expr &operator=(Expr&&) = delete;

118protected:
Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK,
     bool TD, bool VD, bool ID, bool ContainsUnexpandedParameterPack)
  : ValueStmt(SC)
{
  ExprBits.TypeDependent = TD;
  ExprBits.ValueDependent = VD;
  ExprBits.InstantiationDependent = ID;
  ExprBits.ValueKind = VK;
  ExprBits.ObjectKind = OK;
  assert(ExprBits.ObjectKind == OK && "truncated kind")((ExprBits.ObjectKind == OK && "truncated kind") ? static_cast
<void> (0) : __assert_fail ("ExprBits.ObjectKind == OK && \"truncated kind\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 128, __PRETTY_FUNCTION__));
  ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
  setType(T);
}

/// Construct an empty expression.
explicit Expr(StmtClass SC, EmptyShell) : ValueStmt(SC) { }

136public:
QualType getType() const { return TR; }
void setType(QualType t) {
  // In C++, the type of an expression is always adjusted so that it
  // will not have reference type (C++ [expr]p6). Use
  // QualType::getNonReferenceType() to retrieve the non-reference
  // type. Additionally, inspect Expr::isLvalue to determine whether
  // an expression that is adjusted in this manner should be
  // considered an lvalue.
  assert((t.isNull() || !t->isReferenceType()) &&(((t.isNull() || !t->isReferenceType()) && "Expressions can't have reference type"
) ? static_cast<void> (0) : __assert_fail ("(t.isNull() || !t->isReferenceType()) && \"Expressions can't have reference type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 146, __PRETTY_FUNCTION__))
         "Expressions can't have reference type")(((t.isNull() || !t->isReferenceType()) && "Expressions can't have reference type"
) ? static_cast<void> (0) : __assert_fail ("(t.isNull() || !t->isReferenceType()) && \"Expressions can't have reference type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 146, __PRETTY_FUNCTION__));

  TR = t;
}

/// isValueDependent - Determines whether this expression is
/// value-dependent (C++ [temp.dep.constexpr]). For example, the
/// array bound of "Chars" in the following example is
/// value-dependent.
/// @code
/// template<int Size, char (&Chars)[Size]> struct meta_string;
/// @endcode
bool isValueDependent() const { return ExprBits.ValueDependent; }

/// Set whether this expression is value-dependent or not.
void setValueDependent(bool VD) {
  ExprBits.ValueDependent = VD;
}

/// isTypeDependent - Determines whether this expression is
/// type-dependent (C++ [temp.dep.expr]), which means that its type
/// could change from one template instantiation to the next. For
/// example, the expressions "x" and "x + y" are type-dependent in
/// the following code, but "y" is not type-dependent:
/// @code
/// template<typename T>
/// void add(T x, int y) {
///   x + y;
/// }
/// @endcode
bool isTypeDependent() const { return ExprBits.TypeDependent; }

/// Set whether this expression is type-dependent or not.
void setTypeDependent(bool TD) {
  ExprBits.TypeDependent = TD;
}

/// Whether this expression is instantiation-dependent, meaning that
/// it depends in some way on a template parameter, even if neither its type
/// nor (constant) value can change due to the template instantiation.
///
/// In the following example, the expression \c sizeof(sizeof(T() + T())) is
/// instantiation-dependent (since it involves a template parameter \c T), but
/// is neither type- nor value-dependent, since the type of the inner
/// \c sizeof is known (\c std::size_t) and therefore the size of the outer
/// \c sizeof is known.
///
/// \code
/// template<typename T>
/// void f(T x, T y) {
///   sizeof(sizeof(T() + T());
/// }
/// \endcode
///
bool isInstantiationDependent() const {
  return ExprBits.InstantiationDependent;
}

/// Set whether this expression is instantiation-dependent or not.
void setInstantiationDependent(bool ID) {
  ExprBits.InstantiationDependent = ID;
}

/// Whether this expression contains an unexpanded parameter
/// pack (for C++11 variadic templates).
///
/// Given the following function template:
///
/// \code
/// template<typename F, typename ...Types>
/// void forward(const F &f, Types &&...args) {
///   f(static_cast<Types&&>(args)...);
/// }
/// \endcode
///
/// The expressions \c args and \c static_cast<Types&&>(args) both
/// contain parameter packs.
bool containsUnexpandedParameterPack() const {
  return ExprBits.ContainsUnexpandedParameterPack;
}

/// Set the bit that describes whether this expression
/// contains an unexpanded parameter pack.
void setContainsUnexpandedParameterPack(bool PP = true) {
  ExprBits.ContainsUnexpandedParameterPack = PP;
}

/// getExprLoc - Return the preferred location for the arrow when diagnosing
/// a problem with a generic expression.
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__));

/// isUnusedResultAWarning - Return true if this immediate expression should
/// be warned about if the result is unused.  If so, fill in expr, location,
/// and ranges with expr to warn on and source locations/ranges appropriate
/// for a warning.
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
                            SourceRange &R1, SourceRange &R2,
                            ASTContext &Ctx) const;

/// isLValue - True if this expression is an "l-value" according to
/// the rules of the current language.  C and C++ give somewhat
/// different rules for this concept, but in general, the result of
/// an l-value expression identifies a specific object whereas the
/// result of an r-value expression is a value detached from any
/// specific storage.
///
/// C++11 divides the concept of "r-value" into pure r-values
/// ("pr-values") and so-called expiring values ("x-values"), which
/// identify specific objects that can be safely cannibalized for
/// their resources.  This is an unfortunate abuse of terminology on
/// the part of the C++ committee.  In Clang, when we say "r-value",
/// we generally mean a pr-value.
bool isLValue() const { return getValueKind() == VK_LValue; }
bool isRValue() const { return getValueKind() == VK_RValue; }
bool isXValue() const { return getValueKind() == VK_XValue; }
bool isGLValue() const { return getValueKind() != VK_RValue; }

enum LValueClassification {
  LV_Valid,
  LV_NotObjectType,
  LV_IncompleteVoidType,
  LV_DuplicateVectorComponents,
  LV_InvalidExpression,
  LV_InvalidMessageExpression,
  LV_MemberFunction,
  LV_SubObjCPropertySetting,
  LV_ClassTemporary,
  LV_ArrayTemporary
};
/// Reasons why an expression might not be an l-value.
LValueClassification ClassifyLValue(ASTContext &Ctx) const;

enum isModifiableLvalueResult {
  MLV_Valid,
  MLV_NotObjectType,
  MLV_IncompleteVoidType,
  MLV_DuplicateVectorComponents,
  MLV_InvalidExpression,
  MLV_LValueCast,           // Specialized form of MLV_InvalidExpression.
  MLV_IncompleteType,
  MLV_ConstQualified,
  MLV_ConstQualifiedField,
  MLV_ConstAddrSpace,
  MLV_ArrayType,
  MLV_NoSetterProperty,
  MLV_MemberFunction,
  MLV_SubObjCPropertySetting,
  MLV_InvalidMessageExpression,
  MLV_ClassTemporary,
  MLV_ArrayTemporary
};
/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
/// does not have an incomplete type, does not have a const-qualified type,
/// and if it is a structure or union, does not have any member (including,
/// recursively, any member or element of all contained aggregates or unions)
/// with a const-qualified type.
///
/// \param Loc [in,out] - A source location which *may* be filled
/// in with the location of the expression making this a
/// non-modifiable lvalue, if specified.
isModifiableLvalueResult
isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const;

/// The return type of classify(). Represents the C++11 expression
///        taxonomy.
class Classification {
public:
  /// The various classification results. Most of these mean prvalue.
  enum Kinds {
    CL_LValue,
    CL_XValue,
    CL_Function, // Functions cannot be lvalues in C.
    CL_Void, // Void cannot be an lvalue in C.
    CL_AddressableVoid, // Void expression whose address can be taken in C.
    CL_DuplicateVectorComponents, // A vector shuffle with dupes.
    CL_MemberFunction, // An expression referring to a member function
    CL_SubObjCPropertySetting,
    CL_ClassTemporary, // A temporary of class type, or subobject thereof.
    CL_ArrayTemporary, // A temporary of array type.
    CL_ObjCMessageRValue, // ObjC message is an rvalue
    CL_PRValue // A prvalue for any other reason, of any other type
  };
  /// The results of modification testing.
  enum ModifiableType {
    CM_Untested, // testModifiable was false.
    CM_Modifiable,
    CM_RValue, // Not modifiable because it's an rvalue
    CM_Function, // Not modifiable because it's a function; C++ only
    CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext
    CM_NoSetterProperty,// Implicit assignment to ObjC property without setter
    CM_ConstQualified,
    CM_ConstQualifiedField,
    CM_ConstAddrSpace,
    CM_ArrayType,
    CM_IncompleteType
  };

private:
  friend class Expr;

  unsigned short Kind;
  unsigned short Modifiable;

  explicit Classification(Kinds k, ModifiableType m)
    : Kind(k), Modifiable(m)
  {}

public:
  Classification() {}

  Kinds getKind() const { return static_cast<Kinds>(Kind); }
  ModifiableType getModifiable() const {
    assert(Modifiable != CM_Untested && "Did not test for modifiability.")((Modifiable != CM_Untested && "Did not test for modifiability."
) ? static_cast<void> (0) : __assert_fail ("Modifiable != CM_Untested && \"Did not test for modifiability.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 358, __PRETTY_FUNCTION__));
    return static_cast<ModifiableType>(Modifiable);
  }
  bool isLValue() const { return Kind == CL_LValue; }
  bool isXValue() const { return Kind == CL_XValue; }
  bool isGLValue() const { return Kind <= CL_XValue; }
  bool isPRValue() const { return Kind >= CL_Function; }
  bool isRValue() const { return Kind >= CL_XValue; }
  bool isModifiable() const { return getModifiable() == CM_Modifiable; }

  /// Create a simple, modifiably lvalue
  static Classification makeSimpleLValue() {
    return Classification(CL_LValue, CM_Modifiable);
  }

};
/// Classify - Classify this expression according to the C++11
///        expression taxonomy.
///
/// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the
/// old lvalue vs rvalue. This function determines the type of expression this
/// is. There are three expression types:
/// - lvalues are classical lvalues as in C++03.
/// - prvalues are equivalent to rvalues in C++03.
/// - xvalues are expressions yielding unnamed rvalue references, e.g. a
///   function returning an rvalue reference.
/// lvalues and xvalues are collectively referred to as glvalues, while
/// prvalues and xvalues together form rvalues.
Classification Classify(ASTContext &Ctx) const {
  return ClassifyImpl(Ctx, nullptr);
}

/// ClassifyModifiable - Classify this expression according to the
///        C++11 expression taxonomy, and see if it is valid on the left side
///        of an assignment.
///
/// This function extends classify in that it also tests whether the
/// expression is modifiable (C99 6.3.2.1p1).
/// \param Loc A source location that might be filled with a relevant location
///            if the expression is not modifiable.
Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const{
  return ClassifyImpl(Ctx, &Loc);
}

/// getValueKindForType - Given a formal return or parameter type,
/// give its value kind.
static ExprValueKind getValueKindForType(QualType T) {
  if (const ReferenceType *RT = T->getAs<ReferenceType>())
    return (isa<LValueReferenceType>(RT)
              ? VK_LValue
              : (RT->getPointeeType()->isFunctionType()
                   ? VK_LValue : VK_XValue));
  return VK_RValue;
}

/// getValueKind - The value kind that this expression produces.
ExprValueKind getValueKind() const {
  return static_cast<ExprValueKind>(ExprBits.ValueKind);
}

/// getObjectKind - The object kind that this expression produces.
/// Object kinds are meaningful only for expressions that yield an
/// l-value or x-value.
ExprObjectKind getObjectKind() const {
  return static_cast<ExprObjectKind>(ExprBits.ObjectKind);
}

bool isOrdinaryOrBitFieldObject() const {
  ExprObjectKind OK = getObjectKind();
  return (OK == OK_Ordinary || OK == OK_BitField);
}

/// setValueKind - Set the value kind produced by this expression.
void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; }

/// setObjectKind - Set the object kind produced by this expression.
void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; }

436private:
Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const;

439public:

/// Returns true if this expression is a gl-value that
/// potentially refers to a bit-field.
///
/// In C++, whether a gl-value refers to a bitfield is essentially
/// an aspect of the value-kind type system.
bool refersToBitField() const { return getObjectKind() == OK_BitField; }

/// If this expression refers to a bit-field, retrieve the
/// declaration of that bit-field.
///
/// Note that this returns a non-null pointer in subtly different
/// places than refersToBitField returns true.  In particular, this can
/// return a non-null pointer even for r-values loaded from
/// bit-fields, but it will return null for a conditional bit-field.
FieldDecl *getSourceBitField();

const FieldDecl *getSourceBitField() const {
  return const_cast<Expr*>(this)->getSourceBitField();
}

Decl *getReferencedDeclOfCallee();
const Decl *getReferencedDeclOfCallee() const {
  return const_cast<Expr*>(this)->getReferencedDeclOfCallee();
}

/// If this expression is an l-value for an Objective C
/// property, find the underlying property reference expression.
const ObjCPropertyRefExpr *getObjCProperty() const;

/// Check if this expression is the ObjC 'self' implicit parameter.
bool isObjCSelfExpr() const;

/// Returns whether this expression refers to a vector element.
bool refersToVectorElement() const;

/// Returns whether this expression refers to a global register
/// variable.
bool refersToGlobalRegisterVar() const;

/// Returns whether this expression has a placeholder type.
bool hasPlaceholderType() const {
  return getType()->isPlaceholderType();
}

/// Returns whether this expression has a specific placeholder type.
bool hasPlaceholderType(BuiltinType::Kind K) const {
  assert(BuiltinType::isPlaceholderTypeKind(K))((BuiltinType::isPlaceholderTypeKind(K)) ? static_cast<void
> (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind(K)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 487, __PRETTY_FUNCTION__));
  if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType()))
    return BT->getKind() == K;
  return false;
}

/// isKnownToHaveBooleanValue - Return true if this is an integer expression
/// that is known to return 0 or 1.  This happens for _Bool/bool expressions
/// but also int expressions which are produced by things like comparisons in
/// C.
bool isKnownToHaveBooleanValue() const;

/// isIntegerConstantExpr - Return true if this expression is a valid integer
/// constant expression, and, if so, return its value in Result.  If not a
/// valid i-c-e, return false and fill in Loc (if specified) with the location
/// of the invalid expression.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx,
                           SourceLocation *Loc = nullptr,
                           bool isEvaluated = true) const;
bool isIntegerConstantExpr(const ASTContext &Ctx,
                           SourceLocation *Loc = nullptr) const;

/// isCXX98IntegralConstantExpr - Return true if this expression is an
/// integral constant expression in C++98. Can only be used in C++.
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const;

/// isCXX11ConstantExpr - Return true if this expression is a constant
/// expression in C++11. Can only be used in C++.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,
                         SourceLocation *Loc = nullptr) const;

/// isPotentialConstantExpr - Return true if this function's definition
/// might be usable in a constant expression in C++11, if it were marked
/// constexpr. Return false if the function can never produce a constant
/// expression, along with diagnostics describing why not.
static bool isPotentialConstantExpr(const FunctionDecl *FD,
                                    SmallVectorImpl<
                                      PartialDiagnosticAt> &Diags);

/// isPotentialConstantExprUnevaluted - Return true if this expression might
/// be usable in a constant expression in C++11 in an unevaluated context, if
/// it were in function FD marked constexpr. Return false if the function can
/// never produce a constant expression, along with diagnostics describing
/// why not.
static bool isPotentialConstantExprUnevaluated(Expr *E,
                                               const FunctionDecl *FD,
                                               SmallVectorImpl<
                                                 PartialDiagnosticAt> &Diags);

/// isConstantInitializer - Returns true if this expression can be emitted to
/// IR as a constant, and thus can be used as a constant initializer in C.
/// If this expression is not constant and Culprit is non-null,
/// it is used to store the address of first non constant expr.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef,
                           const Expr **Culprit = nullptr) const;

/// EvalStatus is a struct with detailed info about an evaluation in progress.
struct EvalStatus {
  /// Whether the evaluated expression has side effects.
  /// For example, (f() && 0) can be folded, but it still has side effects.
  bool HasSideEffects;

  /// Whether the evaluation hit undefined behavior.
  /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior.
  /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB.
  bool HasUndefinedBehavior;

  /// Diag - If this is non-null, it will be filled in with a stack of notes
  /// indicating why evaluation failed (or why it failed to produce a constant
  /// expression).
  /// If the expression is unfoldable, the notes will indicate why it's not
  /// foldable. If the expression is foldable, but not a constant expression,
  /// the notes will describes why it isn't a constant expression. If the
  /// expression *is* a constant expression, no notes will be produced.
  SmallVectorImpl<PartialDiagnosticAt> *Diag;

  EvalStatus()
      : HasSideEffects(false), HasUndefinedBehavior(false), Diag(nullptr) {}

  // hasSideEffects - Return true if the evaluated expression has
  // side effects.
  bool hasSideEffects() const {
    return HasSideEffects;
  }
};

/// EvalResult is a struct with detailed info about an evaluated expression.
struct EvalResult : EvalStatus {
  /// Val - This is the value the expression can be folded to.
  APValue Val;

  // isGlobalLValue - Return true if the evaluated lvalue expression
  // is global.
  bool isGlobalLValue() const;
};

/// EvaluateAsRValue - Return true if this is a constant which we can fold to
/// an rvalue using any crazy technique (that has nothing to do with language
/// standards) that we want to, even if the expression has side-effects. If
/// this function returns true, it returns the folded constant in Result. If
/// the expression is a glvalue, an lvalue-to-rvalue conversion will be
/// applied.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx,
                      bool InConstantContext = false) const;

/// EvaluateAsBooleanCondition - Return true if this is a constant
/// which we can fold and convert to a boolean condition using
/// any crazy technique that we want to, even if the expression has
/// side-effects.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,
                                bool InConstantContext = false) const;

enum SideEffectsKind {
  SE_NoSideEffects,          ///< Strictly evaluate the expression.
  SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
                             ///< arbitrary unmodeled side effects.
  SE_AllowSideEffects        ///< Allow any unmodeled side effect.
};

/// EvaluateAsInt - Return true if this is a constant which we can fold and
/// convert to an integer, using any crazy technique that we want to.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
                   SideEffectsKind AllowSideEffects = SE_NoSideEffects,
                   bool InConstantContext = false) const;

/// EvaluateAsFloat - Return true if this is a constant which we can fold and
/// convert to a floating point value, using any crazy technique that we
/// want to.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
                     SideEffectsKind AllowSideEffects = SE_NoSideEffects,
                     bool InConstantContext = false) const;

/// EvaluateAsFloat - Return true if this is a constant which we can fold and
/// convert to a fixed point value.
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,
                          SideEffectsKind AllowSideEffects = SE_NoSideEffects,
                          bool InConstantContext = false) const;

/// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
/// constant folded without side-effects, but discard the result.
bool isEvaluatable(const ASTContext &Ctx,
                   SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;

/// HasSideEffects - This routine returns true for all those expressions
/// which have any effect other than producing a value. Example is a function
/// call, volatile variable read, or throwing an exception. If
/// IncludePossibleEffects is false, this call treats certain expressions with
/// potential side effects (such as function call-like expressions,
/// instantiation-dependent expressions, or invocations from a macro) as not
/// having side effects.
bool HasSideEffects(const ASTContext &Ctx,
                    bool IncludePossibleEffects = true) const;

/// Determine whether this expression involves a call to any function
/// that is not trivial.
bool hasNonTrivialCall(const ASTContext &Ctx) const;

/// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
/// integer. This must be called on an expression that constant folds to an
/// integer.
llvm::APSInt EvaluateKnownConstInt(
    const ASTContext &Ctx,
    SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

llvm::APSInt EvaluateKnownConstIntCheckOverflow(
    const ASTContext &Ctx,
    SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

void EvaluateForOverflow(const ASTContext &Ctx) const;

/// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an
/// lvalue with link time known address, with no side-effects.
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
                      bool InConstantContext = false) const;

/// EvaluateAsInitializer - Evaluate an expression as if it were the
/// initializer of the given declaration. Returns true if the initializer
/// can be folded to a constant, and produces any relevant notes. In C++11,
/// notes will be produced if the expression is not a constant expression.
bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx,
                           const VarDecl *VD,
                           SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

/// EvaluateWithSubstitution - Evaluate an expression as if from the context
/// of a call to the given function with the given arguments, inside an
/// unevaluated context. Returns true if the expression could be folded to a
/// constant.
bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
                              const FunctionDecl *Callee,
                              ArrayRef<const Expr*> Args,
                              const Expr *This = nullptr) const;

/// Indicates how the constant expression will be used.
enum ConstExprUsage { EvaluateForCodeGen, EvaluateForMangling };

/// Evaluate an expression that is required to be a constant expression.
bool EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
                            const ASTContext &Ctx) const;

/// If the current Expr is a pointer, this will try to statically
/// determine the number of bytes available where the pointer is pointing.
/// Returns true if all of the above holds and we were able to figure out the
/// size, false otherwise.
///
/// \param Type - How to evaluate the size of the Expr, as defined by the
/// "type" parameter of __builtin_object_size
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
                           unsigned Type) const;

/// Enumeration used to describe the kind of Null pointer constant
/// returned from \c isNullPointerConstant().
enum NullPointerConstantKind {
  /// Expression is not a Null pointer constant.
  NPCK_NotNull = 0,

  /// Expression is a Null pointer constant built from a zero integer
  /// expression that is not a simple, possibly parenthesized, zero literal.
  /// C++ Core Issue 903 will classify these expressions as "not pointers"
  /// once it is adopted.
  /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
  NPCK_ZeroExpression,

  /// Expression is a Null pointer constant built from a literal zero.
  NPCK_ZeroLiteral,

  /// Expression is a C++11 nullptr.
  NPCK_CXX11_nullptr,

  /// Expression is a GNU-style __null constant.
  NPCK_GNUNull
};

/// Enumeration used to describe how \c isNullPointerConstant()
/// should cope with value-dependent expressions.
enum NullPointerConstantValueDependence {
  /// Specifies that the expression should never be value-dependent.
  NPC_NeverValueDependent = 0,

  /// Specifies that a value-dependent expression of integral or
  /// dependent type should be considered a null pointer constant.
  NPC_ValueDependentIsNull,

  /// Specifies that a value-dependent expression should be considered
  /// to never be a null pointer constant.
  NPC_ValueDependentIsNotNull
};

/// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to
/// a Null pointer constant. The return value can further distinguish the
/// kind of NULL pointer constant that was detected.
NullPointerConstantKind isNullPointerConstant(
    ASTContext &Ctx,
    NullPointerConstantValueDependence NPC) const;

/// isOBJCGCCandidate - Return true if this expression may be used in a read/
/// write barrier.
bool isOBJCGCCandidate(ASTContext &Ctx) const;

/// Returns true if this expression is a bound member function.
bool isBoundMemberFunction(ASTContext &Ctx) const;

/// Given an expression of bound-member type, find the type
/// of the member.  Returns null if this is an *overloaded* bound
/// member expression.
static QualType findBoundMemberType(const Expr *expr);

/// Skip past any implicit casts which might surround this expression until
/// reaching a fixed point. Skips:
/// * ImplicitCastExpr
/// * FullExpr
Expr *IgnoreImpCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreImpCasts() const {
  return const_cast<Expr *>(this)->IgnoreImpCasts();
}

/// Skip past any casts which might surround this expression until reaching
/// a fixed point. Skips:
/// * CastExpr
/// * FullExpr
/// * MaterializeTemporaryExpr
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreCasts() const {
  return const_cast<Expr *>(this)->IgnoreCasts();
}

/// Skip past any implicit AST nodes which might surround this expression
/// until reaching a fixed point. Skips:
/// * What IgnoreImpCasts() skips
/// * MaterializeTemporaryExpr
/// * CXXBindTemporaryExpr
Expr *IgnoreImplicit() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreImplicit() const {
  return const_cast<Expr *>(this)->IgnoreImplicit();
}

/// Skip past any parentheses which might surround this expression until
/// reaching a fixed point. Skips:
/// * ParenExpr
/// * UnaryOperator if `UO_Extension`
/// * GenericSelectionExpr if `!isResultDependent()`
/// * ChooseExpr if `!isConditionDependent()`
/// * ConstantExpr
Expr *IgnoreParens() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParens() const {
  return const_cast<Expr *>(this)->IgnoreParens();
}

/// Skip past any parentheses and implicit casts which might surround this
/// expression until reaching a fixed point.
/// FIXME: IgnoreParenImpCasts really ought to be equivalent to
/// IgnoreParens() + IgnoreImpCasts() until reaching a fixed point. However
/// this is currently not the case. Instead IgnoreParenImpCasts() skips:
/// * What IgnoreParens() skips
/// * What IgnoreImpCasts() skips
/// * MaterializeTemporaryExpr
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreParenImpCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenImpCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenImpCasts();
}

/// Skip past any parentheses and casts which might surround this expression
/// until reaching a fixed point. Skips:
/// * What IgnoreParens() skips
/// * What IgnoreCasts() skips
Expr *IgnoreParenCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenCasts();
}

/// Skip conversion operators. If this Expr is a call to a conversion
/// operator, return the argument.
Expr *IgnoreConversionOperator() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreConversionOperator() const {
  return const_cast<Expr *>(this)->IgnoreConversionOperator();
}

/// Skip past any parentheses and lvalue casts which might surround this
/// expression until reaching a fixed point. Skips:
/// * What IgnoreParens() skips
/// * What IgnoreCasts() skips, except that only lvalue-to-rvalue
///   casts are skipped
/// FIXME: This is intended purely as a temporary workaround for code
/// that hasn't yet been rewritten to do the right thing about those
/// casts, and may disappear along with the last internal use.
Expr *IgnoreParenLValueCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenLValueCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenLValueCasts();
}

/// Skip past any parenthese and casts which do not change the value
/// (including ptr->int casts of the same size) until reaching a fixed point.
/// Skips:
/// * What IgnoreParens() skips
/// * CastExpr which do not change the value
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) const {
  return const_cast<Expr *>(this)->IgnoreParenNoopCasts(Ctx);
}

/// Skip past any parentheses and derived-to-base casts until reaching a
/// fixed point. Skips:
/// * What IgnoreParens() skips
/// * CastExpr which represent a derived-to-base cast (CK_DerivedToBase,
///   CK_UncheckedDerivedToBase and CK_NoOp)
Expr *ignoreParenBaseCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *ignoreParenBaseCasts() const {
  return const_cast<Expr *>(this)->ignoreParenBaseCasts();
}

/// Determine whether this expression is a default function argument.
///
/// Default arguments are implicitly generated in the abstract syntax tree
/// by semantic analysis for function calls, object constructions, etc. in
/// C++. Default arguments are represented by \c CXXDefaultArgExpr nodes;
/// this routine also looks through any implicit casts to determine whether
/// the expression is a default argument.
bool isDefaultArgument() const;

/// Determine whether the result of this expression is a
/// temporary object of the given class type.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const;

/// Whether this expression is an implicit reference to 'this' in C++.
bool isImplicitCXXThis() const;

static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs);

/// For an expression of class type or pointer to class type,
/// return the most derived class decl the expression is known to refer to.
///
/// If this expression is a cast, this method looks through it to find the
/// most derived decl that can be inferred from the expression.
/// This is valid because derived-to-base conversions have undefined
/// behavior if the object isn't dynamically of the derived type.
const CXXRecordDecl *getBestDynamicClassType() const;

/// Get the inner expression that determines the best dynamic class.
/// If this is a prvalue, we guarantee that it is of the most-derived type
/// for the object itself.
const Expr *getBestDynamicClassTypeExpr() const;

/// Walk outwards from an expression we want to bind a reference to and
/// find the expression whose lifetime needs to be extended. Record
/// the LHSs of comma expressions and adjustments needed along the path.
const Expr *skipRValueSubobjectAdjustments(
    SmallVectorImpl<const Expr *> &CommaLHS,
    SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
const Expr *skipRValueSubobjectAdjustments() const {
  SmallVector<const Expr *, 8> CommaLHSs;
  SmallVector<SubobjectAdjustment, 8> Adjustments;
  return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
}

/// Checks that the two Expr's will refer to the same value as a comparison
/// operand.  The caller must ensure that the values referenced by the Expr's
/// are not modified between E1 and E2 or the result my be invalid.
static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstExprConstant &&
         T->getStmtClass() <= lastExprConstant;
}
918};

920//===----------------------------------------------------------------------===//
921// Wrapper Expressions.
922//===----------------------------------------------------------------------===//

924/// FullExpr - Represents a "full-expression" node.
925class FullExpr : public Expr {
926protected:
Stmt *SubExpr;

FullExpr(StmtClass SC, Expr *subexpr)
  : Expr(SC, subexpr->getType(),
         subexpr->getValueKind(), subexpr->getObjectKind(),
         subexpr->isTypeDependent(), subexpr->isValueDependent(),
         subexpr->isInstantiationDependent(),
         subexpr->containsUnexpandedParameterPack()), SubExpr(subexpr) {}
FullExpr(StmtClass SC, EmptyShell Empty)
  : Expr(SC, Empty) {}
937public:
const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
Expr *getSubExpr() { return cast<Expr>(SubExpr); }

/// As with any mutator of the AST, be very careful when modifying an
/// existing AST to preserve its invariants.
void setSubExpr(Expr *E) { SubExpr = E; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstFullExprConstant &&
         T->getStmtClass() <= lastFullExprConstant;
}
949};

951/// ConstantExpr - An expression that occurs in a constant context and
952/// optionally the result of evaluating the expression.
953class ConstantExpr final
  : public FullExpr,
    private llvm::TrailingObjects<ConstantExpr, APValue, uint64_t> {
static_assert(std::is_same<uint64_t, llvm::APInt::WordType>::value,
              "this class assumes llvm::APInt::WordType is uint64_t for "
              "trail-allocated storage");

960public:
/// Describes the kind of result that can be trail-allocated.
enum ResultStorageKind { RSK_None, RSK_Int64, RSK_APValue };

964private:
size_t numTrailingObjects(OverloadToken<APValue>) const {
  return ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue;
}
size_t numTrailingObjects(OverloadToken<uint64_t>) const {
  return ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64;
}

void DefaultInit(ResultStorageKind StorageKind);
uint64_t &Int64Result() {
  assert(ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64 &&((ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64 &&
 "invalid accessor") ? static_cast<void> (0) : __assert_fail
 ("ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64 && \"invalid accessor\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 975, __PRETTY_FUNCTION__))
         "invalid accessor")((ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64 &&
 "invalid accessor") ? static_cast<void> (0) : __assert_fail
 ("ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64 && \"invalid accessor\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 975, __PRETTY_FUNCTION__));
  return *getTrailingObjects<uint64_t>();
}
const uint64_t &Int64Result() const {
  return const_cast<ConstantExpr *>(this)->Int64Result();
}
APValue &APValueResult() {
  assert(ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue &&((ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue &&
 "invalid accessor") ? static_cast<void> (0) : __assert_fail
 ("ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue && \"invalid accessor\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 983, __PRETTY_FUNCTION__))
         "invalid accessor")((ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue &&
 "invalid accessor") ? static_cast<void> (0) : __assert_fail
 ("ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue && \"invalid accessor\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 983, __PRETTY_FUNCTION__));
  return *getTrailingObjects<APValue>();
}
const APValue &APValueResult() const {
  return const_cast<ConstantExpr *>(this)->APValueResult();
}

ConstantExpr(Expr *subexpr, ResultStorageKind StorageKind);
ConstantExpr(ResultStorageKind StorageKind, EmptyShell Empty);

993public:
friend TrailingObjects;
friend class ASTStmtReader;
friend class ASTStmtWriter;
static ConstantExpr *Create(const ASTContext &Context, Expr *E,
                            const APValue &Result);
static ConstantExpr *Create(const ASTContext &Context, Expr *E,
                            ResultStorageKind Storage = RSK_None);
static ConstantExpr *CreateEmpty(const ASTContext &Context,
                                 ResultStorageKind StorageKind,
                                 EmptyShell Empty);

static ResultStorageKind getStorageKind(const APValue &Value);
static ResultStorageKind getStorageKind(const Type *T,
                                        const ASTContext &Context);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConstantExprClass;
}

void SetResult(APValue Value, const ASTContext &Context) {
  MoveIntoResult(Value, Context);
}
void MoveIntoResult(APValue &Value, const ASTContext &Context);

APValue::ValueKind getResultAPValueKind() const {
  return static_cast<APValue::ValueKind>(ConstantExprBits.APValueKind);
}
ResultStorageKind getResultStorageKind() const {
  return static_cast<ResultStorageKind>(ConstantExprBits.ResultKind);
}
APValue getAPValueResult() const;
const APValue &getResultAsAPValue() const { return APValueResult(); }
llvm::APSInt getResultAsAPSInt() const;
// Iterators
child_range children() { return child_range(&SubExpr, &SubExpr+1); }
const_child_range children() const {
  return const_child_range(&SubExpr, &SubExpr + 1);
}
1039};

1041//===----------------------------------------------------------------------===//
1042// Primary Expressions.
1043//===----------------------------------------------------------------------===//

1045/// OpaqueValueExpr - An expression referring to an opaque object of a
1046/// fixed type and value class.  These don't correspond to concrete
1047/// syntax; instead they're used to express operations (usually copy
1048/// operations) on values whose source is generally obvious from
1049/// context.
1050class OpaqueValueExpr : public Expr {
friend class ASTStmtReader;
Expr *SourceExpr;

1054public:
OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK,
                ExprObjectKind OK = OK_Ordinary,
                Expr *SourceExpr = nullptr)
  : Expr(OpaqueValueExprClass, T, VK, OK,
         T->isDependentType() ||
         (SourceExpr && SourceExpr->isTypeDependent()),
         T->isDependentType() ||
         (SourceExpr && SourceExpr->isValueDependent()),
         T->isInstantiationDependentType() ||
         (SourceExpr && SourceExpr->isInstantiationDependent()),
         false),
    SourceExpr(SourceExpr) {
  setIsUnique(false);
  OpaqueValueExprBits.Loc = Loc;
}

/// Given an expression which invokes a copy constructor --- i.e.  a
/// CXXConstructExpr, possibly wrapped in an ExprWithCleanups ---
/// find the OpaqueValueExpr that's the source of the construction.
static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);

explicit OpaqueValueExpr(EmptyShell Empty)
  : Expr(OpaqueValueExprClass, Empty) {}

/// Retrieve the location of this expression.
SourceLocation getLocation() const { return OpaqueValueExprBits.Loc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getBeginLoc() : getLocation();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getEndLoc() : getLocation();
}
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getExprLoc() : getLocation();
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

/// The source expression of an opaque value expression is the
/// expression which originally generated the value.  This is
/// provided as a convenience for analyses that don't wish to
/// precisely model the execution behavior of the program.
///
/// The source expression is typically set when building the
/// expression which binds the opaque value expression in the first
/// place.
Expr *getSourceExpr() const { return SourceExpr; }

void setIsUnique(bool V) {
  assert((!V || SourceExpr) &&(((!V || SourceExpr) && "unique OVEs are expected to have source expressions"
) ? static_cast<void> (0) : __assert_fail ("(!V || SourceExpr) && \"unique OVEs are expected to have source expressions\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1112, __PRETTY_FUNCTION__))
         "unique OVEs are expected to have source expressions")(((!V || SourceExpr) && "unique OVEs are expected to have source expressions"
) ? static_cast<void> (0) : __assert_fail ("(!V || SourceExpr) && \"unique OVEs are expected to have source expressions\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1112, __PRETTY_FUNCTION__));
  OpaqueValueExprBits.IsUnique = V;
}

bool isUnique() const { return OpaqueValueExprBits.IsUnique; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == OpaqueValueExprClass;
}
1121};

1123/// A reference to a declared variable, function, enum, etc.
1124/// [C99 6.5.1p2]
1125///
1126/// This encodes all the information about how a declaration is referenced
1127/// within an expression.
1128///
1129/// There are several optional constructs attached to DeclRefExprs only when
1130/// they apply in order to conserve memory. These are laid out past the end of
1131/// the object, and flags in the DeclRefExprBitfield track whether they exist:
1132///
1133///   DeclRefExprBits.HasQualifier:
1134///       Specifies when this declaration reference expression has a C++
1135///       nested-name-specifier.
1136///   DeclRefExprBits.HasFoundDecl:
1137///       Specifies when this declaration reference expression has a record of
1138///       a NamedDecl (different from the referenced ValueDecl) which was found
1139///       during name lookup and/or overload resolution.
1140///   DeclRefExprBits.HasTemplateKWAndArgsInfo:
1141///       Specifies when this declaration reference expression has an explicit
1142///       C++ template keyword and/or template argument list.
1143///   DeclRefExprBits.RefersToEnclosingVariableOrCapture
1144///       Specifies when this declaration reference expression (validly)
1145///       refers to an enclosed local or a captured variable.
1146class DeclRefExpr final
  : public Expr,
    private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
                                  NamedDecl *, ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The declaration that we are referencing.
ValueDecl *D;

/// Provides source/type location info for the declaration name
/// embedded in D.
DeclarationNameLoc DNLoc;

size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
  return hasQualifier();
}

size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
  return hasFoundDecl();
}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

/// Test whether there is a distinct FoundDecl attached to the end of
/// this DRE.
bool hasFoundDecl() const { return DeclRefExprBits.HasFoundDecl; }

DeclRefExpr(const ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
            SourceLocation TemplateKWLoc, ValueDecl *D,
            bool RefersToEnlosingVariableOrCapture,
            const DeclarationNameInfo &NameInfo, NamedDecl *FoundD,
            const TemplateArgumentListInfo *TemplateArgs, QualType T,
            ExprValueKind VK, NonOdrUseReason NOUR);

/// Construct an empty declaration reference expression.
explicit DeclRefExpr(EmptyShell Empty) : Expr(DeclRefExprClass, Empty) {}

/// Computes the type- and value-dependence flags for this
/// declaration reference expression.
void computeDependence(const ASTContext &Ctx);

1192public:
DeclRefExpr(const ASTContext &Ctx, ValueDecl *D,
            bool RefersToEnclosingVariableOrCapture, QualType T,
            ExprValueKind VK, SourceLocation L,
            const DeclarationNameLoc &LocInfo = DeclarationNameLoc(),
            NonOdrUseReason NOUR = NOUR_None);

static DeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, ValueDecl *D,
       bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
       QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr,
       const TemplateArgumentListInfo *TemplateArgs = nullptr,
       NonOdrUseReason NOUR = NOUR_None);

static DeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, ValueDecl *D,
       bool RefersToEnclosingVariableOrCapture,
       const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK,
       NamedDecl *FoundD = nullptr,
       const TemplateArgumentListInfo *TemplateArgs = nullptr,
       NonOdrUseReason NOUR = NOUR_None);

/// Construct an empty declaration reference expression.
static DeclRefExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
                                bool HasFoundDecl,
                                bool HasTemplateKWAndArgsInfo,
                                unsigned NumTemplateArgs);

ValueDecl *getDecl() { return D; }
const ValueDecl *getDecl() const { return D; }
void setDecl(ValueDecl *NewD) { D = NewD; }

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDecl()->getDeclName(), getLocation(), DNLoc);
}

SourceLocation getLocation() const { return DeclRefExprBits.Loc; }
void setLocation(SourceLocation L) { DeclRefExprBits.Loc = L; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

/// Determine whether this declaration reference was preceded by a
/// C++ nested-name-specifier, e.g., \c N::foo.
bool hasQualifier() const { return DeclRefExprBits.HasQualifier; }

/// If the name was qualified, retrieves the nested-name-specifier
/// that precedes the name, with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const {
  if (!hasQualifier())
    return NestedNameSpecifierLoc();
  return *getTrailingObjects<NestedNameSpecifierLoc>();
}

/// If the name was qualified, retrieves the nested-name-specifier
/// that precedes the name. Otherwise, returns NULL.
NestedNameSpecifier *getQualifier() const {
  return getQualifierLoc().getNestedNameSpecifier();
}

/// Get the NamedDecl through which this reference occurred.
///
/// This Decl may be different from the ValueDecl actually referred to in the
/// presence of using declarations, etc. It always returns non-NULL, and may
/// simple return the ValueDecl when appropriate.

NamedDecl *getFoundDecl() {
  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
}

/// Get the NamedDecl through which this reference occurred.
/// See non-const variant.
const NamedDecl *getFoundDecl() const {
  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
}

bool hasTemplateKWAndArgsInfo() const {
  return DeclRefExprBits.HasTemplateKWAndArgsInfo;
}

/// Retrieve the location of the template keyword preceding
/// this name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the name in this declaration reference
/// was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this declaration reference was followed by an
/// explicit template argument list.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

/// Retrieve the template arguments provided as part of this
/// template-id.
const TemplateArgumentLoc *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;
  return getTrailingObjects<TemplateArgumentLoc>();
}

/// Retrieve the number of template arguments provided as part of this
/// template-id.
unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Returns true if this expression refers to a function that
/// was resolved from an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return DeclRefExprBits.HadMultipleCandidates;
}
/// Sets the flag telling whether this expression refers to
/// a function that was resolved from an overloaded set having size
/// greater than 1.
void setHadMultipleCandidates(bool V = true) {
  DeclRefExprBits.HadMultipleCandidates = V;
}

/// Is this expression a non-odr-use reference, and if so, why?
NonOdrUseReason isNonOdrUse() const {
  return static_cast<NonOdrUseReason>(DeclRefExprBits.NonOdrUseReason);
}

/// Does this DeclRefExpr refer to an enclosing local or a captured
/// variable?
bool refersToEnclosingVariableOrCapture() const {
  return DeclRefExprBits.RefersToEnclosingVariableOrCapture;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DeclRefExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1368};

1370/// Used by IntegerLiteral/FloatingLiteral to store the numeric without
1371/// leaking memory.
1372///
1373/// For large floats/integers, APFloat/APInt will allocate memory from the heap
1374/// to represent these numbers.  Unfortunately, when we use a BumpPtrAllocator
1375/// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with
1376/// the APFloat/APInt values will never get freed. APNumericStorage uses
1377/// ASTContext's allocator for memory allocation.
1378class APNumericStorage {
union {
  uint64_t VAL;    ///< Used to store the <= 64 bits integer value.
  uint64_t *pVal;  ///< Used to store the >64 bits integer value.
};
unsigned BitWidth;

bool hasAllocation() const { return llvm::APInt::getNumWords(BitWidth) > 1; }

APNumericStorage(const APNumericStorage &) = delete;
void operator=(const APNumericStorage &) = delete;

1390protected:
APNumericStorage() : VAL(0), BitWidth(0) { }

llvm::APInt getIntValue() const {
  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
  if (NumWords > 1)
    return llvm::APInt(BitWidth, NumWords, pVal);
  else
    return llvm::APInt(BitWidth, VAL);
}
void setIntValue(const ASTContext &C, const llvm::APInt &Val);
1401};

1403class APIntStorage : private APNumericStorage {
1404public:
llvm::APInt getValue() const { return getIntValue(); }
void setValue(const ASTContext &C, const llvm::APInt &Val) {
  setIntValue(C, Val);
}
1409};

1411class APFloatStorage : private APNumericStorage {
1412public:
llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
  return llvm::APFloat(Semantics, getIntValue());
}
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
  setIntValue(C, Val.bitcastToAPInt());
}
1419};

1421class IntegerLiteral : public Expr, public APIntStorage {
SourceLocation Loc;

/// Construct an empty integer literal.
explicit IntegerLiteral(EmptyShell Empty)
  : Expr(IntegerLiteralClass, Empty) { }

1428public:
// type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy,
// or UnsignedLongLongTy
IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
               SourceLocation l);

/// Returns a new integer literal with value 'V' and type 'type'.
/// \param type - either IntTy, LongTy, LongLongTy, UnsignedIntTy,
/// UnsignedLongTy, or UnsignedLongLongTy which should match the size of V
/// \param V - the value that the returned integer literal contains.
static IntegerLiteral *Create(const ASTContext &C, const llvm::APInt &V,
                              QualType type, SourceLocation l);
/// Returns a new empty integer literal.
static IntegerLiteral *Create(const ASTContext &C, EmptyShell Empty);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

/// Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }

void setLocation(SourceLocation Location) { Loc = Location; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == IntegerLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1462};

1464class FixedPointLiteral : public Expr, public APIntStorage {
SourceLocation Loc;
unsigned Scale;

/// \brief Construct an empty integer literal.
explicit FixedPointLiteral(EmptyShell Empty)
    : Expr(FixedPointLiteralClass, Empty) {}

public:
FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
                  SourceLocation l, unsigned Scale);

// Store the int as is without any bit shifting.
static FixedPointLiteral *CreateFromRawInt(const ASTContext &C,
                                           const llvm::APInt &V,
                                           QualType type, SourceLocation l,
                                           unsigned Scale);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

/// \brief Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }

void setLocation(SourceLocation Location) { Loc = Location; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FixedPointLiteralClass;
}

std::string getValueAsString(unsigned Radix) const;

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1503};

1505class CharacterLiteral : public Expr {
1506public:
enum CharacterKind {
  Ascii,
  Wide,
  UTF8,
  UTF16,
  UTF32
};

1515private:
unsigned Value;
SourceLocation Loc;
1518public:
// type should be IntTy
CharacterLiteral(unsigned value, CharacterKind kind, QualType type,
                 SourceLocation l)
  : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
         false, false),
    Value(value), Loc(l) {
  CharacterLiteralBits.Kind = kind;
}

/// Construct an empty character literal.
CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }

SourceLocation getLocation() const { return Loc; }
CharacterKind getKind() const {
  return static_cast<CharacterKind>(CharacterLiteralBits.Kind);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

unsigned getValue() const { return Value; }

void setLocation(SourceLocation Location) { Loc = Location; }
void setKind(CharacterKind kind) { CharacterLiteralBits.Kind = kind; }
void setValue(unsigned Val) { Value = Val; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CharacterLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1556};

1558class FloatingLiteral : public Expr, private APFloatStorage {
SourceLocation Loc;

FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
                QualType Type, SourceLocation L);

/// Construct an empty floating-point literal.
explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty);

1567public:
static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
                               bool isexact, QualType Type, SourceLocation L);
static FloatingLiteral *Create(const ASTContext &C, EmptyShell Empty);

llvm::APFloat getValue() const {
  return APFloatStorage::getValue(getSemantics());
}
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
  assert(&getSemantics() == &Val.getSemantics() && "Inconsistent semantics")((&getSemantics() == &Val.getSemantics() && "Inconsistent semantics"
) ? static_cast<void> (0) : __assert_fail ("&getSemantics() == &Val.getSemantics() && \"Inconsistent semantics\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1576, __PRETTY_FUNCTION__));
  APFloatStorage::setValue(C, Val);
}

/// Get a raw enumeration value representing the floating-point semantics of
/// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
llvm::APFloatBase::Semantics getRawSemantics() const {
  return static_cast<llvm::APFloatBase::Semantics>(
      FloatingLiteralBits.Semantics);
}

/// Set the raw enumeration value representing the floating-point semantics of
/// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
void setRawSemantics(llvm::APFloatBase::Semantics Sem) {
  FloatingLiteralBits.Semantics = Sem;
}

/// Return the APFloat semantics this literal uses.
const llvm::fltSemantics &getSemantics() const {
  return llvm::APFloatBase::EnumToSemantics(
      static_cast<llvm::APFloatBase::Semantics>(
          FloatingLiteralBits.Semantics));
}

/// Set the APFloat semantics this literal uses.
void setSemantics(const llvm::fltSemantics &Sem) {
  FloatingLiteralBits.Semantics = llvm::APFloatBase::SemanticsToEnum(Sem);
}

bool isExact() const { return FloatingLiteralBits.IsExact; }
void setExact(bool E) { FloatingLiteralBits.IsExact = E; }

/// getValueAsApproximateDouble - This returns the value as an inaccurate
/// double.  Note that this may cause loss of precision, but is useful for
/// debugging dumps, etc.
double getValueAsApproximateDouble() const;

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FloatingLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1630};

1632/// ImaginaryLiteral - We support imaginary integer and floating point literals,
1633/// like "1.0i".  We represent these as a wrapper around FloatingLiteral and
1634/// IntegerLiteral classes.  Instances of this class always have a Complex type
1635/// whose element type matches the subexpression.
1636///
1637class ImaginaryLiteral : public Expr {
Stmt *Val;
1639public:
ImaginaryLiteral(Expr *val, QualType Ty)
  : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false,
         false, false),
    Val(val) {}

/// Build an empty imaginary literal.
explicit ImaginaryLiteral(EmptyShell Empty)
  : Expr(ImaginaryLiteralClass, Empty) { }

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return Val->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Val->getEndLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImaginaryLiteralClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
1667};

1669/// StringLiteral - This represents a string literal expression, e.g. "foo"
1670/// or L"bar" (wide strings). The actual string data can be obtained with
1671/// getBytes() and is NOT null-terminated. The length of the string data is
1672/// determined by calling getByteLength().
1673///
1674/// The C type for a string is always a ConstantArrayType. In C++, the char
1675/// type is const qualified, in C it is not.
1676///
1677/// Note that strings in C can be formed by concatenation of multiple string
1678/// literal pptokens in translation phase #6. This keeps track of the locations
1679/// of each of these pieces.
1680///
1681/// Strings in C can also be truncated and extended by assigning into arrays,
1682/// e.g. with constructs like:
1683///   char X[2] = "foobar";
1684/// In this case, getByteLength() will return 6, but the string literal will
1685/// have type "char[2]".
1686class StringLiteral final
  : public Expr,
    private llvm::TrailingObjects<StringLiteral, unsigned, SourceLocation,
                                  char> {
friend class ASTStmtReader;
friend TrailingObjects;

/// StringLiteral is followed by several trailing objects. They are in order:
///
/// * A single unsigned storing the length in characters of this string. The
///   length in bytes is this length times the width of a single character.
///   Always present and stored as a trailing objects because storing it in
///   StringLiteral would increase the size of StringLiteral by sizeof(void *)
///   due to alignment requirements. If you add some data to StringLiteral,
///   consider moving it inside StringLiteral.
///
/// * An array of getNumConcatenated() SourceLocation, one for each of the
///   token this string is made of.
///
/// * An array of getByteLength() char used to store the string data.

1707public:
enum StringKind { Ascii, Wide, UTF8, UTF16, UTF32 };

1710private:
unsigned numTrailingObjects(OverloadToken<unsigned>) const { return 1; }
unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
  return getNumConcatenated();
}

unsigned numTrailingObjects(OverloadToken<char>) const {
  return getByteLength();
}

char *getStrDataAsChar() { return getTrailingObjects<char>(); }
const char *getStrDataAsChar() const { return getTrailingObjects<char>(); }

const uint16_t *getStrDataAsUInt16() const {
  return reinterpret_cast<const uint16_t *>(getTrailingObjects<char>());
}

const uint32_t *getStrDataAsUInt32() const {
  return reinterpret_cast<const uint32_t *>(getTrailingObjects<char>());
}

/// Build a string literal.
StringLiteral(const ASTContext &Ctx, StringRef Str, StringKind Kind,
              bool Pascal, QualType Ty, const SourceLocation *Loc,
              unsigned NumConcatenated);

/// Build an empty string literal.
StringLiteral(EmptyShell Empty, unsigned NumConcatenated, unsigned Length,
              unsigned CharByteWidth);

/// Map a target and string kind to the appropriate character width.
static unsigned mapCharByteWidth(TargetInfo const &Target, StringKind SK);

/// Set one of the string literal token.
void setStrTokenLoc(unsigned TokNum, SourceLocation L) {
  assert(TokNum < getNumConcatenated() && "Invalid tok number")((TokNum < getNumConcatenated() && "Invalid tok number"
) ? static_cast<void> (0) : __assert_fail ("TokNum < getNumConcatenated() && \"Invalid tok number\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1745, __PRETTY_FUNCTION__));
  getTrailingObjects<SourceLocation>()[TokNum] = L;
}

1749public:
/// This is the "fully general" constructor that allows representation of
/// strings formed from multiple concatenated tokens.
static StringLiteral *Create(const ASTContext &Ctx, StringRef Str,
                             StringKind Kind, bool Pascal, QualType Ty,
                             const SourceLocation *Loc,
                             unsigned NumConcatenated);

/// Simple constructor for string literals made from one token.
static StringLiteral *Create(const ASTContext &Ctx, StringRef Str,
                             StringKind Kind, bool Pascal, QualType Ty,
                             SourceLocation Loc) {
  return Create(Ctx, Str, Kind, Pascal, Ty, &Loc, 1);
}

/// Construct an empty string literal.
static StringLiteral *CreateEmpty(const ASTContext &Ctx,
                                  unsigned NumConcatenated, unsigned Length,
                                  unsigned CharByteWidth);

StringRef getString() const {
  assert(getCharByteWidth() == 1 &&((getCharByteWidth() == 1 && "This function is used in places that assume strings use char"
) ? static_cast<void> (0) : __assert_fail ("getCharByteWidth() == 1 && \"This function is used in places that assume strings use char\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1771, __PRETTY_FUNCTION__))
         "This function is used in places that assume strings use char")((getCharByteWidth() == 1 && "This function is used in places that assume strings use char"
) ? static_cast<void> (0) : __assert_fail ("getCharByteWidth() == 1 && \"This function is used in places that assume strings use char\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1771, __PRETTY_FUNCTION__));
  return StringRef(getStrDataAsChar(), getByteLength());
}

/// Allow access to clients that need the byte representation, such as
/// ASTWriterStmt::VisitStringLiteral().
StringRef getBytes() const {
  // FIXME: StringRef may not be the right type to use as a result for this.
  return StringRef(getStrDataAsChar(), getByteLength());
}

void outputString(raw_ostream &OS) const;

uint32_t getCodeUnit(size_t i) const {
  assert(i < getLength() && "out of bounds access")((i < getLength() && "out of bounds access") ? static_cast
<void> (0) : __assert_fail ("i < getLength() && \"out of bounds access\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1785, __PRETTY_FUNCTION__));
  switch (getCharByteWidth()) {
  case 1:
    return static_cast<unsigned char>(getStrDataAsChar()[i]);
  case 2:
    return getStrDataAsUInt16()[i];
  case 4:
    return getStrDataAsUInt32()[i];
  }
  llvm_unreachable("Unsupported character width!")::llvm::llvm_unreachable_internal("Unsupported character width!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1794);
}

unsigned getByteLength() const { return getCharByteWidth() * getLength(); }
unsigned getLength() const { return *getTrailingObjects<unsigned>(); }
unsigned getCharByteWidth() const { return StringLiteralBits.CharByteWidth; }

StringKind getKind() const {
  return static_cast<StringKind>(StringLiteralBits.Kind);
}

bool isAscii() const { return getKind() == Ascii; }
bool isWide() const { return getKind() == Wide; }
bool isUTF8() const { return getKind() == UTF8; }
bool isUTF16() const { return getKind() == UTF16; }
bool isUTF32() const { return getKind() == UTF32; }
bool isPascal() const { return StringLiteralBits.IsPascal; }

bool containsNonAscii() const {
  for (auto c : getString())
    if (!isASCII(c))
      return true;
  return false;
}

bool containsNonAsciiOrNull() const {
  for (auto c : getString())
    if (!isASCII(c) || !c)
      return true;
  return false;
}

/// getNumConcatenated - Get the number of string literal tokens that were
/// concatenated in translation phase #6 to form this string literal.
unsigned getNumConcatenated() const {
  return StringLiteralBits.NumConcatenated;
}

/// Get one of the string literal token.
SourceLocation getStrTokenLoc(unsigned TokNum) const {
  assert(TokNum < getNumConcatenated() && "Invalid tok number")((TokNum < getNumConcatenated() && "Invalid tok number"
) ? static_cast<void> (0) : __assert_fail ("TokNum < getNumConcatenated() && \"Invalid tok number\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1834, __PRETTY_FUNCTION__));
  return getTrailingObjects<SourceLocation>()[TokNum];
}

/// getLocationOfByte - Return a source location that points to the specified
/// byte of this string literal.
///
/// Strings are amazingly complex.  They can be formed from multiple tokens
/// and can have escape sequences in them in addition to the usual trigraph
/// and escaped newline business.  This routine handles this complexity.
///
SourceLocation
getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
                  const LangOptions &Features, const TargetInfo &Target,
                  unsigned *StartToken = nullptr,
                  unsigned *StartTokenByteOffset = nullptr) const;

typedef const SourceLocation *tokloc_iterator;

tokloc_iterator tokloc_begin() const {
  return getTrailingObjects<SourceLocation>();
}

tokloc_iterator tokloc_end() const {
  return getTrailingObjects<SourceLocation>() + getNumConcatenated();
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return *tokloc_begin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return *(tokloc_end() - 1); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == StringLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1875};

1877/// [C99 6.4.2.2] - A predefined identifier such as __func__.
1878class PredefinedExpr final
  : public Expr,
    private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
friend class ASTStmtReader;
friend TrailingObjects;

// PredefinedExpr is optionally followed by a single trailing
// "Stmt *" for the predefined identifier. It is present if and only if
// hasFunctionName() is true and is always a "StringLiteral *".

1888public:
enum IdentKind {
  Func,
  Function,
  LFunction, // Same as Function, but as wide string.
  FuncDName,
  FuncSig,
  LFuncSig, // Same as FuncSig, but as as wide string
  PrettyFunction,
  /// The same as PrettyFunction, except that the
  /// 'virtual' keyword is omitted for virtual member functions.
  PrettyFunctionNoVirtual
};

1902private:
PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK,
               StringLiteral *SL);

explicit PredefinedExpr(EmptyShell Empty, bool HasFunctionName);

/// True if this PredefinedExpr has storage for a function name.
bool hasFunctionName() const { return PredefinedExprBits.HasFunctionName; }

void setFunctionName(StringLiteral *SL) {
  assert(hasFunctionName() &&((hasFunctionName() && "This PredefinedExpr has no storage for a function name!"
) ? static_cast<void> (0) : __assert_fail ("hasFunctionName() && \"This PredefinedExpr has no storage for a function name!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1913, __PRETTY_FUNCTION__))
         "This PredefinedExpr has no storage for a function name!")((hasFunctionName() && "This PredefinedExpr has no storage for a function name!"
) ? static_cast<void> (0) : __assert_fail ("hasFunctionName() && \"This PredefinedExpr has no storage for a function name!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 1913, __PRETTY_FUNCTION__));
  *getTrailingObjects<Stmt *>() = SL;
}

1917public:
/// Create a PredefinedExpr.
static PredefinedExpr *Create(const ASTContext &Ctx, SourceLocation L,
                              QualType FNTy, IdentKind IK, StringLiteral *SL);

/// Create an empty PredefinedExpr.
static PredefinedExpr *CreateEmpty(const ASTContext &Ctx,
                                   bool HasFunctionName);

IdentKind getIdentKind() const {
  return static_cast<IdentKind>(PredefinedExprBits.Kind);
}

SourceLocation getLocation() const { return PredefinedExprBits.Loc; }
void setLocation(SourceLocation L) { PredefinedExprBits.Loc = L; }

StringLiteral *getFunctionName() {
  return hasFunctionName()
             ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
             : nullptr;
}

const StringLiteral *getFunctionName() const {
  return hasFunctionName()
             ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
             : nullptr;
}

static StringRef getIdentKindName(IdentKind IK);
static std::string ComputeName(IdentKind IK, const Decl *CurrentDecl);

SourceLocation getBeginLoc() const { return getLocation(); }
SourceLocation getEndLoc() const { return getLocation(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PredefinedExprClass;
}

// Iterators
child_range children() {
  return child_range(getTrailingObjects<Stmt *>(),
                     getTrailingObjects<Stmt *>() + hasFunctionName());
}

const_child_range children() const {
  return const_child_range(getTrailingObjects<Stmt *>(),
                           getTrailingObjects<Stmt *>() + hasFunctionName());
}
1965};

1967/// ParenExpr - This represents a parethesized expression, e.g. "(1)".  This
1968/// AST node is only formed if full location information is requested.
1969class ParenExpr : public Expr {
SourceLocation L, R;
Stmt *Val;
1972public:
ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
  : Expr(ParenExprClass, val->getType(),
         val->getValueKind(), val->getObjectKind(),
         val->isTypeDependent(), val->isValueDependent(),
         val->isInstantiationDependent(),
         val->containsUnexpandedParameterPack()),
    L(l), R(r), Val(val) {}

/// Construct an empty parenthesized expression.
explicit ParenExpr(EmptyShell Empty)
  : Expr(ParenExprClass, Empty) { }

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return L; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return R; }

/// Get the location of the left parentheses '('.
SourceLocation getLParen() const { return L; }
void setLParen(SourceLocation Loc) { L = Loc; }

/// Get the location of the right parentheses ')'.
SourceLocation getRParen() const { return R; }
void setRParen(SourceLocation Loc) { R = Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ParenExprClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
2009};

2011/// UnaryOperator - This represents the unary-expression's (except sizeof and
2012/// alignof), the postinc/postdec operators from postfix-expression, and various
2013/// extensions.
2014///
2015/// Notes on various nodes:
2016///
2017/// Real/Imag - These return the real/imag part of a complex operand.  If
2018///   applied to a non-complex value, the former returns its operand and the
2019///   later returns zero in the type of the operand.
2020///
2021class UnaryOperator : public Expr {
Stmt *Val;

2024public:
typedef UnaryOperatorKind Opcode;

UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK,
              ExprObjectKind OK, SourceLocation l, bool CanOverflow)
    : Expr(UnaryOperatorClass, type, VK, OK,
           input->isTypeDependent() || type->isDependentType(),
           input->isValueDependent(),
           (input->isInstantiationDependent() ||
            type->isInstantiationDependentType()),
           input->containsUnexpandedParameterPack()),
      Val(input) {
  UnaryOperatorBits.Opc = opc;
  UnaryOperatorBits.CanOverflow = CanOverflow;
  UnaryOperatorBits.Loc = l;
}

/// Build an empty unary operator.
explicit UnaryOperator(EmptyShell Empty) : Expr(UnaryOperatorClass, Empty) {
  UnaryOperatorBits.Opc = UO_AddrOf;
}

Opcode getOpcode() const {
  return static_cast<Opcode>(UnaryOperatorBits.Opc);
}
void setOpcode(Opcode Opc) { UnaryOperatorBits.Opc = Opc; }

Expr *getSubExpr() const { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return UnaryOperatorBits.Loc; }
void setOperatorLoc(SourceLocation L) { UnaryOperatorBits.Loc = L; }

/// Returns true if the unary operator can cause an overflow. For instance,
///   signed int i = INT_MAX; i++;
///   signed char c = CHAR_MAX; c++;
/// Due to integer promotions, c++ is promoted to an int before the postfix
/// increment, and the result is an int that cannot overflow. However, i++
/// can overflow.
bool canOverflow() const { return UnaryOperatorBits.CanOverflow; }
void setCanOverflow(bool C) { UnaryOperatorBits.CanOverflow = C; }

/// isPostfix - Return true if this is a postfix operation, like x++.
static bool isPostfix(Opcode Op) {
  return Op == UO_PostInc || Op == UO_PostDec;
}

/// isPrefix - Return true if this is a prefix operation, like --x.
static bool isPrefix(Opcode Op) {
  return Op == UO_PreInc || Op == UO_PreDec;
}

bool isPrefix() const { return isPrefix(getOpcode()); }
bool isPostfix() const { return isPostfix(getOpcode()); }

static bool isIncrementOp(Opcode Op) {
  return Op == UO_PreInc || Op == UO_PostInc;
}
bool isIncrementOp() const {
  return isIncrementOp(getOpcode());
}

static bool isDecrementOp(Opcode Op) {
  return Op == UO_PreDec || Op == UO_PostDec;
}
bool isDecrementOp() const {
  return isDecrementOp(getOpcode());
}

static bool isIncrementDecrementOp(Opcode Op) { return Op <= UO_PreDec; }
bool isIncrementDecrementOp() const {
  return isIncrementDecrementOp(getOpcode());
}

static bool isArithmeticOp(Opcode Op) {
  return Op >= UO_Plus && Op <= UO_LNot;
}
bool isArithmeticOp() const { return isArithmeticOp(getOpcode()); }

/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
/// corresponds to, e.g. "sizeof" or "[pre]++"
static StringRef getOpcodeStr(Opcode Op);

/// Retrieve the unary opcode that corresponds to the given
/// overloaded operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix);

/// Retrieve the overloaded operator kind that corresponds to
/// the given unary opcode.
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return isPostfix() ? Val->getBeginLoc() : getOperatorLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return isPostfix() ? getOperatorLoc() : Val->getEndLoc();
}
SourceLocation getExprLoc() const { return getOperatorLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnaryOperatorClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
2133};

2135/// Helper class for OffsetOfExpr.

2137// __builtin_offsetof(type, identifier(.identifier|[expr])*)
2138class OffsetOfNode {
2139public:
/// The kind of offsetof node we have.
enum Kind {
  /// An index into an array.
  Array = 0x00,
  /// A field.
  Field = 0x01,
  /// A field in a dependent type, known only by its name.
  Identifier = 0x02,
  /// An implicit indirection through a C++ base class, when the
  /// field found is in a base class.
  Base = 0x03
};

2153private:
enum { MaskBits = 2, Mask = 0x03 };

/// The source range that covers this part of the designator.
SourceRange Range;

/// The data describing the designator, which comes in three
/// different forms, depending on the lower two bits.
///   - An unsigned index into the array of Expr*'s stored after this node
///     in memory, for [constant-expression] designators.
///   - A FieldDecl*, for references to a known field.
///   - An IdentifierInfo*, for references to a field with a given name
///     when the class type is dependent.
///   - A CXXBaseSpecifier*, for references that look at a field in a
///     base class.
uintptr_t Data;

2170public:
/// Create an offsetof node that refers to an array element.
OffsetOfNode(SourceLocation LBracketLoc, unsigned Index,
             SourceLocation RBracketLoc)
    : Range(LBracketLoc, RBracketLoc), Data((Index << 2) | Array) {}

/// Create an offsetof node that refers to a field.
OffsetOfNode(SourceLocation DotLoc, FieldDecl *Field, SourceLocation NameLoc)
    : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
      Data(reinterpret_cast<uintptr_t>(Field) | OffsetOfNode::Field) {}

/// Create an offsetof node that refers to an identifier.
OffsetOfNode(SourceLocation DotLoc, IdentifierInfo *Name,
             SourceLocation NameLoc)
    : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
      Data(reinterpret_cast<uintptr_t>(Name) | Identifier) {}

/// Create an offsetof node that refers into a C++ base class.
explicit OffsetOfNode(const CXXBaseSpecifier *Base)
    : Range(), Data(reinterpret_cast<uintptr_t>(Base) | OffsetOfNode::Base) {}

/// Determine what kind of offsetof node this is.
Kind getKind() const { return static_cast<Kind>(Data & Mask); }

/// For an array element node, returns the index into the array
/// of expressions.
unsigned getArrayExprIndex() const {
  assert(getKind() == Array)((getKind() == Array) ? static_cast<void> (0) : __assert_fail
 ("getKind() == Array", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2197, __PRETTY_FUNCTION__));
  return Data >> 2;
}

/// For a field offsetof node, returns the field.
FieldDecl *getField() const {
  assert(getKind() == Field)((getKind() == Field) ? static_cast<void> (0) : __assert_fail
 ("getKind() == Field", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2203, __PRETTY_FUNCTION__));
  return reinterpret_cast<FieldDecl *>(Data & ~(uintptr_t)Mask);
}

/// For a field or identifier offsetof node, returns the name of
/// the field.
IdentifierInfo *getFieldName() const;

/// For a base class node, returns the base specifier.
CXXBaseSpecifier *getBase() const {
  assert(getKind() == Base)((getKind() == Base) ? static_cast<void> (0) : __assert_fail
 ("getKind() == Base", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2213, __PRETTY_FUNCTION__));
  return reinterpret_cast<CXXBaseSpecifier *>(Data & ~(uintptr_t)Mask);
}

/// Retrieve the source range that covers this offsetof node.
///
/// For an array element node, the source range contains the locations of
/// the square brackets. For a field or identifier node, the source range
/// contains the location of the period (if there is one) and the
/// identifier.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
2226};

2228/// OffsetOfExpr - [C99 7.17] - This represents an expression of the form
2229/// offsetof(record-type, member-designator). For example, given:
2230/// @code
2231/// struct S {
2232///   float f;
2233///   double d;
2234/// };
2235/// struct T {
2236///   int i;
2237///   struct S s[10];
2238/// };
2239/// @endcode
2240/// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).

2242class OffsetOfExpr final
  : public Expr,
    private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
SourceLocation OperatorLoc, RParenLoc;
// Base type;
TypeSourceInfo *TSInfo;
// Number of sub-components (i.e. instances of OffsetOfNode).
unsigned NumComps;
// Number of sub-expressions (i.e. array subscript expressions).
unsigned NumExprs;

size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const {
  return NumComps;
}

OffsetOfExpr(const ASTContext &C, QualType type,
             SourceLocation OperatorLoc, TypeSourceInfo *tsi,
             ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
             SourceLocation RParenLoc);

explicit OffsetOfExpr(unsigned numComps, unsigned numExprs)
  : Expr(OffsetOfExprClass, EmptyShell()),
    TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {}

2266public:

static OffsetOfExpr *Create(const ASTContext &C, QualType type,
                            SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                            ArrayRef<OffsetOfNode> comps,
                            ArrayRef<Expr*> exprs, SourceLocation RParenLoc);

static OffsetOfExpr *CreateEmpty(const ASTContext &C,
                                 unsigned NumComps, unsigned NumExprs);

/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }
void setOperatorLoc(SourceLocation L) { OperatorLoc = L; }

/// Return the location of the right parentheses.
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation R) { RParenLoc = R; }

TypeSourceInfo *getTypeSourceInfo() const {
  return TSInfo;
}
void setTypeSourceInfo(TypeSourceInfo *tsi) {
  TSInfo = tsi;
}

const OffsetOfNode &getComponent(unsigned Idx) const {
  assert(Idx < NumComps && "Subscript out of range")((Idx < NumComps && "Subscript out of range") ? static_cast
<void> (0) : __assert_fail ("Idx < NumComps && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2292, __PRETTY_FUNCTION__));
  return getTrailingObjects<OffsetOfNode>()[Idx];
}

void setComponent(unsigned Idx, OffsetOfNode ON) {
  assert(Idx < NumComps && "Subscript out of range")((Idx < NumComps && "Subscript out of range") ? static_cast
<void> (0) : __assert_fail ("Idx < NumComps && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2297, __PRETTY_FUNCTION__));
  getTrailingObjects<OffsetOfNode>()[Idx] = ON;
}

unsigned getNumComponents() const {
  return NumComps;
}

Expr* getIndexExpr(unsigned Idx) {
  assert(Idx < NumExprs && "Subscript out of range")((Idx < NumExprs && "Subscript out of range") ? static_cast
<void> (0) : __assert_fail ("Idx < NumExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2306, __PRETTY_FUNCTION__));
  return getTrailingObjects<Expr *>()[Idx];
}

const Expr *getIndexExpr(unsigned Idx) const {
  assert(Idx < NumExprs && "Subscript out of range")((Idx < NumExprs && "Subscript out of range") ? static_cast
<void> (0) : __assert_fail ("Idx < NumExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2311, __PRETTY_FUNCTION__));
  return getTrailingObjects<Expr *>()[Idx];
}

void setIndexExpr(unsigned Idx, Expr* E) {
  assert(Idx < NumComps && "Subscript out of range")((Idx < NumComps && "Subscript out of range") ? static_cast
<void> (0) : __assert_fail ("Idx < NumComps && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2316, __PRETTY_FUNCTION__));
  getTrailingObjects<Expr *>()[Idx] = E;
}

unsigned getNumExpressions() const {
  return NumExprs;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return OperatorLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == OffsetOfExprClass;
}

// Iterators
child_range children() {
  Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
  return child_range(begin, begin + NumExprs);
}
const_child_range children() const {
  Stmt *const *begin =
      reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
  return const_child_range(begin, begin + NumExprs);
}
friend TrailingObjects;
2342};

2344/// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
2345/// expression operand.  Used for sizeof/alignof (C99 6.5.3.4) and
2346/// vec_step (OpenCL 1.1 6.11.12).
2347class UnaryExprOrTypeTraitExpr : public Expr {
union {
  TypeSourceInfo *Ty;
  Stmt *Ex;
} Argument;
SourceLocation OpLoc, RParenLoc;

2354public:
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo,
                         QualType resultType, SourceLocation op,
                         SourceLocation rp) :
    Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
         false, // Never type-dependent (C++ [temp.dep.expr]p3).
         // Value-dependent if the argument is type-dependent.
         TInfo->getType()->isDependentType(),
         TInfo->getType()->isInstantiationDependentType(),
         TInfo->getType()->containsUnexpandedParameterPack()),
    OpLoc(op), RParenLoc(rp) {
  UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
  UnaryExprOrTypeTraitExprBits.IsType = true;
  Argument.Ty = TInfo;
}

UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E,
                         QualType resultType, SourceLocation op,
                         SourceLocation rp);

/// Construct an empty sizeof/alignof expression.
explicit UnaryExprOrTypeTraitExpr(EmptyShell Empty)
  : Expr(UnaryExprOrTypeTraitExprClass, Empty) { }

UnaryExprOrTypeTrait getKind() const {
  return static_cast<UnaryExprOrTypeTrait>(UnaryExprOrTypeTraitExprBits.Kind);
}
void setKind(UnaryExprOrTypeTrait K) { UnaryExprOrTypeTraitExprBits.Kind = K;}

bool isArgumentType() const { return UnaryExprOrTypeTraitExprBits.IsType; }
QualType getArgumentType() const {
  return getArgumentTypeInfo()->getType();
}
TypeSourceInfo *getArgumentTypeInfo() const {
  assert(isArgumentType() && "calling getArgumentType() when arg is expr")((isArgumentType() && "calling getArgumentType() when arg is expr"
) ? static_cast<void> (0) : __assert_fail ("isArgumentType() && \"calling getArgumentType() when arg is expr\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2388, __PRETTY_FUNCTION__));
  return Argument.Ty;
}
Expr *getArgumentExpr() {
  assert(!isArgumentType() && "calling getArgumentExpr() when arg is type")((!isArgumentType() && "calling getArgumentExpr() when arg is type"
) ? static_cast<void> (0) : __assert_fail ("!isArgumentType() && \"calling getArgumentExpr() when arg is type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2392, __PRETTY_FUNCTION__));
  return static_cast<Expr*>(Argument.Ex);
}
const Expr *getArgumentExpr() const {
  return const_cast<UnaryExprOrTypeTraitExpr*>(this)->getArgumentExpr();
}

void setArgument(Expr *E) {
  Argument.Ex = E;
  UnaryExprOrTypeTraitExprBits.IsType = false;
}
void setArgument(TypeSourceInfo *TInfo) {
  Argument.Ty = TInfo;
  UnaryExprOrTypeTraitExprBits.IsType = true;
}

/// Gets the argument type, or the type of the argument expression, whichever
/// is appropriate.
QualType getTypeOfArgument() const {
  return isArgumentType() ? getArgumentType() : getArgumentExpr()->getType();
}

SourceLocation getOperatorLoc() const { return OpLoc; }
void setOperatorLoc(SourceLocation L) { OpLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return OpLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
}

// Iterators
child_range children();
const_child_range children() const;
2430};

2432//===----------------------------------------------------------------------===//
2433// Postfix Operators.
2434//===----------------------------------------------------------------------===//

2436/// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
2437class ArraySubscriptExpr : public Expr {
enum { LHS, RHS, END_EXPR };
Stmt *SubExprs[END_EXPR];

bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); }

2443public:
ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
                   ExprValueKind VK, ExprObjectKind OK,
                   SourceLocation rbracketloc)
: Expr(ArraySubscriptExprClass, t, VK, OK,
       lhs->isTypeDependent() || rhs->isTypeDependent(),
       lhs->isValueDependent() || rhs->isValueDependent(),
       (lhs->isInstantiationDependent() ||
        rhs->isInstantiationDependent()),
       (lhs->containsUnexpandedParameterPack() ||
        rhs->containsUnexpandedParameterPack())) {
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  ArraySubscriptExprBits.RBracketLoc = rbracketloc;
}

/// Create an empty array subscript expression.
explicit ArraySubscriptExpr(EmptyShell Shell)
  : Expr(ArraySubscriptExprClass, Shell) { }

/// An array access can be written A[4] or 4[A] (both are equivalent).
/// - getBase() and getIdx() always present the normalized view: A[4].
///    In this case getBase() returns "A" and getIdx() returns "4".
/// - getLHS() and getRHS() present the syntactic view. e.g. for
///    4[A] getLHS() returns "4".
/// Note: Because vector element access is also written A[4] we must
/// predicate the format conversion in getBase and getIdx only on the
/// the type of the RHS, as it is possible for the LHS to be a vector of
/// integer type
Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }

Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

Expr *getBase() { return lhsIsBase() ? getLHS() : getRHS(); }
const Expr *getBase() const { return lhsIsBase() ? getLHS() : getRHS(); }

Expr *getIdx() { return lhsIsBase() ? getRHS() : getLHS(); }
const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getLHS()->getBeginLoc();
}
SourceLocation getEndLoc() const { return getRBracketLoc(); }

SourceLocation getRBracketLoc() const {
  return ArraySubscriptExprBits.RBracketLoc;
}
void setRBracketLoc(SourceLocation L) {
  ArraySubscriptExprBits.RBracketLoc = L;
}

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getExprLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ArraySubscriptExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
2513};

2515/// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
2516/// CallExpr itself represents a normal function call, e.g., "f(x, 2)",
2517/// while its subclasses may represent alternative syntax that (semantically)
2518/// results in a function call. For example, CXXOperatorCallExpr is
2519/// a subclass for overloaded operator calls that use operator syntax, e.g.,
2520/// "str1 + str2" to resolve to a function call.
2521class CallExpr : public Expr {
enum { FN = 0, PREARGS_START = 1 };

/// The number of arguments in the call expression.
unsigned NumArgs;

/// The location of the right parenthese. This has a different meaning for
/// the derived classes of CallExpr.
SourceLocation RParenLoc;

void updateDependenciesFromArg(Expr *Arg);

// CallExpr store some data in trailing objects. However since CallExpr
// is used a base of other expression classes we cannot use
// llvm::TrailingObjects. Instead we manually perform the pointer arithmetic
// and casts.
//
// The trailing objects are in order:
//
// * A single "Stmt *" for the callee expression.
//
// * An array of getNumPreArgs() "Stmt *" for the pre-argument expressions.
//
// * An array of getNumArgs() "Stmt *" for the argument expressions.
//
// Note that we store the offset in bytes from the this pointer to the start
// of the trailing objects. It would be perfectly possible to compute it
// based on the dynamic kind of the CallExpr. However 1.) we have plenty of
// space in the bit-fields of Stmt. 2.) It was benchmarked to be faster to
// compute this once and then load the offset from the bit-fields of Stmt,
// instead of re-computing the offset each time the trailing objects are
// accessed.

/// Return a pointer to the start of the trailing array of "Stmt *".
Stmt **getTrailingStmts() {
  return reinterpret_cast<Stmt **>(reinterpret_cast<char *>(this) +
                                   CallExprBits.OffsetToTrailingObjects);
}
Stmt *const *getTrailingStmts() const {
  return const_cast<CallExpr *>(this)->getTrailingStmts();
}

/// Map a statement class to the appropriate offset in bytes from the
/// this pointer to the trailing objects.
static unsigned offsetToTrailingObjects(StmtClass SC);

2567public:
enum class ADLCallKind : bool { NotADL, UsesADL };
static constexpr ADLCallKind NotADL = ADLCallKind::NotADL;
static constexpr ADLCallKind UsesADL = ADLCallKind::UsesADL;

2572protected:
/// Build a call expression, assuming that appropriate storage has been
/// allocated for the trailing objects.
CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
         ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
         SourceLocation RParenLoc, unsigned MinNumArgs, ADLCallKind UsesADL);

/// Build an empty call expression, for deserialization.
CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs,
         EmptyShell Empty);

/// Return the size in bytes needed for the trailing objects.
/// Used by the derived classes to allocate the right amount of storage.
static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs) {
  return (1 + NumPreArgs + NumArgs) * sizeof(Stmt *);
}

Stmt *getPreArg(unsigned I) {
  assert(I < getNumPreArgs() && "Prearg access out of range!")((I < getNumPreArgs() && "Prearg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumPreArgs() && \"Prearg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2590, __PRETTY_FUNCTION__));
  return getTrailingStmts()[PREARGS_START + I];
}
const Stmt *getPreArg(unsigned I) const {
  assert(I < getNumPreArgs() && "Prearg access out of range!")((I < getNumPreArgs() && "Prearg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumPreArgs() && \"Prearg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2594, __PRETTY_FUNCTION__));
  return getTrailingStmts()[PREARGS_START + I];
}
void setPreArg(unsigned I, Stmt *PreArg) {
  assert(I < getNumPreArgs() && "Prearg access out of range!")((I < getNumPreArgs() && "Prearg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumPreArgs() && \"Prearg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2598, __PRETTY_FUNCTION__));
  getTrailingStmts()[PREARGS_START + I] = PreArg;
}

unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; }

2604public:
/// Create a call expression. Fn is the callee expression, Args is the
/// argument array, Ty is the type of the call expression (which is *not*
/// the return type in general), VK is the value kind of the call expression
/// (lvalue, rvalue, ...), and RParenLoc is the location of the right
/// parenthese in the call expression. MinNumArgs specifies the minimum
/// number of arguments. The actual number of arguments will be the greater
/// of Args.size() and MinNumArgs. This is used in a few places to allocate
/// enough storage for the default arguments. UsesADL specifies whether the
/// callee was found through argument-dependent lookup.
///
/// Note that you can use CreateTemporary if you need a temporary call
/// expression on the stack.
static CallExpr *Create(const ASTContext &Ctx, Expr *Fn,
                        ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
                        SourceLocation RParenLoc, unsigned MinNumArgs = 0,
                        ADLCallKind UsesADL = NotADL);

/// Create a temporary call expression with no arguments in the memory
/// pointed to by Mem. Mem must points to at least sizeof(CallExpr)
/// + sizeof(Stmt *) bytes of storage, aligned to alignof(CallExpr):
///
/// \code{.cpp}
///   alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
///   CallExpr *TheCall = CallExpr::CreateTemporary(Buffer, etc);
/// \endcode
static CallExpr *CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
                                 ExprValueKind VK, SourceLocation RParenLoc,
                                 ADLCallKind UsesADL = NotADL);

/// Create an empty call expression, for deserialization.
static CallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
                             EmptyShell Empty);

Expr *getCallee() { return cast<Expr>(getTrailingStmts()[FN]); }
const Expr *getCallee() const { return cast<Expr>(getTrailingStmts()[FN]); }
void setCallee(Expr *F) { getTrailingStmts()[FN] = F; }

ADLCallKind getADLCallKind() const {
  return static_cast<ADLCallKind>(CallExprBits.UsesADL);
}
void setADLCallKind(ADLCallKind V = UsesADL) {
  CallExprBits.UsesADL = static_cast<bool>(V);
}
bool usesADL() const { return getADLCallKind() == UsesADL; }

Decl *getCalleeDecl() { return getCallee()->getReferencedDeclOfCallee(); }
const Decl *getCalleeDecl() const {
  return getCallee()->getReferencedDeclOfCallee();
}

/// If the callee is a FunctionDecl, return it. Otherwise return null.
FunctionDecl *getDirectCallee() {
  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
}
const FunctionDecl *getDirectCallee() const {
  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
}

/// getNumArgs - Return the number of actual arguments to this call.
unsigned getNumArgs() const { return NumArgs; }

/// Retrieve the call arguments.
Expr **getArgs() {
  return reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START +
                                   getNumPreArgs());
}
const Expr *const *getArgs() const {
  return reinterpret_cast<const Expr *const *>(
      getTrailingStmts() + PREARGS_START + getNumPreArgs());
}

/// getArg - Return the specified argument.
Expr *getArg(unsigned Arg) {
  assert(Arg < getNumArgs() && "Arg access out of range!")((Arg < getNumArgs() && "Arg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Arg < getNumArgs() && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2678, __PRETTY_FUNCTION__));
  return getArgs()[Arg];
}
const Expr *getArg(unsigned Arg) const {
  assert(Arg < getNumArgs() && "Arg access out of range!")((Arg < getNumArgs() && "Arg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Arg < getNumArgs() && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2682, __PRETTY_FUNCTION__));
  return getArgs()[Arg];
}

/// setArg - Set the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr) {
  assert(Arg < getNumArgs() && "Arg access out of range!")((Arg < getNumArgs() && "Arg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Arg < getNumArgs() && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2688, __PRETTY_FUNCTION__));
  getArgs()[Arg] = ArgExpr;
}

/// Reduce the number of arguments in this call expression. This is used for
/// example during error recovery to drop extra arguments. There is no way
/// to perform the opposite because: 1.) We don't track how much storage
/// we have for the argument array 2.) This would potentially require growing
/// the argument array, something we cannot support since the arguments are
/// stored in a trailing array.
void shrinkNumArgs(unsigned NewNumArgs) {
  assert((NewNumArgs <= getNumArgs()) &&(((NewNumArgs <= getNumArgs()) && "shrinkNumArgs cannot increase the number of arguments!"
) ? static_cast<void> (0) : __assert_fail ("(NewNumArgs <= getNumArgs()) && \"shrinkNumArgs cannot increase the number of arguments!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2700, __PRETTY_FUNCTION__))
         "shrinkNumArgs cannot increase the number of arguments!")(((NewNumArgs <= getNumArgs()) && "shrinkNumArgs cannot increase the number of arguments!"
) ? static_cast<void> (0) : __assert_fail ("(NewNumArgs <= getNumArgs()) && \"shrinkNumArgs cannot increase the number of arguments!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 2700, __PRETTY_FUNCTION__));
  NumArgs = NewNumArgs;
}

/// Bluntly set a new number of arguments without doing any checks whatsoever.
/// Only used during construction of a CallExpr in a few places in Sema.
/// FIXME: Find a way to remove it.
void setNumArgsUnsafe(unsigned NewNumArgs) { NumArgs = NewNumArgs; }

typedef ExprIterator arg_iterator;
typedef ConstExprIterator const_arg_iterator;
typedef llvm::iterator_range<arg_iterator> arg_range;
typedef llvm::iterator_range<const_arg_iterator> const_arg_range;

arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
const_arg_range arguments() const {
  return const_arg_range(arg_begin(), arg_end());
}

arg_iterator arg_begin() {
  return getTrailingStmts() + PREARGS_START + getNumPreArgs();
}
arg_iterator arg_end() { return arg_begin() + getNumArgs(); }

const_arg_iterator arg_begin() const {
  return getTrailingStmts() + PREARGS_START + getNumPreArgs();
}
const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }

/// This method provides fast access to all the subexpressions of
/// a CallExpr without going through the slower virtual child_iterator
/// interface.  This provides efficient reverse iteration of the
/// subexpressions.  This is currently used for CFG construction.
ArrayRef<Stmt *> getRawSubExprs() {
  return llvm::makeArrayRef(getTrailingStmts(),
                            PREARGS_START + getNumPreArgs() + getNumArgs());
}

/// getNumCommas - Return the number of commas that must have been present in
/// this function call.
unsigned getNumCommas() const { return getNumArgs() ? getNumArgs() - 1 : 0; }

/// getBuiltinCallee - If this is a call to a builtin, return the builtin ID
/// of the callee. If not, return 0.
unsigned getBuiltinCallee() const;

/// Returns \c true if this is a call to a builtin which does not
/// evaluate side-effects within its arguments.
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const;

/// getCallReturnType - Get the return type of the call expr. This is not
/// always the type of the expr itself, if the return type is a reference
/// type.
QualType getCallReturnType(const ASTContext &Ctx) const;

/// Returns the WarnUnusedResultAttr that is either declared on the called
/// function, or its return type declaration.
const Attr *getUnusedResultAttr(const ASTContext &Ctx) const;

/// Returns true if this call expression should warn on unused results.
bool hasUnusedResultAttr(const ASTContext &Ctx) const {
  return getUnusedResultAttr(Ctx) != nullptr;
}

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

/// Return true if this is a call to __assume() or __builtin_assume() with
/// a non-value-dependent constant parameter evaluating as false.
bool isBuiltinAssumeFalse(const ASTContext &Ctx) const;

bool isCallToStdMove() const {
  const FunctionDecl *FD = getDirectCallee();
  return getNumArgs() == 1 && FD && FD->isInStdNamespace() &&
         FD->getIdentifier() && FD->getIdentifier()->isStr("move");
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstCallExprConstant &&
         T->getStmtClass() <= lastCallExprConstant;
}

// Iterators
child_range children() {
  return child_range(getTrailingStmts(), getTrailingStmts() + PREARGS_START +
                                             getNumPreArgs() + getNumArgs());
}

const_child_range children() const {
  return const_child_range(getTrailingStmts(),
                           getTrailingStmts() + PREARGS_START +
                               getNumPreArgs() + getNumArgs());
}
2796};

2798/// Extra data stored in some MemberExpr objects.
2799struct MemberExprNameQualifier {
/// The nested-name-specifier that qualifies the name, including
/// source-location information.
NestedNameSpecifierLoc QualifierLoc;

/// The DeclAccessPair through which the MemberDecl was found due to
/// name qualifiers.
DeclAccessPair FoundDecl;
2807};

2809/// MemberExpr - [C99 6.5.2.3] Structure and Union Members.  X->F and X.F.
2810///
2811class MemberExpr final
  : public Expr,
    private llvm::TrailingObjects<MemberExpr, MemberExprNameQualifier,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
friend class ASTReader;
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Base - the expression for the base pointer or structure references.  In
/// X.F, this is "X".
Stmt *Base;

/// MemberDecl - This is the decl being referenced by the field/member name.
/// In X.F, this is the decl referenced by F.
ValueDecl *MemberDecl;

/// MemberDNLoc - Provides source/type location info for the
/// declaration name embedded in MemberDecl.
DeclarationNameLoc MemberDNLoc;

/// MemberLoc - This is the location of the member name.
SourceLocation MemberLoc;

size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const {
  return hasQualifierOrFoundDecl();
}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

bool hasQualifierOrFoundDecl() const {
  return MemberExprBits.HasQualifierOrFoundDecl;
}

bool hasTemplateKWAndArgsInfo() const {
  return MemberExprBits.HasTemplateKWAndArgsInfo;
}

MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
           ValueDecl *MemberDecl, const DeclarationNameInfo &NameInfo,
           QualType T, ExprValueKind VK, ExprObjectKind OK,
           NonOdrUseReason NOUR);
MemberExpr(EmptyShell Empty)
    : Expr(MemberExprClass, Empty), Base(), MemberDecl() {}

2859public:
static MemberExpr *Create(const ASTContext &C, Expr *Base, bool IsArrow,
                          SourceLocation OperatorLoc,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc, ValueDecl *MemberDecl,
                          DeclAccessPair FoundDecl,
                          DeclarationNameInfo MemberNameInfo,
                          const TemplateArgumentListInfo *TemplateArgs,
                          QualType T, ExprValueKind VK, ExprObjectKind OK,
                          NonOdrUseReason NOUR);

/// Create an implicit MemberExpr, with no location, qualifier, template
/// arguments, and so on. Suitable only for non-static member access.
static MemberExpr *CreateImplicit(const ASTContext &C, Expr *Base,
                                  bool IsArrow, ValueDecl *MemberDecl,
                                  QualType T, ExprValueKind VK,
                                  ExprObjectKind OK) {
  return Create(C, Base, IsArrow, SourceLocation(), NestedNameSpecifierLoc(),
                SourceLocation(), MemberDecl,
                DeclAccessPair::make(MemberDecl, MemberDecl->getAccess()),
                DeclarationNameInfo(), nullptr, T, VK, OK, NOUR_None);
}

static MemberExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
                               bool HasFoundDecl,
                               bool HasTemplateKWAndArgsInfo,
                               unsigned NumTemplateArgs);

void setBase(Expr *E) { Base = E; }
Expr *getBase() const { return cast<Expr>(Base); }

/// Retrieve the member declaration to which this expression refers.
///
/// The returned declaration will be a FieldDecl or (in C++) a VarDecl (for
/// static data members), a CXXMethodDecl, or an EnumConstantDecl.
ValueDecl *getMemberDecl() const { return MemberDecl; }
void setMemberDecl(ValueDecl *D) { MemberDecl = D; }

/// Retrieves the declaration found by lookup.
DeclAccessPair getFoundDecl() const {
  if (!hasQualifierOrFoundDecl())
    return DeclAccessPair::make(getMemberDecl(),
                                getMemberDecl()->getAccess());
  return getTrailingObjects<MemberExprNameQualifier>()->FoundDecl;
}

/// Determines whether this member expression actually had
/// a C++ nested-name-specifier prior to the name of the member, e.g.,
/// x->Base::foo.
bool hasQualifier() const { return getQualifier() != nullptr; }

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name, with source-location
/// information.
NestedNameSpecifierLoc getQualifierLoc() const {
  if (!hasQualifierOrFoundDecl())
    return NestedNameSpecifierLoc();
  return getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc;
}

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name. Otherwise, returns
/// NULL.
NestedNameSpecifier *getQualifier() const {
  return getQualifierLoc().getNestedNameSpecifier();
}

/// Retrieve the location of the template keyword preceding
/// the member name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the member name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the member name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the member name was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether the member name was followed by an
/// explicit template argument list.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

/// Retrieve the template arguments provided as part of this
/// template-id.
const TemplateArgumentLoc *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;

  return getTrailingObjects<TemplateArgumentLoc>();
}

/// Retrieve the number of template arguments provided as part of this
/// template-id.
unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Retrieve the member declaration name info.
DeclarationNameInfo getMemberNameInfo() const {
  return DeclarationNameInfo(MemberDecl->getDeclName(),
                             MemberLoc, MemberDNLoc);
}

SourceLocation getOperatorLoc() const { return MemberExprBits.OperatorLoc; }

bool isArrow() const { return MemberExprBits.IsArrow; }
void setArrow(bool A) { MemberExprBits.IsArrow = A; }

/// getMemberLoc - Return the location of the "member", in X->F, it is the
/// location of 'F'.
SourceLocation getMemberLoc() const { return MemberLoc; }
void setMemberLoc(SourceLocation L) { MemberLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return MemberLoc; }

/// Determine whether the base of this explicit is implicit.
bool isImplicitAccess() const {
  return getBase() && getBase()->isImplicitCXXThis();
}

/// Returns true if this member expression refers to a method that
/// was resolved from an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return MemberExprBits.HadMultipleCandidates;
}
/// Sets the flag telling whether this expression refers to
/// a method that was resolved from an overloaded set having size
/// greater than 1.
void setHadMultipleCandidates(bool V = true) {
  MemberExprBits.HadMultipleCandidates = V;
}

/// Returns true if virtual dispatch is performed.
/// If the member access is fully qualified, (i.e. X::f()), virtual
/// dispatching is not performed. In -fapple-kext mode qualified
/// calls to virtual method will still go through the vtable.
bool performsVirtualDispatch(const LangOptions &LO) const {
  return LO.AppleKext || !hasQualifier();
}

/// Is this expression a non-odr-use reference, and if so, why?
/// This is only meaningful if the named member is a static member.
NonOdrUseReason isNonOdrUse() const {
  return static_cast<NonOdrUseReason>(MemberExprBits.NonOdrUseReason);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MemberExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base+1); }
const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}
3048};

3050/// CompoundLiteralExpr - [C99 6.5.2.5]
3051///
3052class CompoundLiteralExpr : public Expr {
/// LParenLoc - If non-null, this is the location of the left paren in a
/// compound literal like "(int){4}".  This can be null if this is a
/// synthesized compound expression.
SourceLocation LParenLoc;

/// The type as written.  This can be an incomplete array type, in
/// which case the actual expression type will be different.
/// The int part of the pair stores whether this expr is file scope.
llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
Stmt *Init;
3063public:
CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo,
                    QualType T, ExprValueKind VK, Expr *init, bool fileScope)
  : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary,
         tinfo->getType()->isDependentType(),
         init->isValueDependent(),
         (init->isInstantiationDependent() ||
          tinfo->getType()->isInstantiationDependentType()),
         init->containsUnexpandedParameterPack()),
    LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {}

/// Construct an empty compound literal.
explicit CompoundLiteralExpr(EmptyShell Empty)
  : Expr(CompoundLiteralExprClass, Empty) { }

const Expr *getInitializer() const { return cast<Expr>(Init); }
Expr *getInitializer() { return cast<Expr>(Init); }
void setInitializer(Expr *E) { Init = E; }

bool isFileScope() const { return TInfoAndScope.getInt(); }
void setFileScope(bool FS) { TInfoAndScope.setInt(FS); }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }

TypeSourceInfo *getTypeSourceInfo() const {
  return TInfoAndScope.getPointer();
}
void setTypeSourceInfo(TypeSourceInfo *tinfo) {
  TInfoAndScope.setPointer(tinfo);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  // FIXME: Init should never be null.
  if (!Init)
    return SourceLocation();
  if (LParenLoc.isInvalid())
    return Init->getBeginLoc();
  return LParenLoc;
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  // FIXME: Init should never be null.
  if (!Init)
    return SourceLocation();
  return Init->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CompoundLiteralExprClass;
}

// Iterators
child_range children() { return child_range(&Init, &Init+1); }
const_child_range children() const {
  return const_child_range(&Init, &Init + 1);
}
3119};

3121/// CastExpr - Base class for type casts, including both implicit
3122/// casts (ImplicitCastExpr) and explicit casts that have some
3123/// representation in the source code (ExplicitCastExpr's derived
3124/// classes).
3125class CastExpr : public Expr {
Stmt *Op;

bool CastConsistency() const;

const CXXBaseSpecifier * const *path_buffer() const {
  return const_cast<CastExpr*>(this)->path_buffer();
}
CXXBaseSpecifier **path_buffer();

3135protected:
CastExpr(StmtClass SC, QualType ty, ExprValueKind VK, const CastKind kind,
         Expr *op, unsigned BasePathSize)
    : Expr(SC, ty, VK, OK_Ordinary,
           // Cast expressions are type-dependent if the type is
           // dependent (C++ [temp.dep.expr]p3).
           ty->isDependentType(),
           // Cast expressions are value-dependent if the type is
           // dependent or if the subexpression is value-dependent.
           ty->isDependentType() || (op && op->isValueDependent()),
           (ty->isInstantiationDependentType() ||
            (op && op->isInstantiationDependent())),
           // An implicit cast expression doesn't (lexically) contain an
           // unexpanded pack, even if its target type does.
           ((SC != ImplicitCastExprClass &&
             ty->containsUnexpandedParameterPack()) ||
            (op && op->containsUnexpandedParameterPack()))),
      Op(op) {
  CastExprBits.Kind = kind;
  CastExprBits.PartOfExplicitCast = false;
  CastExprBits.BasePathSize = BasePathSize;
  assert((CastExprBits.BasePathSize == BasePathSize) &&(((CastExprBits.BasePathSize == BasePathSize) && "BasePathSize overflow!"
) ? static_cast<void> (0) : __assert_fail ("(CastExprBits.BasePathSize == BasePathSize) && \"BasePathSize overflow!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3157, __PRETTY_FUNCTION__))
         "BasePathSize overflow!")(((CastExprBits.BasePathSize == BasePathSize) && "BasePathSize overflow!"
) ? static_cast<void> (0) : __assert_fail ("(CastExprBits.BasePathSize == BasePathSize) && \"BasePathSize overflow!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3157, __PRETTY_FUNCTION__));
  assert(CastConsistency())((CastConsistency()) ? static_cast<void> (0) : __assert_fail
 ("CastConsistency()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3158, __PRETTY_FUNCTION__));
}

/// Construct an empty cast.
CastExpr(StmtClass SC, EmptyShell Empty, unsigned BasePathSize)
  : Expr(SC, Empty) {
  CastExprBits.PartOfExplicitCast = false;
  CastExprBits.BasePathSize = BasePathSize;
  assert((CastExprBits.BasePathSize == BasePathSize) &&(((CastExprBits.BasePathSize == BasePathSize) && "BasePathSize overflow!"
) ? static_cast<void> (0) : __assert_fail ("(CastExprBits.BasePathSize == BasePathSize) && \"BasePathSize overflow!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3167, __PRETTY_FUNCTION__))
         "BasePathSize overflow!")(((CastExprBits.BasePathSize == BasePathSize) && "BasePathSize overflow!"
) ? static_cast<void> (0) : __assert_fail ("(CastExprBits.BasePathSize == BasePathSize) && \"BasePathSize overflow!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3167, __PRETTY_FUNCTION__));
}

3170public:
CastKind getCastKind() const { return (CastKind) CastExprBits.Kind; }
void setCastKind(CastKind K) { CastExprBits.Kind = K; }

static const char *getCastKindName(CastKind CK);
const char *getCastKindName() const { return getCastKindName(getCastKind()); }

Expr *getSubExpr() { return cast<Expr>(Op); }
const Expr *getSubExpr() const { return cast<Expr>(Op); }
void setSubExpr(Expr *E) { Op = E; }

/// Retrieve the cast subexpression as it was written in the source
/// code, looking through any implicit casts or other intermediate nodes
/// introduced by semantic analysis.
Expr *getSubExprAsWritten();
const Expr *getSubExprAsWritten() const {
  return const_cast<CastExpr *>(this)->getSubExprAsWritten();
}

/// If this cast applies a user-defined conversion, retrieve the conversion
/// function that it invokes.
NamedDecl *getConversionFunction() const;

typedef CXXBaseSpecifier **path_iterator;
typedef const CXXBaseSpecifier *const *path_const_iterator;
bool path_empty() const { return path_size() == 0; }
unsigned path_size() const { return CastExprBits.BasePathSize; }
path_iterator path_begin() { return path_buffer(); }
path_iterator path_end() { return path_buffer() + path_size(); }
path_const_iterator path_begin() const { return path_buffer(); }
path_const_iterator path_end() const { return path_buffer() + path_size(); }

llvm::iterator_range<path_iterator> path() {
  return llvm::make_range(path_begin(), path_end());
}
llvm::iterator_range<path_const_iterator> path() const {
  return llvm::make_range(path_begin(), path_end());
}

const FieldDecl *getTargetUnionField() const {
  assert(getCastKind() == CK_ToUnion)((getCastKind() == CK_ToUnion) ? static_cast<void> (0) :
 __assert_fail ("getCastKind() == CK_ToUnion", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3210, __PRETTY_FUNCTION__));
  return getTargetFieldForToUnionCast(getType(), getSubExpr()->getType());
}

static const FieldDecl *getTargetFieldForToUnionCast(QualType unionType,
                                                     QualType opType);
static const FieldDecl *getTargetFieldForToUnionCast(const RecordDecl *RD,
                                                     QualType opType);

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstCastExprConstant &&
         T->getStmtClass() <= lastCastExprConstant;
}

// Iterators
child_range children() { return child_range(&Op, &Op+1); }
const_child_range children() const { return const_child_range(&Op, &Op + 1); }
3227};

3229/// ImplicitCastExpr - Allows us to explicitly represent implicit type
3230/// conversions, which have no direct representation in the original
3231/// source code. For example: converting T[]->T*, void f()->void
3232/// (*f)(), float->double, short->int, etc.
3233///
3234/// In C, implicit casts always produce rvalues. However, in C++, an
3235/// implicit cast whose result is being bound to a reference will be
3236/// an lvalue or xvalue. For example:
3237///
3238/// @code
3239/// class Base { };
3240/// class Derived : public Base { };
3241/// Derived &&ref();
3242/// void f(Derived d) {
3243///   Base& b = d; // initializer is an ImplicitCastExpr
3244///                // to an lvalue of type Base
3245///   Base&& r = ref(); // initializer is an ImplicitCastExpr
3246///                     // to an xvalue of type Base
3247/// }
3248/// @endcode
3249class ImplicitCastExpr final
  : public CastExpr,
    private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *> {

ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
                 unsigned BasePathLength, ExprValueKind VK)
  : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength) { }

/// Construct an empty implicit cast.
explicit ImplicitCastExpr(EmptyShell Shell, unsigned PathSize)
  : CastExpr(ImplicitCastExprClass, Shell, PathSize) { }

3261public:
enum OnStack_t { OnStack };
ImplicitCastExpr(OnStack_t _, QualType ty, CastKind kind, Expr *op,
                 ExprValueKind VK)
  : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, 0) {
}

bool isPartOfExplicitCast() const { return CastExprBits.PartOfExplicitCast; }
void setIsPartOfExplicitCast(bool PartOfExplicitCast) {
  CastExprBits.PartOfExplicitCast = PartOfExplicitCast;
}

static ImplicitCastExpr *Create(const ASTContext &Context, QualType T,
                                CastKind Kind, Expr *Operand,
                                const CXXCastPath *BasePath,
                                ExprValueKind Cat);

static ImplicitCastExpr *CreateEmpty(const ASTContext &Context,
                                     unsigned PathSize);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImplicitCastExprClass;
}

friend TrailingObjects;
friend class CastExpr;
3294};

3296/// ExplicitCastExpr - An explicit cast written in the source
3297/// code.
3298///
3299/// This class is effectively an abstract class, because it provides
3300/// the basic representation of an explicitly-written cast without
3301/// specifying which kind of cast (C cast, functional cast, static
3302/// cast, etc.) was written; specific derived classes represent the
3303/// particular style of cast and its location information.
3304///
3305/// Unlike implicit casts, explicit cast nodes have two different
3306/// types: the type that was written into the source code, and the
3307/// actual type of the expression as determined by semantic
3308/// analysis. These types may differ slightly. For example, in C++ one
3309/// can cast to a reference type, which indicates that the resulting
3310/// expression will be an lvalue or xvalue. The reference type, however,
3311/// will not be used as the type of the expression.
3312class ExplicitCastExpr : public CastExpr {
/// TInfo - Source type info for the (written) type
/// this expression is casting to.
TypeSourceInfo *TInfo;

3317protected:
ExplicitCastExpr(StmtClass SC, QualType exprTy, ExprValueKind VK,
                 CastKind kind, Expr *op, unsigned PathSize,
                 TypeSourceInfo *writtenTy)
  : CastExpr(SC, exprTy, VK, kind, op, PathSize), TInfo(writtenTy) {}

/// Construct an empty explicit cast.
ExplicitCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize)
  : CastExpr(SC, Shell, PathSize) { }

3327public:
/// getTypeInfoAsWritten - Returns the type source info for the type
/// that this expression is casting to.
TypeSourceInfo *getTypeInfoAsWritten() const { return TInfo; }
void setTypeInfoAsWritten(TypeSourceInfo *writtenTy) { TInfo = writtenTy; }

/// getTypeAsWritten - Returns the type that this expression is
/// casting to, as written in the source code.
QualType getTypeAsWritten() const { return TInfo->getType(); }

static bool classof(const Stmt *T) {
   return T->getStmtClass() >= firstExplicitCastExprConstant &&
          T->getStmtClass() <= lastExplicitCastExprConstant;
}
3341};

3343/// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
3344/// cast in C++ (C++ [expr.cast]), which uses the syntax
3345/// (Type)expr. For example: @c (int)f.
3346class CStyleCastExpr final
  : public ExplicitCastExpr,
    private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *> {
SourceLocation LPLoc; // the location of the left paren
SourceLocation RPLoc; // the location of the right paren

CStyleCastExpr(QualType exprTy, ExprValueKind vk, CastKind kind, Expr *op,
               unsigned PathSize, TypeSourceInfo *writtenTy,
               SourceLocation l, SourceLocation r)
  : ExplicitCastExpr(CStyleCastExprClass, exprTy, vk, kind, op, PathSize,
                     writtenTy), LPLoc(l), RPLoc(r) {}

/// Construct an empty C-style explicit cast.
explicit CStyleCastExpr(EmptyShell Shell, unsigned PathSize)
  : ExplicitCastExpr(CStyleCastExprClass, Shell, PathSize) { }

3362public:
static CStyleCastExpr *Create(const ASTContext &Context, QualType T,
                              ExprValueKind VK, CastKind K,
                              Expr *Op, const CXXCastPath *BasePath,
                              TypeSourceInfo *WrittenTy, SourceLocation L,
                              SourceLocation R);

static CStyleCastExpr *CreateEmpty(const ASTContext &Context,
                                   unsigned PathSize);

SourceLocation getLParenLoc() const { return LPLoc; }
void setLParenLoc(SourceLocation L) { LPLoc = L; }

SourceLocation getRParenLoc() const { return RPLoc; }
void setRParenLoc(SourceLocation L) { RPLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LPLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CStyleCastExprClass;
}

friend TrailingObjects;
friend class CastExpr;
3389};

3391/// A builtin binary operation expression such as "x + y" or "x <= y".
3392///
3393/// This expression node kind describes a builtin binary operation,
3394/// such as "x + y" for integer values "x" and "y". The operands will
3395/// already have been converted to appropriate types (e.g., by
3396/// performing promotions or conversions).
3397///
3398/// In C++, where operators may be overloaded, a different kind of
3399/// expression node (CXXOperatorCallExpr) is used to express the
3400/// invocation of an overloaded operator with operator syntax. Within
3401/// a C++ template, whether BinaryOperator or CXXOperatorCallExpr is
3402/// used to store an expression "x + y" depends on the subexpressions
3403/// for x and y. If neither x or y is type-dependent, and the "+"
3404/// operator resolves to a built-in operation, BinaryOperator will be
3405/// used to express the computation (x and y may still be
3406/// value-dependent). If either x or y is type-dependent, or if the
3407/// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
3408/// be used to express the computation.
3409class BinaryOperator : public Expr {
enum { LHS, RHS, END_EXPR };
Stmt *SubExprs[END_EXPR];

3413public:
typedef BinaryOperatorKind Opcode;

BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
               ExprValueKind VK, ExprObjectKind OK,
               SourceLocation opLoc, FPOptions FPFeatures)
  : Expr(BinaryOperatorClass, ResTy, VK, OK,
         lhs->isTypeDependent() || rhs->isTypeDependent(),
         lhs->isValueDependent() || rhs->isValueDependent(),
         (lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack())) {
  BinaryOperatorBits.Opc = opc;
  BinaryOperatorBits.FPFeatures = FPFeatures.getInt();
  BinaryOperatorBits.OpLoc = opLoc;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  assert(!isCompoundAssignmentOp() &&((!isCompoundAssignmentOp() && "Use CompoundAssignOperator for compound assignments"
) ? static_cast<void> (0) : __assert_fail ("!isCompoundAssignmentOp() && \"Use CompoundAssignOperator for compound assignments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3432, __PRETTY_FUNCTION__))
         "Use CompoundAssignOperator for compound assignments")((!isCompoundAssignmentOp() && "Use CompoundAssignOperator for compound assignments"
) ? static_cast<void> (0) : __assert_fail ("!isCompoundAssignmentOp() && \"Use CompoundAssignOperator for compound assignments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3432, __PRETTY_FUNCTION__));
}

/// Construct an empty binary operator.
explicit BinaryOperator(EmptyShell Empty) : Expr(BinaryOperatorClass, Empty) {
  BinaryOperatorBits.Opc = BO_Comma;
}

SourceLocation getExprLoc() const { return getOperatorLoc(); }
SourceLocation getOperatorLoc() const { return BinaryOperatorBits.OpLoc; }
void setOperatorLoc(SourceLocation L) { BinaryOperatorBits.OpLoc = L; }

Opcode getOpcode() const {
  return static_cast<Opcode>(BinaryOperatorBits.Opc);
}
void setOpcode(Opcode Opc) { BinaryOperatorBits.Opc = Opc; }

Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getLHS()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getRHS()->getEndLoc();
}

/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
/// corresponds to, e.g. "<<=".
static StringRef getOpcodeStr(Opcode Op);

StringRef getOpcodeStr() const { return getOpcodeStr(getOpcode()); }

/// Retrieve the binary opcode that corresponds to the given
/// overloaded operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO);

/// Retrieve the overloaded operator kind that corresponds to
/// the given binary opcode.
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);

/// predicates to categorize the respective opcodes.
static bool isPtrMemOp(Opcode Opc) {
  return Opc == BO_PtrMemD || Opc == BO_PtrMemI;
}
bool isPtrMemOp() const { return isPtrMemOp(getOpcode()); }

static bool isMultiplicativeOp(Opcode Opc) {
  return Opc >= BO_Mul && Opc <= BO_Rem;
}
bool isMultiplicativeOp() const { return isMultiplicativeOp(getOpcode()); }
static bool isAdditiveOp(Opcode Opc) { return Opc == BO_Add || Opc==BO_Sub; }
bool isAdditiveOp() const { return isAdditiveOp(getOpcode()); }
static bool isShiftOp(Opcode Opc) { return Opc == BO_Shl || Opc == BO_Shr; }
bool isShiftOp() const { return isShiftOp(getOpcode()); }

static bool isBitwiseOp(Opcode Opc) { return Opc >= BO_And && Opc <= BO_Or; }
bool isBitwiseOp() const { return isBitwiseOp(getOpcode()); }

static bool isRelationalOp(Opcode Opc) { return Opc >= BO_LT && Opc<=BO_GE; }
bool isRelationalOp() const { return isRelationalOp(getOpcode()); }

static bool isEqualityOp(Opcode Opc) { return Opc == BO_EQ || Opc == BO_NE; }
bool isEqualityOp() const { return isEqualityOp(getOpcode()); }

static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
bool isComparisonOp() const { return isComparisonOp(getOpcode()); }

static bool isCommaOp(Opcode Opc) { return Opc == BO_Comma; }
bool isCommaOp() const { return isCommaOp(getOpcode()); }

static Opcode negateComparisonOp(Opcode Opc) {
  switch (Opc) {
  default:
    llvm_unreachable("Not a comparison operator.")::llvm::llvm_unreachable_internal("Not a comparison operator."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3508);
  case BO_LT: return BO_GE;
  case BO_GT: return BO_LE;
  case BO_LE: return BO_GT;
  case BO_GE: return BO_LT;
  case BO_EQ: return BO_NE;
  case BO_NE: return BO_EQ;
  }
}

static Opcode reverseComparisonOp(Opcode Opc) {
  switch (Opc) {
  default:
    llvm_unreachable("Not a comparison operator.")::llvm::llvm_unreachable_internal("Not a comparison operator."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3521);
  case BO_LT: return BO_GT;
  case BO_GT: return BO_LT;
  case BO_LE: return BO_GE;
  case BO_GE: return BO_LE;
  case BO_EQ:
  case BO_NE:
    return Opc;
  }
}

static bool isLogicalOp(Opcode Opc) { return Opc == BO_LAnd || Opc==BO_LOr; }
bool isLogicalOp() const { return isLogicalOp(getOpcode()); }

static bool isAssignmentOp(Opcode Opc) {
  return Opc >= BO_Assign && Opc <= BO_OrAssign;
}
bool isAssignmentOp() const { return isAssignmentOp(getOpcode()); }

static bool isCompoundAssignmentOp(Opcode Opc) {
  return Opc > BO_Assign && Opc <= BO_OrAssign;
}
bool isCompoundAssignmentOp() const {
  return isCompoundAssignmentOp(getOpcode());
}
static Opcode getOpForCompoundAssignment(Opcode Opc) {
  assert(isCompoundAssignmentOp(Opc))((isCompoundAssignmentOp(Opc)) ? static_cast<void> (0) :
 __assert_fail ("isCompoundAssignmentOp(Opc)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3547, __PRETTY_FUNCTION__));
  if (Opc >= BO_AndAssign)
    return Opcode(unsigned(Opc) - BO_AndAssign + BO_And);
  else
    return Opcode(unsigned(Opc) - BO_MulAssign + BO_Mul);
}

static bool isShiftAssignOp(Opcode Opc) {
  return Opc == BO_ShlAssign || Opc == BO_ShrAssign;
}
bool isShiftAssignOp() const {
  return isShiftAssignOp(getOpcode());
}

// Return true if a binary operator using the specified opcode and operands
// would match the 'p = (i8*)nullptr + n' idiom for casting a pointer-sized
// integer to a pointer.
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc,
                                             Expr *LHS, Expr *RHS);

static bool classof(const Stmt *S) {
  return S->getStmtClass() >= firstBinaryOperatorConstant &&
         S->getStmtClass() <= lastBinaryOperatorConstant;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}

// Set the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
void setFPFeatures(FPOptions F) {
  BinaryOperatorBits.FPFeatures = F.getInt();
}

FPOptions getFPFeatures() const {
  return FPOptions(BinaryOperatorBits.FPFeatures);
}

// Get the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
bool isFPContractableWithinStatement() const {
  return getFPFeatures().allowFPContractWithinStatement();
}

// Get the FENV_ACCESS status of this operator. Only meaningful for
// operations on floating point types.
bool isFEnvAccessOn() const { return getFPFeatures().allowFEnvAccess(); }

3600protected:
BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
               ExprValueKind VK, ExprObjectKind OK,
               SourceLocation opLoc, FPOptions FPFeatures, bool dead2)
  : Expr(CompoundAssignOperatorClass, ResTy, VK, OK,
         lhs->isTypeDependent() || rhs->isTypeDependent(),
         lhs->isValueDependent() || rhs->isValueDependent(),
         (lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack())) {
  BinaryOperatorBits.Opc = opc;
  BinaryOperatorBits.FPFeatures = FPFeatures.getInt();
  BinaryOperatorBits.OpLoc = opLoc;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
}

BinaryOperator(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) {
  BinaryOperatorBits.Opc = BO_MulAssign;
}
3621};

3623/// CompoundAssignOperator - For compound assignments (e.g. +=), we keep
3624/// track of the type the operation is performed in.  Due to the semantics of
3625/// these operators, the operands are promoted, the arithmetic performed, an
3626/// implicit conversion back to the result type done, then the assignment takes
3627/// place.  This captures the intermediate type which the computation is done
3628/// in.
3629class CompoundAssignOperator : public BinaryOperator {
QualType ComputationLHSType;
QualType ComputationResultType;
3632public:
CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
                       ExprValueKind VK, ExprObjectKind OK,
                       QualType CompLHSType, QualType CompResultType,
                       SourceLocation OpLoc, FPOptions FPFeatures)
  : BinaryOperator(lhs, rhs, opc, ResType, VK, OK, OpLoc, FPFeatures,
                   true),
    ComputationLHSType(CompLHSType),
    ComputationResultType(CompResultType) {
  assert(isCompoundAssignmentOp() &&((isCompoundAssignmentOp() && "Only should be used for compound assignments"
) ? static_cast<void> (0) : __assert_fail ("isCompoundAssignmentOp() && \"Only should be used for compound assignments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3642, __PRETTY_FUNCTION__))
         "Only should be used for compound assignments")((isCompoundAssignmentOp() && "Only should be used for compound assignments"
) ? static_cast<void> (0) : __assert_fail ("isCompoundAssignmentOp() && \"Only should be used for compound assignments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3642, __PRETTY_FUNCTION__));
}

/// Build an empty compound assignment operator expression.
explicit CompoundAssignOperator(EmptyShell Empty)
  : BinaryOperator(CompoundAssignOperatorClass, Empty) { }

// The two computation types are the type the LHS is converted
// to for the computation and the type of the result; the two are
// distinct in a few cases (specifically, int+=ptr and ptr-=ptr).
QualType getComputationLHSType() const { return ComputationLHSType; }
void setComputationLHSType(QualType T) { ComputationLHSType = T; }

QualType getComputationResultType() const { return ComputationResultType; }
void setComputationResultType(QualType T) { ComputationResultType = T; }

static bool classof(const Stmt *S) {
  return S->getStmtClass() == CompoundAssignOperatorClass;
}
3661};

3663/// AbstractConditionalOperator - An abstract base class for
3664/// ConditionalOperator and BinaryConditionalOperator.
3665class AbstractConditionalOperator : public Expr {
SourceLocation QuestionLoc, ColonLoc;
friend class ASTStmtReader;

3669protected:
AbstractConditionalOperator(StmtClass SC, QualType T,
                            ExprValueKind VK, ExprObjectKind OK,
                            bool TD, bool VD, bool ID,
                            bool ContainsUnexpandedParameterPack,
                            SourceLocation qloc,
                            SourceLocation cloc)
  : Expr(SC, T, VK, OK, TD, VD, ID, ContainsUnexpandedParameterPack),
    QuestionLoc(qloc), ColonLoc(cloc) {}

AbstractConditionalOperator(StmtClass SC, EmptyShell Empty)
  : Expr(SC, Empty) { }

3682public:
// getCond - Return the expression representing the condition for
//   the ?: operator.
Expr *getCond() const;

// getTrueExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to true.
Expr *getTrueExpr() const;

// getFalseExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to false.  This is
//   the same as getRHS.
Expr *getFalseExpr() const;

SourceLocation getQuestionLoc() const { return QuestionLoc; }
SourceLocation getColonLoc() const { return ColonLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConditionalOperatorClass ||
         T->getStmtClass() == BinaryConditionalOperatorClass;
}
3703};

3705/// ConditionalOperator - The ?: ternary operator.  The GNU "missing
3706/// middle" extension is a BinaryConditionalOperator.
3707class ConditionalOperator : public AbstractConditionalOperator {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.

friend class ASTStmtReader;
3712public:
ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs,
                    SourceLocation CLoc, Expr *rhs,
                    QualType t, ExprValueKind VK, ExprObjectKind OK)
  : AbstractConditionalOperator(ConditionalOperatorClass, t, VK, OK,
         // FIXME: the type of the conditional operator doesn't
         // depend on the type of the conditional, but the standard
         // seems to imply that it could. File a bug!
         (lhs->isTypeDependent() || rhs->isTypeDependent()),
         (cond->isValueDependent() || lhs->isValueDependent() ||
          rhs->isValueDependent()),
         (cond->isInstantiationDependent() ||
          lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (cond->containsUnexpandedParameterPack() ||
          lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack()),
                                QLoc, CLoc) {
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
}

/// Build an empty conditional operator.
explicit ConditionalOperator(EmptyShell Empty)
  : AbstractConditionalOperator(ConditionalOperatorClass, Empty) { }

// getCond - Return the expression representing the condition for
//   the ?: operator.
Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }

// getTrueExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to true.
Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }

// getFalseExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to false.  This is
//   the same as getRHS.
Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }

Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCond()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getRHS()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConditionalOperatorClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
3773};

3775/// BinaryConditionalOperator - The GNU extension to the conditional
3776/// operator which allows the middle operand to be omitted.
3777///
3778/// This is a different expression kind on the assumption that almost
3779/// every client ends up needing to know that these are different.
3780class BinaryConditionalOperator : public AbstractConditionalOperator {
enum { COMMON, COND, LHS, RHS, NUM_SUBEXPRS };

/// - the common condition/left-hand-side expression, which will be
///   evaluated as the opaque value
/// - the condition, expressed in terms of the opaque value
/// - the left-hand-side, expressed in terms of the opaque value
/// - the right-hand-side
Stmt *SubExprs[NUM_SUBEXPRS];
OpaqueValueExpr *OpaqueValue;

friend class ASTStmtReader;
3792public:
BinaryConditionalOperator(Expr *common, OpaqueValueExpr *opaqueValue,
                          Expr *cond, Expr *lhs, Expr *rhs,
                          SourceLocation qloc, SourceLocation cloc,
                          QualType t, ExprValueKind VK, ExprObjectKind OK)
  : AbstractConditionalOperator(BinaryConditionalOperatorClass, t, VK, OK,
         (common->isTypeDependent() || rhs->isTypeDependent()),
         (common->isValueDependent() || rhs->isValueDependent()),
         (common->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (common->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack()),
                                qloc, cloc),
    OpaqueValue(opaqueValue) {
  SubExprs[COMMON] = common;
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  assert(OpaqueValue->getSourceExpr() == common && "Wrong opaque value")((OpaqueValue->getSourceExpr() == common && "Wrong opaque value"
) ? static_cast<void> (0) : __assert_fail ("OpaqueValue->getSourceExpr() == common && \"Wrong opaque value\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 3810, __PRETTY_FUNCTION__));
}

/// Build an empty conditional operator.
explicit BinaryConditionalOperator(EmptyShell Empty)
  : AbstractConditionalOperator(BinaryConditionalOperatorClass, Empty) { }

/// getCommon - Return the common expression, written to the
///   left of the condition.  The opaque value will be bound to the
///   result of this expression.
Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }

/// getOpaqueValue - Return the opaque value placeholder.
OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }

/// getCond - Return the condition expression; this is defined
///   in terms of the opaque value.
Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }

/// getTrueExpr - Return the subexpression which will be
///   evaluated if the condition evaluates to true;  this is defined
///   in terms of the opaque value.
Expr *getTrueExpr() const {
  return cast<Expr>(SubExprs[LHS]);
}

/// getFalseExpr - Return the subexpression which will be
///   evaluated if the condnition evaluates to false; this is
///   defined in terms of the opaque value.
Expr *getFalseExpr() const {
  return cast<Expr>(SubExprs[RHS]);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommon()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getFalseExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == BinaryConditionalOperatorClass;
}

// Iterators
child_range children() {
  return child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
}
3861};

3863inline Expr *AbstractConditionalOperator::getCond() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getCond();
return cast<BinaryConditionalOperator>(this)->getCond();
3867}

3869inline Expr *AbstractConditionalOperator::getTrueExpr() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getTrueExpr();
return cast<BinaryConditionalOperator>(this)->getTrueExpr();
3873}

3875inline Expr *AbstractConditionalOperator::getFalseExpr() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getFalseExpr();
return cast<BinaryConditionalOperator>(this)->getFalseExpr();
3879}

3881/// AddrLabelExpr - The GNU address of label extension, representing &&label.
3882class AddrLabelExpr : public Expr {
SourceLocation AmpAmpLoc, LabelLoc;
LabelDecl *Label;
3885public:
AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L,
              QualType t)
  : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false, false,
         false),
    AmpAmpLoc(AALoc), LabelLoc(LLoc), Label(L) {}

/// Build an empty address of a label expression.
explicit AddrLabelExpr(EmptyShell Empty)
  : Expr(AddrLabelExprClass, Empty) { }

SourceLocation getAmpAmpLoc() const { return AmpAmpLoc; }
void setAmpAmpLoc(SourceLocation L) { AmpAmpLoc = L; }
SourceLocation getLabelLoc() const { return LabelLoc; }
void setLabelLoc(SourceLocation L) { LabelLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return AmpAmpLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return LabelLoc; }

LabelDecl *getLabel() const { return Label; }
void setLabel(LabelDecl *L) { Label = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AddrLabelExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
3918};

3920/// StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
3921/// The StmtExpr contains a single CompoundStmt node, which it evaluates and
3922/// takes the value of the last subexpression.
3923///
3924/// A StmtExpr is always an r-value; values "returned" out of a
3925/// StmtExpr will be copied.
3926class StmtExpr : public Expr {
Stmt *SubStmt;
SourceLocation LParenLoc, RParenLoc;
3929public:
// FIXME: Does type-dependence need to be computed differently?
// FIXME: Do we need to compute instantiation instantiation-dependence for
// statements? (ugh!)
StmtExpr(CompoundStmt *substmt, QualType T,
         SourceLocation lp, SourceLocation rp) :
  Expr(StmtExprClass, T, VK_RValue, OK_Ordinary,
       T->isDependentType(), false, false, false),
  SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { }

/// Build an empty statement expression.
explicit StmtExpr(EmptyShell Empty) : Expr(StmtExprClass, Empty) { }

CompoundStmt *getSubStmt() { return cast<CompoundStmt>(SubStmt); }
const CompoundStmt *getSubStmt() const { return cast<CompoundStmt>(SubStmt); }
void setSubStmt(CompoundStmt *S) { SubStmt = S; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LParenLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == StmtExprClass;
}

// Iterators
child_range children() { return child_range(&SubStmt, &SubStmt+1); }
const_child_range children() const {
  return const_child_range(&SubStmt, &SubStmt + 1);
}
3963};

3965/// ShuffleVectorExpr - clang-specific builtin-in function
3966/// __builtin_shufflevector.
3967/// This AST node represents a operator that does a constant
3968/// shuffle, similar to LLVM's shufflevector instruction. It takes
3969/// two vectors and a variable number of constant indices,
3970/// and returns the appropriately shuffled vector.
3971class ShuffleVectorExpr : public Expr {
SourceLocation BuiltinLoc, RParenLoc;

// SubExprs - the list of values passed to the __builtin_shufflevector
// function. The first two are vectors, and the rest are constant
// indices.  The number of values in this list is always
// 2+the number of indices in the vector type.
Stmt **SubExprs;
unsigned NumExprs;

3981public:
ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
                  SourceLocation BLoc, SourceLocation RP);

/// Build an empty vector-shuffle expression.
explicit ShuffleVectorExpr(EmptyShell Empty)
  : Expr(ShuffleVectorExprClass, Empty), SubExprs(nullptr) { }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ShuffleVectorExprClass;
}

/// getNumSubExprs - Return the size of the SubExprs array.  This includes the
/// constant expression, the actual arguments passed in, and the function
/// pointers.
unsigned getNumSubExprs() const { return NumExprs; }

/// Retrieve the array of expressions.
Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }

/// getExpr - Return the Expr at the specified index.
Expr *getExpr(unsigned Index) {
  assert((Index < NumExprs) && "Arg access out of range!")(((Index < NumExprs) && "Arg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("(Index < NumExprs) && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4012, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[Index]);
}
const Expr *getExpr(unsigned Index) const {
  assert((Index < NumExprs) && "Arg access out of range!")(((Index < NumExprs) && "Arg access out of range!"
) ? static_cast<void> (0) : __assert_fail ("(Index < NumExprs) && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4016, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[Index]);
}

void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);

llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const {
  assert((N < NumExprs - 2) && "Shuffle idx out of range!")(((N < NumExprs - 2) && "Shuffle idx out of range!"
) ? static_cast<void> (0) : __assert_fail ("(N < NumExprs - 2) && \"Shuffle idx out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4023, __PRETTY_FUNCTION__));
  return getExpr(N+2)->EvaluateKnownConstInt(Ctx);
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+NumExprs);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + NumExprs);
}
4034};

4036/// ConvertVectorExpr - Clang builtin function __builtin_convertvector
4037/// This AST node provides support for converting a vector type to another
4038/// vector type of the same arity.
4039class ConvertVectorExpr : public Expr {
4040private:
Stmt *SrcExpr;
TypeSourceInfo *TInfo;
SourceLocation BuiltinLoc, RParenLoc;

friend class ASTReader;
friend class ASTStmtReader;
explicit ConvertVectorExpr(EmptyShell Empty) : Expr(ConvertVectorExprClass, Empty) {}

4049public:
ConvertVectorExpr(Expr* SrcExpr, TypeSourceInfo *TI, QualType DstType,
           ExprValueKind VK, ExprObjectKind OK,
           SourceLocation BuiltinLoc, SourceLocation RParenLoc)
  : Expr(ConvertVectorExprClass, DstType, VK, OK,
         DstType->isDependentType(),
         DstType->isDependentType() || SrcExpr->isValueDependent(),
         (DstType->isInstantiationDependentType() ||
          SrcExpr->isInstantiationDependent()),
         (DstType->containsUnexpandedParameterPack() ||
          SrcExpr->containsUnexpandedParameterPack())),
SrcExpr(SrcExpr), TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {}

/// getSrcExpr - Return the Expr to be converted.
Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }

/// getTypeSourceInfo - Return the destination type.
TypeSourceInfo *getTypeSourceInfo() const {
  return TInfo;
}
void setTypeSourceInfo(TypeSourceInfo *ti) {
  TInfo = ti;
}

/// getBuiltinLoc - Return the location of the __builtin_convertvector token.
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }

/// getRParenLoc - Return the location of final right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConvertVectorExprClass;
}

// Iterators
child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
const_child_range children() const {
  return const_child_range(&SrcExpr, &SrcExpr + 1);
}
4091};

4093/// ChooseExpr - GNU builtin-in function __builtin_choose_expr.
4094/// This AST node is similar to the conditional operator (?:) in C, with
4095/// the following exceptions:
4096/// - the test expression must be a integer constant expression.
4097/// - the expression returned acts like the chosen subexpression in every
4098///   visible way: the type is the same as that of the chosen subexpression,
4099///   and all predicates (whether it's an l-value, whether it's an integer
4100///   constant expression, etc.) return the same result as for the chosen
4101///   sub-expression.
4102class ChooseExpr : public Expr {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
SourceLocation BuiltinLoc, RParenLoc;
bool CondIsTrue;
4107public:
ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
           QualType t, ExprValueKind VK, ExprObjectKind OK,
           SourceLocation RP, bool condIsTrue,
           bool TypeDependent, bool ValueDependent)
  : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent,
         (cond->isInstantiationDependent() ||
          lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (cond->containsUnexpandedParameterPack() ||
          lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack())),
    BuiltinLoc(BLoc), RParenLoc(RP), CondIsTrue(condIsTrue) {
    SubExprs[COND] = cond;
    SubExprs[LHS] = lhs;
    SubExprs[RHS] = rhs;
  }

/// Build an empty __builtin_choose_expr.
explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { }

/// isConditionTrue - Return whether the condition is true (i.e. not
/// equal to zero).
bool isConditionTrue() const {
  assert(!isConditionDependent() &&((!isConditionDependent() && "Dependent condition isn't true or false"
) ? static_cast<void> (0) : __assert_fail ("!isConditionDependent() && \"Dependent condition isn't true or false\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4132, __PRETTY_FUNCTION__))
         "Dependent condition isn't true or false")((!isConditionDependent() && "Dependent condition isn't true or false"
) ? static_cast<void> (0) : __assert_fail ("!isConditionDependent() && \"Dependent condition isn't true or false\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4132, __PRETTY_FUNCTION__));
  return CondIsTrue;
}
void setIsConditionTrue(bool isTrue) { CondIsTrue = isTrue; }

bool isConditionDependent() const {
  return getCond()->isTypeDependent() || getCond()->isValueDependent();
}

/// getChosenSubExpr - Return the subexpression chosen according to the
/// condition.
Expr *getChosenSubExpr() const {
  return isConditionTrue() ? getLHS() : getRHS();
}

Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
void setCond(Expr *E) { SubExprs[COND] = E; }
Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ChooseExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
4174};

4176/// GNUNullExpr - Implements the GNU __null extension, which is a name
4177/// for a null pointer constant that has integral type (e.g., int or
4178/// long) and is the same size and alignment as a pointer. The __null
4179/// extension is typically only used by system headers, which define
4180/// NULL as __null in C++ rather than using 0 (which is an integer
4181/// that may not match the size of a pointer).
4182class GNUNullExpr : public Expr {
/// TokenLoc - The location of the __null keyword.
SourceLocation TokenLoc;

4186public:
GNUNullExpr(QualType Ty, SourceLocation Loc)
  : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false,
         false),
    TokenLoc(Loc) { }

/// Build an empty GNU __null expression.
explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { }

/// getTokenLocation - The location of the __null token.
SourceLocation getTokenLocation() const { return TokenLoc; }
void setTokenLocation(SourceLocation L) { TokenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return TokenLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return TokenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == GNUNullExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4213};

4215/// Represents a call to the builtin function \c __builtin_va_arg.
4216class VAArgExpr : public Expr {
Stmt *Val;
llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
SourceLocation BuiltinLoc, RParenLoc;
4220public:
VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
          SourceLocation RPLoc, QualType t, bool IsMS)
    : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary, t->isDependentType(),
           false, (TInfo->getType()->isInstantiationDependentType() ||
                   e->isInstantiationDependent()),
           (TInfo->getType()->containsUnexpandedParameterPack() ||
            e->containsUnexpandedParameterPack())),
      Val(e), TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {}

/// Create an empty __builtin_va_arg expression.
explicit VAArgExpr(EmptyShell Empty)
    : Expr(VAArgExprClass, Empty), Val(nullptr), TInfo(nullptr, false) {}

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

/// Returns whether this is really a Win64 ABI va_arg expression.
bool isMicrosoftABI() const { return TInfo.getInt(); }
void setIsMicrosoftABI(bool IsMS) { TInfo.setInt(IsMS); }

TypeSourceInfo *getWrittenTypeInfo() const { return TInfo.getPointer(); }
void setWrittenTypeInfo(TypeSourceInfo *TI) { TInfo.setPointer(TI); }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == VAArgExprClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
4263};

4265/// Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(),
4266/// __builtin_FUNCTION(), or __builtin_FILE().
4267class SourceLocExpr final : public Expr {
SourceLocation BuiltinLoc, RParenLoc;
DeclContext *ParentContext;

4271public:
enum IdentKind { Function, File, Line, Column };

SourceLocExpr(const ASTContext &Ctx, IdentKind Type, SourceLocation BLoc,
              SourceLocation RParenLoc, DeclContext *Context);

/// Build an empty call expression.
explicit SourceLocExpr(EmptyShell Empty) : Expr(SourceLocExprClass, Empty) {}

/// Return the result of evaluating this SourceLocExpr in the specified
/// (and possibly null) default argument or initialization context.
APValue EvaluateInContext(const ASTContext &Ctx,
                          const Expr *DefaultExpr) const;

/// Return a string representing the name of the specific builtin function.
StringRef getBuiltinStr() const;

IdentKind getIdentKind() const {
  return static_cast<IdentKind>(SourceLocExprBits.Kind);
}

bool isStringType() const {
  switch (getIdentKind()) {
  case File:
  case Function:
    return true;
  case Line:
  case Column:
    return false;
  }
  llvm_unreachable("unknown source location expression kind")::llvm::llvm_unreachable_internal("unknown source location expression kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4301);
}
bool isIntType() const LLVM_READONLY__attribute__((__pure__)) { return !isStringType(); }

/// If the SourceLocExpr has been resolved return the subexpression
/// representing the resolved value. Otherwise return null.
const DeclContext *getParentContext() const { return ParentContext; }
DeclContext *getParentContext() { return ParentContext; }

SourceLocation getLocation() const { return BuiltinLoc; }
SourceLocation getBeginLoc() const { return BuiltinLoc; }
SourceLocation getEndLoc() const { return RParenLoc; }

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(child_iterator(), child_iterator());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == SourceLocExprClass;
}

4326private:
friend class ASTStmtReader;
4328};

4330/// Describes an C or C++ initializer list.
4331///
4332/// InitListExpr describes an initializer list, which can be used to
4333/// initialize objects of different types, including
4334/// struct/class/union types, arrays, and vectors. For example:
4335///
4336/// @code
4337/// struct foo x = { 1, { 2, 3 } };
4338/// @endcode
4339///
4340/// Prior to semantic analysis, an initializer list will represent the
4341/// initializer list as written by the user, but will have the
4342/// placeholder type "void". This initializer list is called the
4343/// syntactic form of the initializer, and may contain C99 designated
4344/// initializers (represented as DesignatedInitExprs), initializations
4345/// of subobject members without explicit braces, and so on. Clients
4346/// interested in the original syntax of the initializer list should
4347/// use the syntactic form of the initializer list.
4348///
4349/// After semantic analysis, the initializer list will represent the
4350/// semantic form of the initializer, where the initializations of all
4351/// subobjects are made explicit with nested InitListExpr nodes and
4352/// C99 designators have been eliminated by placing the designated
4353/// initializations into the subobject they initialize. Additionally,
4354/// any "holes" in the initialization, where no initializer has been
4355/// specified for a particular subobject, will be replaced with
4356/// implicitly-generated ImplicitValueInitExpr expressions that
4357/// value-initialize the subobjects. Note, however, that the
4358/// initializer lists may still have fewer initializers than there are
4359/// elements to initialize within the object.
4360///
4361/// After semantic analysis has completed, given an initializer list,
4362/// method isSemanticForm() returns true if and only if this is the
4363/// semantic form of the initializer list (note: the same AST node
4364/// may at the same time be the syntactic form).
4365/// Given the semantic form of the initializer list, one can retrieve
4366/// the syntactic form of that initializer list (when different)
4367/// using method getSyntacticForm(); the method returns null if applied
4368/// to a initializer list which is already in syntactic form.
4369/// Similarly, given the syntactic form (i.e., an initializer list such
4370/// that isSemanticForm() returns false), one can retrieve the semantic
4371/// form using method getSemanticForm().
4372/// Since many initializer lists have the same syntactic and semantic forms,
4373/// getSyntacticForm() may return NULL, indicating that the current
4374/// semantic initializer list also serves as its syntactic form.
4375class InitListExpr : public Expr {
// FIXME: Eliminate this vector in favor of ASTContext allocation
typedef ASTVector<Stmt *> InitExprsTy;
InitExprsTy InitExprs;
SourceLocation LBraceLoc, RBraceLoc;

/// The alternative form of the initializer list (if it exists).
/// The int part of the pair stores whether this initializer list is
/// in semantic form. If not null, the pointer points to:
///   - the syntactic form, if this is in semantic form;
///   - the semantic form, if this is in syntactic form.
llvm::PointerIntPair<InitListExpr *, 1, bool> AltForm;

/// Either:
///  If this initializer list initializes an array with more elements than
///  there are initializers in the list, specifies an expression to be used
///  for value initialization of the rest of the elements.
/// Or
///  If this initializer list initializes a union, specifies which
///  field within the union will be initialized.
llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;

4397public:
InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
             ArrayRef<Expr*> initExprs, SourceLocation rbraceloc);

/// Build an empty initializer list.
explicit InitListExpr(EmptyShell Empty)
  : Expr(InitListExprClass, Empty), AltForm(nullptr, true) { }

unsigned getNumInits() const { return InitExprs.size(); }

/// Retrieve the set of initializers.
Expr **getInits() { return reinterpret_cast<Expr **>(InitExprs.data()); }

/// Retrieve the set of initializers.
Expr * const *getInits() const {
  return reinterpret_cast<Expr * const *>(InitExprs.data());
}

ArrayRef<Expr *> inits() {
  return llvm::makeArrayRef(getInits(), getNumInits());
}

ArrayRef<Expr *> inits() const {
  return llvm::makeArrayRef(getInits(), getNumInits());
}

const Expr *getInit(unsigned Init) const {
  assert(Init < getNumInits() && "Initializer access out of range!")((Init < getNumInits() && "Initializer access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Init < getNumInits() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4424, __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(InitExprs[Init]);
}

Expr *getInit(unsigned Init) {
  assert(Init < getNumInits() && "Initializer access out of range!")((Init < getNumInits() && "Initializer access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Init < getNumInits() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4429, __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(InitExprs[Init]);
}

void setInit(unsigned Init, Expr *expr) {
  assert(Init < getNumInits() && "Initializer access out of range!")((Init < getNumInits() && "Initializer access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Init < getNumInits() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4434, __PRETTY_FUNCTION__));
  InitExprs[Init] = expr;

  if (expr) {
    ExprBits.TypeDependent |= expr->isTypeDependent();
    ExprBits.ValueDependent |= expr->isValueDependent();
    ExprBits.InstantiationDependent |= expr->isInstantiationDependent();
    ExprBits.ContainsUnexpandedParameterPack |=
        expr->containsUnexpandedParameterPack();
  }
}

/// Reserve space for some number of initializers.
void reserveInits(const ASTContext &C, unsigned NumInits);

/// Specify the number of initializers
///
/// If there are more than @p NumInits initializers, the remaining
/// initializers will be destroyed. If there are fewer than @p
/// NumInits initializers, NULL expressions will be added for the
/// unknown initializers.
void resizeInits(const ASTContext &Context, unsigned NumInits);

/// Updates the initializer at index @p Init with the new
/// expression @p expr, and returns the old expression at that
/// location.
///
/// When @p Init is out of range for this initializer list, the
/// initializer list will be extended with NULL expressions to
/// accommodate the new entry.
Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);

/// If this initializer list initializes an array with more elements
/// than there are initializers in the list, specifies an expression to be
/// used for value initialization of the rest of the elements.
Expr *getArrayFiller() {
  return ArrayFillerOrUnionFieldInit.dyn_cast<Expr *>();
}
const Expr *getArrayFiller() const {
  return const_cast<InitListExpr *>(this)->getArrayFiller();
}
void setArrayFiller(Expr *filler);

/// Return true if this is an array initializer and its array "filler"
/// has been set.
bool hasArrayFiller() const { return getArrayFiller(); }

/// If this initializes a union, specifies which field in the
/// union to initialize.
///
/// Typically, this field is the first named field within the
/// union. However, a designated initializer can specify the
/// initialization of a different field within the union.
FieldDecl *getInitializedFieldInUnion() {
  return ArrayFillerOrUnionFieldInit.dyn_cast<FieldDecl *>();
}
const FieldDecl *getInitializedFieldInUnion() const {
  return const_cast<InitListExpr *>(this)->getInitializedFieldInUnion();
}
void setInitializedFieldInUnion(FieldDecl *FD) {
  assert((FD == nullptr(((FD == nullptr || getInitializedFieldInUnion() == nullptr ||
 getInitializedFieldInUnion() == FD) && "Only one field of a union may be initialized at a time!"
) ? static_cast<void> (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4497, __PRETTY_FUNCTION__))
          || getInitializedFieldInUnion() == nullptr(((FD == nullptr || getInitializedFieldInUnion() == nullptr ||
 getInitializedFieldInUnion() == FD) && "Only one field of a union may be initialized at a time!"
) ? static_cast<void> (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4497, __PRETTY_FUNCTION__))
          || getInitializedFieldInUnion() == FD)(((FD == nullptr || getInitializedFieldInUnion() == nullptr ||
 getInitializedFieldInUnion() == FD) && "Only one field of a union may be initialized at a time!"
) ? static_cast<void> (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4497, __PRETTY_FUNCTION__))
         && "Only one field of a union may be initialized at a time!")(((FD == nullptr || getInitializedFieldInUnion() == nullptr ||
 getInitializedFieldInUnion() == FD) && "Only one field of a union may be initialized at a time!"
) ? static_cast<void> (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4497, __PRETTY_FUNCTION__));
  ArrayFillerOrUnionFieldInit = FD;
}

// Explicit InitListExpr's originate from source code (and have valid source
// locations). Implicit InitListExpr's are created by the semantic analyzer.
// FIXME: This is wrong; InitListExprs created by semantic analysis have
// valid source locations too!
bool isExplicit() const {
  return LBraceLoc.isValid() && RBraceLoc.isValid();
}

// Is this an initializer for an array of characters, initialized by a string
// literal or an @encode?
bool isStringLiteralInit() const;

/// Is this a transparent initializer list (that is, an InitListExpr that is
/// purely syntactic, and whose semantics are that of the sole contained
/// initializer)?
bool isTransparent() const;

/// Is this the zero initializer {0} in a language which considers it
/// idiomatic?
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const;

SourceLocation getLBraceLoc() const { return LBraceLoc; }
void setLBraceLoc(SourceLocation Loc) { LBraceLoc = Loc; }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setRBraceLoc(SourceLocation Loc) { RBraceLoc = Loc; }

bool isSemanticForm() const { return AltForm.getInt(); }
InitListExpr *getSemanticForm() const {
  return isSemanticForm() ? nullptr : AltForm.getPointer();
}
bool isSyntacticForm() const {
  return !AltForm.getInt() || !AltForm.getPointer();
}
InitListExpr *getSyntacticForm() const {
  return isSemanticForm() ? AltForm.getPointer() : nullptr;
}

void setSyntacticForm(InitListExpr *Init) {
  AltForm.setPointer(Init);
  AltForm.setInt(true);
  Init->AltForm.setPointer(this);
  Init->AltForm.setInt(false);
}

bool hadArrayRangeDesignator() const {
  return InitListExprBits.HadArrayRangeDesignator != 0;
}
void sawArrayRangeDesignator(bool ARD = true) {
  InitListExprBits.HadArrayRangeDesignator = ARD;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == InitListExprClass;
}

// Iterators
child_range children() {
  const_child_range CCR = const_cast<const InitListExpr *>(this)->children();
  return child_range(cast_away_const(CCR.begin()),
                     cast_away_const(CCR.end()));
}

const_child_range children() const {
  // FIXME: This does not include the array filler expression.
  if (InitExprs.empty())
    return const_child_range(const_child_iterator(), const_child_iterator());
  return const_child_range(&InitExprs[0], &InitExprs[0] + InitExprs.size());
}

typedef InitExprsTy::iterator iterator;
typedef InitExprsTy::const_iterator const_iterator;
typedef InitExprsTy::reverse_iterator reverse_iterator;
typedef InitExprsTy::const_reverse_iterator const_reverse_iterator;

iterator begin() { return InitExprs.begin(); }
const_iterator begin() const { return InitExprs.begin(); }
iterator end() { return InitExprs.end(); }
const_iterator end() const { return InitExprs.end(); }
reverse_iterator rbegin() { return InitExprs.rbegin(); }
const_reverse_iterator rbegin() const { return InitExprs.rbegin(); }
reverse_iterator rend() { return InitExprs.rend(); }
const_reverse_iterator rend() const { return InitExprs.rend(); }

friend class ASTStmtReader;
friend class ASTStmtWriter;
4589};

4591/// Represents a C99 designated initializer expression.
4592///
4593/// A designated initializer expression (C99 6.7.8) contains one or
4594/// more designators (which can be field designators, array
4595/// designators, or GNU array-range designators) followed by an
4596/// expression that initializes the field or element(s) that the
4597/// designators refer to. For example, given:
4598///
4599/// @code
4600/// struct point {
4601///   double x;
4602///   double y;
4603/// };
4604/// struct point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
4605/// @endcode
4606///
4607/// The InitListExpr contains three DesignatedInitExprs, the first of
4608/// which covers @c [2].y=1.0. This DesignatedInitExpr will have two
4609/// designators, one array designator for @c [2] followed by one field
4610/// designator for @c .y. The initialization expression will be 1.0.
4611class DesignatedInitExpr final
  : public Expr,
    private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
4614public:
/// Forward declaration of the Designator class.
class Designator;

4618private:
/// The location of the '=' or ':' prior to the actual initializer
/// expression.
SourceLocation EqualOrColonLoc;

/// Whether this designated initializer used the GNU deprecated
/// syntax rather than the C99 '=' syntax.
unsigned GNUSyntax : 1;

/// The number of designators in this initializer expression.
unsigned NumDesignators : 15;

/// The number of subexpressions of this initializer expression,
/// which contains both the initializer and any additional
/// expressions used by array and array-range designators.
unsigned NumSubExprs : 16;

/// The designators in this designated initialization
/// expression.
Designator *Designators;

DesignatedInitExpr(const ASTContext &C, QualType Ty,
                   llvm::ArrayRef<Designator> Designators,
                   SourceLocation EqualOrColonLoc, bool GNUSyntax,
                   ArrayRef<Expr *> IndexExprs, Expr *Init);

explicit DesignatedInitExpr(unsigned NumSubExprs)
  : Expr(DesignatedInitExprClass, EmptyShell()),
    NumDesignators(0), NumSubExprs(NumSubExprs), Designators(nullptr) { }

4648public:
/// A field designator, e.g., ".x".
struct FieldDesignator {
  /// Refers to the field that is being initialized. The low bit
  /// of this field determines whether this is actually a pointer
  /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
  /// initially constructed, a field designator will store an
  /// IdentifierInfo*. After semantic analysis has resolved that
  /// name, the field designator will instead store a FieldDecl*.
  uintptr_t NameOrField;

  /// The location of the '.' in the designated initializer.
  unsigned DotLoc;

  /// The location of the field name in the designated initializer.
  unsigned FieldLoc;
};

/// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
struct ArrayOrRangeDesignator {
  /// Location of the first index expression within the designated
  /// initializer expression's list of subexpressions.
  unsigned Index;
  /// The location of the '[' starting the array range designator.
  unsigned LBracketLoc;
  /// The location of the ellipsis separating the start and end
  /// indices. Only valid for GNU array-range designators.
  unsigned EllipsisLoc;
  /// The location of the ']' terminating the array range designator.
  unsigned RBracketLoc;
};

/// Represents a single C99 designator.
///
/// @todo This class is infuriatingly similar to clang::Designator,
/// but minor differences (storing indices vs. storing pointers)
/// keep us from reusing it. Try harder, later, to rectify these
/// differences.
class Designator {
  /// The kind of designator this describes.
  enum {
    FieldDesignator,
    ArrayDesignator,
    ArrayRangeDesignator
  } Kind;

  union {
    /// A field designator, e.g., ".x".
    struct FieldDesignator Field;
    /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
    struct ArrayOrRangeDesignator ArrayOrRange;
  };
  friend class DesignatedInitExpr;

public:
  Designator() {}

  /// Initializes a field designator.
  Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
             SourceLocation FieldLoc)
    : Kind(FieldDesignator) {
    Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
    Field.DotLoc = DotLoc.getRawEncoding();
    Field.FieldLoc = FieldLoc.getRawEncoding();
  }

  /// Initializes an array designator.
  Designator(unsigned Index, SourceLocation LBracketLoc,
             SourceLocation RBracketLoc)
    : Kind(ArrayDesignator) {
    ArrayOrRange.Index = Index;
    ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
    ArrayOrRange.EllipsisLoc = SourceLocation().getRawEncoding();
    ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
  }

  /// Initializes a GNU array-range designator.
  Designator(unsigned Index, SourceLocation LBracketLoc,
             SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
    : Kind(ArrayRangeDesignator) {
    ArrayOrRange.Index = Index;
    ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
    ArrayOrRange.EllipsisLoc = EllipsisLoc.getRawEncoding();
    ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
  }

  bool isFieldDesignator() const { return Kind == FieldDesignator; }
  bool isArrayDesignator() const { return Kind == ArrayDesignator; }
  bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }

  IdentifierInfo *getFieldName() const;

  FieldDecl *getField() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")((Kind == FieldDesignator && "Only valid on a field designator"
) ? static_cast<void> (0) : __assert_fail ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4741, __PRETTY_FUNCTION__));
    if (Field.NameOrField & 0x01)
      return nullptr;
    else
      return reinterpret_cast<FieldDecl *>(Field.NameOrField);
  }

  void setField(FieldDecl *FD) {
    assert(Kind == FieldDesignator && "Only valid on a field designator")((Kind == FieldDesignator && "Only valid on a field designator"
) ? static_cast<void> (0) : __assert_fail ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4749, __PRETTY_FUNCTION__));
    Field.NameOrField = reinterpret_cast<uintptr_t>(FD);
  }

  SourceLocation getDotLoc() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")((Kind == FieldDesignator && "Only valid on a field designator"
) ? static_cast<void> (0) : __assert_fail ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4754, __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(Field.DotLoc);
  }

  SourceLocation getFieldLoc() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")((Kind == FieldDesignator && "Only valid on a field designator"
) ? static_cast<void> (0) : __assert_fail ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4759, __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(Field.FieldLoc);
  }

  SourceLocation getLBracketLoc() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
 "Only valid on an array or array-range designator") ? static_cast
<void> (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4765, __PRETTY_FUNCTION__))
           "Only valid on an array or array-range designator")(((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
 "Only valid on an array or array-range designator") ? static_cast
<void> (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4765, __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(ArrayOrRange.LBracketLoc);
  }

  SourceLocation getRBracketLoc() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
 "Only valid on an array or array-range designator") ? static_cast
<void> (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4771, __PRETTY_FUNCTION__))
           "Only valid on an array or array-range designator")(((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
 "Only valid on an array or array-range designator") ? static_cast
<void> (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4771, __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(ArrayOrRange.RBracketLoc);
  }

  SourceLocation getEllipsisLoc() const {
    assert(Kind == ArrayRangeDesignator &&((Kind == ArrayRangeDesignator && "Only valid on an array-range designator"
) ? static_cast<void> (0) : __assert_fail ("Kind == ArrayRangeDesignator && \"Only valid on an array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4777, __PRETTY_FUNCTION__))
           "Only valid on an array-range designator")((Kind == ArrayRangeDesignator && "Only valid on an array-range designator"
) ? static_cast<void> (0) : __assert_fail ("Kind == ArrayRangeDesignator && \"Only valid on an array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4777, __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(ArrayOrRange.EllipsisLoc);
  }

  unsigned getFirstExprIndex() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
 "Only valid on an array or array-range designator") ? static_cast
<void> (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4783, __PRETTY_FUNCTION__))
           "Only valid on an array or array-range designator")(((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
 "Only valid on an array or array-range designator") ? static_cast
<void> (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4783, __PRETTY_FUNCTION__));
    return ArrayOrRange.Index;
  }

  SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
    if (Kind == FieldDesignator)
      return getDotLoc().isInvalid()? getFieldLoc() : getDotLoc();
    else
      return getLBracketLoc();
  }
  SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
    return Kind == FieldDesignator ? getFieldLoc() : getRBracketLoc();
  }
  SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
    return SourceRange(getBeginLoc(), getEndLoc());
  }
};

static DesignatedInitExpr *Create(const ASTContext &C,
                                  llvm::ArrayRef<Designator> Designators,
                                  ArrayRef<Expr*> IndexExprs,
                                  SourceLocation EqualOrColonLoc,
                                  bool GNUSyntax, Expr *Init);

static DesignatedInitExpr *CreateEmpty(const ASTContext &C,
                                       unsigned NumIndexExprs);

/// Returns the number of designators in this initializer.
unsigned size() const { return NumDesignators; }

// Iterator access to the designators.
llvm::MutableArrayRef<Designator> designators() {
  return {Designators, NumDesignators};
}

llvm::ArrayRef<Designator> designators() const {
  return {Designators, NumDesignators};
}

Designator *getDesignator(unsigned Idx) { return &designators()[Idx]; }
const Designator *getDesignator(unsigned Idx) const {
  return &designators()[Idx];
}

void setDesignators(const ASTContext &C, const Designator *Desigs,
                    unsigned NumDesigs);

Expr *getArrayIndex(const Designator &D) const;
Expr *getArrayRangeStart(const Designator &D) const;
Expr *getArrayRangeEnd(const Designator &D) const;

/// Retrieve the location of the '=' that precedes the
/// initializer value itself, if present.
SourceLocation getEqualOrColonLoc() const { return EqualOrColonLoc; }
void setEqualOrColonLoc(SourceLocation L) { EqualOrColonLoc = L; }

/// Whether this designated initializer should result in direct-initialization
/// of the designated subobject (eg, '{.foo{1, 2, 3}}').
bool isDirectInit() const { return EqualOrColonLoc.isInvalid(); }

/// Determines whether this designated initializer used the
/// deprecated GNU syntax for designated initializers.
bool usesGNUSyntax() const { return GNUSyntax; }
void setGNUSyntax(bool GNU) { GNUSyntax = GNU; }

/// Retrieve the initializer value.
Expr *getInit() const {
  return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
}

void setInit(Expr *init) {
  *child_begin() = init;
}

/// Retrieve the total number of subexpressions in this
/// designated initializer expression, including the actual
/// initialized value and any expressions that occur within array
/// and array-range designators.
unsigned getNumSubExprs() const { return NumSubExprs; }

Expr *getSubExpr(unsigned Idx) const {
  assert(Idx < NumSubExprs && "Subscript out of range")((Idx < NumSubExprs && "Subscript out of range") ?
 static_cast<void> (0) : __assert_fail ("Idx < NumSubExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4864, __PRETTY_FUNCTION__));
  return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
}

void setSubExpr(unsigned Idx, Expr *E) {
  assert(Idx < NumSubExprs && "Subscript out of range")((Idx < NumSubExprs && "Subscript out of range") ?
 static_cast<void> (0) : __assert_fail ("Idx < NumSubExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 4869, __PRETTY_FUNCTION__));
  getTrailingObjects<Stmt *>()[Idx] = E;
}

/// Replaces the designator at index @p Idx with the series
/// of designators in [First, Last).
void ExpandDesignator(const ASTContext &C, unsigned Idx,
                      const Designator *First, const Designator *Last);

SourceRange getDesignatorsSourceRange() const;

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DesignatedInitExprClass;
}

// Iterators
child_range children() {
  Stmt **begin = getTrailingObjects<Stmt *>();
  return child_range(begin, begin + NumSubExprs);
}
const_child_range children() const {
  Stmt * const *begin = getTrailingObjects<Stmt *>();
  return const_child_range(begin, begin + NumSubExprs);
}

friend TrailingObjects;
4898};

4900/// Represents a place-holder for an object not to be initialized by
4901/// anything.
4902///
4903/// This only makes sense when it appears as part of an updater of a
4904/// DesignatedInitUpdateExpr (see below). The base expression of a DIUE
4905/// initializes a big object, and the NoInitExpr's mark the spots within the
4906/// big object not to be overwritten by the updater.
4907///
4908/// \see DesignatedInitUpdateExpr
4909class NoInitExpr : public Expr {
4910public:
explicit NoInitExpr(QualType ty)
  : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary,
         false, false, ty->isInstantiationDependentType(), false) { }

explicit NoInitExpr(EmptyShell Empty)
  : Expr(NoInitExprClass, Empty) { }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == NoInitExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4932};

4934// In cases like:
4935//   struct Q { int a, b, c; };
4936//   Q *getQ();
4937//   void foo() {
4938//     struct A { Q q; } a = { *getQ(), .q.b = 3 };
4939//   }
4940//
4941// We will have an InitListExpr for a, with type A, and then a
4942// DesignatedInitUpdateExpr for "a.q" with type Q. The "base" for this DIUE
4943// is the call expression *getQ(); the "updater" for the DIUE is ".q.b = 3"
4944//
4945class DesignatedInitUpdateExpr : public Expr {
// BaseAndUpdaterExprs[0] is the base expression;
// BaseAndUpdaterExprs[1] is an InitListExpr overwriting part of the base.
Stmt *BaseAndUpdaterExprs[2];

4950public:
DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc,
                         Expr *baseExprs, SourceLocation rBraceLoc);

explicit DesignatedInitUpdateExpr(EmptyShell Empty)
  : Expr(DesignatedInitUpdateExprClass, Empty) { }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DesignatedInitUpdateExprClass;
}

Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); }
void setBase(Expr *Base) { BaseAndUpdaterExprs[0] = Base; }

InitListExpr *getUpdater() const {
  return cast<InitListExpr>(BaseAndUpdaterExprs[1]);
}
void setUpdater(Expr *Updater) { BaseAndUpdaterExprs[1] = Updater; }

// Iterators
// children = the base and the updater
child_range children() {
  return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2);
}
const_child_range children() const {
  return const_child_range(&BaseAndUpdaterExprs[0],
                           &BaseAndUpdaterExprs[0] + 2);
}
4981};

4983/// Represents a loop initializing the elements of an array.
4984///
4985/// The need to initialize the elements of an array occurs in a number of
4986/// contexts:
4987///
4988///  * in the implicit copy/move constructor for a class with an array member
4989///  * when a lambda-expression captures an array by value
4990///  * when a decomposition declaration decomposes an array
4991///
4992/// There are two subexpressions: a common expression (the source array)
4993/// that is evaluated once up-front, and a per-element initializer that
4994/// runs once for each array element.
4995///
4996/// Within the per-element initializer, the common expression may be referenced
4997/// via an OpaqueValueExpr, and the current index may be obtained via an
4998/// ArrayInitIndexExpr.
4999class ArrayInitLoopExpr : public Expr {
Stmt *SubExprs[2];

explicit ArrayInitLoopExpr(EmptyShell Empty)
    : Expr(ArrayInitLoopExprClass, Empty), SubExprs{} {}

5005public:
explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
    : Expr(ArrayInitLoopExprClass, T, VK_RValue, OK_Ordinary, false,
           CommonInit->isValueDependent() || ElementInit->isValueDependent(),
           T->isInstantiationDependentType(),
           CommonInit->containsUnexpandedParameterPack() ||
               ElementInit->containsUnexpandedParameterPack()),
      SubExprs{CommonInit, ElementInit} {}

/// Get the common subexpression shared by all initializations (the source
/// array).
OpaqueValueExpr *getCommonExpr() const {
  return cast<OpaqueValueExpr>(SubExprs[0]);
}

/// Get the initializer to use for each array element.
Expr *getSubExpr() const { return cast<Expr>(SubExprs[1]); }

llvm::APInt getArraySize() const {
  return cast<ConstantArrayType>(getType()->castAsArrayTypeUnsafe())
      ->getSize();
}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == ArrayInitLoopExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getEndLoc();
}

child_range children() {
  return child_range(SubExprs, SubExprs + 2);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + 2);
}

friend class ASTReader;
friend class ASTStmtReader;
friend class ASTStmtWriter;
5049};

5051/// Represents the index of the current element of an array being
5052/// initialized by an ArrayInitLoopExpr. This can only appear within the
5053/// subexpression of an ArrayInitLoopExpr.
5054class ArrayInitIndexExpr : public Expr {
explicit ArrayInitIndexExpr(EmptyShell Empty)
    : Expr(ArrayInitIndexExprClass, Empty) {}

5058public:
explicit ArrayInitIndexExpr(QualType T)
    : Expr(ArrayInitIndexExprClass, T, VK_RValue, OK_Ordinary,
           false, false, false, false) {}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == ArrayInitIndexExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

friend class ASTReader;
friend class ASTStmtReader;
5079};

5081/// Represents an implicitly-generated value initialization of
5082/// an object of a given type.
5083///
5084/// Implicit value initializations occur within semantic initializer
5085/// list expressions (InitListExpr) as placeholders for subobject
5086/// initializations not explicitly specified by the user.
5087///
5088/// \see InitListExpr
5089class ImplicitValueInitExpr : public Expr {
5090public:
explicit ImplicitValueInitExpr(QualType ty)
  : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary,
         false, false, ty->isInstantiationDependentType(), false) { }

/// Construct an empty implicit value initialization.
explicit ImplicitValueInitExpr(EmptyShell Empty)
  : Expr(ImplicitValueInitExprClass, Empty) { }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImplicitValueInitExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
5113};

5115class ParenListExpr final
  : public Expr,
    private llvm::TrailingObjects<ParenListExpr, Stmt *> {
friend class ASTStmtReader;
friend TrailingObjects;

/// The location of the left and right parentheses.
SourceLocation LParenLoc, RParenLoc;

/// Build a paren list.
ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
              SourceLocation RParenLoc);

/// Build an empty paren list.
ParenListExpr(EmptyShell Empty, unsigned NumExprs);

5131public:
/// Create a paren list.
static ParenListExpr *Create(const ASTContext &Ctx, SourceLocation LParenLoc,
                             ArrayRef<Expr *> Exprs,
                             SourceLocation RParenLoc);

/// Create an empty paren list.
static ParenListExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumExprs);

/// Return the number of expressions in this paren list.
unsigned getNumExprs() const { return ParenListExprBits.NumExprs; }

Expr *getExpr(unsigned Init) {
  assert(Init < getNumExprs() && "Initializer access out of range!")((Init < getNumExprs() && "Initializer access out of range!"
) ? static_cast<void> (0) : __assert_fail ("Init < getNumExprs() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5144, __PRETTY_FUNCTION__));
  return getExprs()[Init];
}

const Expr *getExpr(unsigned Init) const {
  return const_cast<ParenListExpr *>(this)->getExpr(Init);
}

Expr **getExprs() {
  return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>());
}

ArrayRef<Expr *> exprs() {
  return llvm::makeArrayRef(getExprs(), getNumExprs());
}

SourceLocation getLParenLoc() const { return LParenLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }
SourceLocation getBeginLoc() const { return getLParenLoc(); }
SourceLocation getEndLoc() const { return getRParenLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ParenListExprClass;
}

// Iterators
child_range children() {
  return child_range(getTrailingObjects<Stmt *>(),
                     getTrailingObjects<Stmt *>() + getNumExprs());
}
const_child_range children() const {
  return const_child_range(getTrailingObjects<Stmt *>(),
                           getTrailingObjects<Stmt *>() + getNumExprs());
}
5178};

5180/// Represents a C11 generic selection.
5181///
5182/// A generic selection (C11 6.5.1.1) contains an unevaluated controlling
5183/// expression, followed by one or more generic associations.  Each generic
5184/// association specifies a type name and an expression, or "default" and an
5185/// expression (in which case it is known as a default generic association).
5186/// The type and value of the generic selection are identical to those of its
5187/// result expression, which is defined as the expression in the generic
5188/// association with a type name that is compatible with the type of the
5189/// controlling expression, or the expression in the default generic association
5190/// if no types are compatible.  For example:
5191///
5192/// @code
5193/// _Generic(X, double: 1, float: 2, default: 3)
5194/// @endcode
5195///
5196/// The above expression evaluates to 1 if 1.0 is substituted for X, 2 if 1.0f
5197/// or 3 if "hello".
5198///
5199/// As an extension, generic selections are allowed in C++, where the following
5200/// additional semantics apply:
5201///
5202/// Any generic selection whose controlling expression is type-dependent or
5203/// which names a dependent type in its association list is result-dependent,
5204/// which means that the choice of result expression is dependent.
5205/// Result-dependent generic associations are both type- and value-dependent.
5206class GenericSelectionExpr final
  : public Expr,
    private llvm::TrailingObjects<GenericSelectionExpr, Stmt *,
                                  TypeSourceInfo *> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The number of association expressions and the index of the result
/// expression in the case where the generic selection expression is not
/// result-dependent. The result index is equal to ResultDependentIndex
/// if and only if the generic selection expression is result-dependent.
unsigned NumAssocs, ResultIndex;
enum : unsigned {
  ResultDependentIndex = std::numeric_limits<unsigned>::max(),
  ControllingIndex = 0,
  AssocExprStartIndex = 1
};

/// The location of the "default" and of the right parenthesis.
SourceLocation DefaultLoc, RParenLoc;

// GenericSelectionExpr is followed by several trailing objects.
// They are (in order):
//
// * A single Stmt * for the controlling expression.
// * An array of getNumAssocs() Stmt * for the association expressions.
// * An array of getNumAssocs() TypeSourceInfo *, one for each of the
//   association expressions.
unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
  // Add one to account for the controlling expression; the remainder
  // are the associated expressions.
  return 1 + getNumAssocs();
}

unsigned numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
  return getNumAssocs();
}

template <bool Const> class AssociationIteratorTy;
/// Bundle together an association expression and its TypeSourceInfo.
/// The Const template parameter is for the const and non-const versions
/// of AssociationTy.
template <bool Const> class AssociationTy {
  friend class GenericSelectionExpr;
  template <bool OtherConst> friend class AssociationIteratorTy;
  using ExprPtrTy =
      typename std::conditional<Const, const Expr *, Expr *>::type;
  using TSIPtrTy = typename std::conditional<Const, const TypeSourceInfo *,
                                             TypeSourceInfo *>::type;
  ExprPtrTy E;
  TSIPtrTy TSI;
  bool Selected;
  AssociationTy(ExprPtrTy E, TSIPtrTy TSI, bool Selected)
      : E(E), TSI(TSI), Selected(Selected) {}

public:
  ExprPtrTy getAssociationExpr() const { return E; }
  TSIPtrTy getTypeSourceInfo() const { return TSI; }
  QualType getType() const { return TSI ? TSI->getType() : QualType(); }
  bool isSelected() const { return Selected; }
  AssociationTy *operator->() { return this; }
  const AssociationTy *operator->() const { return this; }
}; // class AssociationTy

/// Iterator over const and non-const Association objects. The Association
/// objects are created on the fly when the iterator is dereferenced.
/// This abstract over how exactly the association expressions and the
/// corresponding TypeSourceInfo * are stored.
template <bool Const>
class AssociationIteratorTy
    : public llvm::iterator_facade_base<
          AssociationIteratorTy<Const>, std::input_iterator_tag,
          AssociationTy<Const>, std::ptrdiff_t, AssociationTy<Const>,
          AssociationTy<Const>> {
  friend class GenericSelectionExpr;
  // FIXME: This iterator could conceptually be a random access iterator, and
  // it would be nice if we could strengthen the iterator category someday.
  // However this iterator does not satisfy two requirements of forward
  // iterators:
  // a) reference = T& or reference = const T&
  // b) If It1 and It2 are both dereferenceable, then It1 == It2 if and only
  //    if *It1 and *It2 are bound to the same objects.
  // An alternative design approach was discussed during review;
  // store an Association object inside the iterator, and return a reference
  // to it when dereferenced. This idea was discarded beacuse of nasty
  // lifetime issues:
  //    AssociationIterator It = ...;
  //    const Association &Assoc = *It++; // Oops, Assoc is dangling.
  using BaseTy = typename AssociationIteratorTy::iterator_facade_base;
  using StmtPtrPtrTy =
      typename std::conditional<Const, const Stmt *const *, Stmt **>::type;
  using TSIPtrPtrTy =
      typename std::conditional<Const, const TypeSourceInfo *const *,
                                TypeSourceInfo **>::type;
  StmtPtrPtrTy E; // = nullptr; FIXME: Once support for gcc 4.8 is dropped.
  TSIPtrPtrTy TSI; // Kept in sync with E.
  unsigned Offset = 0, SelectedOffset = 0;
  AssociationIteratorTy(StmtPtrPtrTy E, TSIPtrPtrTy TSI, unsigned Offset,
                        unsigned SelectedOffset)
      : E(E), TSI(TSI), Offset(Offset), SelectedOffset(SelectedOffset) {}

public:
  AssociationIteratorTy() : E(nullptr), TSI(nullptr) {}
  typename BaseTy::reference operator*() const {
    return AssociationTy<Const>(cast<Expr>(*E), *TSI,
                                Offset == SelectedOffset);
  }
  typename BaseTy::pointer operator->() const { return **this; }
  using BaseTy::operator++;
  AssociationIteratorTy &operator++() {
    ++E;
    ++TSI;
    ++Offset;
    return *this;
  }
  bool operator==(AssociationIteratorTy Other) const { return E == Other.E; }
}; // class AssociationIterator

/// Build a non-result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
                     Expr *ControllingExpr,
                     ArrayRef<TypeSourceInfo *> AssocTypes,
                     ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
                     SourceLocation RParenLoc,
                     bool ContainsUnexpandedParameterPack,
                     unsigned ResultIndex);

/// Build a result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
                     Expr *ControllingExpr,
                     ArrayRef<TypeSourceInfo *> AssocTypes,
                     ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
                     SourceLocation RParenLoc,
                     bool ContainsUnexpandedParameterPack);

/// Build an empty generic selection expression for deserialization.
explicit GenericSelectionExpr(EmptyShell Empty, unsigned NumAssocs);

5345public:
/// Create a non-result-dependent generic selection expression.
static GenericSelectionExpr *
Create(const ASTContext &Context, SourceLocation GenericLoc,
       Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
       ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
       SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack,
       unsigned ResultIndex);

/// Create a result-dependent generic selection expression.
static GenericSelectionExpr *
Create(const ASTContext &Context, SourceLocation GenericLoc,
       Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
       ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
       SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack);

/// Create an empty generic selection expression for deserialization.
static GenericSelectionExpr *CreateEmpty(const ASTContext &Context,
                                         unsigned NumAssocs);

using Association = AssociationTy<false>;
using ConstAssociation = AssociationTy<true>;
using AssociationIterator = AssociationIteratorTy<false>;
using ConstAssociationIterator = AssociationIteratorTy<true>;
using association_range = llvm::iterator_range<AssociationIterator>;
using const_association_range =
    llvm::iterator_range<ConstAssociationIterator>;

/// The number of association expressions.
unsigned getNumAssocs() const { return NumAssocs; }

/// The zero-based index of the result expression's generic association in
/// the generic selection's association list.  Defined only if the
/// generic selection is not result-dependent.
unsigned getResultIndex() const {
  assert(!isResultDependent() &&((!isResultDependent() && "Generic selection is result-dependent but getResultIndex called!"
) ? static_cast<void> (0) : __assert_fail ("!isResultDependent() && \"Generic selection is result-dependent but getResultIndex called!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5381, __PRETTY_FUNCTION__))
         "Generic selection is result-dependent but getResultIndex called!")((!isResultDependent() && "Generic selection is result-dependent but getResultIndex called!"
) ? static_cast<void> (0) : __assert_fail ("!isResultDependent() && \"Generic selection is result-dependent but getResultIndex called!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5381, __PRETTY_FUNCTION__));
  return ResultIndex;
}

/// Whether this generic selection is result-dependent.
bool isResultDependent() const { return ResultIndex == ResultDependentIndex; }

/// Return the controlling expression of this generic selection expression.
Expr *getControllingExpr() {
  return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
}
const Expr *getControllingExpr() const {
  return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
}

/// Return the result expression of this controlling expression. Defined if
/// and only if the generic selection expression is not result-dependent.
Expr *getResultExpr() {
  return cast<Expr>(
      getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
}
const Expr *getResultExpr() const {
  return cast<Expr>(
      getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
}

ArrayRef<Expr *> getAssocExprs() const {
  return {reinterpret_cast<Expr *const *>(getTrailingObjects<Stmt *>() +
                                          AssocExprStartIndex),
          NumAssocs};
}
ArrayRef<TypeSourceInfo *> getAssocTypeSourceInfos() const {
  return {getTrailingObjects<TypeSourceInfo *>(), NumAssocs};
}

/// Return the Ith association expression with its TypeSourceInfo,
/// bundled together in GenericSelectionExpr::(Const)Association.
Association getAssociation(unsigned I) {
  assert(I < getNumAssocs() &&((I < getNumAssocs() && "Out-of-range index in GenericSelectionExpr::getAssociation!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumAssocs() && \"Out-of-range index in GenericSelectionExpr::getAssociation!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5420, __PRETTY_FUNCTION__))
         "Out-of-range index in GenericSelectionExpr::getAssociation!")((I < getNumAssocs() && "Out-of-range index in GenericSelectionExpr::getAssociation!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumAssocs() && \"Out-of-range index in GenericSelectionExpr::getAssociation!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5420, __PRETTY_FUNCTION__));
  return Association(
      cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
      getTrailingObjects<TypeSourceInfo *>()[I],
      !isResultDependent() && (getResultIndex() == I));
}
ConstAssociation getAssociation(unsigned I) const {
  assert(I < getNumAssocs() &&((I < getNumAssocs() && "Out-of-range index in GenericSelectionExpr::getAssociation!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumAssocs() && \"Out-of-range index in GenericSelectionExpr::getAssociation!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5428, __PRETTY_FUNCTION__))
         "Out-of-range index in GenericSelectionExpr::getAssociation!")((I < getNumAssocs() && "Out-of-range index in GenericSelectionExpr::getAssociation!"
) ? static_cast<void> (0) : __assert_fail ("I < getNumAssocs() && \"Out-of-range index in GenericSelectionExpr::getAssociation!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5428, __PRETTY_FUNCTION__));
  return ConstAssociation(
      cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
      getTrailingObjects<TypeSourceInfo *>()[I],
      !isResultDependent() && (getResultIndex() == I));
}

association_range associations() {
  AssociationIterator Begin(getTrailingObjects<Stmt *>() +
                                AssocExprStartIndex,
                            getTrailingObjects<TypeSourceInfo *>(),
                            /*Offset=*/0, ResultIndex);
  AssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
                          /*Offset=*/NumAssocs, ResultIndex);
  return llvm::make_range(Begin, End);
}

const_association_range associations() const {
  ConstAssociationIterator Begin(getTrailingObjects<Stmt *>() +
                                     AssocExprStartIndex,
                                 getTrailingObjects<TypeSourceInfo *>(),
                                 /*Offset=*/0, ResultIndex);
  ConstAssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
                               /*Offset=*/NumAssocs, ResultIndex);
  return llvm::make_range(Begin, End);
}

SourceLocation getGenericLoc() const {
  return GenericSelectionExprBits.GenericLoc;
}
SourceLocation getDefaultLoc() const { return DefaultLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }
SourceLocation getBeginLoc() const { return getGenericLoc(); }
SourceLocation getEndLoc() const { return getRParenLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == GenericSelectionExprClass;
}

child_range children() {
  return child_range(getTrailingObjects<Stmt *>(),
                     getTrailingObjects<Stmt *>() +
                         numTrailingObjects(OverloadToken<Stmt *>()));
}
const_child_range children() const {
  return const_child_range(getTrailingObjects<Stmt *>(),
                           getTrailingObjects<Stmt *>() +
                               numTrailingObjects(OverloadToken<Stmt *>()));
}
5477};

5479//===----------------------------------------------------------------------===//
5480// Clang Extensions
5481//===----------------------------------------------------------------------===//

5483/// ExtVectorElementExpr - This represents access to specific elements of a
5484/// vector, and may occur on the left hand side or right hand side.  For example
5485/// the following is legal:  "V.xy = V.zw" if V is a 4 element extended vector.
5486///
5487/// Note that the base may have either vector or pointer to vector type, just
5488/// like a struct field reference.
5489///
5490class ExtVectorElementExpr : public Expr {
Stmt *Base;
IdentifierInfo *Accessor;
SourceLocation AccessorLoc;
5494public:
ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
                     IdentifierInfo &accessor, SourceLocation loc)
  : Expr(ExtVectorElementExprClass, ty, VK,
         (VK == VK_RValue ? OK_Ordinary : OK_VectorComponent),
         base->isTypeDependent(), base->isValueDependent(),
         base->isInstantiationDependent(),
         base->containsUnexpandedParameterPack()),
    Base(base), Accessor(&accessor), AccessorLoc(loc) {}

/// Build an empty vector element expression.
explicit ExtVectorElementExpr(EmptyShell Empty)
  : Expr(ExtVectorElementExprClass, Empty) { }

const Expr *getBase() const { return cast<Expr>(Base); }
Expr *getBase() { return cast<Expr>(Base); }
void setBase(Expr *E) { Base = E; }

IdentifierInfo &getAccessor() const { return *Accessor; }
void setAccessor(IdentifierInfo *II) { Accessor = II; }

SourceLocation getAccessorLoc() const { return AccessorLoc; }
void setAccessorLoc(SourceLocation L) { AccessorLoc = L; }

/// getNumElements - Get the number of components being selected.
unsigned getNumElements() const;

/// containsDuplicateElements - Return true if any element access is
/// repeated.
bool containsDuplicateElements() const;

/// getEncodedElementAccess - Encode the elements accessed into an llvm
/// aggregate Constant of ConstantInt(s).
void getEncodedElementAccess(SmallVectorImpl<uint32_t> &Elts) const;

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return AccessorLoc; }

/// isArrow - Return true if the base expression is a pointer to vector,
/// return false if the base expression is a vector.
bool isArrow() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExtVectorElementExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base+1); }
const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}
5547};

5549/// BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
5550/// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
5551class BlockExpr : public Expr {
5552protected:
BlockDecl *TheBlock;
5554public:
BlockExpr(BlockDecl *BD, QualType ty)
  : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary,
         ty->isDependentType(), ty->isDependentType(),
         ty->isInstantiationDependentType() || BD->isDependentContext(),
         false),
    TheBlock(BD) {}

/// Build an empty block expression.
explicit BlockExpr(EmptyShell Empty) : Expr(BlockExprClass, Empty) { }

const BlockDecl *getBlockDecl() const { return TheBlock; }
BlockDecl *getBlockDecl() { return TheBlock; }
void setBlockDecl(BlockDecl *BD) { TheBlock = BD; }

// Convenience functions for probing the underlying BlockDecl.
SourceLocation getCaretLocation() const;
const Stmt *getBody() const;
Stmt *getBody();

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCaretLocation();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBody()->getEndLoc();
}

/// getFunctionType - Return the underlying function type for this block.
const FunctionProtoType *getFunctionType() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == BlockExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
5595};

5597/// AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2]
5598/// This AST node provides support for reinterpreting a type to another
5599/// type of the same size.
5600class AsTypeExpr : public Expr {
5601private:
Stmt *SrcExpr;
SourceLocation BuiltinLoc, RParenLoc;

friend class ASTReader;
friend class ASTStmtReader;
explicit AsTypeExpr(EmptyShell Empty) : Expr(AsTypeExprClass, Empty) {}

5609public:
AsTypeExpr(Expr* SrcExpr, QualType DstType,
           ExprValueKind VK, ExprObjectKind OK,
           SourceLocation BuiltinLoc, SourceLocation RParenLoc)
  : Expr(AsTypeExprClass, DstType, VK, OK,
         DstType->isDependentType(),
         DstType->isDependentType() || SrcExpr->isValueDependent(),
         (DstType->isInstantiationDependentType() ||
          SrcExpr->isInstantiationDependent()),
         (DstType->containsUnexpandedParameterPack() ||
          SrcExpr->containsUnexpandedParameterPack())),
SrcExpr(SrcExpr), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {}

/// getSrcExpr - Return the Expr to be converted.
Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }

/// getBuiltinLoc - Return the location of the __builtin_astype token.
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }

/// getRParenLoc - Return the location of final right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AsTypeExprClass;
}

// Iterators
child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
const_child_range children() const {
  return const_child_range(&SrcExpr, &SrcExpr + 1);
}
5643};

5645/// PseudoObjectExpr - An expression which accesses a pseudo-object
5646/// l-value.  A pseudo-object is an abstract object, accesses to which
5647/// are translated to calls.  The pseudo-object expression has a
5648/// syntactic form, which shows how the expression was actually
5649/// written in the source code, and a semantic form, which is a series
5650/// of expressions to be executed in order which detail how the
5651/// operation is actually evaluated.  Optionally, one of the semantic
5652/// forms may also provide a result value for the expression.
5653///
5654/// If any of the semantic-form expressions is an OpaqueValueExpr,
5655/// that OVE is required to have a source expression, and it is bound
5656/// to the result of that source expression.  Such OVEs may appear
5657/// only in subsequent semantic-form expressions and as
5658/// sub-expressions of the syntactic form.
5659///
5660/// PseudoObjectExpr should be used only when an operation can be
5661/// usefully described in terms of fairly simple rewrite rules on
5662/// objects and functions that are meant to be used by end-developers.
5663/// For example, under the Itanium ABI, dynamic casts are implemented
5664/// as a call to a runtime function called __dynamic_cast; using this
5665/// class to describe that would be inappropriate because that call is
5666/// not really part of the user-visible semantics, and instead the
5667/// cast is properly reflected in the AST and IR-generation has been
5668/// taught to generate the call as necessary.  In contrast, an
5669/// Objective-C property access is semantically defined to be
5670/// equivalent to a particular message send, and this is very much
5671/// part of the user model.  The name of this class encourages this
5672/// modelling design.
5673class PseudoObjectExpr final
  : public Expr,
    private llvm::TrailingObjects<PseudoObjectExpr, Expr *> {
// PseudoObjectExprBits.NumSubExprs - The number of sub-expressions.
// Always at least two, because the first sub-expression is the
// syntactic form.

// PseudoObjectExprBits.ResultIndex - The index of the
// sub-expression holding the result.  0 means the result is void,
// which is unambiguous because it's the index of the syntactic
// form.  Note that this is therefore 1 higher than the value passed
// in to Create, which is an index within the semantic forms.
// Note also that ASTStmtWriter assumes this encoding.

Expr **getSubExprsBuffer() { return getTrailingObjects<Expr *>(); }
const Expr * const *getSubExprsBuffer() const {
  return getTrailingObjects<Expr *>();
}

PseudoObjectExpr(QualType type, ExprValueKind VK,
                 Expr *syntactic, ArrayRef<Expr*> semantic,
                 unsigned resultIndex);

PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs);

unsigned getNumSubExprs() const {
  return PseudoObjectExprBits.NumSubExprs;
}

5702public:
/// NoResult - A value for the result index indicating that there is
/// no semantic result.
enum : unsigned { NoResult = ~0U };

static PseudoObjectExpr *Create(const ASTContext &Context, Expr *syntactic,
                                ArrayRef<Expr*> semantic,
                                unsigned resultIndex);

static PseudoObjectExpr *Create(const ASTContext &Context, EmptyShell shell,
                                unsigned numSemanticExprs);

/// Return the syntactic form of this expression, i.e. the
/// expression it actually looks like.  Likely to be expressed in
/// terms of OpaqueValueExprs bound in the semantic form.
Expr *getSyntacticForm() { return getSubExprsBuffer()[0]; }
const Expr *getSyntacticForm() const { return getSubExprsBuffer()[0]; }

/// Return the index of the result-bearing expression into the semantics
/// expressions, or PseudoObjectExpr::NoResult if there is none.
unsigned getResultExprIndex() const {
  if (PseudoObjectExprBits.ResultIndex == 0) return NoResult;
  return PseudoObjectExprBits.ResultIndex - 1;
}

/// Return the result-bearing expression, or null if there is none.
Expr *getResultExpr() {
  if (PseudoObjectExprBits.ResultIndex == 0)
    return nullptr;
  return getSubExprsBuffer()[PseudoObjectExprBits.ResultIndex];
}
const Expr *getResultExpr() const {
  return const_cast<PseudoObjectExpr*>(this)->getResultExpr();
}

unsigned getNumSemanticExprs() const { return getNumSubExprs() - 1; }

typedef Expr * const *semantics_iterator;
typedef const Expr * const *const_semantics_iterator;
semantics_iterator semantics_begin() {
  return getSubExprsBuffer() + 1;
}
const_semantics_iterator semantics_begin() const {
  return getSubExprsBuffer() + 1;
}
semantics_iterator semantics_end() {
  return getSubExprsBuffer() + getNumSubExprs();
}
const_semantics_iterator semantics_end() const {
  return getSubExprsBuffer() + getNumSubExprs();
}

llvm::iterator_range<semantics_iterator> semantics() {
  return llvm::make_range(semantics_begin(), semantics_end());
}
llvm::iterator_range<const_semantics_iterator> semantics() const {
  return llvm::make_range(semantics_begin(), semantics_end());
}

Expr *getSemanticExpr(unsigned index) {
  assert(index + 1 < getNumSubExprs())((index + 1 < getNumSubExprs()) ? static_cast<void> (
0) : __assert_fail ("index + 1 < getNumSubExprs()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5762, __PRETTY_FUNCTION__));
  return getSubExprsBuffer()[index + 1];
}
const Expr *getSemanticExpr(unsigned index) const {
  return const_cast<PseudoObjectExpr*>(this)->getSemanticExpr(index);
}

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getExprLoc();
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getEndLoc();
}

child_range children() {
  const_child_range CCR =
      const_cast<const PseudoObjectExpr *>(this)->children();
  return child_range(cast_away_const(CCR.begin()),
                     cast_away_const(CCR.end()));
}
const_child_range children() const {
  Stmt *const *cs = const_cast<Stmt *const *>(
      reinterpret_cast<const Stmt *const *>(getSubExprsBuffer()));
  return const_child_range(cs, cs + getNumSubExprs());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PseudoObjectExprClass;
}

friend TrailingObjects;
friend class ASTStmtReader;
5798};

5800/// AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*,
5801/// __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the
5802/// similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>,
5803/// and corresponding __opencl_atomic_* for OpenCL 2.0.
5804/// All of these instructions take one primary pointer, at least one memory
5805/// order. The instructions for which getScopeModel returns non-null value
5806/// take one synch scope.
5807class AtomicExpr : public Expr {
5808public:
enum AtomicOp {
5810#define BUILTIN(ID, TYPE, ATTRS)
5811#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) AO ## ID,
5812#include "clang/Basic/Builtins.def"
  // Avoid trailing comma
  BI_First = 0
};

5817private:
/// Location of sub-expressions.
/// The location of Scope sub-expression is NumSubExprs - 1, which is
/// not fixed, therefore is not defined in enum.
enum { PTR, ORDER, VAL1, ORDER_FAIL, VAL2, WEAK, END_EXPR };
Stmt *SubExprs[END_EXPR + 1];
unsigned NumSubExprs;
SourceLocation BuiltinLoc, RParenLoc;
AtomicOp Op;

friend class ASTStmtReader;
5828public:
AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t,
           AtomicOp op, SourceLocation RP);

/// Determine the number of arguments the specified atomic builtin
/// should have.
static unsigned getNumSubExprs(AtomicOp Op);

/// Build an empty AtomicExpr.
explicit AtomicExpr(EmptyShell Empty) : Expr(AtomicExprClass, Empty) { }

Expr *getPtr() const {
  return cast<Expr>(SubExprs[PTR]);
}
Expr *getOrder() const {
  return cast<Expr>(SubExprs[ORDER]);
}
Expr *getScope() const {
  assert(getScopeModel() && "No scope")((getScopeModel() && "No scope") ? static_cast<void
> (0) : __assert_fail ("getScopeModel() && \"No scope\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5846, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[NumSubExprs - 1]);
}
Expr *getVal1() const {
  if (Op == AO__c11_atomic_init || Op == AO__opencl_atomic_init)
    return cast<Expr>(SubExprs[ORDER]);
  assert(NumSubExprs > VAL1)((NumSubExprs > VAL1) ? static_cast<void> (0) : __assert_fail
 ("NumSubExprs > VAL1", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5852, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[VAL1]);
}
Expr *getOrderFail() const {
  assert(NumSubExprs > ORDER_FAIL)((NumSubExprs > ORDER_FAIL) ? static_cast<void> (0) :
 __assert_fail ("NumSubExprs > ORDER_FAIL", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5856, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[ORDER_FAIL]);
}
Expr *getVal2() const {
  if (Op == AO__atomic_exchange)
    return cast<Expr>(SubExprs[ORDER_FAIL]);
  assert(NumSubExprs > VAL2)((NumSubExprs > VAL2) ? static_cast<void> (0) : __assert_fail
 ("NumSubExprs > VAL2", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5862, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[VAL2]);
}
Expr *getWeak() const {
  assert(NumSubExprs > WEAK)((NumSubExprs > WEAK) ? static_cast<void> (0) : __assert_fail
 ("NumSubExprs > WEAK", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5866, __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[WEAK]);
}
QualType getValueType() const;

AtomicOp getOp() const { return Op; }
unsigned getNumSubExprs() const { return NumSubExprs; }

Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
const Expr * const *getSubExprs() const {
  return reinterpret_cast<Expr * const *>(SubExprs);
}

bool isVolatile() const {
  return getPtr()->getType()->getPointeeType().isVolatileQualified();
}

bool isCmpXChg() const {
  return getOp() == AO__c11_atomic_compare_exchange_strong ||
         getOp() == AO__c11_atomic_compare_exchange_weak ||
         getOp() == AO__opencl_atomic_compare_exchange_strong ||
         getOp() == AO__opencl_atomic_compare_exchange_weak ||
         getOp() == AO__atomic_compare_exchange ||
         getOp() == AO__atomic_compare_exchange_n;
}

bool isOpenCL() const {
  return getOp() >= AO__opencl_atomic_init &&
2
←
Assuming the condition is true→
4
←
Returning the value 1, which participates in a condition later→
         getOp() <= AO__opencl_atomic_fetch_max;
3
←
Assuming the condition is true→
}

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AtomicExprClass;
}

// Iterators
child_range children() {
  return child_range(SubExprs, SubExprs+NumSubExprs);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + NumSubExprs);
}

/// Get atomic scope model for the atomic op code.
/// \return empty atomic scope model if the atomic op code does not have
///   scope operand.
static std::unique_ptr<AtomicScopeModel> getScopeModel(AtomicOp Op) {
  auto Kind =
      (Op >= AO__opencl_atomic_load && Op <= AO__opencl_atomic_fetch_max)
          ? AtomicScopeModelKind::OpenCL
          : AtomicScopeModelKind::None;
  return AtomicScopeModel::create(Kind);
}

/// Get atomic scope model.
/// \return empty atomic scope model if this atomic expression does not have
///   scope operand.
std::unique_ptr<AtomicScopeModel> getScopeModel() const {
  return getScopeModel(getOp());
}
5932};

5934/// TypoExpr - Internal placeholder for expressions where typo correction
5935/// still needs to be performed and/or an error diagnostic emitted.
5936class TypoExpr : public Expr {
5937public:
TypoExpr(QualType T)
    : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary,
           /*isTypeDependent*/ true,
           /*isValueDependent*/ true,
           /*isInstantiationDependent*/ true,
           /*containsUnexpandedParameterPack*/ false) {
  assert(T->isDependentType() && "TypoExpr given a non-dependent type")((T->isDependentType() && "TypoExpr given a non-dependent type"
) ? static_cast<void> (0) : __assert_fail ("T->isDependentType() && \"TypoExpr given a non-dependent type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Expr.h"
, 5944, __PRETTY_FUNCTION__));
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == TypoExprClass;
}

5961};
5962} // end namespace clang

5964#endif // LLVM_CLANG_AST_EXPR_H