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/Constants.h" 19 #include "llvm/Function.h" 20 #include "llvm/ADT/SmallString.h" 21 using namespace clang; 22 using namespace CodeGen; 23 24 //===----------------------------------------------------------------------===// 25 // Complex Expression Emitter 26 //===----------------------------------------------------------------------===// 27 28 typedef CodeGenFunction::ComplexPairTy ComplexPairTy; 29 30 namespace { 31 class ComplexExprEmitter 32 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 33 CodeGenFunction &CGF; 34 CGBuilderTy &Builder; 35 // True is we should ignore the value of a 36 bool IgnoreReal; 37 bool IgnoreImag; 38 public: 39 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false) 40 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) { 41 } 42 43 44 //===--------------------------------------------------------------------===// 45 // Utilities 46 //===--------------------------------------------------------------------===// 47 48 bool TestAndClearIgnoreReal() { 49 bool I = IgnoreReal; 50 IgnoreReal = false; 51 return I; 52 } 53 bool TestAndClearIgnoreImag() { 54 bool I = IgnoreImag; 55 IgnoreImag = false; 56 return I; 57 } 58 59 /// EmitLoadOfLValue - Given an expression with complex type that represents a 60 /// value l-value, this method emits the address of the l-value, then loads 61 /// and returns the result. 62 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 63 return EmitLoadOfLValue(CGF.EmitLValue(E)); 64 } 65 66 ComplexPairTy EmitLoadOfLValue(LValue LV) { 67 assert(LV.isSimple() && "complex l-value must be simple"); 68 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 69 } 70 71 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load 72 /// the real and imaginary pieces. 73 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile); 74 75 /// EmitStoreThroughLValue - Given an l-value of complex type, store 76 /// a complex number into it. 77 void EmitStoreThroughLValue(ComplexPairTy Val, LValue LV) { 78 assert(LV.isSimple() && "complex l-value must be simple"); 79 return EmitStoreOfComplex(Val, LV.getAddress(), LV.isVolatileQualified()); 80 } 81 82 /// EmitStoreOfComplex - Store the specified real/imag parts into the 83 /// specified value pointer. 84 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol); 85 86 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 87 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 88 QualType DestType); 89 90 //===--------------------------------------------------------------------===// 91 // Visitor Methods 92 //===--------------------------------------------------------------------===// 93 94 ComplexPairTy Visit(Expr *E) { 95 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); 96 } 97 98 ComplexPairTy VisitStmt(Stmt *S) { 99 S->dump(CGF.getContext().getSourceManager()); 100 llvm_unreachable("Stmt can't have complex result type!"); 101 } 102 ComplexPairTy VisitExpr(Expr *S); 103 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 104 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 105 return Visit(GE->getResultExpr()); 106 } 107 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 108 ComplexPairTy 109 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 110 return Visit(PE->getReplacement()); 111 } 112 113 // l-values. 114 ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) { 115 if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) { 116 if (result.isReference()) 117 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E)); 118 119 llvm::ConstantStruct *pair = 120 cast<llvm::ConstantStruct>(result.getValue()); 121 return ComplexPairTy(pair->getOperand(0), pair->getOperand(1)); 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)); 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 VisitExprWithCleanups(ExprWithCleanups *E) { 191 CGF.enterFullExpression(E); 192 CodeGenFunction::RunCleanupsScope Scope(CGF); 193 return Visit(E->getSubExpr()); 194 } 195 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 196 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 197 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 198 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 199 return ComplexPairTy(Null, Null); 200 } 201 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 202 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 203 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 204 llvm::Constant *Null = 205 llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 206 return ComplexPairTy(Null, Null); 207 } 208 209 struct BinOpInfo { 210 ComplexPairTy LHS; 211 ComplexPairTy RHS; 212 QualType Ty; // Computation Type. 213 }; 214 215 BinOpInfo EmitBinOps(const BinaryOperator *E); 216 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 217 ComplexPairTy (ComplexExprEmitter::*Func) 218 (const BinOpInfo &), 219 ComplexPairTy &Val); 220 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 221 ComplexPairTy (ComplexExprEmitter::*Func) 222 (const BinOpInfo &)); 223 224 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 225 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 226 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 227 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 228 229 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 230 return EmitBinAdd(EmitBinOps(E)); 231 } 232 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 233 return EmitBinSub(EmitBinOps(E)); 234 } 235 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 236 return EmitBinMul(EmitBinOps(E)); 237 } 238 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 239 return EmitBinDiv(EmitBinOps(E)); 240 } 241 242 // Compound assignments. 243 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 244 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 245 } 246 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 247 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 248 } 249 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 250 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 251 } 252 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 253 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 254 } 255 256 // GCC rejects rem/and/or/xor for integer complex. 257 // Logical and/or always return int, never complex. 258 259 // No comparisons produce a complex result. 260 261 LValue EmitBinAssignLValue(const BinaryOperator *E, 262 ComplexPairTy &Val); 263 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 264 ComplexPairTy VisitBinComma (const BinaryOperator *E); 265 266 267 ComplexPairTy 268 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 269 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 270 271 ComplexPairTy VisitInitListExpr(InitListExpr *E); 272 273 ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 274 return EmitLoadOfLValue(E); 275 } 276 277 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 278 279 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) { 280 return CGF.EmitAtomicExpr(E).getComplexVal(); 281 } 282 }; 283 } // end anonymous namespace. 284 285 //===----------------------------------------------------------------------===// 286 // Utilities 287 //===----------------------------------------------------------------------===// 288 289 /// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to 290 /// load the real and imaginary pieces, returning them as Real/Imag. 291 ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr, 292 bool isVolatile) { 293 llvm::Value *Real=0, *Imag=0; 294 295 if (!IgnoreReal || isVolatile) { 296 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0, 297 SrcPtr->getName() + ".realp"); 298 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real"); 299 } 300 301 if (!IgnoreImag || isVolatile) { 302 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1, 303 SrcPtr->getName() + ".imagp"); 304 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag"); 305 } 306 return ComplexPairTy(Real, Imag); 307 } 308 309 /// EmitStoreOfComplex - Store the specified real/imag parts into the 310 /// specified value pointer. 311 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr, 312 bool isVolatile) { 313 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 314 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 315 316 Builder.CreateStore(Val.first, RealPtr, isVolatile); 317 Builder.CreateStore(Val.second, ImagPtr, isVolatile); 318 } 319 320 321 322 //===----------------------------------------------------------------------===// 323 // Visitor Methods 324 //===----------------------------------------------------------------------===// 325 326 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 327 CGF.ErrorUnsupported(E, "complex expression"); 328 llvm::Type *EltTy = 329 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 330 llvm::Value *U = llvm::UndefValue::get(EltTy); 331 return ComplexPairTy(U, U); 332 } 333 334 ComplexPairTy ComplexExprEmitter:: 335 VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 336 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 337 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 338 } 339 340 341 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 342 if (E->getCallReturnType()->isReferenceType()) 343 return EmitLoadOfLValue(E); 344 345 return CGF.EmitCallExpr(E).getComplexVal(); 346 } 347 348 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 349 CodeGenFunction::StmtExprEvaluation eval(CGF); 350 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 351 } 352 353 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 354 ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 355 QualType SrcType, 356 QualType DestType) { 357 // Get the src/dest element type. 358 SrcType = SrcType->getAs<ComplexType>()->getElementType(); 359 DestType = DestType->getAs<ComplexType>()->getElementType(); 360 361 // C99 6.3.1.6: When a value of complex type is converted to another 362 // complex type, both the real and imaginary parts follow the conversion 363 // rules for the corresponding real types. 364 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 365 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 366 return Val; 367 } 368 369 ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op, 370 QualType DestTy) { 371 switch (CK) { 372 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 373 374 // Atomic to non-atomic casts may be more than a no-op for some platforms and 375 // for some types. 376 case CK_AtomicToNonAtomic: 377 case CK_NonAtomicToAtomic: 378 case CK_NoOp: 379 case CK_LValueToRValue: 380 case CK_UserDefinedConversion: 381 return Visit(Op); 382 383 case CK_LValueBitCast: { 384 llvm::Value *V = CGF.EmitLValue(Op).getAddress(); 385 V = Builder.CreateBitCast(V, 386 CGF.ConvertType(CGF.getContext().getPointerType(DestTy))); 387 // FIXME: Are the qualifiers correct here? 388 return EmitLoadOfComplex(V, DestTy.isVolatileQualified()); 389 } 390 391 case CK_BitCast: 392 case CK_BaseToDerived: 393 case CK_DerivedToBase: 394 case CK_UncheckedDerivedToBase: 395 case CK_Dynamic: 396 case CK_ToUnion: 397 case CK_ArrayToPointerDecay: 398 case CK_FunctionToPointerDecay: 399 case CK_NullToPointer: 400 case CK_NullToMemberPointer: 401 case CK_BaseToDerivedMemberPointer: 402 case CK_DerivedToBaseMemberPointer: 403 case CK_MemberPointerToBoolean: 404 case CK_ReinterpretMemberPointer: 405 case CK_ConstructorConversion: 406 case CK_IntegralToPointer: 407 case CK_PointerToIntegral: 408 case CK_PointerToBoolean: 409 case CK_ToVoid: 410 case CK_VectorSplat: 411 case CK_IntegralCast: 412 case CK_IntegralToBoolean: 413 case CK_IntegralToFloating: 414 case CK_FloatingToIntegral: 415 case CK_FloatingToBoolean: 416 case CK_FloatingCast: 417 case CK_CPointerToObjCPointerCast: 418 case CK_BlockPointerToObjCPointerCast: 419 case CK_AnyPointerToBlockPointerCast: 420 case CK_ObjCObjectLValueCast: 421 case CK_FloatingComplexToReal: 422 case CK_FloatingComplexToBoolean: 423 case CK_IntegralComplexToReal: 424 case CK_IntegralComplexToBoolean: 425 case CK_ARCProduceObject: 426 case CK_ARCConsumeObject: 427 case CK_ARCReclaimReturnedObject: 428 case CK_ARCExtendBlockObject: 429 case CK_CopyAndAutoreleaseBlockObject: 430 llvm_unreachable("invalid cast kind for complex value"); 431 432 case CK_FloatingRealToComplex: 433 case CK_IntegralRealToComplex: { 434 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 435 436 // Convert the input element to the element type of the complex. 437 DestTy = DestTy->getAs<ComplexType>()->getElementType(); 438 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 439 440 // Return (realval, 0). 441 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 442 } 443 444 case CK_FloatingComplexCast: 445 case CK_FloatingComplexToIntegralComplex: 446 case CK_IntegralComplexCast: 447 case CK_IntegralComplexToFloatingComplex: 448 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 449 } 450 451 llvm_unreachable("unknown cast resulting in complex value"); 452 } 453 454 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 455 TestAndClearIgnoreReal(); 456 TestAndClearIgnoreImag(); 457 ComplexPairTy Op = Visit(E->getSubExpr()); 458 459 llvm::Value *ResR, *ResI; 460 if (Op.first->getType()->isFloatingPointTy()) { 461 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 462 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 463 } else { 464 ResR = Builder.CreateNeg(Op.first, "neg.r"); 465 ResI = Builder.CreateNeg(Op.second, "neg.i"); 466 } 467 return ComplexPairTy(ResR, ResI); 468 } 469 470 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 471 TestAndClearIgnoreReal(); 472 TestAndClearIgnoreImag(); 473 // ~(a+ib) = a + i*-b 474 ComplexPairTy Op = Visit(E->getSubExpr()); 475 llvm::Value *ResI; 476 if (Op.second->getType()->isFloatingPointTy()) 477 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 478 else 479 ResI = Builder.CreateNeg(Op.second, "conj.i"); 480 481 return ComplexPairTy(Op.first, ResI); 482 } 483 484 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 485 llvm::Value *ResR, *ResI; 486 487 if (Op.LHS.first->getType()->isFloatingPointTy()) { 488 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 489 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 490 } else { 491 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 492 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 493 } 494 return ComplexPairTy(ResR, ResI); 495 } 496 497 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 498 llvm::Value *ResR, *ResI; 499 if (Op.LHS.first->getType()->isFloatingPointTy()) { 500 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 501 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 502 } else { 503 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 504 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 505 } 506 return ComplexPairTy(ResR, ResI); 507 } 508 509 510 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 511 using llvm::Value; 512 Value *ResR, *ResI; 513 514 if (Op.LHS.first->getType()->isFloatingPointTy()) { 515 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 516 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 517 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 518 519 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 520 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 521 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 522 } else { 523 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 524 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 525 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 526 527 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 528 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 529 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 530 } 531 return ComplexPairTy(ResR, ResI); 532 } 533 534 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 535 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 536 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 537 538 539 llvm::Value *DSTr, *DSTi; 540 if (Op.LHS.first->getType()->isFloatingPointTy()) { 541 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 542 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c 543 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d 544 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd 545 546 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c 547 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d 548 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd 549 550 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c 551 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d 552 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad 553 554 DSTr = Builder.CreateFDiv(Tmp3, Tmp6); 555 DSTi = Builder.CreateFDiv(Tmp9, Tmp6); 556 } else { 557 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 558 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 559 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 560 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 561 562 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 563 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 564 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 565 566 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 567 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 568 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 569 570 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 571 DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 572 DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 573 } else { 574 DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 575 DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 576 } 577 } 578 579 return ComplexPairTy(DSTr, DSTi); 580 } 581 582 ComplexExprEmitter::BinOpInfo 583 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 584 TestAndClearIgnoreReal(); 585 TestAndClearIgnoreImag(); 586 BinOpInfo Ops; 587 Ops.LHS = Visit(E->getLHS()); 588 Ops.RHS = Visit(E->getRHS()); 589 Ops.Ty = E->getType(); 590 return Ops; 591 } 592 593 594 LValue ComplexExprEmitter:: 595 EmitCompoundAssignLValue(const CompoundAssignOperator *E, 596 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 597 ComplexPairTy &Val) { 598 TestAndClearIgnoreReal(); 599 TestAndClearIgnoreImag(); 600 QualType LHSTy = E->getLHS()->getType(); 601 602 BinOpInfo OpInfo; 603 604 // Load the RHS and LHS operands. 605 // __block variables need to have the rhs evaluated first, plus this should 606 // improve codegen a little. 607 OpInfo.Ty = E->getComputationResultType(); 608 609 // The RHS should have been converted to the computation type. 610 assert(OpInfo.Ty->isAnyComplexType()); 611 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 612 E->getRHS()->getType())); 613 OpInfo.RHS = Visit(E->getRHS()); 614 615 LValue LHS = CGF.EmitLValue(E->getLHS()); 616 617 // Load from the l-value. 618 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS); 619 620 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 621 622 // Expand the binary operator. 623 ComplexPairTy Result = (this->*Func)(OpInfo); 624 625 // Truncate the result back to the LHS type. 626 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 627 Val = Result; 628 629 // Store the result value into the LHS lvalue. 630 EmitStoreThroughLValue(Result, LHS); 631 632 return LHS; 633 } 634 635 // Compound assignments. 636 ComplexPairTy ComplexExprEmitter:: 637 EmitCompoundAssign(const CompoundAssignOperator *E, 638 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 639 ComplexPairTy Val; 640 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 641 642 // The result of an assignment in C is the assigned r-value. 643 if (!CGF.getContext().getLangOpts().CPlusPlus) 644 return Val; 645 646 // If the lvalue is non-volatile, return the computed value of the assignment. 647 if (!LV.isVolatileQualified()) 648 return Val; 649 650 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 651 } 652 653 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 654 ComplexPairTy &Val) { 655 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 656 E->getRHS()->getType()) && 657 "Invalid assignment"); 658 TestAndClearIgnoreReal(); 659 TestAndClearIgnoreImag(); 660 661 // Emit the RHS. __block variables need the RHS evaluated first. 662 Val = Visit(E->getRHS()); 663 664 // Compute the address to store into. 665 LValue LHS = CGF.EmitLValue(E->getLHS()); 666 667 // Store the result value into the LHS lvalue. 668 EmitStoreThroughLValue(Val, LHS); 669 670 return LHS; 671 } 672 673 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 674 ComplexPairTy Val; 675 LValue LV = EmitBinAssignLValue(E, Val); 676 677 // The result of an assignment in C is the assigned r-value. 678 if (!CGF.getContext().getLangOpts().CPlusPlus) 679 return Val; 680 681 // If the lvalue is non-volatile, return the computed value of the assignment. 682 if (!LV.isVolatileQualified()) 683 return Val; 684 685 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 686 } 687 688 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 689 CGF.EmitIgnoredExpr(E->getLHS()); 690 return Visit(E->getRHS()); 691 } 692 693 ComplexPairTy ComplexExprEmitter:: 694 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 695 TestAndClearIgnoreReal(); 696 TestAndClearIgnoreImag(); 697 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 698 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 699 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 700 701 // Bind the common expression if necessary. 702 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 703 704 CodeGenFunction::ConditionalEvaluation eval(CGF); 705 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 706 707 eval.begin(CGF); 708 CGF.EmitBlock(LHSBlock); 709 ComplexPairTy LHS = Visit(E->getTrueExpr()); 710 LHSBlock = Builder.GetInsertBlock(); 711 CGF.EmitBranch(ContBlock); 712 eval.end(CGF); 713 714 eval.begin(CGF); 715 CGF.EmitBlock(RHSBlock); 716 ComplexPairTy RHS = Visit(E->getFalseExpr()); 717 RHSBlock = Builder.GetInsertBlock(); 718 CGF.EmitBlock(ContBlock); 719 eval.end(CGF); 720 721 // Create a PHI node for the real part. 722 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 723 RealPN->addIncoming(LHS.first, LHSBlock); 724 RealPN->addIncoming(RHS.first, RHSBlock); 725 726 // Create a PHI node for the imaginary part. 727 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 728 ImagPN->addIncoming(LHS.second, LHSBlock); 729 ImagPN->addIncoming(RHS.second, RHSBlock); 730 731 return ComplexPairTy(RealPN, ImagPN); 732 } 733 734 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 735 return Visit(E->getChosenSubExpr(CGF.getContext())); 736 } 737 738 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 739 bool Ignore = TestAndClearIgnoreReal(); 740 (void)Ignore; 741 assert (Ignore == false && "init list ignored"); 742 Ignore = TestAndClearIgnoreImag(); 743 (void)Ignore; 744 assert (Ignore == false && "init list ignored"); 745 746 if (E->getNumInits() == 2) { 747 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 748 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 749 return ComplexPairTy(Real, Imag); 750 } else if (E->getNumInits() == 1) { 751 return Visit(E->getInit(0)); 752 } 753 754 // Empty init list intializes to null 755 assert(E->getNumInits() == 0 && "Unexpected number of inits"); 756 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType(); 757 llvm::Type* LTy = CGF.ConvertType(Ty); 758 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 759 return ComplexPairTy(zeroConstant, zeroConstant); 760 } 761 762 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 763 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 764 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 765 766 if (!ArgPtr) { 767 CGF.ErrorUnsupported(E, "complex va_arg expression"); 768 llvm::Type *EltTy = 769 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 770 llvm::Value *U = llvm::UndefValue::get(EltTy); 771 return ComplexPairTy(U, U); 772 } 773 774 // FIXME Volatility. 775 return EmitLoadOfComplex(ArgPtr, false); 776 } 777 778 //===----------------------------------------------------------------------===// 779 // Entry Point into this File 780 //===----------------------------------------------------------------------===// 781 782 /// EmitComplexExpr - Emit the computation of the specified expression of 783 /// complex type, ignoring the result. 784 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 785 bool IgnoreImag) { 786 assert(E && E->getType()->isAnyComplexType() && 787 "Invalid complex expression to emit"); 788 789 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 790 .Visit(const_cast<Expr*>(E)); 791 } 792 793 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression 794 /// of complex type, storing into the specified Value*. 795 void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 796 llvm::Value *DestAddr, 797 bool DestIsVolatile) { 798 assert(E && E->getType()->isAnyComplexType() && 799 "Invalid complex expression to emit"); 800 ComplexExprEmitter Emitter(*this); 801 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 802 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 803 } 804 805 /// StoreComplexToAddr - Store a complex number into the specified address. 806 void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 807 llvm::Value *DestAddr, 808 bool DestIsVolatile) { 809 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 810 } 811 812 /// LoadComplexFromAddr - Load a complex number from the specified address. 813 ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 814 bool SrcIsVolatile) { 815 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 816 } 817 818 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 819 assert(E->getOpcode() == BO_Assign); 820 ComplexPairTy Val; // ignored 821 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 822 } 823 824 LValue CodeGenFunction:: 825 EmitComplexCompoundAssignmentLValue(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