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