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