CGExprComplex.cpp revision 9d232c884ea9872d6555df0fd7359699819bc1f1
1ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===// 2ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// 3ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// The LLVM Compiler Infrastructure 4ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// 5ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// This file is distributed under the University of Illinois Open Source 6ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// License. See LICENSE.TXT for details. 7ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// 8ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew//===----------------------------------------------------------------------===// 9ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// 10ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// This contains code to emit Expr nodes with complex types as LLVM code. 11ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew// 12ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew//===----------------------------------------------------------------------===// 13fed9641096e27f79a0f2d9adfe9839dd8d11dc0fWanlong Gao 14fed9641096e27f79a0f2d9adfe9839dd8d11dc0fWanlong Gao#include "CodeGenFunction.h" 15ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew#include "CodeGenModule.h" 16ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew#include "clang/AST/ASTContext.h" 17ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew#include "clang/AST/StmtVisitor.h" 184bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak#include "llvm/ADT/SmallString.h" 194bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak#include "llvm/IR/Constants.h" 204bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak#include "llvm/IR/Function.h" 216b01d689606d971217ccb961f3c44db8c2024d08robbiewusing namespace clang; 224bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modakusing namespace CodeGen; 236b01d689606d971217ccb961f3c44db8c2024d08robbiew 244bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak//===----------------------------------------------------------------------===// 256b01d689606d971217ccb961f3c44db8c2024d08robbiew// Complex Expression Emitter 264bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak//===----------------------------------------------------------------------===// 276b01d689606d971217ccb961f3c44db8c2024d08robbiew 284bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modaktypedef CodeGenFunction::ComplexPairTy ComplexPairTy; 29ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew 306b01d689606d971217ccb961f3c44db8c2024d08robbiew/// Return the complex type that we are meant to emit. 316b01d689606d971217ccb961f3c44db8c2024d08robbiewstatic const ComplexType *getComplexType(QualType type) { 32ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew type = type.getCanonicalType(); 33ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew if (const ComplexType *comp = dyn_cast<ComplexType>(type)) { 34ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return comp; 35ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } else { 364bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak return cast<ComplexType>(cast<AtomicType>(type)->getValueType()); 376b01d689606d971217ccb961f3c44db8c2024d08robbiew } 386b01d689606d971217ccb961f3c44db8c2024d08robbiew} 396b01d689606d971217ccb961f3c44db8c2024d08robbiew 406b01d689606d971217ccb961f3c44db8c2024d08robbiewnamespace { 416b01d689606d971217ccb961f3c44db8c2024d08robbiewclass ComplexExprEmitter 426b01d689606d971217ccb961f3c44db8c2024d08robbiew : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 434bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak CodeGenFunction &CGF; 446b01d689606d971217ccb961f3c44db8c2024d08robbiew CGBuilderTy &Builder; 456b01d689606d971217ccb961f3c44db8c2024d08robbiew // True is we should ignore the value of a 466b01d689606d971217ccb961f3c44db8c2024d08robbiew bool IgnoreReal; 476b01d689606d971217ccb961f3c44db8c2024d08robbiew bool IgnoreImag; 486b01d689606d971217ccb961f3c44db8c2024d08robbiewpublic: 496b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false) 506b01d689606d971217ccb961f3c44db8c2024d08robbiew : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) { 514bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak } 526b01d689606d971217ccb961f3c44db8c2024d08robbiew 536b01d689606d971217ccb961f3c44db8c2024d08robbiew 544bb656a129f7507823e9e6d6b98b1a02fd80ef89subrata_modak //===--------------------------------------------------------------------===// 55ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew // Utilities 56ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew //===--------------------------------------------------------------------===// 57ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew 586b01d689606d971217ccb961f3c44db8c2024d08robbiew bool TestAndClearIgnoreReal() { 596b01d689606d971217ccb961f3c44db8c2024d08robbiew bool I = IgnoreReal; 606b01d689606d971217ccb961f3c44db8c2024d08robbiew IgnoreReal = false; 616b01d689606d971217ccb961f3c44db8c2024d08robbiew return I; 626b01d689606d971217ccb961f3c44db8c2024d08robbiew } 636b01d689606d971217ccb961f3c44db8c2024d08robbiew bool TestAndClearIgnoreImag() { 646b01d689606d971217ccb961f3c44db8c2024d08robbiew bool I = IgnoreImag; 65ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew IgnoreImag = false; 66ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return I; 67ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } 68143090a9f7b93c011573dc044a58b2eea48e07e5robbiew 69143090a9f7b93c011573dc044a58b2eea48e07e5robbiew /// EmitLoadOfLValue - Given an expression with complex type that represents a 70143090a9f7b93c011573dc044a58b2eea48e07e5robbiew /// value l-value, this method emits the address of the l-value, then loads 71143090a9f7b93c011573dc044a58b2eea48e07e5robbiew /// and returns the result. 72143090a9f7b93c011573dc044a58b2eea48e07e5robbiew ComplexPairTy EmitLoadOfLValue(const Expr *E) { 73143090a9f7b93c011573dc044a58b2eea48e07e5robbiew return EmitLoadOfLValue(CGF.EmitLValue(E)); 74ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } 75ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew 76ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy EmitLoadOfLValue(LValue LV); 7777772ef57f3c92243d1df2064fdb2b321e40227dyaberauneya 7877772ef57f3c92243d1df2064fdb2b321e40227dyaberauneya /// EmitStoreOfComplex - Store the specified real/imag parts into the 79ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew /// specified value pointer. 80ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit); 8177772ef57f3c92243d1df2064fdb2b321e40227dyaberauneya 8289911a1fbdf83d83b13218a88432b4c59b01fdf1yaberauneya /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 8389911a1fbdf83d83b13218a88432b4c59b01fdf1yaberauneya ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 844bdda040bc045dd8d921d54d3b54db5dabeb9958Stanislav Kholmanskikh QualType DestType); 85ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew 86ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew //===--------------------------------------------------------------------===// 87ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew // Visitor Methods 88ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew //===--------------------------------------------------------------------===// 89fdce7d5e2a219d201a2b0e3bab6b61b01ec1d716Cyril Hrubis 90fdce7d5e2a219d201a2b0e3bab6b61b01ec1d716Cyril Hrubis ComplexPairTy Visit(Expr *E) { 91ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); 9256207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 93ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew 94ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy VisitStmt(Stmt *S) { 9589af32a63ce8a780ea39337339e14caae244b5a4Cyril Hrubis S->dump(CGF.getContext().getSourceManager()); 9689af32a63ce8a780ea39337339e14caae244b5a4Cyril Hrubis llvm_unreachable("Stmt can't have complex result type!"); 976b01d689606d971217ccb961f3c44db8c2024d08robbiew } 9845e285d46ab47b0ff76c88acb5ba97b0bd5f753dGarrett Cooper ComplexPairTy VisitExpr(Expr *S); 9962383b8186495f45d903ca077cfb0c54a6cce00cGarrett Cooper ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 1006b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 1016b01d689606d971217ccb961f3c44db8c2024d08robbiew return Visit(GE->getResultExpr()); 1026b01d689606d971217ccb961f3c44db8c2024d08robbiew } 1036b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 1046b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy 105d59a659cd639ca2780b00049d102acd2a783d585Caspar Zhang VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 1066b01d689606d971217ccb961f3c44db8c2024d08robbiew return Visit(PE->getReplacement()); 107359980f68b19c77c698b121b57a071dfe6e3ca31Jan Stancek } 1086b01d689606d971217ccb961f3c44db8c2024d08robbiew 1096b01d689606d971217ccb961f3c44db8c2024d08robbiew // l-values. 1106b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) { 1116b01d689606d971217ccb961f3c44db8c2024d08robbiew if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) { 1126b01d689606d971217ccb961f3c44db8c2024d08robbiew if (result.isReference()) 11356207cec7732e09c216c751c0b5f88a242bacae6subrata_modak return EmitLoadOfLValue(result.getReferenceLValue(CGF, E)); 1146b01d689606d971217ccb961f3c44db8c2024d08robbiew 1156b01d689606d971217ccb961f3c44db8c2024d08robbiew llvm::ConstantStruct *pair = 11656207cec7732e09c216c751c0b5f88a242bacae6subrata_modak cast<llvm::ConstantStruct>(result.getValue()); 1176b01d689606d971217ccb961f3c44db8c2024d08robbiew return ComplexPairTy(pair->getOperand(0), pair->getOperand(1)); 118359980f68b19c77c698b121b57a071dfe6e3ca31Jan Stancek } 1196b01d689606d971217ccb961f3c44db8c2024d08robbiew return EmitLoadOfLValue(E); 12056207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 12156207cec7732e09c216c751c0b5f88a242bacae6subrata_modak ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 12256207cec7732e09c216c751c0b5f88a242bacae6subrata_modak return EmitLoadOfLValue(E); 12356207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 1246b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { 1256b01d689606d971217ccb961f3c44db8c2024d08robbiew return CGF.EmitObjCMessageExpr(E).getComplexVal(); 12656207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 1276b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 1286b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 1291e6f5a673655551de5734ff31ef48cd63b604e6dGarrett Cooper ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) { 1302c28215423293e443469a07ae7011135d058b671Garrett Cooper if (E->isGLValue()) 131ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E)); 132ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return CGF.getOpaqueRValueMapping(E).getComplexVal(); 133ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } 13456207cec7732e09c216c751c0b5f88a242bacae6subrata_modak 135ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) { 1366b01d689606d971217ccb961f3c44db8c2024d08robbiew return CGF.EmitPseudoObjectRValue(E).getComplexVal(); 137ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } 13856207cec7732e09c216c751c0b5f88a242bacae6subrata_modak 1396b01d689606d971217ccb961f3c44db8c2024d08robbiew // FIXME: CompoundLiteralExpr 14053740500924f6439623a8ac256b5be2d6c59ed1fGarrett Cooper 1416b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy); 142ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 1436b01d689606d971217ccb961f3c44db8c2024d08robbiew // Unlike for scalars, we don't have to worry about function->ptr demotion 144ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew // here. 1456b01d689606d971217ccb961f3c44db8c2024d08robbiew return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 146ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } 14756207cec7732e09c216c751c0b5f88a242bacae6subrata_modak ComplexPairTy VisitCastExpr(CastExpr *E) { 14856207cec7732e09c216c751c0b5f88a242bacae6subrata_modak return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 14956207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 15004c009ed372517d4a2080052cb1ba41a07f993c7subrata_modak ComplexPairTy VisitCallExpr(const CallExpr *E); 15104c009ed372517d4a2080052cb1ba41a07f993c7subrata_modak ComplexPairTy VisitStmtExpr(const StmtExpr *E); 15256207cec7732e09c216c751c0b5f88a242bacae6subrata_modak 15356207cec7732e09c216c751c0b5f88a242bacae6subrata_modak // Operators. 15456207cec7732e09c216c751c0b5f88a242bacae6subrata_modak ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 155143090a9f7b93c011573dc044a58b2eea48e07e5robbiew bool isInc, bool isPre) { 156143090a9f7b93c011573dc044a58b2eea48e07e5robbiew LValue LV = CGF.EmitLValue(E->getSubExpr()); 1574bdda040bc045dd8d921d54d3b54db5dabeb9958Stanislav Kholmanskikh return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); 1582c28215423293e443469a07ae7011135d058b671Garrett Cooper } 159ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 160ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return VisitPrePostIncDec(E, false, false); 161ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew } 162ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 163ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew return VisitPrePostIncDec(E, true, false); 16456207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 165ac9784e4b6099dba38e356f4dde08a8d91846a48robbiew ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 1666b01d689606d971217ccb961f3c44db8c2024d08robbiew return VisitPrePostIncDec(E, false, true); 16756207cec7732e09c216c751c0b5f88a242bacae6subrata_modak } 16856207cec7732e09c216c751c0b5f88a242bacae6subrata_modak ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 16956207cec7732e09c216c751c0b5f88a242bacae6subrata_modak return VisitPrePostIncDec(E, true, true); 1706b01d689606d971217ccb961f3c44db8c2024d08robbiew } 1716b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 1726b01d689606d971217ccb961f3c44db8c2024d08robbiew ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 1736b01d689606d971217ccb961f3c44db8c2024d08robbiew TestAndClearIgnoreReal(); 174ec6edca7aa42b6affd989ef91b5897f96795e40fChris Dearman TestAndClearIgnoreImag(); 175 return Visit(E->getSubExpr()); 176 } 177 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 178 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 179 // LNot,Real,Imag never return complex. 180 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 181 return Visit(E->getSubExpr()); 182 } 183 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 184 return Visit(DAE->getExpr()); 185 } 186 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) { 187 CGF.enterFullExpression(E); 188 CodeGenFunction::RunCleanupsScope Scope(CGF); 189 return Visit(E->getSubExpr()); 190 } 191 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 192 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 193 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); 194 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 195 return ComplexPairTy(Null, Null); 196 } 197 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 198 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 199 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); 200 llvm::Constant *Null = 201 llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 202 return ComplexPairTy(Null, Null); 203 } 204 205 struct BinOpInfo { 206 ComplexPairTy LHS; 207 ComplexPairTy RHS; 208 QualType Ty; // Computation Type. 209 }; 210 211 BinOpInfo EmitBinOps(const BinaryOperator *E); 212 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 213 ComplexPairTy (ComplexExprEmitter::*Func) 214 (const BinOpInfo &), 215 ComplexPairTy &Val); 216 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 217 ComplexPairTy (ComplexExprEmitter::*Func) 218 (const BinOpInfo &)); 219 220 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 221 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 222 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 223 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 224 225 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 226 return EmitBinAdd(EmitBinOps(E)); 227 } 228 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 229 return EmitBinSub(EmitBinOps(E)); 230 } 231 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 232 return EmitBinMul(EmitBinOps(E)); 233 } 234 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 235 return EmitBinDiv(EmitBinOps(E)); 236 } 237 238 // Compound assignments. 239 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 240 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 241 } 242 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 243 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 244 } 245 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 246 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 247 } 248 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 249 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 250 } 251 252 // GCC rejects rem/and/or/xor for integer complex. 253 // Logical and/or always return int, never complex. 254 255 // No comparisons produce a complex result. 256 257 LValue EmitBinAssignLValue(const BinaryOperator *E, 258 ComplexPairTy &Val); 259 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 260 ComplexPairTy VisitBinComma (const BinaryOperator *E); 261 262 263 ComplexPairTy 264 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 265 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 266 267 ComplexPairTy VisitInitListExpr(InitListExpr *E); 268 269 ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 270 return EmitLoadOfLValue(E); 271 } 272 273 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 274 275 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) { 276 return CGF.EmitAtomicExpr(E).getComplexVal(); 277 } 278}; 279} // end anonymous namespace. 280 281//===----------------------------------------------------------------------===// 282// Utilities 283//===----------------------------------------------------------------------===// 284 285/// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to 286/// load the real and imaginary pieces, returning them as Real/Imag. 287ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue) { 288 assert(lvalue.isSimple() && "non-simple complex l-value?"); 289 llvm::Value *SrcPtr = lvalue.getAddress(); 290 bool isVolatile = lvalue.isVolatileQualified(); 291 292 llvm::Value *Real=0, *Imag=0; 293 294 if (!IgnoreReal || isVolatile) { 295 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0, 296 SrcPtr->getName() + ".realp"); 297 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real"); 298 } 299 300 if (!IgnoreImag || isVolatile) { 301 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1, 302 SrcPtr->getName() + ".imagp"); 303 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag"); 304 } 305 return ComplexPairTy(Real, Imag); 306} 307 308/// EmitStoreOfComplex - Store the specified real/imag parts into the 309/// specified value pointer. 310void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, 311 LValue lvalue, 312 bool isInit) { 313 llvm::Value *Ptr = lvalue.getAddress(); 314 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 315 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 316 317 // TODO: alignment 318 Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified()); 319 Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified()); 320} 321 322 323 324//===----------------------------------------------------------------------===// 325// Visitor Methods 326//===----------------------------------------------------------------------===// 327 328ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 329 CGF.ErrorUnsupported(E, "complex expression"); 330 llvm::Type *EltTy = 331 CGF.ConvertType(getComplexType(E->getType())->getElementType()); 332 llvm::Value *U = llvm::UndefValue::get(EltTy); 333 return ComplexPairTy(U, U); 334} 335 336ComplexPairTy ComplexExprEmitter:: 337VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 338 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 339 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 340} 341 342 343ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 344 if (E->getCallReturnType()->isReferenceType()) 345 return EmitLoadOfLValue(E); 346 347 return CGF.EmitCallExpr(E).getComplexVal(); 348} 349 350ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 351 CodeGenFunction::StmtExprEvaluation eval(CGF); 352 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 353} 354 355/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 356ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 357 QualType SrcType, 358 QualType DestType) { 359 // Get the src/dest element type. 360 SrcType = SrcType->castAs<ComplexType>()->getElementType(); 361 DestType = DestType->castAs<ComplexType>()->getElementType(); 362 363 // C99 6.3.1.6: When a value of complex type is converted to another 364 // complex type, both the real and imaginary parts follow the conversion 365 // rules for the corresponding real types. 366 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 367 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 368 return Val; 369} 370 371ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op, 372 QualType DestTy) { 373 switch (CK) { 374 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 375 376 // Atomic to non-atomic casts may be more than a no-op for some platforms and 377 // for some types. 378 case CK_AtomicToNonAtomic: 379 case CK_NonAtomicToAtomic: 380 case CK_NoOp: 381 case CK_LValueToRValue: 382 case CK_UserDefinedConversion: 383 return Visit(Op); 384 385 case CK_LValueBitCast: { 386 LValue origLV = CGF.EmitLValue(Op); 387 llvm::Value *V = origLV.getAddress(); 388 V = Builder.CreateBitCast(V, 389 CGF.ConvertType(CGF.getContext().getPointerType(DestTy))); 390 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy, 391 origLV.getAlignment())); 392 } 393 394 case CK_BitCast: 395 case CK_BaseToDerived: 396 case CK_DerivedToBase: 397 case CK_UncheckedDerivedToBase: 398 case CK_Dynamic: 399 case CK_ToUnion: 400 case CK_ArrayToPointerDecay: 401 case CK_FunctionToPointerDecay: 402 case CK_NullToPointer: 403 case CK_NullToMemberPointer: 404 case CK_BaseToDerivedMemberPointer: 405 case CK_DerivedToBaseMemberPointer: 406 case CK_MemberPointerToBoolean: 407 case CK_ReinterpretMemberPointer: 408 case CK_ConstructorConversion: 409 case CK_IntegralToPointer: 410 case CK_PointerToIntegral: 411 case CK_PointerToBoolean: 412 case CK_ToVoid: 413 case CK_VectorSplat: 414 case CK_IntegralCast: 415 case CK_IntegralToBoolean: 416 case CK_IntegralToFloating: 417 case CK_FloatingToIntegral: 418 case CK_FloatingToBoolean: 419 case CK_FloatingCast: 420 case CK_CPointerToObjCPointerCast: 421 case CK_BlockPointerToObjCPointerCast: 422 case CK_AnyPointerToBlockPointerCast: 423 case CK_ObjCObjectLValueCast: 424 case CK_FloatingComplexToReal: 425 case CK_FloatingComplexToBoolean: 426 case CK_IntegralComplexToReal: 427 case CK_IntegralComplexToBoolean: 428 case CK_ARCProduceObject: 429 case CK_ARCConsumeObject: 430 case CK_ARCReclaimReturnedObject: 431 case CK_ARCExtendBlockObject: 432 case CK_CopyAndAutoreleaseBlockObject: 433 case CK_BuiltinFnToFnPtr: 434 case CK_ZeroToOCLEvent: 435 llvm_unreachable("invalid cast kind for complex value"); 436 437 case CK_FloatingRealToComplex: 438 case CK_IntegralRealToComplex: { 439 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 440 441 // Convert the input element to the element type of the complex. 442 DestTy = DestTy->castAs<ComplexType>()->getElementType(); 443 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 444 445 // Return (realval, 0). 446 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 447 } 448 449 case CK_FloatingComplexCast: 450 case CK_FloatingComplexToIntegralComplex: 451 case CK_IntegralComplexCast: 452 case CK_IntegralComplexToFloatingComplex: 453 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 454 } 455 456 llvm_unreachable("unknown cast resulting in complex value"); 457} 458 459ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 460 TestAndClearIgnoreReal(); 461 TestAndClearIgnoreImag(); 462 ComplexPairTy Op = Visit(E->getSubExpr()); 463 464 llvm::Value *ResR, *ResI; 465 if (Op.first->getType()->isFloatingPointTy()) { 466 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 467 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 468 } else { 469 ResR = Builder.CreateNeg(Op.first, "neg.r"); 470 ResI = Builder.CreateNeg(Op.second, "neg.i"); 471 } 472 return ComplexPairTy(ResR, ResI); 473} 474 475ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 476 TestAndClearIgnoreReal(); 477 TestAndClearIgnoreImag(); 478 // ~(a+ib) = a + i*-b 479 ComplexPairTy Op = Visit(E->getSubExpr()); 480 llvm::Value *ResI; 481 if (Op.second->getType()->isFloatingPointTy()) 482 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 483 else 484 ResI = Builder.CreateNeg(Op.second, "conj.i"); 485 486 return ComplexPairTy(Op.first, ResI); 487} 488 489ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 490 llvm::Value *ResR, *ResI; 491 492 if (Op.LHS.first->getType()->isFloatingPointTy()) { 493 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 494 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 495 } else { 496 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 497 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 498 } 499 return ComplexPairTy(ResR, ResI); 500} 501 502ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 503 llvm::Value *ResR, *ResI; 504 if (Op.LHS.first->getType()->isFloatingPointTy()) { 505 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 506 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 507 } else { 508 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 509 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 510 } 511 return ComplexPairTy(ResR, ResI); 512} 513 514 515ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 516 using llvm::Value; 517 Value *ResR, *ResI; 518 519 if (Op.LHS.first->getType()->isFloatingPointTy()) { 520 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 521 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 522 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 523 524 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 525 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 526 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 527 } else { 528 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 529 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 530 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 531 532 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 533 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 534 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 535 } 536 return ComplexPairTy(ResR, ResI); 537} 538 539ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 540 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 541 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 542 543 544 llvm::Value *DSTr, *DSTi; 545 if (Op.LHS.first->getType()->isFloatingPointTy()) { 546 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 547 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c 548 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d 549 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd 550 551 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c 552 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d 553 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd 554 555 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c 556 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d 557 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad 558 559 DSTr = Builder.CreateFDiv(Tmp3, Tmp6); 560 DSTi = Builder.CreateFDiv(Tmp9, Tmp6); 561 } else { 562 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 563 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 564 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 565 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 566 567 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 568 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 569 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 570 571 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 572 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 573 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 574 575 if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 576 DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 577 DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 578 } else { 579 DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 580 DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 581 } 582 } 583 584 return ComplexPairTy(DSTr, DSTi); 585} 586 587ComplexExprEmitter::BinOpInfo 588ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 589 TestAndClearIgnoreReal(); 590 TestAndClearIgnoreImag(); 591 BinOpInfo Ops; 592 Ops.LHS = Visit(E->getLHS()); 593 Ops.RHS = Visit(E->getRHS()); 594 Ops.Ty = E->getType(); 595 return Ops; 596} 597 598 599LValue ComplexExprEmitter:: 600EmitCompoundAssignLValue(const CompoundAssignOperator *E, 601 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 602 ComplexPairTy &Val) { 603 TestAndClearIgnoreReal(); 604 TestAndClearIgnoreImag(); 605 QualType LHSTy = E->getLHS()->getType(); 606 607 BinOpInfo OpInfo; 608 609 // Load the RHS and LHS operands. 610 // __block variables need to have the rhs evaluated first, plus this should 611 // improve codegen a little. 612 OpInfo.Ty = E->getComputationResultType(); 613 614 // The RHS should have been converted to the computation type. 615 assert(OpInfo.Ty->isAnyComplexType()); 616 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 617 E->getRHS()->getType())); 618 OpInfo.RHS = Visit(E->getRHS()); 619 620 LValue LHS = CGF.EmitLValue(E->getLHS()); 621 622 // Load from the l-value. 623 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS); 624 625 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 626 627 // Expand the binary operator. 628 ComplexPairTy Result = (this->*Func)(OpInfo); 629 630 // Truncate the result back to the LHS type. 631 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 632 Val = Result; 633 634 // Store the result value into the LHS lvalue. 635 EmitStoreOfComplex(Result, LHS, /*isInit*/ false); 636 637 return LHS; 638} 639 640// Compound assignments. 641ComplexPairTy ComplexExprEmitter:: 642EmitCompoundAssign(const CompoundAssignOperator *E, 643 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 644 ComplexPairTy Val; 645 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 646 647 // The result of an assignment in C is the assigned r-value. 648 if (!CGF.getLangOpts().CPlusPlus) 649 return Val; 650 651 // If the lvalue is non-volatile, return the computed value of the assignment. 652 if (!LV.isVolatileQualified()) 653 return Val; 654 655 return EmitLoadOfLValue(LV); 656} 657 658LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 659 ComplexPairTy &Val) { 660 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 661 E->getRHS()->getType()) && 662 "Invalid assignment"); 663 TestAndClearIgnoreReal(); 664 TestAndClearIgnoreImag(); 665 666 // Emit the RHS. __block variables need the RHS evaluated first. 667 Val = Visit(E->getRHS()); 668 669 // Compute the address to store into. 670 LValue LHS = CGF.EmitLValue(E->getLHS()); 671 672 // Store the result value into the LHS lvalue. 673 EmitStoreOfComplex(Val, LHS, /*isInit*/ false); 674 675 return LHS; 676} 677 678ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 679 ComplexPairTy Val; 680 LValue LV = EmitBinAssignLValue(E, Val); 681 682 // The result of an assignment in C is the assigned r-value. 683 if (!CGF.getLangOpts().CPlusPlus) 684 return Val; 685 686 // If the lvalue is non-volatile, return the computed value of the assignment. 687 if (!LV.isVolatileQualified()) 688 return Val; 689 690 return EmitLoadOfLValue(LV); 691} 692 693ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 694 CGF.EmitIgnoredExpr(E->getLHS()); 695 return Visit(E->getRHS()); 696} 697 698ComplexPairTy ComplexExprEmitter:: 699VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 700 TestAndClearIgnoreReal(); 701 TestAndClearIgnoreImag(); 702 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 703 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 704 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 705 706 // Bind the common expression if necessary. 707 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 708 709 CodeGenFunction::ConditionalEvaluation eval(CGF); 710 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 711 712 eval.begin(CGF); 713 CGF.EmitBlock(LHSBlock); 714 ComplexPairTy LHS = Visit(E->getTrueExpr()); 715 LHSBlock = Builder.GetInsertBlock(); 716 CGF.EmitBranch(ContBlock); 717 eval.end(CGF); 718 719 eval.begin(CGF); 720 CGF.EmitBlock(RHSBlock); 721 ComplexPairTy RHS = Visit(E->getFalseExpr()); 722 RHSBlock = Builder.GetInsertBlock(); 723 CGF.EmitBlock(ContBlock); 724 eval.end(CGF); 725 726 // Create a PHI node for the real part. 727 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 728 RealPN->addIncoming(LHS.first, LHSBlock); 729 RealPN->addIncoming(RHS.first, RHSBlock); 730 731 // Create a PHI node for the imaginary part. 732 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 733 ImagPN->addIncoming(LHS.second, LHSBlock); 734 ImagPN->addIncoming(RHS.second, RHSBlock); 735 736 return ComplexPairTy(RealPN, ImagPN); 737} 738 739ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 740 return Visit(E->getChosenSubExpr(CGF.getContext())); 741} 742 743ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 744 bool Ignore = TestAndClearIgnoreReal(); 745 (void)Ignore; 746 assert (Ignore == false && "init list ignored"); 747 Ignore = TestAndClearIgnoreImag(); 748 (void)Ignore; 749 assert (Ignore == false && "init list ignored"); 750 751 if (E->getNumInits() == 2) { 752 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 753 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 754 return ComplexPairTy(Real, Imag); 755 } else if (E->getNumInits() == 1) { 756 return Visit(E->getInit(0)); 757 } 758 759 // Empty init list intializes to null 760 assert(E->getNumInits() == 0 && "Unexpected number of inits"); 761 QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); 762 llvm::Type* LTy = CGF.ConvertType(Ty); 763 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 764 return ComplexPairTy(zeroConstant, zeroConstant); 765} 766 767ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 768 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 769 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 770 771 if (!ArgPtr) { 772 CGF.ErrorUnsupported(E, "complex va_arg expression"); 773 llvm::Type *EltTy = 774 CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType()); 775 llvm::Value *U = llvm::UndefValue::get(EltTy); 776 return ComplexPairTy(U, U); 777 } 778 779 return EmitLoadOfLValue( 780 CGF.MakeNaturalAlignAddrLValue(ArgPtr, E->getType())); 781} 782 783//===----------------------------------------------------------------------===// 784// Entry Point into this File 785//===----------------------------------------------------------------------===// 786 787/// EmitComplexExpr - Emit the computation of the specified expression of 788/// complex type, ignoring the result. 789ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 790 bool IgnoreImag) { 791 assert(E && getComplexType(E->getType()) && 792 "Invalid complex expression to emit"); 793 794 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 795 .Visit(const_cast<Expr*>(E)); 796} 797 798void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest, 799 bool isInit) { 800 assert(E && getComplexType(E->getType()) && 801 "Invalid complex expression to emit"); 802 ComplexExprEmitter Emitter(*this); 803 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 804 Emitter.EmitStoreOfComplex(Val, dest, isInit); 805} 806 807/// EmitStoreOfComplex - Store a complex number into the specified l-value. 808void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest, 809 bool isInit) { 810 ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit); 811} 812 813/// EmitLoadOfComplex - Load a complex number from the specified address. 814ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src) { 815 return ComplexExprEmitter(*this).EmitLoadOfLValue(src); 816} 817 818LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 819 assert(E->getOpcode() == BO_Assign); 820 ComplexPairTy Val; // ignored 821 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 822} 823 824LValue CodeGenFunction:: 825EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 826 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &); 827 switch (E->getOpcode()) { 828 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break; 829 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break; 830 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break; 831 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break; 832 833 default: 834 llvm_unreachable("unexpected complex compound assignment"); 835 } 836 837 ComplexPairTy Val; // ignored 838 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 839} 840