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> 22 using namespace clang; 23 using namespace CodeGen; 24 25 //===----------------------------------------------------------------------===// 26 // Complex Expression Emitter 27 //===----------------------------------------------------------------------===// 28 29 typedef CodeGenFunction::ComplexPairTy ComplexPairTy; 30 31 /// Return the complex type that we are meant to emit. 32 static 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 41 namespace { 42 class ComplexExprEmitter 43 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 44 CodeGenFunction &CGF; 45 CGBuilderTy &Builder; 46 bool IgnoreReal; 47 bool IgnoreImag; 48 public: 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. 295 ComplexPairTy 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=nullptr, *Imag=nullptr; 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. 329 void 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 356 ComplexPairTy 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 364 ComplexPairTy ComplexExprEmitter:: 365 VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 366 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 367 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 368 } 369 370 371 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 372 if (E->getCallReturnType()->isReferenceType()) 373 return EmitLoadOfLValue(E); 374 375 return CGF.EmitCallExpr(E).getComplexVal(); 376 } 377 378 ComplexPairTy 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. 387 ComplexPairTy 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 402 ComplexPairTy 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 413 ComplexPairTy 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 case CK_AddressSpaceConversion: 479 llvm_unreachable("invalid cast kind for complex value"); 480 481 case CK_FloatingRealToComplex: 482 case CK_IntegralRealToComplex: 483 return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), 484 Op->getType(), DestTy); 485 486 case CK_FloatingComplexCast: 487 case CK_FloatingComplexToIntegralComplex: 488 case CK_IntegralComplexCast: 489 case CK_IntegralComplexToFloatingComplex: 490 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 491 } 492 493 llvm_unreachable("unknown cast resulting in complex value"); 494 } 495 496 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 497 TestAndClearIgnoreReal(); 498 TestAndClearIgnoreImag(); 499 ComplexPairTy Op = Visit(E->getSubExpr()); 500 501 llvm::Value *ResR, *ResI; 502 if (Op.first->getType()->isFloatingPointTy()) { 503 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 504 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 505 } else { 506 ResR = Builder.CreateNeg(Op.first, "neg.r"); 507 ResI = Builder.CreateNeg(Op.second, "neg.i"); 508 } 509 return ComplexPairTy(ResR, ResI); 510 } 511 512 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 513 TestAndClearIgnoreReal(); 514 TestAndClearIgnoreImag(); 515 // ~(a+ib) = a + i*-b 516 ComplexPairTy Op = Visit(E->getSubExpr()); 517 llvm::Value *ResI; 518 if (Op.second->getType()->isFloatingPointTy()) 519 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 520 else 521 ResI = Builder.CreateNeg(Op.second, "conj.i"); 522 523 return ComplexPairTy(Op.first, ResI); 524 } 525 526 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 527 llvm::Value *ResR, *ResI; 528 529 if (Op.LHS.first->getType()->isFloatingPointTy()) { 530 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 531 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 532 } else { 533 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 534 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 535 } 536 return ComplexPairTy(ResR, ResI); 537 } 538 539 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 540 llvm::Value *ResR, *ResI; 541 if (Op.LHS.first->getType()->isFloatingPointTy()) { 542 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 543 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 544 } else { 545 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 546 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 547 } 548 return ComplexPairTy(ResR, ResI); 549 } 550 551 552 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 553 using llvm::Value; 554 Value *ResR, *ResI; 555 556 if (Op.LHS.first->getType()->isFloatingPointTy()) { 557 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 558 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 559 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 560 561 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 562 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 563 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 564 } else { 565 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 566 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 567 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 568 569 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 570 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 571 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 572 } 573 return ComplexPairTy(ResR, ResI); 574 } 575 576 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 577 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 578 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 579 580 581 llvm::Value *DSTr, *DSTi; 582 if (Op.LHS.first->getType()->isFloatingPointTy()) { 583 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 584 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c 585 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d 586 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd 587 588 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c 589 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d 590 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd 591 592 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c 593 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d 594 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad 595 596 DSTr = Builder.CreateFDiv(Tmp3, Tmp6); 597 DSTi = Builder.CreateFDiv(Tmp9, Tmp6); 598 } else { 599 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 600 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 601 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 602 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 603 604 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 605 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 606 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 607 608 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 609 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 610 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 611 612 if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 613 DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 614 DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 615 } else { 616 DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 617 DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 618 } 619 } 620 621 return ComplexPairTy(DSTr, DSTi); 622 } 623 624 ComplexExprEmitter::BinOpInfo 625 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 626 TestAndClearIgnoreReal(); 627 TestAndClearIgnoreImag(); 628 BinOpInfo Ops; 629 Ops.LHS = Visit(E->getLHS()); 630 Ops.RHS = Visit(E->getRHS()); 631 Ops.Ty = E->getType(); 632 return Ops; 633 } 634 635 636 LValue ComplexExprEmitter:: 637 EmitCompoundAssignLValue(const CompoundAssignOperator *E, 638 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 639 RValue &Val) { 640 TestAndClearIgnoreReal(); 641 TestAndClearIgnoreImag(); 642 QualType LHSTy = E->getLHS()->getType(); 643 644 BinOpInfo OpInfo; 645 646 // Load the RHS and LHS operands. 647 // __block variables need to have the rhs evaluated first, plus this should 648 // improve codegen a little. 649 OpInfo.Ty = E->getComputationResultType(); 650 651 // The RHS should have been converted to the computation type. 652 assert(OpInfo.Ty->isAnyComplexType()); 653 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 654 E->getRHS()->getType())); 655 OpInfo.RHS = Visit(E->getRHS()); 656 657 LValue LHS = CGF.EmitLValue(E->getLHS()); 658 659 // Load from the l-value and convert it. 660 if (LHSTy->isAnyComplexType()) { 661 ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, E->getExprLoc()); 662 OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty); 663 } else { 664 llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, E->getExprLoc()); 665 OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty); 666 } 667 668 // Expand the binary operator. 669 ComplexPairTy Result = (this->*Func)(OpInfo); 670 671 // Truncate the result and store it into the LHS lvalue. 672 if (LHSTy->isAnyComplexType()) { 673 ComplexPairTy ResVal = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 674 EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false); 675 Val = RValue::getComplex(ResVal); 676 } else { 677 llvm::Value *ResVal = 678 CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy); 679 CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false); 680 Val = RValue::get(ResVal); 681 } 682 683 return LHS; 684 } 685 686 // Compound assignments. 687 ComplexPairTy ComplexExprEmitter:: 688 EmitCompoundAssign(const CompoundAssignOperator *E, 689 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 690 RValue Val; 691 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 692 693 // The result of an assignment in C is the assigned r-value. 694 if (!CGF.getLangOpts().CPlusPlus) 695 return Val.getComplexVal(); 696 697 // If the lvalue is non-volatile, return the computed value of the assignment. 698 if (!LV.isVolatileQualified()) 699 return Val.getComplexVal(); 700 701 return EmitLoadOfLValue(LV, E->getExprLoc()); 702 } 703 704 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 705 ComplexPairTy &Val) { 706 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 707 E->getRHS()->getType()) && 708 "Invalid assignment"); 709 TestAndClearIgnoreReal(); 710 TestAndClearIgnoreImag(); 711 712 // Emit the RHS. __block variables need the RHS evaluated first. 713 Val = Visit(E->getRHS()); 714 715 // Compute the address to store into. 716 LValue LHS = CGF.EmitLValue(E->getLHS()); 717 718 // Store the result value into the LHS lvalue. 719 EmitStoreOfComplex(Val, LHS, /*isInit*/ false); 720 721 return LHS; 722 } 723 724 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 725 ComplexPairTy Val; 726 LValue LV = EmitBinAssignLValue(E, Val); 727 728 // The result of an assignment in C is the assigned r-value. 729 if (!CGF.getLangOpts().CPlusPlus) 730 return Val; 731 732 // If the lvalue is non-volatile, return the computed value of the assignment. 733 if (!LV.isVolatileQualified()) 734 return Val; 735 736 return EmitLoadOfLValue(LV, E->getExprLoc()); 737 } 738 739 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 740 CGF.EmitIgnoredExpr(E->getLHS()); 741 return Visit(E->getRHS()); 742 } 743 744 ComplexPairTy ComplexExprEmitter:: 745 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 746 TestAndClearIgnoreReal(); 747 TestAndClearIgnoreImag(); 748 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 749 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 750 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 751 752 // Bind the common expression if necessary. 753 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 754 755 RegionCounter Cnt = CGF.getPGORegionCounter(E); 756 CodeGenFunction::ConditionalEvaluation eval(CGF); 757 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, Cnt.getCount()); 758 759 eval.begin(CGF); 760 CGF.EmitBlock(LHSBlock); 761 Cnt.beginRegion(Builder); 762 ComplexPairTy LHS = Visit(E->getTrueExpr()); 763 LHSBlock = Builder.GetInsertBlock(); 764 CGF.EmitBranch(ContBlock); 765 eval.end(CGF); 766 767 eval.begin(CGF); 768 CGF.EmitBlock(RHSBlock); 769 ComplexPairTy RHS = Visit(E->getFalseExpr()); 770 RHSBlock = Builder.GetInsertBlock(); 771 CGF.EmitBlock(ContBlock); 772 eval.end(CGF); 773 774 // Create a PHI node for the real part. 775 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 776 RealPN->addIncoming(LHS.first, LHSBlock); 777 RealPN->addIncoming(RHS.first, RHSBlock); 778 779 // Create a PHI node for the imaginary part. 780 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 781 ImagPN->addIncoming(LHS.second, LHSBlock); 782 ImagPN->addIncoming(RHS.second, RHSBlock); 783 784 return ComplexPairTy(RealPN, ImagPN); 785 } 786 787 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 788 return Visit(E->getChosenSubExpr()); 789 } 790 791 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 792 bool Ignore = TestAndClearIgnoreReal(); 793 (void)Ignore; 794 assert (Ignore == false && "init list ignored"); 795 Ignore = TestAndClearIgnoreImag(); 796 (void)Ignore; 797 assert (Ignore == false && "init list ignored"); 798 799 if (E->getNumInits() == 2) { 800 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 801 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 802 return ComplexPairTy(Real, Imag); 803 } else if (E->getNumInits() == 1) { 804 return Visit(E->getInit(0)); 805 } 806 807 // Empty init list intializes to null 808 assert(E->getNumInits() == 0 && "Unexpected number of inits"); 809 QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); 810 llvm::Type* LTy = CGF.ConvertType(Ty); 811 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 812 return ComplexPairTy(zeroConstant, zeroConstant); 813 } 814 815 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 816 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 817 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 818 819 if (!ArgPtr) { 820 CGF.ErrorUnsupported(E, "complex va_arg expression"); 821 llvm::Type *EltTy = 822 CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType()); 823 llvm::Value *U = llvm::UndefValue::get(EltTy); 824 return ComplexPairTy(U, U); 825 } 826 827 return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(ArgPtr, E->getType()), 828 E->getExprLoc()); 829 } 830 831 //===----------------------------------------------------------------------===// 832 // Entry Point into this File 833 //===----------------------------------------------------------------------===// 834 835 /// EmitComplexExpr - Emit the computation of the specified expression of 836 /// complex type, ignoring the result. 837 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 838 bool IgnoreImag) { 839 assert(E && getComplexType(E->getType()) && 840 "Invalid complex expression to emit"); 841 842 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 843 .Visit(const_cast<Expr*>(E)); 844 } 845 846 void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest, 847 bool isInit) { 848 assert(E && getComplexType(E->getType()) && 849 "Invalid complex expression to emit"); 850 ComplexExprEmitter Emitter(*this); 851 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 852 Emitter.EmitStoreOfComplex(Val, dest, isInit); 853 } 854 855 /// EmitStoreOfComplex - Store a complex number into the specified l-value. 856 void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest, 857 bool isInit) { 858 ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit); 859 } 860 861 /// EmitLoadOfComplex - Load a complex number from the specified address. 862 ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src, 863 SourceLocation loc) { 864 return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc); 865 } 866 867 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 868 assert(E->getOpcode() == BO_Assign); 869 ComplexPairTy Val; // ignored 870 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 871 } 872 873 typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)( 874 const ComplexExprEmitter::BinOpInfo &); 875 876 static CompoundFunc getComplexOp(BinaryOperatorKind Op) { 877 switch (Op) { 878 case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul; 879 case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv; 880 case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub; 881 case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd; 882 default: 883 llvm_unreachable("unexpected complex compound assignment"); 884 } 885 } 886 887 LValue CodeGenFunction:: 888 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 889 CompoundFunc Op = getComplexOp(E->getOpcode()); 890 RValue Val; 891 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 892 } 893 894 LValue CodeGenFunction:: 895 EmitScalarCompooundAssignWithComplex(const CompoundAssignOperator *E, 896 llvm::Value *&Result) { 897 CompoundFunc Op = getComplexOp(E->getOpcode()); 898 RValue Val; 899 LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 900 Result = Val.getScalarVal(); 901 return Ret; 902 } 903