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 case CK_BuiltinFnToFnPtr: 431 llvm_unreachable("invalid cast kind for complex value"); 432 433 case CK_FloatingRealToComplex: 434 case CK_IntegralRealToComplex: { 435 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 436 437 // Convert the input element to the element type of the complex. 438 DestTy = DestTy->getAs<ComplexType>()->getElementType(); 439 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 440 441 // Return (realval, 0). 442 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 443 } 444 445 case CK_FloatingComplexCast: 446 case CK_FloatingComplexToIntegralComplex: 447 case CK_IntegralComplexCast: 448 case CK_IntegralComplexToFloatingComplex: 449 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 450 } 451 452 llvm_unreachable("unknown cast resulting in complex value"); 453 } 454 455 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 456 TestAndClearIgnoreReal(); 457 TestAndClearIgnoreImag(); 458 ComplexPairTy Op = Visit(E->getSubExpr()); 459 460 llvm::Value *ResR, *ResI; 461 if (Op.first->getType()->isFloatingPointTy()) { 462 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 463 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 464 } else { 465 ResR = Builder.CreateNeg(Op.first, "neg.r"); 466 ResI = Builder.CreateNeg(Op.second, "neg.i"); 467 } 468 return ComplexPairTy(ResR, ResI); 469 } 470 471 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 472 TestAndClearIgnoreReal(); 473 TestAndClearIgnoreImag(); 474 // ~(a+ib) = a + i*-b 475 ComplexPairTy Op = Visit(E->getSubExpr()); 476 llvm::Value *ResI; 477 if (Op.second->getType()->isFloatingPointTy()) 478 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 479 else 480 ResI = Builder.CreateNeg(Op.second, "conj.i"); 481 482 return ComplexPairTy(Op.first, ResI); 483 } 484 485 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 486 llvm::Value *ResR, *ResI; 487 488 if (Op.LHS.first->getType()->isFloatingPointTy()) { 489 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 490 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 491 } else { 492 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 493 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 494 } 495 return ComplexPairTy(ResR, ResI); 496 } 497 498 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 499 llvm::Value *ResR, *ResI; 500 if (Op.LHS.first->getType()->isFloatingPointTy()) { 501 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 502 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 503 } else { 504 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 505 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 506 } 507 return ComplexPairTy(ResR, ResI); 508 } 509 510 511 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 512 using llvm::Value; 513 Value *ResR, *ResI; 514 515 if (Op.LHS.first->getType()->isFloatingPointTy()) { 516 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 517 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 518 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 519 520 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 521 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 522 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 523 } else { 524 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 525 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 526 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 527 528 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 529 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 530 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 531 } 532 return ComplexPairTy(ResR, ResI); 533 } 534 535 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 536 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 537 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 538 539 540 llvm::Value *DSTr, *DSTi; 541 if (Op.LHS.first->getType()->isFloatingPointTy()) { 542 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 543 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c 544 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d 545 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd 546 547 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c 548 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d 549 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd 550 551 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c 552 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d 553 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad 554 555 DSTr = Builder.CreateFDiv(Tmp3, Tmp6); 556 DSTi = Builder.CreateFDiv(Tmp9, Tmp6); 557 } else { 558 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 559 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 560 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 561 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 562 563 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 564 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 565 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 566 567 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 568 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 569 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 570 571 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 572 DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 573 DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 574 } else { 575 DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 576 DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 577 } 578 } 579 580 return ComplexPairTy(DSTr, DSTi); 581 } 582 583 ComplexExprEmitter::BinOpInfo 584 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 585 TestAndClearIgnoreReal(); 586 TestAndClearIgnoreImag(); 587 BinOpInfo Ops; 588 Ops.LHS = Visit(E->getLHS()); 589 Ops.RHS = Visit(E->getRHS()); 590 Ops.Ty = E->getType(); 591 return Ops; 592 } 593 594 595 LValue ComplexExprEmitter:: 596 EmitCompoundAssignLValue(const CompoundAssignOperator *E, 597 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 598 ComplexPairTy &Val) { 599 TestAndClearIgnoreReal(); 600 TestAndClearIgnoreImag(); 601 QualType LHSTy = E->getLHS()->getType(); 602 603 BinOpInfo OpInfo; 604 605 // Load the RHS and LHS operands. 606 // __block variables need to have the rhs evaluated first, plus this should 607 // improve codegen a little. 608 OpInfo.Ty = E->getComputationResultType(); 609 610 // The RHS should have been converted to the computation type. 611 assert(OpInfo.Ty->isAnyComplexType()); 612 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 613 E->getRHS()->getType())); 614 OpInfo.RHS = Visit(E->getRHS()); 615 616 LValue LHS = CGF.EmitLValue(E->getLHS()); 617 618 // Load from the l-value. 619 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS); 620 621 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 622 623 // Expand the binary operator. 624 ComplexPairTy Result = (this->*Func)(OpInfo); 625 626 // Truncate the result back to the LHS type. 627 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 628 Val = Result; 629 630 // Store the result value into the LHS lvalue. 631 EmitStoreThroughLValue(Result, LHS); 632 633 return LHS; 634 } 635 636 // Compound assignments. 637 ComplexPairTy ComplexExprEmitter:: 638 EmitCompoundAssign(const CompoundAssignOperator *E, 639 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 640 ComplexPairTy Val; 641 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 642 643 // The result of an assignment in C is the assigned r-value. 644 if (!CGF.getContext().getLangOpts().CPlusPlus) 645 return Val; 646 647 // If the lvalue is non-volatile, return the computed value of the assignment. 648 if (!LV.isVolatileQualified()) 649 return Val; 650 651 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 652 } 653 654 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 655 ComplexPairTy &Val) { 656 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 657 E->getRHS()->getType()) && 658 "Invalid assignment"); 659 TestAndClearIgnoreReal(); 660 TestAndClearIgnoreImag(); 661 662 // Emit the RHS. __block variables need the RHS evaluated first. 663 Val = Visit(E->getRHS()); 664 665 // Compute the address to store into. 666 LValue LHS = CGF.EmitLValue(E->getLHS()); 667 668 // Store the result value into the LHS lvalue. 669 EmitStoreThroughLValue(Val, LHS); 670 671 return LHS; 672 } 673 674 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 675 ComplexPairTy Val; 676 LValue LV = EmitBinAssignLValue(E, Val); 677 678 // The result of an assignment in C is the assigned r-value. 679 if (!CGF.getContext().getLangOpts().CPlusPlus) 680 return Val; 681 682 // If the lvalue is non-volatile, return the computed value of the assignment. 683 if (!LV.isVolatileQualified()) 684 return Val; 685 686 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 687 } 688 689 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 690 CGF.EmitIgnoredExpr(E->getLHS()); 691 return Visit(E->getRHS()); 692 } 693 694 ComplexPairTy ComplexExprEmitter:: 695 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 696 TestAndClearIgnoreReal(); 697 TestAndClearIgnoreImag(); 698 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 699 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 700 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 701 702 // Bind the common expression if necessary. 703 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 704 705 CodeGenFunction::ConditionalEvaluation eval(CGF); 706 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 707 708 eval.begin(CGF); 709 CGF.EmitBlock(LHSBlock); 710 ComplexPairTy LHS = Visit(E->getTrueExpr()); 711 LHSBlock = Builder.GetInsertBlock(); 712 CGF.EmitBranch(ContBlock); 713 eval.end(CGF); 714 715 eval.begin(CGF); 716 CGF.EmitBlock(RHSBlock); 717 ComplexPairTy RHS = Visit(E->getFalseExpr()); 718 RHSBlock = Builder.GetInsertBlock(); 719 CGF.EmitBlock(ContBlock); 720 eval.end(CGF); 721 722 // Create a PHI node for the real part. 723 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 724 RealPN->addIncoming(LHS.first, LHSBlock); 725 RealPN->addIncoming(RHS.first, RHSBlock); 726 727 // Create a PHI node for the imaginary part. 728 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 729 ImagPN->addIncoming(LHS.second, LHSBlock); 730 ImagPN->addIncoming(RHS.second, RHSBlock); 731 732 return ComplexPairTy(RealPN, ImagPN); 733 } 734 735 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 736 return Visit(E->getChosenSubExpr(CGF.getContext())); 737 } 738 739 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 740 bool Ignore = TestAndClearIgnoreReal(); 741 (void)Ignore; 742 assert (Ignore == false && "init list ignored"); 743 Ignore = TestAndClearIgnoreImag(); 744 (void)Ignore; 745 assert (Ignore == false && "init list ignored"); 746 747 if (E->getNumInits() == 2) { 748 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 749 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 750 return ComplexPairTy(Real, Imag); 751 } else if (E->getNumInits() == 1) { 752 return Visit(E->getInit(0)); 753 } 754 755 // Empty init list intializes to null 756 assert(E->getNumInits() == 0 && "Unexpected number of inits"); 757 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType(); 758 llvm::Type* LTy = CGF.ConvertType(Ty); 759 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 760 return ComplexPairTy(zeroConstant, zeroConstant); 761 } 762 763 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 764 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 765 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 766 767 if (!ArgPtr) { 768 CGF.ErrorUnsupported(E, "complex va_arg expression"); 769 llvm::Type *EltTy = 770 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 771 llvm::Value *U = llvm::UndefValue::get(EltTy); 772 return ComplexPairTy(U, U); 773 } 774 775 // FIXME Volatility. 776 return EmitLoadOfComplex(ArgPtr, false); 777 } 778 779 //===----------------------------------------------------------------------===// 780 // Entry Point into this File 781 //===----------------------------------------------------------------------===// 782 783 /// EmitComplexExpr - Emit the computation of the specified expression of 784 /// complex type, ignoring the result. 785 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 786 bool IgnoreImag) { 787 assert(E && E->getType()->isAnyComplexType() && 788 "Invalid complex expression to emit"); 789 790 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 791 .Visit(const_cast<Expr*>(E)); 792 } 793 794 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression 795 /// of complex type, storing into the specified Value*. 796 void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 797 llvm::Value *DestAddr, 798 bool DestIsVolatile) { 799 assert(E && E->getType()->isAnyComplexType() && 800 "Invalid complex expression to emit"); 801 ComplexExprEmitter Emitter(*this); 802 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 803 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 804 } 805 806 /// StoreComplexToAddr - Store a complex number into the specified address. 807 void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 808 llvm::Value *DestAddr, 809 bool DestIsVolatile) { 810 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 811 } 812 813 /// LoadComplexFromAddr - Load a complex number from the specified address. 814 ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 815 bool SrcIsVolatile) { 816 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 817 } 818 819 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 820 assert(E->getOpcode() == BO_Assign); 821 ComplexPairTy Val; // ignored 822 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 823 } 824 825 LValue CodeGenFunction:: 826 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 827 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &); 828 switch (E->getOpcode()) { 829 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break; 830 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break; 831 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break; 832 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break; 833 834 default: 835 llvm_unreachable("unexpected complex compound assignment"); 836 } 837 838 ComplexPairTy Val; // ignored 839 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 840 } 841