CGExprComplex.cpp revision dfb1eb208e401a0e5ecf2910e1a73b09aa69fd26
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; 38 // True if we should ignore the value of a=b 39 bool IgnoreRealAssign; 40 bool IgnoreImagAssign; 41public: 42 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false, 43 bool irn=false, bool iin=false) 44 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii), 45 IgnoreRealAssign(irn), IgnoreImagAssign(iin) { 46 } 47 48 49 //===--------------------------------------------------------------------===// 50 // Utilities 51 //===--------------------------------------------------------------------===// 52 53 bool TestAndClearIgnoreReal() { 54 bool I = IgnoreReal; 55 IgnoreReal = false; 56 return I; 57 } 58 bool TestAndClearIgnoreImag() { 59 bool I = IgnoreImag; 60 IgnoreImag = false; 61 return I; 62 } 63 bool TestAndClearIgnoreRealAssign() { 64 bool I = IgnoreRealAssign; 65 IgnoreRealAssign = false; 66 return I; 67 } 68 bool TestAndClearIgnoreImagAssign() { 69 bool I = IgnoreImagAssign; 70 IgnoreImagAssign = false; 71 return I; 72 } 73 74 /// EmitLoadOfLValue - Given an expression with complex type that represents a 75 /// value l-value, this method emits the address of the l-value, then loads 76 /// and returns the result. 77 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 78 LValue LV = CGF.EmitLValue(E); 79 if (LV.isSimple()) 80 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 81 82 if (LV.isPropertyRef()) 83 return CGF.EmitObjCPropertyGet(LV.getPropertyRefExpr()).getComplexVal(); 84 85 assert(LV.isKVCRef() && "Unknown LValue type!"); 86 return CGF.EmitObjCPropertyGet(LV.getKVCRefExpr()).getComplexVal(); 87 } 88 89 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load 90 /// the real and imaginary pieces. 91 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile); 92 93 /// EmitStoreOfComplex - Store the specified real/imag parts into the 94 /// specified value pointer. 95 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol); 96 97 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 98 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 99 QualType DestType); 100 101 //===--------------------------------------------------------------------===// 102 // Visitor Methods 103 //===--------------------------------------------------------------------===// 104 105 ComplexPairTy VisitStmt(Stmt *S) { 106 S->dump(CGF.getContext().getSourceManager()); 107 assert(0 && "Stmt can't have complex result type!"); 108 return ComplexPairTy(); 109 } 110 ComplexPairTy VisitExpr(Expr *S); 111 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 112 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 113 114 // l-values. 115 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); } 116 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 117 return EmitLoadOfLValue(E); 118 } 119 ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 120 return EmitLoadOfLValue(E); 121 } 122 ComplexPairTy VisitObjCImplicitSetterGetterRefExpr( 123 ObjCImplicitSetterGetterRefExpr *E) { 124 return EmitLoadOfLValue(E); 125 } 126 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { 127 return CGF.EmitObjCMessageExpr(E).getComplexVal(); 128 } 129 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 130 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 131 132 // FIXME: CompoundLiteralExpr 133 134 ComplexPairTy EmitCast(Expr *Op, QualType DestTy); 135 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 136 // Unlike for scalars, we don't have to worry about function->ptr demotion 137 // here. 138 return EmitCast(E->getSubExpr(), E->getType()); 139 } 140 ComplexPairTy VisitCastExpr(CastExpr *E) { 141 return EmitCast(E->getSubExpr(), E->getType()); 142 } 143 ComplexPairTy VisitCallExpr(const CallExpr *E); 144 ComplexPairTy VisitStmtExpr(const StmtExpr *E); 145 146 // Operators. 147 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 148 bool isInc, bool isPre) { 149 LValue LV = CGF.EmitLValue(E->getSubExpr()); 150 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); 151 } 152 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 153 return VisitPrePostIncDec(E, false, false); 154 } 155 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 156 return VisitPrePostIncDec(E, true, false); 157 } 158 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 159 return VisitPrePostIncDec(E, false, true); 160 } 161 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 162 return VisitPrePostIncDec(E, true, true); 163 } 164 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 165 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 166 TestAndClearIgnoreReal(); 167 TestAndClearIgnoreImag(); 168 TestAndClearIgnoreRealAssign(); 169 TestAndClearIgnoreImagAssign(); 170 return Visit(E->getSubExpr()); 171 } 172 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 173 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 174 // LNot,Real,Imag never return complex. 175 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 176 return Visit(E->getSubExpr()); 177 } 178 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 179 return Visit(DAE->getExpr()); 180 } 181 ComplexPairTy VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 182 return CGF.EmitCXXExprWithTemporaries(E).getComplexVal(); 183 } 184 ComplexPairTy VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 185 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 186 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 187 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 188 return ComplexPairTy(Null, Null); 189 } 190 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 191 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 192 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 193 llvm::Constant *Null = 194 llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 195 return ComplexPairTy(Null, Null); 196 } 197 198 struct BinOpInfo { 199 ComplexPairTy LHS; 200 ComplexPairTy RHS; 201 QualType Ty; // Computation Type. 202 }; 203 204 BinOpInfo EmitBinOps(const BinaryOperator *E); 205 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 206 ComplexPairTy (ComplexExprEmitter::*Func) 207 (const BinOpInfo &)); 208 209 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 210 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 211 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 212 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 213 214 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 215 return EmitBinMul(EmitBinOps(E)); 216 } 217 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 218 return EmitBinAdd(EmitBinOps(E)); 219 } 220 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 221 return EmitBinSub(EmitBinOps(E)); 222 } 223 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 224 return EmitBinDiv(EmitBinOps(E)); 225 } 226 227 // Compound assignments. 228 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 229 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 230 } 231 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 232 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 233 } 234 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 235 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 236 } 237 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 238 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 239 } 240 241 // GCC rejects rem/and/or/xor for integer complex. 242 // Logical and/or always return int, never complex. 243 244 // No comparisons produce a complex result. 245 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 246 ComplexPairTy VisitBinComma (const BinaryOperator *E); 247 248 249 ComplexPairTy VisitConditionalOperator(const ConditionalOperator *CO); 250 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 251 252 ComplexPairTy VisitInitListExpr(InitListExpr *E); 253 254 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 255}; 256} // end anonymous namespace. 257 258//===----------------------------------------------------------------------===// 259// Utilities 260//===----------------------------------------------------------------------===// 261 262/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to 263/// load the real and imaginary pieces, returning them as Real/Imag. 264ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr, 265 bool isVolatile) { 266 llvm::Value *Real=0, *Imag=0; 267 268 if (!IgnoreReal) { 269 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0, 270 SrcPtr->getName() + ".realp"); 271 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real"); 272 } 273 274 if (!IgnoreImag) { 275 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1, 276 SrcPtr->getName() + ".imagp"); 277 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag"); 278 } 279 return ComplexPairTy(Real, Imag); 280} 281 282/// EmitStoreOfComplex - Store the specified real/imag parts into the 283/// specified value pointer. 284void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr, 285 bool isVolatile) { 286 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 287 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 288 289 Builder.CreateStore(Val.first, RealPtr, isVolatile); 290 Builder.CreateStore(Val.second, ImagPtr, isVolatile); 291} 292 293 294 295//===----------------------------------------------------------------------===// 296// Visitor Methods 297//===----------------------------------------------------------------------===// 298 299ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 300 CGF.ErrorUnsupported(E, "complex expression"); 301 const llvm::Type *EltTy = 302 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 303 llvm::Value *U = llvm::UndefValue::get(EltTy); 304 return ComplexPairTy(U, U); 305} 306 307ComplexPairTy ComplexExprEmitter:: 308VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 309 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 310 return 311 ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 312} 313 314 315ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 316 if (E->getCallReturnType()->isReferenceType()) 317 return EmitLoadOfLValue(E); 318 319 return CGF.EmitCallExpr(E).getComplexVal(); 320} 321 322ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 323 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 324} 325 326/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 327ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 328 QualType SrcType, 329 QualType DestType) { 330 // Get the src/dest element type. 331 SrcType = SrcType->getAs<ComplexType>()->getElementType(); 332 DestType = DestType->getAs<ComplexType>()->getElementType(); 333 334 // C99 6.3.1.6: When a value of complex type is converted to another 335 // complex type, both the real and imaginary parts follow the conversion 336 // rules for the corresponding real types. 337 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 338 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 339 return Val; 340} 341 342ComplexPairTy ComplexExprEmitter::EmitCast(Expr *Op, QualType DestTy) { 343 // Two cases here: cast from (complex to complex) and (scalar to complex). 344 if (Op->getType()->isAnyComplexType()) 345 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 346 347 // C99 6.3.1.7: When a value of real type is converted to a complex type, the 348 // real part of the complex result value is determined by the rules of 349 // conversion to the corresponding real type and the imaginary part of the 350 // complex result value is a positive zero or an unsigned zero. 351 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 352 353 // Convert the input element to the element type of the complex. 354 DestTy = DestTy->getAs<ComplexType>()->getElementType(); 355 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 356 357 // Return (realval, 0). 358 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 359} 360 361ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 362 TestAndClearIgnoreReal(); 363 TestAndClearIgnoreImag(); 364 TestAndClearIgnoreRealAssign(); 365 TestAndClearIgnoreImagAssign(); 366 ComplexPairTy Op = Visit(E->getSubExpr()); 367 368 llvm::Value *ResR, *ResI; 369 if (Op.first->getType()->isFloatingPointTy()) { 370 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 371 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 372 } else { 373 ResR = Builder.CreateNeg(Op.first, "neg.r"); 374 ResI = Builder.CreateNeg(Op.second, "neg.i"); 375 } 376 return ComplexPairTy(ResR, ResI); 377} 378 379ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 380 TestAndClearIgnoreReal(); 381 TestAndClearIgnoreImag(); 382 TestAndClearIgnoreRealAssign(); 383 TestAndClearIgnoreImagAssign(); 384 // ~(a+ib) = a + i*-b 385 ComplexPairTy Op = Visit(E->getSubExpr()); 386 llvm::Value *ResI; 387 if (Op.second->getType()->isFloatingPointTy()) 388 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 389 else 390 ResI = Builder.CreateNeg(Op.second, "conj.i"); 391 392 return ComplexPairTy(Op.first, ResI); 393} 394 395ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 396 llvm::Value *ResR, *ResI; 397 398 if (Op.LHS.first->getType()->isFloatingPointTy()) { 399 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 400 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 401 } else { 402 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 403 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 404 } 405 return ComplexPairTy(ResR, ResI); 406} 407 408ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 409 llvm::Value *ResR, *ResI; 410 if (Op.LHS.first->getType()->isFloatingPointTy()) { 411 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 412 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 413 } else { 414 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 415 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 416 } 417 return ComplexPairTy(ResR, ResI); 418} 419 420 421ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 422 using llvm::Value; 423 Value *ResR, *ResI; 424 425 if (Op.LHS.first->getType()->isFloatingPointTy()) { 426 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 427 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 428 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 429 430 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 431 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 432 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 433 } else { 434 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 435 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 436 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 437 438 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 439 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 440 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 441 } 442 return ComplexPairTy(ResR, ResI); 443} 444 445ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 446 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 447 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 448 449 450 llvm::Value *DSTr, *DSTi; 451 if (Op.LHS.first->getType()->isFloatingPointTy()) { 452 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 453 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr, "tmp"); // a*c 454 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi, "tmp"); // b*d 455 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2, "tmp"); // ac+bd 456 457 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr, "tmp"); // c*c 458 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi, "tmp"); // d*d 459 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5, "tmp"); // cc+dd 460 461 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr, "tmp"); // b*c 462 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi, "tmp"); // a*d 463 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8, "tmp"); // bc-ad 464 465 DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp"); 466 DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp"); 467 } else { 468 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 469 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c 470 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d 471 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd 472 473 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c 474 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d 475 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd 476 477 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c 478 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d 479 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad 480 481 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 482 DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp"); 483 DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp"); 484 } else { 485 DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp"); 486 DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp"); 487 } 488 } 489 490 return ComplexPairTy(DSTr, DSTi); 491} 492 493ComplexExprEmitter::BinOpInfo 494ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 495 TestAndClearIgnoreReal(); 496 TestAndClearIgnoreImag(); 497 TestAndClearIgnoreRealAssign(); 498 TestAndClearIgnoreImagAssign(); 499 BinOpInfo Ops; 500 Ops.LHS = Visit(E->getLHS()); 501 Ops.RHS = Visit(E->getRHS()); 502 Ops.Ty = E->getType(); 503 return Ops; 504} 505 506 507// Compound assignments. 508ComplexPairTy ComplexExprEmitter:: 509EmitCompoundAssign(const CompoundAssignOperator *E, 510 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 511 TestAndClearIgnoreReal(); 512 TestAndClearIgnoreImag(); 513 bool ignreal = TestAndClearIgnoreRealAssign(); 514 bool ignimag = TestAndClearIgnoreImagAssign(); 515 QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType(); 516 517 BinOpInfo OpInfo; 518 519 // Load the RHS and LHS operands. 520 // __block variables need to have the rhs evaluated first, plus this should 521 // improve codegen a little. It is possible for the RHS to be complex or 522 // scalar. 523 OpInfo.Ty = E->getComputationResultType(); 524 OpInfo.RHS = EmitCast(E->getRHS(), OpInfo.Ty); 525 526 LValue LHSLV = CGF.EmitLValue(E->getLHS()); 527 assert(!LHSLV.isKVCRef() && 528 "setter/getter access of complex using property syntax NYI"); 529 // We know the LHS is a complex lvalue. 530 ComplexPairTy LHSComplexPair; 531 if (LHSLV.isPropertyRef()) 532 LHSComplexPair = 533 CGF.EmitObjCPropertyGet(LHSLV.getPropertyRefExpr()).getComplexVal(); 534 else 535 LHSComplexPair = EmitLoadOfComplex(LHSLV.getAddress(), 536 LHSLV.isVolatileQualified()); 537 538 OpInfo.LHS=EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 539 540 // Expand the binary operator. 541 ComplexPairTy Result = (this->*Func)(OpInfo); 542 543 // Truncate the result back to the LHS type. 544 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 545 546 // Store the result value into the LHS lvalue. 547 if (LHSLV.isPropertyRef()) 548 CGF.EmitObjCPropertySet(LHSLV.getPropertyRefExpr(), 549 RValue::getComplex(Result)); 550 else 551 EmitStoreOfComplex(Result, LHSLV.getAddress(), LHSLV.isVolatileQualified()); 552 // And now return the LHS 553 IgnoreReal = ignreal; 554 IgnoreImag = ignimag; 555 IgnoreRealAssign = ignreal; 556 IgnoreImagAssign = ignimag; 557 if (LHSLV.isPropertyRef()) 558 return CGF.EmitObjCPropertyGet(LHSLV.getPropertyRefExpr()).getComplexVal(); 559 return EmitLoadOfComplex(LHSLV.getAddress(), LHSLV.isVolatileQualified()); 560} 561 562ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 563 TestAndClearIgnoreReal(); 564 TestAndClearIgnoreImag(); 565 bool ignreal = TestAndClearIgnoreRealAssign(); 566 bool ignimag = TestAndClearIgnoreImagAssign(); 567 assert(CGF.getContext().getCanonicalType(E->getLHS()->getType()) == 568 CGF.getContext().getCanonicalType(E->getRHS()->getType()) && 569 "Invalid assignment"); 570 // Emit the RHS. 571 ComplexPairTy Val = Visit(E->getRHS()); 572 573 // Compute the address to store into. 574 LValue LHS = CGF.EmitLValue(E->getLHS()); 575 576 // Store into it, if simple. 577 if (LHS.isSimple()) { 578 EmitStoreOfComplex(Val, LHS.getAddress(), LHS.isVolatileQualified()); 579 580 // And now return the LHS 581 IgnoreReal = ignreal; 582 IgnoreImag = ignimag; 583 IgnoreRealAssign = ignreal; 584 IgnoreImagAssign = ignimag; 585 return EmitLoadOfComplex(LHS.getAddress(), LHS.isVolatileQualified()); 586 } 587 588 // Otherwise we must have a property setter (no complex vector/bitfields). 589 if (LHS.isPropertyRef()) 590 CGF.EmitObjCPropertySet(LHS.getPropertyRefExpr(), RValue::getComplex(Val)); 591 else 592 CGF.EmitObjCPropertySet(LHS.getKVCRefExpr(), RValue::getComplex(Val)); 593 594 // There is no reload after a store through a method, but we need to restore 595 // the Ignore* flags. 596 IgnoreReal = ignreal; 597 IgnoreImag = ignimag; 598 IgnoreRealAssign = ignreal; 599 IgnoreImagAssign = ignimag; 600 return Val; 601} 602 603ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 604 CGF.EmitStmt(E->getLHS()); 605 CGF.EnsureInsertPoint(); 606 return Visit(E->getRHS()); 607} 608 609ComplexPairTy ComplexExprEmitter:: 610VisitConditionalOperator(const ConditionalOperator *E) { 611 if (!E->getLHS()) { 612 CGF.ErrorUnsupported(E, "conditional operator with missing LHS"); 613 const llvm::Type *EltTy = 614 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 615 llvm::Value *U = llvm::UndefValue::get(EltTy); 616 return ComplexPairTy(U, U); 617 } 618 619 TestAndClearIgnoreReal(); 620 TestAndClearIgnoreImag(); 621 TestAndClearIgnoreRealAssign(); 622 TestAndClearIgnoreImagAssign(); 623 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 624 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 625 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 626 627 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 628 629 CGF.EmitBlock(LHSBlock); 630 631 // Handle the GNU extension for missing LHS. 632 assert(E->getLHS() && "Must have LHS for complex value"); 633 634 ComplexPairTy LHS = Visit(E->getLHS()); 635 LHSBlock = Builder.GetInsertBlock(); 636 CGF.EmitBranch(ContBlock); 637 638 CGF.EmitBlock(RHSBlock); 639 640 ComplexPairTy RHS = Visit(E->getRHS()); 641 RHSBlock = Builder.GetInsertBlock(); 642 CGF.EmitBranch(ContBlock); 643 644 CGF.EmitBlock(ContBlock); 645 646 // Create a PHI node for the real part. 647 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), "cond.r"); 648 RealPN->reserveOperandSpace(2); 649 RealPN->addIncoming(LHS.first, LHSBlock); 650 RealPN->addIncoming(RHS.first, RHSBlock); 651 652 // Create a PHI node for the imaginary part. 653 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), "cond.i"); 654 ImagPN->reserveOperandSpace(2); 655 ImagPN->addIncoming(LHS.second, LHSBlock); 656 ImagPN->addIncoming(RHS.second, RHSBlock); 657 658 return ComplexPairTy(RealPN, ImagPN); 659} 660 661ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 662 return Visit(E->getChosenSubExpr(CGF.getContext())); 663} 664 665ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 666 bool Ignore = TestAndClearIgnoreReal(); 667 (void)Ignore; 668 assert (Ignore == false && "init list ignored"); 669 Ignore = TestAndClearIgnoreImag(); 670 (void)Ignore; 671 assert (Ignore == false && "init list ignored"); 672 if (E->getNumInits()) 673 return Visit(E->getInit(0)); 674 675 // Empty init list intializes to null 676 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType(); 677 const llvm::Type* LTy = CGF.ConvertType(Ty); 678 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 679 return ComplexPairTy(zeroConstant, zeroConstant); 680} 681 682ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 683 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 684 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 685 686 if (!ArgPtr) { 687 CGF.ErrorUnsupported(E, "complex va_arg expression"); 688 const llvm::Type *EltTy = 689 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 690 llvm::Value *U = llvm::UndefValue::get(EltTy); 691 return ComplexPairTy(U, U); 692 } 693 694 // FIXME Volatility. 695 return EmitLoadOfComplex(ArgPtr, false); 696} 697 698//===----------------------------------------------------------------------===// 699// Entry Point into this File 700//===----------------------------------------------------------------------===// 701 702/// EmitComplexExpr - Emit the computation of the specified expression of 703/// complex type, ignoring the result. 704ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 705 bool IgnoreImag, bool IgnoreRealAssign, bool IgnoreImagAssign) { 706 assert(E && E->getType()->isAnyComplexType() && 707 "Invalid complex expression to emit"); 708 709 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag, IgnoreRealAssign, 710 IgnoreImagAssign) 711 .Visit(const_cast<Expr*>(E)); 712} 713 714/// EmitComplexExprIntoAddr - Emit the computation of the specified expression 715/// of complex type, storing into the specified Value*. 716void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 717 llvm::Value *DestAddr, 718 bool DestIsVolatile) { 719 assert(E && E->getType()->isAnyComplexType() && 720 "Invalid complex expression to emit"); 721 ComplexExprEmitter Emitter(*this); 722 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 723 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 724} 725 726/// StoreComplexToAddr - Store a complex number into the specified address. 727void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 728 llvm::Value *DestAddr, 729 bool DestIsVolatile) { 730 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 731} 732 733/// LoadComplexFromAddr - Load a complex number from the specified address. 734ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 735 bool SrcIsVolatile) { 736 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 737} 738