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