18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/IR/MDBuilder.h"
24 #include "llvm/IR/Metadata.h"
26 using namespace clang;
27 using namespace CodeGen;
38 if (
const ComplexType *comp = dyn_cast<ComplexType>(type)) {
41 return cast<ComplexType>(cast<AtomicType>(
type)->getValueType());
46 class ComplexExprEmitter
47 :
public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
62 bool TestAndClearIgnoreReal() {
67 bool TestAndClearIgnoreImag() {
77 return EmitLoadOfLValue(CGF.EmitLValue(E), E->
getExprLoc());
103 S->dump(CGF.getContext().getSourceManager());
104 llvm_unreachable(
"Stmt can't have complex result type!");
120 if (result.isReference())
121 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E),
124 llvm::Constant *pair = result.getValue();
126 pair->getAggregateElement(1U));
128 return EmitLoadOfLValue(E);
131 return EmitLoadOfLValue(E);
134 return CGF.EmitObjCMessageExpr(E).getComplexVal();
140 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->
getExprLoc());
141 return CGF.getOpaqueRValueMapping(E).getComplexVal();
145 return CGF.EmitPseudoObjectRValue(E).getComplexVal();
164 bool isInc,
bool isPre) {
166 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
169 return VisitPrePostIncDec(E,
false,
false);
172 return VisitPrePostIncDec(E,
true,
false);
175 return VisitPrePostIncDec(E,
false,
true);
178 return VisitPrePostIncDec(E,
true,
true);
182 TestAndClearIgnoreReal();
183 TestAndClearIgnoreImag();
200 CGF.enterFullExpression(E);
207 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
213 llvm::Constant *Null =
214 llvm::Constant::getNullValue(CGF.ConvertType(Elem));
231 (
const BinOpInfo &));
239 const BinOpInfo &Op);
242 return EmitBinAdd(EmitBinOps(E));
245 return EmitBinSub(EmitBinOps(E));
248 return EmitBinMul(EmitBinOps(E));
251 return EmitBinDiv(EmitBinOps(E));
256 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
259 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
262 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
265 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
286 return EmitLoadOfLValue(E);
292 return CGF.EmitAtomicExpr(E).getComplexVal();
305 assert(lvalue.
isSimple() &&
"non-simple complex l-value?");
307 return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal();
315 unsigned AlignI = std::min(AlignR, ComplexAlign);
319 if (!IgnoreReal || isVolatile) {
321 SrcPtr->getName() +
".realp");
322 Real =
Builder.CreateAlignedLoad(RealP, AlignR, isVolatile,
323 SrcPtr->getName() +
".real");
326 if (!IgnoreImag || isVolatile) {
328 SrcPtr->getName() +
".imagp");
329 Imag =
Builder.CreateAlignedLoad(ImagP, AlignI, isVolatile,
330 SrcPtr->getName() +
".imag");
340 (!isInit && CGF.LValueIsSuitableForInlineAtomic(lvalue)))
350 unsigned AlignI = std::min(AlignR, ComplexAlign);
352 Builder.CreateAlignedStore(Val.first, RealPtr, AlignR,
354 Builder.CreateAlignedStore(Val.second, ImagPtr, AlignI,
365 CGF.ErrorUnsupported(E,
"complex expression");
375 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
381 return EmitLoadOfLValue(E);
383 return CGF.EmitCallExpr(E).getComplexVal();
389 assert(RetAlloca &&
"Expected complex return value");
390 return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->
getType()),
405 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
406 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
415 Val = CGF.EmitScalarConversion(Val, SrcType, DestType);
418 return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType()));
424 case CK_Dependent: llvm_unreachable(
"dependent cast kind in IR gen!");
436 LValue origLV = CGF.EmitLValue(Op);
439 CGF.ConvertType(CGF.getContext().getPointerType(DestTy)));
440 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy,
487 llvm_unreachable(
"invalid cast kind for complex value");
491 return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op),
498 return EmitComplexToComplexCast(Visit(Op), Op->
getType(), DestTy);
501 llvm_unreachable(
"unknown cast resulting in complex value");
505 TestAndClearIgnoreReal();
506 TestAndClearIgnoreImag();
510 if (Op.first->getType()->isFloatingPointTy()) {
511 ResR =
Builder.CreateFNeg(Op.first,
"neg.r");
512 ResI =
Builder.CreateFNeg(Op.second,
"neg.i");
514 ResR =
Builder.CreateNeg(Op.first,
"neg.r");
515 ResI =
Builder.CreateNeg(Op.second,
"neg.i");
521 TestAndClearIgnoreReal();
522 TestAndClearIgnoreImag();
526 if (Op.second->getType()->isFloatingPointTy())
527 ResI =
Builder.CreateFNeg(Op.second,
"conj.i");
529 ResI =
Builder.CreateNeg(Op.second,
"conj.i");
534 ComplexPairTy ComplexExprEmitter::EmitBinAdd(
const BinOpInfo &Op) {
537 if (Op.LHS.first->getType()->isFloatingPointTy()) {
538 ResR =
Builder.CreateFAdd(Op.LHS.first, Op.RHS.first,
"add.r");
539 if (Op.LHS.second && Op.RHS.second)
540 ResI =
Builder.CreateFAdd(Op.LHS.second, Op.RHS.second,
"add.i");
542 ResI = Op.LHS.second ? Op.LHS.second : Op.RHS.second;
543 assert(ResI &&
"Only one operand may be real!");
545 ResR =
Builder.CreateAdd(Op.LHS.first, Op.RHS.first,
"add.r");
546 assert(Op.LHS.second && Op.RHS.second &&
547 "Both operands of integer complex operators must be complex!");
548 ResI =
Builder.CreateAdd(Op.LHS.second, Op.RHS.second,
"add.i");
553 ComplexPairTy ComplexExprEmitter::EmitBinSub(
const BinOpInfo &Op) {
555 if (Op.LHS.first->getType()->isFloatingPointTy()) {
556 ResR =
Builder.CreateFSub(Op.LHS.first, Op.RHS.first,
"sub.r");
557 if (Op.LHS.second && Op.RHS.second)
558 ResI =
Builder.CreateFSub(Op.LHS.second, Op.RHS.second,
"sub.i");
560 ResI = Op.LHS.second ? Op.LHS.second
561 :
Builder.CreateFNeg(Op.RHS.second,
"sub.i");
562 assert(ResI &&
"Only one operand may be real!");
564 ResR =
Builder.CreateSub(Op.LHS.first, Op.RHS.first,
"sub.r");
565 assert(Op.LHS.second && Op.RHS.second &&
566 "Both operands of integer complex operators must be complex!");
567 ResI =
Builder.CreateSub(Op.LHS.second, Op.RHS.second,
"sub.i");
573 ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName,
574 const BinOpInfo &Op) {
589 CGF.CGM.getTypes().arrangeFreeFunctionCall(
592 llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo);
593 llvm::Constant *Func = CGF.CGM.CreateBuiltinFunction(FTy, LibCallName);
594 llvm::Instruction *Call;
598 cast<llvm::CallInst>(Call)->setCallingConv(CGF.CGM.getBuiltinCC());
599 cast<llvm::CallInst>(Call)->setDoesNotThrow();
607 switch (Ty->getTypeID()) {
609 llvm_unreachable(
"Unsupported floating point type!");
610 case llvm::Type::HalfTyID:
612 case llvm::Type::FloatTyID:
614 case llvm::Type::DoubleTyID:
616 case llvm::Type::PPC_FP128TyID:
618 case llvm::Type::X86_FP80TyID:
620 case llvm::Type::FP128TyID:
627 ComplexPairTy ComplexExprEmitter::EmitBinMul(
const BinOpInfo &Op) {
630 llvm::MDBuilder MDHelper(CGF.getLLVMContext());
632 if (Op.LHS.first->getType()->isFloatingPointTy()) {
641 if (Op.LHS.second && Op.RHS.second) {
652 Value *AC =
Builder.CreateFMul(Op.LHS.first, Op.RHS.first,
"mul_ac");
653 Value *BD =
Builder.CreateFMul(Op.LHS.second, Op.RHS.second,
"mul_bd");
654 Value *AD =
Builder.CreateFMul(Op.LHS.first, Op.RHS.second,
"mul_ad");
655 Value *BC =
Builder.CreateFMul(Op.LHS.second, Op.RHS.first,
"mul_bc");
659 ResR =
Builder.CreateFSub(AC, BD,
"mul_r");
660 ResI =
Builder.CreateFAdd(AD, BC,
"mul_i");
664 Value *IsRNaN =
Builder.CreateFCmpUNO(ResR, ResR,
"isnan_cmp");
665 llvm::BasicBlock *ContBB = CGF.createBasicBlock(
"complex_mul_cont");
666 llvm::BasicBlock *INaNBB = CGF.createBasicBlock(
"complex_mul_imag_nan");
667 llvm::Instruction *Branch =
Builder.CreateCondBr(IsRNaN, INaNBB, ContBB);
668 llvm::BasicBlock *OrigBB = Branch->getParent();
672 llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1);
673 Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
676 CGF.EmitBlock(INaNBB);
677 Value *IsINaN =
Builder.CreateFCmpUNO(ResI, ResI,
"isnan_cmp");
678 llvm::BasicBlock *LibCallBB = CGF.createBasicBlock(
"complex_mul_libcall");
679 Branch =
Builder.CreateCondBr(IsINaN, LibCallBB, ContBB);
680 Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
683 CGF.EmitBlock(LibCallBB);
684 Value *LibCallR, *LibCallI;
685 std::tie(LibCallR, LibCallI) = EmitComplexBinOpLibCall(
691 CGF.EmitBlock(ContBB);
692 llvm::PHINode *RealPHI =
Builder.CreatePHI(ResR->getType(), 3,
"real_mul_phi");
693 RealPHI->addIncoming(ResR, OrigBB);
694 RealPHI->addIncoming(ResR, INaNBB);
695 RealPHI->addIncoming(LibCallR, LibCallBB);
696 llvm::PHINode *ImagPHI =
Builder.CreatePHI(ResI->getType(), 3,
"imag_mul_phi");
697 ImagPHI->addIncoming(ResI, OrigBB);
698 ImagPHI->addIncoming(ResI, INaNBB);
699 ImagPHI->addIncoming(LibCallI, LibCallBB);
702 assert((Op.LHS.second || Op.RHS.second) &&
703 "At least one operand must be complex!");
708 ResR =
Builder.CreateFMul(Op.LHS.first, Op.RHS.first,
"mul.rl");
711 ?
Builder.CreateFMul(Op.LHS.second, Op.RHS.first,
"mul.il")
712 :
Builder.CreateFMul(Op.LHS.first, Op.RHS.second,
"mul.ir");
714 assert(Op.LHS.second && Op.RHS.second &&
715 "Both operands of integer complex operators must be complex!");
716 Value *ResRl =
Builder.CreateMul(Op.LHS.first, Op.RHS.first,
"mul.rl");
717 Value *ResRr =
Builder.CreateMul(Op.LHS.second, Op.RHS.second,
"mul.rr");
718 ResR =
Builder.CreateSub(ResRl, ResRr,
"mul.r");
720 Value *ResIl =
Builder.CreateMul(Op.LHS.second, Op.RHS.first,
"mul.il");
721 Value *ResIr =
Builder.CreateMul(Op.LHS.first, Op.RHS.second,
"mul.ir");
722 ResI =
Builder.CreateAdd(ResIl, ResIr,
"mul.i");
729 ComplexPairTy ComplexExprEmitter::EmitBinDiv(
const BinOpInfo &Op) {
730 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
731 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
735 if (LHSr->getType()->isFloatingPointTy()) {
742 BinOpInfo LibCallOp = Op;
745 LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType());
747 StringRef LibCallName;
748 switch (LHSr->getType()->getTypeID()) {
750 llvm_unreachable(
"Unsupported floating point type!");
751 case llvm::Type::HalfTyID:
752 return EmitComplexBinOpLibCall(
"__divhc3", LibCallOp);
753 case llvm::Type::FloatTyID:
754 return EmitComplexBinOpLibCall(
"__divsc3", LibCallOp);
755 case llvm::Type::DoubleTyID:
756 return EmitComplexBinOpLibCall(
"__divdc3", LibCallOp);
757 case llvm::Type::PPC_FP128TyID:
758 return EmitComplexBinOpLibCall(
"__divtc3", LibCallOp);
759 case llvm::Type::X86_FP80TyID:
760 return EmitComplexBinOpLibCall(
"__divxc3", LibCallOp);
761 case llvm::Type::FP128TyID:
762 return EmitComplexBinOpLibCall(
"__divtc3", LibCallOp);
765 assert(LHSi &&
"Can have at most one non-complex operand!");
767 DSTr =
Builder.CreateFDiv(LHSr, RHSr);
768 DSTi =
Builder.CreateFDiv(LHSi, RHSr);
770 assert(Op.LHS.second && Op.RHS.second &&
771 "Both operands of integer complex operators must be complex!");
786 DSTr =
Builder.CreateUDiv(Tmp3, Tmp6);
787 DSTi =
Builder.CreateUDiv(Tmp9, Tmp6);
789 DSTr =
Builder.CreateSDiv(Tmp3, Tmp6);
790 DSTi =
Builder.CreateSDiv(Tmp9, Tmp6);
797 ComplexExprEmitter::BinOpInfo
799 TestAndClearIgnoreReal();
800 TestAndClearIgnoreImag();
805 Ops.LHS = Visit(E->
getLHS());
809 Ops.RHS = Visit(E->
getRHS());
816 LValue ComplexExprEmitter::
820 TestAndClearIgnoreReal();
821 TestAndClearIgnoreImag();
824 LHSTy = AT->getValueType();
838 .hasSameUnqualifiedType(ComplexElementTy, E->
getRHS()->
getType()));
841 assert(CGF.getContext()
843 OpInfo.RHS = Visit(E->
getRHS());
851 OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty);
857 if (!CGF.getContext().hasSameUnqualifiedType(ComplexElementTy, LHSTy))
858 LHSVal = CGF.EmitScalarConversion(LHSVal, LHSTy, ComplexElementTy);
861 OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty);
870 ComplexPairTy ResVal = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
871 EmitStoreOfComplex(ResVal, LHS,
false);
875 CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy);
876 CGF.EmitStoreOfScalar(ResVal, LHS,
false);
886 ComplexPairTy (ComplexExprEmitter::*Func)(
const BinOpInfo&)){
888 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
891 if (!CGF.getLangOpts().CPlusPlus)
903 assert(CGF.getContext().hasSameUnqualifiedType(E->
getLHS()->
getType(),
905 "Invalid assignment");
906 TestAndClearIgnoreReal();
907 TestAndClearIgnoreImag();
916 EmitStoreOfComplex(Val, LHS,
false);
923 LValue LV = EmitBinAssignLValue(E, Val);
926 if (!CGF.getLangOpts().CPlusPlus)
937 CGF.EmitIgnoredExpr(E->
getLHS());
938 return Visit(E->
getRHS());
943 TestAndClearIgnoreReal();
944 TestAndClearIgnoreImag();
945 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock(
"cond.true");
946 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"cond.false");
947 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"cond.end");
954 CGF.EmitBranchOnBoolExpr(E->
getCond(), LHSBlock, RHSBlock,
955 CGF.getProfileCount(E));
958 CGF.EmitBlock(LHSBlock);
959 CGF.incrementProfileCounter(E);
961 LHSBlock =
Builder.GetInsertBlock();
962 CGF.EmitBranch(ContBlock);
966 CGF.EmitBlock(RHSBlock);
968 RHSBlock =
Builder.GetInsertBlock();
969 CGF.EmitBlock(ContBlock);
973 llvm::PHINode *RealPN =
Builder.CreatePHI(LHS.first->getType(), 2,
"cond.r");
974 RealPN->addIncoming(LHS.first, LHSBlock);
975 RealPN->addIncoming(RHS.first, RHSBlock);
978 llvm::PHINode *ImagPN =
Builder.CreatePHI(LHS.first->getType(), 2,
"cond.i");
979 ImagPN->addIncoming(LHS.second, LHSBlock);
980 ImagPN->addIncoming(RHS.second, RHSBlock);
990 bool Ignore = TestAndClearIgnoreReal();
992 assert (Ignore ==
false &&
"init list ignored");
993 Ignore = TestAndClearIgnoreImag();
995 assert (Ignore ==
false &&
"init list ignored");
1006 assert(E->
getNumInits() == 0 &&
"Unexpected number of inits");
1008 llvm::Type* LTy = CGF.ConvertType(Ty);
1009 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
1018 CGF.ErrorUnsupported(E,
"complex va_arg expression");
1025 return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(ArgPtr, E->
getType()),
1038 "Invalid complex expression to emit");
1040 return ComplexExprEmitter(*
this, IgnoreReal, IgnoreImag)
1041 .Visit(const_cast<Expr *>(E));
1047 "Invalid complex expression to emit");
1048 ComplexExprEmitter Emitter(*
this);
1050 Emitter.EmitStoreOfComplex(Val, dest, isInit);
1056 ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
1062 return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc);
1068 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
1072 const ComplexExprEmitter::BinOpInfo &);
1076 case BO_MulAssign:
return &ComplexExprEmitter::EmitBinMul;
1077 case BO_DivAssign:
return &ComplexExprEmitter::EmitBinDiv;
1078 case BO_SubAssign:
return &ComplexExprEmitter::EmitBinSub;
1079 case BO_AddAssign:
return &ComplexExprEmitter::EmitBinAdd;
1081 llvm_unreachable(
"unexpected complex compound assignment");
1089 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
1097 LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
1098 Result = Val.getScalarVal();
Defines the clang::ASTContext interface.
unsigned getNumInits() const
CastKind getCastKind() const
LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E)
CompoundStmt * getSubStmt()
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty)
Lookup the libcall name for a given floating point type complex multiply.
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
const Expr * getResultExpr() const
[ARC] Consumes a retainable object pointer that has just been produced, e.g. as the return value of a...
llvm::Value * getAddress() const
CK_Dynamic - A C++ dynamic_cast.
LValue EmitComplexAssignmentLValue(const BinaryOperator *E)
Emit an l-value for an assignment (simple or compound) of complex type.
An object to manage conditionally-evaluated expressions.
LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, llvm::Value *&Result)
bool isVolatileQualified() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Converts between different integral complex types. _Complex char -> _Complex long long _Complex unsig...
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
Converting between two Objective-C object types, which can occur when performing reference binding to...
[ARC] Causes a value of block type to be copied to the heap, if it is not already there...
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
Converts a floating point complex to bool by comparing against 0+0i.
Describes an C or C++ initializer list.
Expr * getChosenSubExpr() const
CharUnits getAlignment() const
Expr * getTrueExpr() const
const Expr * getSubExpr() const
A builtin binary operation expression such as "x + y" or "x <= y".
bool isUnsignedIntegerType() const
A default argument (C++ [dcl.fct.default]).
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Causes a block literal to by copied to the heap and then autoreleased.
CastKind
CastKind - The kind of operation required for a conversion.
const Expr * getExpr() const
Get the initialization expression that will be used.
VAArgExpr, used for the builtin function __builtin_va_arg.
Converts between different floating point complex types. _Complex float -> _Complex double...
bool isRealFloatingType() const
Floating point categories.
Converts an integral complex to an integral real of the source's element type by discarding the imagi...
bool isAnyComplexType() const
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
bool isAtomicType() const
void add(RValue rvalue, QualType type, bool needscopy=false)
Expr * getSubExpr() const
An expression that sends a message to the given Objective-C object or class.
Converts from an integral complex to a floating complex. _Complex unsigned -> _Complex float...
Represents a reference to a non-type template parameter that has been substituted with a template arg...
The result type of a method or function.
llvm::IRBuilder< PreserveNames, llvm::ConstantFolder, CGBuilderInserterTy > CGBuilderTy
QualType getComputationResultType() const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
QualType getElementType() const
static const ComplexType * getComplexType(QualType type)
Return the complex type that we are meant to emit.
Converts from an integral real to an integral complex whose element type matches the source...
SourceLocation getExprLoc() const LLVM_READONLY
Represents a C11 generic selection.
QualType getCallReturnType(const ASTContext &Ctx) const
Converts a floating point complex to floating point real of the source's element type. Just discards the imaginary component. _Complex long double -> long double.
Expr * getReplacement() const
SourceLocation getExprLoc() const LLVM_READONLY
static const Type * getElementType(const Expr *BaseExpr)
static CompoundFunc getComplexOp(BinaryOperatorKind Op)
const Expr * getExpr() const
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Converts an integral complex to bool by comparing against 0+0i.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
CodeGenFunction::ComplexPairTy ComplexPairTy
A conversion of a floating point real to a floating point complex of the original type...
[ARC] Reclaim a retainable object pointer object that may have been produced and autoreleased as part...
Expr * getFalseExpr() const
QualType getCanonicalType() const
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
[ARC] Produces a retainable object pointer so that it may be consumed, e.g. by being passed to a cons...
Converts from T to _Atomic(T).
Converts from a floating complex to an integral complex. _Complex float -> _Complex int...
const Expr * getSubExpr() const
ComplexPairTy(ComplexExprEmitter::* CompoundFunc)(const ComplexExprEmitter::BinOpInfo &)
SourceLocation getExprLoc() const LLVM_READONLY
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
ObjCIvarRefExpr - A reference to an ObjC instance variable.
A use of a default initializer in a constructor or in aggregate initialization.
const Expr * getSubExpr() const
BoundNodesTreeBuilder *const Builder
Converts from _Atomic(T) to T.
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
static RValue get(llvm::Value *V)
const Expr * getInit(unsigned Init) const
Represents an implicitly-generated value initialization of an object of a given type.