CGExprComplex.cpp revision de7fb8413b13651fd85b7125d08b3c9ac2816d9d
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#include "llvm/Support/Compiler.h" 22using namespace clang; 23using namespace CodeGen; 24 25//===----------------------------------------------------------------------===// 26// Complex Expression Emitter 27//===----------------------------------------------------------------------===// 28 29typedef CodeGenFunction::ComplexPairTy ComplexPairTy; 30 31namespace { 32class VISIBILITY_HIDDEN ComplexExprEmitter 33 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 34 CodeGenFunction &CGF; 35 llvm::IRBuilder<> &Builder; 36public: 37 ComplexExprEmitter(CodeGenFunction &cgf) : CGF(cgf), Builder(CGF.Builder) { 38 } 39 40 41 //===--------------------------------------------------------------------===// 42 // Utilities 43 //===--------------------------------------------------------------------===// 44 45 /// EmitLoadOfLValue - Given an expression with complex type that represents a 46 /// value l-value, this method emits the address of the l-value, then loads 47 /// and returns the result. 48 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 49 LValue LV = CGF.EmitLValue(E); 50 // FIXME: Volatile 51 return EmitLoadOfComplex(LV.getAddress(), false); 52 } 53 54 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load 55 /// the real and imaginary pieces. 56 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile); 57 58 /// EmitStoreOfComplex - Store the specified real/imag parts into the 59 /// specified value pointer. 60 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol); 61 62 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 63 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 64 QualType DestType); 65 66 //===--------------------------------------------------------------------===// 67 // Visitor Methods 68 //===--------------------------------------------------------------------===// 69 70 ComplexPairTy VisitStmt(Stmt *S) { 71 S->dump(CGF.getContext().getSourceManager()); 72 assert(0 && "Stmt can't have complex result type!"); 73 return ComplexPairTy(); 74 } 75 ComplexPairTy VisitExpr(Expr *S); 76 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 77 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 78 79 // l-values. 80 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); } 81 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 82 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 83 84 // FIXME: CompoundLiteralExpr 85 86 ComplexPairTy EmitCast(Expr *Op, QualType DestTy); 87 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 88 // Unlike for scalars, we don't have to worry about function->ptr demotion 89 // here. 90 return EmitCast(E->getSubExpr(), E->getType()); 91 } 92 ComplexPairTy VisitCastExpr(CastExpr *E) { 93 return EmitCast(E->getSubExpr(), E->getType()); 94 } 95 ComplexPairTy VisitCallExpr(const CallExpr *E); 96 ComplexPairTy VisitStmtExpr(const StmtExpr *E); 97 ComplexPairTy VisitOverloadExpr(const OverloadExpr *OE); 98 99 // Operators. 100 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 101 bool isInc, bool isPre); 102 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 103 return VisitPrePostIncDec(E, false, false); 104 } 105 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 106 return VisitPrePostIncDec(E, true, false); 107 } 108 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 109 return VisitPrePostIncDec(E, false, true); 110 } 111 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 112 return VisitPrePostIncDec(E, true, true); 113 } 114 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 115 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 116 return Visit(E->getSubExpr()); 117 } 118 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 119 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 120 // LNot,SizeOf,AlignOf,Real,Imag never return complex. 121 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 122 return Visit(E->getSubExpr()); 123 } 124 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 125 return Visit(DAE->getExpr()); 126 } 127 128 struct BinOpInfo { 129 ComplexPairTy LHS; 130 ComplexPairTy RHS; 131 QualType Ty; // Computation Type. 132 }; 133 134 BinOpInfo EmitBinOps(const BinaryOperator *E); 135 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 136 ComplexPairTy (ComplexExprEmitter::*Func) 137 (const BinOpInfo &)); 138 139 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 140 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 141 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 142 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 143 144 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 145 return EmitBinMul(EmitBinOps(E)); 146 } 147 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 148 return EmitBinAdd(EmitBinOps(E)); 149 } 150 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 151 return EmitBinSub(EmitBinOps(E)); 152 } 153 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 154 return EmitBinDiv(EmitBinOps(E)); 155 } 156 157 // Compound assignments. 158 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 159 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 160 } 161 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 162 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 163 } 164 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 165 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 166 } 167 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 168 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 169 } 170 171 // GCC rejects rem/and/or/xor for integer complex. 172 // Logical and/or always return int, never complex. 173 174 // No comparisons produce a complex result. 175 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 176 ComplexPairTy VisitBinComma (const BinaryOperator *E); 177 178 179 ComplexPairTy VisitConditionalOperator(const ConditionalOperator *CO); 180 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 181 182 ComplexPairTy VisitInitListExpr(InitListExpr *E); 183}; 184} // end anonymous namespace. 185 186//===----------------------------------------------------------------------===// 187// Utilities 188//===----------------------------------------------------------------------===// 189 190/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to 191/// load the real and imaginary pieces, returning them as Real/Imag. 192ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr, 193 bool isVolatile) { 194 llvm::SmallString<64> Name(SrcPtr->getNameStart(), 195 SrcPtr->getNameStart()+SrcPtr->getNameLen()); 196 197 Name += ".realp"; 198 llvm::Value *RealPtr = Builder.CreateStructGEP(SrcPtr, 0, Name.c_str()); 199 200 Name.pop_back(); // .realp -> .real 201 llvm::Value *Real = Builder.CreateLoad(RealPtr, isVolatile, Name.c_str()); 202 203 Name.resize(Name.size()-4); // .real -> .imagp 204 Name += "imagp"; 205 206 llvm::Value *ImagPtr = Builder.CreateStructGEP(SrcPtr, 1, Name.c_str()); 207 208 Name.pop_back(); // .imagp -> .imag 209 llvm::Value *Imag = Builder.CreateLoad(ImagPtr, isVolatile, Name.c_str()); 210 return ComplexPairTy(Real, Imag); 211} 212 213/// EmitStoreOfComplex - Store the specified real/imag parts into the 214/// specified value pointer. 215void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr, 216 bool isVolatile) { 217 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 218 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 219 220 Builder.CreateStore(Val.first, RealPtr, isVolatile); 221 Builder.CreateStore(Val.second, ImagPtr, isVolatile); 222} 223 224 225 226//===----------------------------------------------------------------------===// 227// Visitor Methods 228//===----------------------------------------------------------------------===// 229 230ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 231 CGF.WarnUnsupported(E, "complex expression"); 232 const llvm::Type *EltTy = 233 CGF.ConvertType(E->getType()->getAsComplexType()->getElementType()); 234 llvm::Value *U = llvm::UndefValue::get(EltTy); 235 return ComplexPairTy(U, U); 236} 237 238ComplexPairTy ComplexExprEmitter:: 239VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 240 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 241 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 242} 243 244 245ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 246 return CGF.EmitCallExpr(E).getComplexVal(); 247} 248 249ComplexPairTy ComplexExprEmitter::VisitOverloadExpr(const OverloadExpr *E) { 250 return CGF.EmitCallExpr(E->getFn(), E->arg_begin(), 251 E->arg_end(CGF.getContext())).getComplexVal(); 252} 253 254ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 255 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 256} 257 258/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 259ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 260 QualType SrcType, 261 QualType DestType) { 262 // Get the src/dest element type. 263 SrcType = SrcType->getAsComplexType()->getElementType(); 264 DestType = DestType->getAsComplexType()->getElementType(); 265 266 // C99 6.3.1.6: When a value of complextype is converted to another 267 // complex type, both the real and imaginary parts followthe conversion 268 // rules for the corresponding real types. 269 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 270 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 271 return Val; 272} 273 274ComplexPairTy ComplexExprEmitter::EmitCast(Expr *Op, QualType DestTy) { 275 // Two cases here: cast from (complex to complex) and (scalar to complex). 276 if (Op->getType()->isAnyComplexType()) 277 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 278 279 // C99 6.3.1.7: When a value of real type is converted to a complex type, the 280 // real part of the complex result value is determined by the rules of 281 // conversion to the corresponding real type and the imaginary part of the 282 // complex result value is a positive zero or an unsigned zero. 283 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 284 285 // Convert the input element to the element type of the complex. 286 DestTy = DestTy->getAsComplexType()->getElementType(); 287 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 288 289 // Return (realval, 0). 290 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 291} 292 293ComplexPairTy ComplexExprEmitter::VisitPrePostIncDec(const UnaryOperator *E, 294 bool isInc, bool isPre) { 295 LValue LV = CGF.EmitLValue(E->getSubExpr()); 296 // FIXME: Handle volatile! 297 ComplexPairTy InVal = EmitLoadOfComplex(LV.getAddress(), false); 298 299 uint64_t AmountVal = isInc ? 1 : -1; 300 301 llvm::Value *NextVal; 302 if (isa<llvm::IntegerType>(InVal.first->getType())) 303 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal); 304 else if (InVal.first->getType() == llvm::Type::FloatTy) 305 // FIXME: Handle long double. 306 NextVal = 307 llvm::ConstantFP::get(llvm::APFloat(static_cast<float>(AmountVal))); 308 else { 309 // FIXME: Handle long double. 310 assert(InVal.first->getType() == llvm::Type::DoubleTy); 311 NextVal = 312 llvm::ConstantFP::get(llvm::APFloat(static_cast<double>(AmountVal))); 313 } 314 315 // Add the inc/dec to the real part. 316 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 317 318 ComplexPairTy IncVal(NextVal, InVal.second); 319 320 // Store the updated result through the lvalue. 321 EmitStoreOfComplex(IncVal, LV.getAddress(), false); /* FIXME: Volatile */ 322 323 // If this is a postinc, return the value read from memory, otherwise use the 324 // updated value. 325 return isPre ? IncVal : InVal; 326} 327 328ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 329 ComplexPairTy Op = Visit(E->getSubExpr()); 330 llvm::Value *ResR = Builder.CreateNeg(Op.first, "neg.r"); 331 llvm::Value *ResI = Builder.CreateNeg(Op.second, "neg.i"); 332 return ComplexPairTy(ResR, ResI); 333} 334 335ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 336 // ~(a+ib) = a + i*-b 337 ComplexPairTy Op = Visit(E->getSubExpr()); 338 llvm::Value *ResI = Builder.CreateNeg(Op.second, "conj.i"); 339 return ComplexPairTy(Op.first, ResI); 340} 341 342ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 343 llvm::Value *ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 344 llvm::Value *ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 345 return ComplexPairTy(ResR, ResI); 346} 347 348ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 349 llvm::Value *ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 350 llvm::Value *ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 351 return ComplexPairTy(ResR, ResI); 352} 353 354 355ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 356 llvm::Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 357 llvm::Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 358 llvm::Value *ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 359 360 llvm::Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 361 llvm::Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 362 llvm::Value *ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 363 return ComplexPairTy(ResR, ResI); 364} 365 366ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 367 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 368 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 369 370 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 371 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c 372 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d 373 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd 374 375 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c 376 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d 377 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd 378 379 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c 380 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d 381 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad 382 383 llvm::Value *DSTr, *DSTi; 384 if (Tmp3->getType()->isFloatingPoint()) { 385 DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp"); 386 DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp"); 387 } else { 388 if (Op.Ty->getAsComplexType()->getElementType()->isUnsignedIntegerType()) { 389 DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp"); 390 DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp"); 391 } else { 392 DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp"); 393 DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp"); 394 } 395 } 396 397 return ComplexPairTy(DSTr, DSTi); 398} 399 400ComplexExprEmitter::BinOpInfo 401ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 402 BinOpInfo Ops; 403 Ops.LHS = Visit(E->getLHS()); 404 Ops.RHS = Visit(E->getRHS()); 405 Ops.Ty = E->getType(); 406 return Ops; 407} 408 409 410// Compound assignments. 411ComplexPairTy ComplexExprEmitter:: 412EmitCompoundAssign(const CompoundAssignOperator *E, 413 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 414 QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType(); 415 416 // Load the LHS and RHS operands. 417 LValue LHSLV = CGF.EmitLValue(E->getLHS()); 418 419 BinOpInfo OpInfo; 420 OpInfo.Ty = E->getComputationType(); 421 422 // We know the LHS is a complex lvalue. 423 OpInfo.LHS = EmitLoadOfComplex(LHSLV.getAddress(), false);// FIXME: Volatile. 424 OpInfo.LHS = EmitComplexToComplexCast(OpInfo.LHS, LHSTy, OpInfo.Ty); 425 426 // It is possible for the RHS to be complex or scalar. 427 OpInfo.RHS = EmitCast(E->getRHS(), OpInfo.Ty); 428 429 // Expand the binary operator. 430 ComplexPairTy Result = (this->*Func)(OpInfo); 431 432 // Truncate the result back to the LHS type. 433 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 434 435 // Store the result value into the LHS lvalue. 436 EmitStoreOfComplex(Result, LHSLV.getAddress(), false); // FIXME: VOLATILE 437 return Result; 438} 439 440ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 441 assert(CGF.getContext().getCanonicalType(E->getLHS()->getType()) == 442 CGF.getContext().getCanonicalType(E->getRHS()->getType()) && 443 "Invalid assignment"); 444 // Emit the RHS. 445 ComplexPairTy Val = Visit(E->getRHS()); 446 447 // Compute the address to store into. 448 LValue LHS = CGF.EmitLValue(E->getLHS()); 449 450 // Store into it. 451 // FIXME: Volatility! 452 EmitStoreOfComplex(Val, LHS.getAddress(), false); 453 return Val; 454} 455 456ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 457 CGF.EmitStmt(E->getLHS()); 458 return Visit(E->getRHS()); 459} 460 461ComplexPairTy ComplexExprEmitter:: 462VisitConditionalOperator(const ConditionalOperator *E) { 463 llvm::BasicBlock *LHSBlock = llvm::BasicBlock::Create("cond.?"); 464 llvm::BasicBlock *RHSBlock = llvm::BasicBlock::Create("cond.:"); 465 llvm::BasicBlock *ContBlock = llvm::BasicBlock::Create("cond.cont"); 466 467 llvm::Value *Cond = CGF.EvaluateExprAsBool(E->getCond()); 468 Builder.CreateCondBr(Cond, LHSBlock, RHSBlock); 469 470 CGF.EmitBlock(LHSBlock); 471 472 // Handle the GNU extension for missing LHS. 473 assert(E->getLHS() && "Must have LHS for complex value"); 474 475 ComplexPairTy LHS = Visit(E->getLHS()); 476 Builder.CreateBr(ContBlock); 477 LHSBlock = Builder.GetInsertBlock(); 478 479 CGF.EmitBlock(RHSBlock); 480 481 ComplexPairTy RHS = Visit(E->getRHS()); 482 Builder.CreateBr(ContBlock); 483 RHSBlock = Builder.GetInsertBlock(); 484 485 CGF.EmitBlock(ContBlock); 486 487 // Create a PHI node for the real part. 488 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), "cond.r"); 489 RealPN->reserveOperandSpace(2); 490 RealPN->addIncoming(LHS.first, LHSBlock); 491 RealPN->addIncoming(RHS.first, RHSBlock); 492 493 // Create a PHI node for the imaginary part. 494 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), "cond.i"); 495 ImagPN->reserveOperandSpace(2); 496 ImagPN->addIncoming(LHS.second, LHSBlock); 497 ImagPN->addIncoming(RHS.second, RHSBlock); 498 499 return ComplexPairTy(RealPN, ImagPN); 500} 501 502ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 503 // Emit the LHS or RHS as appropriate. 504 return Visit(E->isConditionTrue(CGF.getContext()) ? E->getLHS() :E->getRHS()); 505} 506 507ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 508 if (E->getNumInits()) 509 return Visit(E->getInit(0)); 510 511 // Empty init list intializes to null 512 QualType Ty = E->getType()->getAsComplexType()->getElementType(); 513 const llvm::Type* LTy = CGF.ConvertType(Ty); 514 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 515 return ComplexPairTy(zeroConstant, zeroConstant); 516} 517 518//===----------------------------------------------------------------------===// 519// Entry Point into this File 520//===----------------------------------------------------------------------===// 521 522/// EmitComplexExpr - Emit the computation of the specified expression of 523/// complex type, ignoring the result. 524ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E) { 525 assert(E && E->getType()->isAnyComplexType() && 526 "Invalid complex expression to emit"); 527 528 return ComplexExprEmitter(*this).Visit(const_cast<Expr*>(E)); 529} 530 531/// EmitComplexExprIntoAddr - Emit the computation of the specified expression 532/// of complex type, storing into the specified Value*. 533void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 534 llvm::Value *DestAddr, 535 bool DestIsVolatile) { 536 assert(E && E->getType()->isAnyComplexType() && 537 "Invalid complex expression to emit"); 538 ComplexExprEmitter Emitter(*this); 539 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 540 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 541} 542 543/// LoadComplexFromAddr - Load a complex number from the specified address. 544ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 545 bool SrcIsVolatile) { 546 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 547} 548