1//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This contains code to emit Expr nodes with complex types as LLVM code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenFunction.h" 15#include "CodeGenModule.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/StmtVisitor.h" 18#include "llvm/ADT/SmallString.h" 19#include "llvm/IR/Constants.h" 20#include "llvm/IR/Function.h" 21#include <algorithm> 22using namespace clang; 23using namespace CodeGen; 24 25//===----------------------------------------------------------------------===// 26// Complex Expression Emitter 27//===----------------------------------------------------------------------===// 28 29typedef CodeGenFunction::ComplexPairTy ComplexPairTy; 30 31/// Return the complex type that we are meant to emit. 32static const ComplexType *getComplexType(QualType type) { 33 type = type.getCanonicalType(); 34 if (const ComplexType *comp = dyn_cast<ComplexType>(type)) { 35 return comp; 36 } else { 37 return cast<ComplexType>(cast<AtomicType>(type)->getValueType()); 38 } 39} 40 41namespace { 42class ComplexExprEmitter 43 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 44 CodeGenFunction &CGF; 45 CGBuilderTy &Builder; 46 bool IgnoreReal; 47 bool IgnoreImag; 48public: 49 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false) 50 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) { 51 } 52 53 54 //===--------------------------------------------------------------------===// 55 // Utilities 56 //===--------------------------------------------------------------------===// 57 58 bool TestAndClearIgnoreReal() { 59 bool I = IgnoreReal; 60 IgnoreReal = false; 61 return I; 62 } 63 bool TestAndClearIgnoreImag() { 64 bool I = IgnoreImag; 65 IgnoreImag = false; 66 return I; 67 } 68 69 /// EmitLoadOfLValue - Given an expression with complex type that represents a 70 /// value l-value, this method emits the address of the l-value, then loads 71 /// and returns the result. 72 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 73 return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc()); 74 } 75 76 ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc); 77 78 /// EmitStoreOfComplex - Store the specified real/imag parts into the 79 /// specified value pointer. 80 void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit); 81 82 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 83 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 84 QualType DestType); 85 /// EmitComplexToComplexCast - Emit a cast from scalar value Val to DestType. 86 ComplexPairTy EmitScalarToComplexCast(llvm::Value *Val, QualType SrcType, 87 QualType DestType); 88 89 //===--------------------------------------------------------------------===// 90 // Visitor Methods 91 //===--------------------------------------------------------------------===// 92 93 ComplexPairTy Visit(Expr *E) { 94 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); 95 } 96 97 ComplexPairTy VisitStmt(Stmt *S) { 98 S->dump(CGF.getContext().getSourceManager()); 99 llvm_unreachable("Stmt can't have complex result type!"); 100 } 101 ComplexPairTy VisitExpr(Expr *S); 102 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 103 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 104 return Visit(GE->getResultExpr()); 105 } 106 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 107 ComplexPairTy 108 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 109 return Visit(PE->getReplacement()); 110 } 111 112 // l-values. 113 ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) { 114 if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) { 115 if (result.isReference()) 116 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E), 117 E->getExprLoc()); 118 119 llvm::Constant *pair = result.getValue(); 120 return ComplexPairTy(pair->getAggregateElement(0U), 121 pair->getAggregateElement(1U)); 122 } 123 return EmitLoadOfLValue(E); 124 } 125 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 126 return EmitLoadOfLValue(E); 127 } 128 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { 129 return CGF.EmitObjCMessageExpr(E).getComplexVal(); 130 } 131 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 132 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 133 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) { 134 if (E->isGLValue()) 135 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->getExprLoc()); 136 return CGF.getOpaqueRValueMapping(E).getComplexVal(); 137 } 138 139 ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) { 140 return CGF.EmitPseudoObjectRValue(E).getComplexVal(); 141 } 142 143 // FIXME: CompoundLiteralExpr 144 145 ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy); 146 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 147 // Unlike for scalars, we don't have to worry about function->ptr demotion 148 // here. 149 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 150 } 151 ComplexPairTy VisitCastExpr(CastExpr *E) { 152 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 153 } 154 ComplexPairTy VisitCallExpr(const CallExpr *E); 155 ComplexPairTy VisitStmtExpr(const StmtExpr *E); 156 157 // Operators. 158 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 159 bool isInc, bool isPre) { 160 LValue LV = CGF.EmitLValue(E->getSubExpr()); 161 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); 162 } 163 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 164 return VisitPrePostIncDec(E, false, false); 165 } 166 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 167 return VisitPrePostIncDec(E, true, false); 168 } 169 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 170 return VisitPrePostIncDec(E, false, true); 171 } 172 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 173 return VisitPrePostIncDec(E, true, true); 174 } 175 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 176 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 177 TestAndClearIgnoreReal(); 178 TestAndClearIgnoreImag(); 179 return Visit(E->getSubExpr()); 180 } 181 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 182 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 183 // LNot,Real,Imag never return complex. 184 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 185 return Visit(E->getSubExpr()); 186 } 187 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 188 return Visit(DAE->getExpr()); 189 } 190 ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 191 CodeGenFunction::CXXDefaultInitExprScope Scope(CGF); 192 return Visit(DIE->getExpr()); 193 } 194 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) { 195 CGF.enterFullExpression(E); 196 CodeGenFunction::RunCleanupsScope Scope(CGF); 197 return Visit(E->getSubExpr()); 198 } 199 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 200 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 201 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); 202 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 203 return ComplexPairTy(Null, Null); 204 } 205 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 206 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 207 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); 208 llvm::Constant *Null = 209 llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 210 return ComplexPairTy(Null, Null); 211 } 212 213 struct BinOpInfo { 214 ComplexPairTy LHS; 215 ComplexPairTy RHS; 216 QualType Ty; // Computation Type. 217 }; 218 219 BinOpInfo EmitBinOps(const BinaryOperator *E); 220 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 221 ComplexPairTy (ComplexExprEmitter::*Func) 222 (const BinOpInfo &), 223 RValue &Val); 224 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 225 ComplexPairTy (ComplexExprEmitter::*Func) 226 (const BinOpInfo &)); 227 228 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 229 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 230 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 231 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 232 233 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 234 return EmitBinAdd(EmitBinOps(E)); 235 } 236 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 237 return EmitBinSub(EmitBinOps(E)); 238 } 239 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 240 return EmitBinMul(EmitBinOps(E)); 241 } 242 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 243 return EmitBinDiv(EmitBinOps(E)); 244 } 245 246 // Compound assignments. 247 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 248 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 249 } 250 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 251 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 252 } 253 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 254 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 255 } 256 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 257 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 258 } 259 260 // GCC rejects rem/and/or/xor for integer complex. 261 // Logical and/or always return int, never complex. 262 263 // No comparisons produce a complex result. 264 265 LValue EmitBinAssignLValue(const BinaryOperator *E, 266 ComplexPairTy &Val); 267 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 268 ComplexPairTy VisitBinComma (const BinaryOperator *E); 269 270 271 ComplexPairTy 272 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 273 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 274 275 ComplexPairTy VisitInitListExpr(InitListExpr *E); 276 277 ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 278 return EmitLoadOfLValue(E); 279 } 280 281 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 282 283 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) { 284 return CGF.EmitAtomicExpr(E).getComplexVal(); 285 } 286}; 287} // end anonymous namespace. 288 289//===----------------------------------------------------------------------===// 290// Utilities 291//===----------------------------------------------------------------------===// 292 293/// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to 294/// load the real and imaginary pieces, returning them as Real/Imag. 295ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue, 296 SourceLocation loc) { 297 assert(lvalue.isSimple() && "non-simple complex l-value?"); 298 if (lvalue.getType()->isAtomicType()) 299 return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal(); 300 301 llvm::Value *SrcPtr = lvalue.getAddress(); 302 bool isVolatile = lvalue.isVolatileQualified(); 303 unsigned AlignR = lvalue.getAlignment().getQuantity(); 304 ASTContext &C = CGF.getContext(); 305 QualType ComplexTy = lvalue.getType(); 306 unsigned ComplexAlign = C.getTypeAlignInChars(ComplexTy).getQuantity(); 307 unsigned AlignI = std::min(AlignR, ComplexAlign); 308 309 llvm::Value *Real=0, *Imag=0; 310 311 if (!IgnoreReal || isVolatile) { 312 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0, 313 SrcPtr->getName() + ".realp"); 314 Real = Builder.CreateAlignedLoad(RealP, AlignR, isVolatile, 315 SrcPtr->getName() + ".real"); 316 } 317 318 if (!IgnoreImag || isVolatile) { 319 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1, 320 SrcPtr->getName() + ".imagp"); 321 Imag = Builder.CreateAlignedLoad(ImagP, AlignI, isVolatile, 322 SrcPtr->getName() + ".imag"); 323 } 324 return ComplexPairTy(Real, Imag); 325} 326 327/// EmitStoreOfComplex - Store the specified real/imag parts into the 328/// specified value pointer. 329void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, 330 LValue lvalue, 331 bool isInit) { 332 if (lvalue.getType()->isAtomicType()) 333 return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit); 334 335 llvm::Value *Ptr = lvalue.getAddress(); 336 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 337 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 338 unsigned AlignR = lvalue.getAlignment().getQuantity(); 339 ASTContext &C = CGF.getContext(); 340 QualType ComplexTy = lvalue.getType(); 341 unsigned ComplexAlign = C.getTypeAlignInChars(ComplexTy).getQuantity(); 342 unsigned AlignI = std::min(AlignR, ComplexAlign); 343 344 Builder.CreateAlignedStore(Val.first, RealPtr, AlignR, 345 lvalue.isVolatileQualified()); 346 Builder.CreateAlignedStore(Val.second, ImagPtr, AlignI, 347 lvalue.isVolatileQualified()); 348} 349 350 351 352//===----------------------------------------------------------------------===// 353// Visitor Methods 354//===----------------------------------------------------------------------===// 355 356ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 357 CGF.ErrorUnsupported(E, "complex expression"); 358 llvm::Type *EltTy = 359 CGF.ConvertType(getComplexType(E->getType())->getElementType()); 360 llvm::Value *U = llvm::UndefValue::get(EltTy); 361 return ComplexPairTy(U, U); 362} 363 364ComplexPairTy ComplexExprEmitter:: 365VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 366 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 367 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 368} 369 370 371ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 372 if (E->getCallReturnType()->isReferenceType()) 373 return EmitLoadOfLValue(E); 374 375 return CGF.EmitCallExpr(E).getComplexVal(); 376} 377 378ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 379 CodeGenFunction::StmtExprEvaluation eval(CGF); 380 llvm::Value *RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true); 381 assert(RetAlloca && "Expected complex return value"); 382 return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()), 383 E->getExprLoc()); 384} 385 386/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 387ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 388 QualType SrcType, 389 QualType DestType) { 390 // Get the src/dest element type. 391 SrcType = SrcType->castAs<ComplexType>()->getElementType(); 392 DestType = DestType->castAs<ComplexType>()->getElementType(); 393 394 // C99 6.3.1.6: When a value of complex type is converted to another 395 // complex type, both the real and imaginary parts follow the conversion 396 // rules for the corresponding real types. 397 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 398 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 399 return Val; 400} 401 402ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val, 403 QualType SrcType, 404 QualType DestType) { 405 // Convert the input element to the element type of the complex. 406 DestType = DestType->castAs<ComplexType>()->getElementType(); 407 Val = CGF.EmitScalarConversion(Val, SrcType, DestType); 408 409 // Return (realval, 0). 410 return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType())); 411} 412 413ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op, 414 QualType DestTy) { 415 switch (CK) { 416 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 417 418 // Atomic to non-atomic casts may be more than a no-op for some platforms and 419 // for some types. 420 case CK_AtomicToNonAtomic: 421 case CK_NonAtomicToAtomic: 422 case CK_NoOp: 423 case CK_LValueToRValue: 424 case CK_UserDefinedConversion: 425 return Visit(Op); 426 427 case CK_LValueBitCast: { 428 LValue origLV = CGF.EmitLValue(Op); 429 llvm::Value *V = origLV.getAddress(); 430 V = Builder.CreateBitCast(V, 431 CGF.ConvertType(CGF.getContext().getPointerType(DestTy))); 432 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy, 433 origLV.getAlignment()), 434 Op->getExprLoc()); 435 } 436 437 case CK_BitCast: 438 case CK_BaseToDerived: 439 case CK_DerivedToBase: 440 case CK_UncheckedDerivedToBase: 441 case CK_Dynamic: 442 case CK_ToUnion: 443 case CK_ArrayToPointerDecay: 444 case CK_FunctionToPointerDecay: 445 case CK_NullToPointer: 446 case CK_NullToMemberPointer: 447 case CK_BaseToDerivedMemberPointer: 448 case CK_DerivedToBaseMemberPointer: 449 case CK_MemberPointerToBoolean: 450 case CK_ReinterpretMemberPointer: 451 case CK_ConstructorConversion: 452 case CK_IntegralToPointer: 453 case CK_PointerToIntegral: 454 case CK_PointerToBoolean: 455 case CK_ToVoid: 456 case CK_VectorSplat: 457 case CK_IntegralCast: 458 case CK_IntegralToBoolean: 459 case CK_IntegralToFloating: 460 case CK_FloatingToIntegral: 461 case CK_FloatingToBoolean: 462 case CK_FloatingCast: 463 case CK_CPointerToObjCPointerCast: 464 case CK_BlockPointerToObjCPointerCast: 465 case CK_AnyPointerToBlockPointerCast: 466 case CK_ObjCObjectLValueCast: 467 case CK_FloatingComplexToReal: 468 case CK_FloatingComplexToBoolean: 469 case CK_IntegralComplexToReal: 470 case CK_IntegralComplexToBoolean: 471 case CK_ARCProduceObject: 472 case CK_ARCConsumeObject: 473 case CK_ARCReclaimReturnedObject: 474 case CK_ARCExtendBlockObject: 475 case CK_CopyAndAutoreleaseBlockObject: 476 case CK_BuiltinFnToFnPtr: 477 case CK_ZeroToOCLEvent: 478 llvm_unreachable("invalid cast kind for complex value"); 479 480 case CK_FloatingRealToComplex: 481 case CK_IntegralRealToComplex: 482 return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), 483 Op->getType(), DestTy); 484 485 case CK_FloatingComplexCast: 486 case CK_FloatingComplexToIntegralComplex: 487 case CK_IntegralComplexCast: 488 case CK_IntegralComplexToFloatingComplex: 489 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 490 } 491 492 llvm_unreachable("unknown cast resulting in complex value"); 493} 494 495ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 496 TestAndClearIgnoreReal(); 497 TestAndClearIgnoreImag(); 498 ComplexPairTy Op = Visit(E->getSubExpr()); 499 500 llvm::Value *ResR, *ResI; 501 if (Op.first->getType()->isFloatingPointTy()) { 502 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 503 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 504 } else { 505 ResR = Builder.CreateNeg(Op.first, "neg.r"); 506 ResI = Builder.CreateNeg(Op.second, "neg.i"); 507 } 508 return ComplexPairTy(ResR, ResI); 509} 510 511ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 512 TestAndClearIgnoreReal(); 513 TestAndClearIgnoreImag(); 514 // ~(a+ib) = a + i*-b 515 ComplexPairTy Op = Visit(E->getSubExpr()); 516 llvm::Value *ResI; 517 if (Op.second->getType()->isFloatingPointTy()) 518 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 519 else 520 ResI = Builder.CreateNeg(Op.second, "conj.i"); 521 522 return ComplexPairTy(Op.first, ResI); 523} 524 525ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 526 llvm::Value *ResR, *ResI; 527 528 if (Op.LHS.first->getType()->isFloatingPointTy()) { 529 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 530 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 531 } else { 532 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 533 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 534 } 535 return ComplexPairTy(ResR, ResI); 536} 537 538ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 539 llvm::Value *ResR, *ResI; 540 if (Op.LHS.first->getType()->isFloatingPointTy()) { 541 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 542 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 543 } else { 544 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 545 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 546 } 547 return ComplexPairTy(ResR, ResI); 548} 549 550 551ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 552 using llvm::Value; 553 Value *ResR, *ResI; 554 555 if (Op.LHS.first->getType()->isFloatingPointTy()) { 556 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 557 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 558 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 559 560 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 561 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 562 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 563 } else { 564 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 565 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 566 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 567 568 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 569 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 570 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 571 } 572 return ComplexPairTy(ResR, ResI); 573} 574 575ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 576 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 577 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 578 579 580 llvm::Value *DSTr, *DSTi; 581 if (Op.LHS.first->getType()->isFloatingPointTy()) { 582 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 583 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c 584 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d 585 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd 586 587 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c 588 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d 589 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd 590 591 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c 592 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d 593 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad 594 595 DSTr = Builder.CreateFDiv(Tmp3, Tmp6); 596 DSTi = Builder.CreateFDiv(Tmp9, Tmp6); 597 } else { 598 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 599 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 600 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 601 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 602 603 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 604 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 605 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 606 607 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 608 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 609 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 610 611 if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 612 DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 613 DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 614 } else { 615 DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 616 DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 617 } 618 } 619 620 return ComplexPairTy(DSTr, DSTi); 621} 622 623ComplexExprEmitter::BinOpInfo 624ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 625 TestAndClearIgnoreReal(); 626 TestAndClearIgnoreImag(); 627 BinOpInfo Ops; 628 Ops.LHS = Visit(E->getLHS()); 629 Ops.RHS = Visit(E->getRHS()); 630 Ops.Ty = E->getType(); 631 return Ops; 632} 633 634 635LValue ComplexExprEmitter:: 636EmitCompoundAssignLValue(const CompoundAssignOperator *E, 637 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 638 RValue &Val) { 639 TestAndClearIgnoreReal(); 640 TestAndClearIgnoreImag(); 641 QualType LHSTy = E->getLHS()->getType(); 642 643 BinOpInfo OpInfo; 644 645 // Load the RHS and LHS operands. 646 // __block variables need to have the rhs evaluated first, plus this should 647 // improve codegen a little. 648 OpInfo.Ty = E->getComputationResultType(); 649 650 // The RHS should have been converted to the computation type. 651 assert(OpInfo.Ty->isAnyComplexType()); 652 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 653 E->getRHS()->getType())); 654 OpInfo.RHS = Visit(E->getRHS()); 655 656 LValue LHS = CGF.EmitLValue(E->getLHS()); 657 658 // Load from the l-value and convert it. 659 if (LHSTy->isAnyComplexType()) { 660 ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, E->getExprLoc()); 661 OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty); 662 } else { 663 llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, E->getExprLoc()); 664 OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty); 665 } 666 667 // Expand the binary operator. 668 ComplexPairTy Result = (this->*Func)(OpInfo); 669 670 // Truncate the result and store it into the LHS lvalue. 671 if (LHSTy->isAnyComplexType()) { 672 ComplexPairTy ResVal = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 673 EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false); 674 Val = RValue::getComplex(ResVal); 675 } else { 676 llvm::Value *ResVal = 677 CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy); 678 CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false); 679 Val = RValue::get(ResVal); 680 } 681 682 return LHS; 683} 684 685// Compound assignments. 686ComplexPairTy ComplexExprEmitter:: 687EmitCompoundAssign(const CompoundAssignOperator *E, 688 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 689 RValue Val; 690 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 691 692 // The result of an assignment in C is the assigned r-value. 693 if (!CGF.getLangOpts().CPlusPlus) 694 return Val.getComplexVal(); 695 696 // If the lvalue is non-volatile, return the computed value of the assignment. 697 if (!LV.isVolatileQualified()) 698 return Val.getComplexVal(); 699 700 return EmitLoadOfLValue(LV, E->getExprLoc()); 701} 702 703LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 704 ComplexPairTy &Val) { 705 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 706 E->getRHS()->getType()) && 707 "Invalid assignment"); 708 TestAndClearIgnoreReal(); 709 TestAndClearIgnoreImag(); 710 711 // Emit the RHS. __block variables need the RHS evaluated first. 712 Val = Visit(E->getRHS()); 713 714 // Compute the address to store into. 715 LValue LHS = CGF.EmitLValue(E->getLHS()); 716 717 // Store the result value into the LHS lvalue. 718 EmitStoreOfComplex(Val, LHS, /*isInit*/ false); 719 720 return LHS; 721} 722 723ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 724 ComplexPairTy Val; 725 LValue LV = EmitBinAssignLValue(E, Val); 726 727 // The result of an assignment in C is the assigned r-value. 728 if (!CGF.getLangOpts().CPlusPlus) 729 return Val; 730 731 // If the lvalue is non-volatile, return the computed value of the assignment. 732 if (!LV.isVolatileQualified()) 733 return Val; 734 735 return EmitLoadOfLValue(LV, E->getExprLoc()); 736} 737 738ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 739 CGF.EmitIgnoredExpr(E->getLHS()); 740 return Visit(E->getRHS()); 741} 742 743ComplexPairTy ComplexExprEmitter:: 744VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 745 TestAndClearIgnoreReal(); 746 TestAndClearIgnoreImag(); 747 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 748 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 749 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 750 751 // Bind the common expression if necessary. 752 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 753 754 CodeGenFunction::ConditionalEvaluation eval(CGF); 755 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 756 757 eval.begin(CGF); 758 CGF.EmitBlock(LHSBlock); 759 ComplexPairTy LHS = Visit(E->getTrueExpr()); 760 LHSBlock = Builder.GetInsertBlock(); 761 CGF.EmitBranch(ContBlock); 762 eval.end(CGF); 763 764 eval.begin(CGF); 765 CGF.EmitBlock(RHSBlock); 766 ComplexPairTy RHS = Visit(E->getFalseExpr()); 767 RHSBlock = Builder.GetInsertBlock(); 768 CGF.EmitBlock(ContBlock); 769 eval.end(CGF); 770 771 // Create a PHI node for the real part. 772 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 773 RealPN->addIncoming(LHS.first, LHSBlock); 774 RealPN->addIncoming(RHS.first, RHSBlock); 775 776 // Create a PHI node for the imaginary part. 777 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 778 ImagPN->addIncoming(LHS.second, LHSBlock); 779 ImagPN->addIncoming(RHS.second, RHSBlock); 780 781 return ComplexPairTy(RealPN, ImagPN); 782} 783 784ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 785 return Visit(E->getChosenSubExpr()); 786} 787 788ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 789 bool Ignore = TestAndClearIgnoreReal(); 790 (void)Ignore; 791 assert (Ignore == false && "init list ignored"); 792 Ignore = TestAndClearIgnoreImag(); 793 (void)Ignore; 794 assert (Ignore == false && "init list ignored"); 795 796 if (E->getNumInits() == 2) { 797 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 798 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 799 return ComplexPairTy(Real, Imag); 800 } else if (E->getNumInits() == 1) { 801 return Visit(E->getInit(0)); 802 } 803 804 // Empty init list intializes to null 805 assert(E->getNumInits() == 0 && "Unexpected number of inits"); 806 QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); 807 llvm::Type* LTy = CGF.ConvertType(Ty); 808 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 809 return ComplexPairTy(zeroConstant, zeroConstant); 810} 811 812ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 813 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 814 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 815 816 if (!ArgPtr) { 817 CGF.ErrorUnsupported(E, "complex va_arg expression"); 818 llvm::Type *EltTy = 819 CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType()); 820 llvm::Value *U = llvm::UndefValue::get(EltTy); 821 return ComplexPairTy(U, U); 822 } 823 824 return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(ArgPtr, E->getType()), 825 E->getExprLoc()); 826} 827 828//===----------------------------------------------------------------------===// 829// Entry Point into this File 830//===----------------------------------------------------------------------===// 831 832/// EmitComplexExpr - Emit the computation of the specified expression of 833/// complex type, ignoring the result. 834ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 835 bool IgnoreImag) { 836 assert(E && getComplexType(E->getType()) && 837 "Invalid complex expression to emit"); 838 839 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 840 .Visit(const_cast<Expr*>(E)); 841} 842 843void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest, 844 bool isInit) { 845 assert(E && getComplexType(E->getType()) && 846 "Invalid complex expression to emit"); 847 ComplexExprEmitter Emitter(*this); 848 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 849 Emitter.EmitStoreOfComplex(Val, dest, isInit); 850} 851 852/// EmitStoreOfComplex - Store a complex number into the specified l-value. 853void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest, 854 bool isInit) { 855 ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit); 856} 857 858/// EmitLoadOfComplex - Load a complex number from the specified address. 859ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src, 860 SourceLocation loc) { 861 return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc); 862} 863 864LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 865 assert(E->getOpcode() == BO_Assign); 866 ComplexPairTy Val; // ignored 867 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 868} 869 870typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)( 871 const ComplexExprEmitter::BinOpInfo &); 872 873static CompoundFunc getComplexOp(BinaryOperatorKind Op) { 874 switch (Op) { 875 case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul; 876 case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv; 877 case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub; 878 case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd; 879 default: 880 llvm_unreachable("unexpected complex compound assignment"); 881 } 882} 883 884LValue CodeGenFunction:: 885EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 886 CompoundFunc Op = getComplexOp(E->getOpcode()); 887 RValue Val; 888 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 889} 890 891LValue CodeGenFunction:: 892EmitScalarCompooundAssignWithComplex(const CompoundAssignOperator *E, 893 llvm::Value *&Result) { 894 CompoundFunc Op = getComplexOp(E->getOpcode()); 895 RValue Val; 896 LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 897 Result = Val.getScalarVal(); 898 return Ret; 899} 900