CGExprConstant.cpp revision 248a753f6b670692523c99afaeb8fe98f7ae3ca7
1//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 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 Constant Expr nodes as LLVM code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenFunction.h" 15#include "CodeGenModule.h" 16#include "clang/AST/AST.h" 17#include "llvm/Constants.h" 18#include "llvm/Function.h" 19#include "llvm/GlobalVariable.h" 20#include "llvm/Support/Compiler.h" 21using namespace clang; 22using namespace CodeGen; 23 24namespace { 25class VISIBILITY_HIDDEN ConstExprEmitter : 26 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 27 CodeGenModule &CGM; 28 CodeGenFunction *CGF; 29public: 30 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 31 : CGM(cgm), CGF(cgf) { 32 } 33 34 //===--------------------------------------------------------------------===// 35 // Visitor Methods 36 //===--------------------------------------------------------------------===// 37 38 llvm::Constant *VisitStmt(Stmt *S) { 39 CGM.WarnUnsupported(S, "constant expression"); 40 QualType T = cast<Expr>(S)->getType(); 41 return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); 42 } 43 44 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 45 return Visit(PE->getSubExpr()); 46 } 47 48 // Leaves 49 llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) { 50 return llvm::ConstantInt::get(E->getValue()); 51 } 52 llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) { 53 return llvm::ConstantFP::get(ConvertType(E->getType()), E->getValue()); 54 } 55 llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) { 56 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 57 } 58 llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 59 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 60 } 61 62 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 63 return Visit(E->getInitializer()); 64 } 65 66 llvm::Constant *VisitCastExpr(const CastExpr* E) { 67 llvm::Constant *C = Visit(E->getSubExpr()); 68 69 return EmitConversion(C, E->getSubExpr()->getType(), E->getType()); 70 } 71 72 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 73 return Visit(DAE->getExpr()); 74 } 75 76 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, 77 const llvm::ArrayType *AType) { 78 std::vector<llvm::Constant*> Elts; 79 unsigned NumInitElements = ILE->getNumInits(); 80 // FIXME: Check for wide strings 81 if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) && 82 ILE->getType()->getAsArrayType()->getElementType()->isCharType()) 83 return Visit(ILE->getInit(0)); 84 const llvm::Type *ElemTy = AType->getElementType(); 85 unsigned NumElements = AType->getNumElements(); 86 87 // Initialising an array requires us to automatically 88 // initialise any elements that have not been initialised explicitly 89 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 90 91 // Copy initializer elements. 92 unsigned i = 0; 93 for (; i < NumInitableElts; ++i) { 94 95 llvm::Constant *C = Visit(ILE->getInit(i)); 96 // FIXME: Remove this when sema of initializers is finished (and the code 97 // above). 98 if (C == 0 && ILE->getInit(i)->getType()->isVoidType()) { 99 if (ILE->getType()->isVoidType()) return 0; 100 return llvm::UndefValue::get(AType); 101 } 102 assert (C && "Failed to create initializer expression"); 103 Elts.push_back(C); 104 } 105 106 // Initialize remaining array elements. 107 for (; i < NumElements; ++i) 108 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 109 110 return llvm::ConstantArray::get(AType, Elts); 111 } 112 113 llvm::Constant *EmitStructInitialization(InitListExpr *ILE, 114 const llvm::StructType *SType) { 115 116 TagDecl *TD = ILE->getType()->getAsRecordType()->getDecl(); 117 std::vector<llvm::Constant*> Elts; 118 const CGRecordLayout *CGR = CGM.getTypes().getCGRecordLayout(TD); 119 unsigned NumInitElements = ILE->getNumInits(); 120 unsigned NumElements = SType->getNumElements(); 121 122 // Initialising an structure requires us to automatically 123 // initialise any elements that have not been initialised explicitly 124 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 125 126 // Copy initializer elements. Skip padding fields. 127 unsigned EltNo = 0; // Element no in ILE 128 unsigned FieldNo = 0; // Field no in SType 129 while (EltNo < NumInitableElts) { 130 131 // Zero initialize padding field. 132 if (CGR->isPaddingField(FieldNo)) { 133 const llvm::Type *FieldTy = SType->getElementType(FieldNo); 134 Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 135 FieldNo++; 136 continue; 137 } 138 139 llvm::Constant *C = Visit(ILE->getInit(EltNo)); 140 // FIXME: Remove this when sema of initializers is finished (and the code 141 // above). 142 if (C == 0 && ILE->getInit(EltNo)->getType()->isVoidType()) { 143 if (ILE->getType()->isVoidType()) return 0; 144 return llvm::UndefValue::get(SType); 145 } 146 assert (C && "Failed to create initializer expression"); 147 Elts.push_back(C); 148 EltNo++; 149 FieldNo++; 150 } 151 152 // Initialize remaining structure elements. 153 for (unsigned i = Elts.size(); i < NumElements; ++i) { 154 const llvm::Type *FieldTy = SType->getElementType(i); 155 Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 156 } 157 158 return llvm::ConstantStruct::get(SType, Elts); 159 } 160 161 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE, 162 const llvm::VectorType *VType) { 163 164 std::vector<llvm::Constant*> Elts; 165 unsigned NumInitElements = ILE->getNumInits(); 166 unsigned NumElements = VType->getNumElements(); 167 168 assert (NumInitElements == NumElements 169 && "Unsufficient vector init elelments"); 170 // Copy initializer elements. 171 unsigned i = 0; 172 for (; i < NumElements; ++i) { 173 174 llvm::Constant *C = Visit(ILE->getInit(i)); 175 // FIXME: Remove this when sema of initializers is finished (and the code 176 // above). 177 if (C == 0 && ILE->getInit(i)->getType()->isVoidType()) { 178 if (ILE->getType()->isVoidType()) return 0; 179 return llvm::UndefValue::get(VType); 180 } 181 assert (C && "Failed to create initializer expression"); 182 Elts.push_back(C); 183 } 184 185 return llvm::ConstantVector::get(VType, Elts); 186 } 187 188 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 189 const llvm::CompositeType *CType = 190 dyn_cast<llvm::CompositeType>(ConvertType(ILE->getType())); 191 192 if (!CType) { 193 // We have a scalar in braces. Just use the first element. 194 return Visit(ILE->getInit(0)); 195 } 196 197 if (const llvm::ArrayType *AType = dyn_cast<llvm::ArrayType>(CType)) 198 return EmitArrayInitialization(ILE, AType); 199 200 if (const llvm::StructType *SType = dyn_cast<llvm::StructType>(CType)) 201 return EmitStructInitialization(ILE, SType); 202 203 if (const llvm::VectorType *VType = dyn_cast<llvm::VectorType>(CType)) 204 return EmitVectorInitialization(ILE, VType); 205 206 // Make sure we have an array at this point 207 assert(0 && "Unable to handle InitListExpr"); 208 // Get rid of control reaches end of void function warning. 209 // Not reached. 210 return 0; 211 } 212 213 llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) { 214 Expr* SExpr = ICExpr->getSubExpr(); 215 QualType SType = SExpr->getType(); 216 llvm::Constant *C; // the intermediate expression 217 QualType T; // the type of the intermediate expression 218 if (SType->isArrayType()) { 219 // Arrays decay to a pointer to the first element 220 // VLAs would require special handling, but they can't occur here 221 C = EmitLValue(SExpr); 222 llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 223 llvm::Constant *Ops[] = {Idx0, Idx0}; 224 C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 225 226 QualType ElemType = SType->getAsArrayType()->getElementType(); 227 T = CGM.getContext().getPointerType(ElemType); 228 } else if (SType->isFunctionType()) { 229 // Function types decay to a pointer to the function 230 C = EmitLValue(SExpr); 231 T = CGM.getContext().getPointerType(SType); 232 } else { 233 C = Visit(SExpr); 234 T = SType; 235 } 236 237 // Perform the conversion; note that an implicit cast can both promote 238 // and convert an array/function 239 return EmitConversion(C, T, ICExpr->getType()); 240 } 241 242 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 243 const char *StrData = E->getStrData(); 244 unsigned Len = E->getByteLength(); 245 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 246 247 // Otherwise this must be a string initializing an array in a static 248 // initializer. Don't emit it as the address of the string, emit the string 249 // data itself as an inline array. 250 const ConstantArrayType *CAT = E->getType()->getAsConstantArrayType(); 251 assert(CAT && "String isn't pointer or array!"); 252 253 std::string Str(StrData, StrData + Len); 254 // Null terminate the string before potentially truncating it. 255 // FIXME: What about wchar_t strings? 256 Str.push_back(0); 257 258 uint64_t RealLen = CAT->getSize().getZExtValue(); 259 // String or grow the initializer to the required size. 260 if (RealLen != Str.size()) 261 Str.resize(RealLen); 262 263 return llvm::ConstantArray::get(Str, false); 264 } 265 266 llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) { 267 const ValueDecl *Decl = E->getDecl(); 268 if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl)) 269 return llvm::ConstantInt::get(EC->getInitVal()); 270 assert(0 && "Unsupported decl ref type!"); 271 return 0; 272 } 273 274 llvm::Constant *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) { 275 return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf()); 276 } 277 278 // Unary operators 279 llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) { 280 return Visit(E->getSubExpr()); 281 } 282 llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) { 283 return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr())); 284 } 285 llvm::Constant *VisitUnaryNot(const UnaryOperator *E) { 286 return llvm::ConstantExpr::getNot(Visit(E->getSubExpr())); 287 } 288 llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) { 289 llvm::Constant *SubExpr = Visit(E->getSubExpr()); 290 291 if (E->getSubExpr()->getType()->isRealFloatingType()) { 292 // Compare against 0.0 for fp scalars. 293 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 294 SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr, 295 Zero); 296 } else { 297 assert((E->getSubExpr()->getType()->isIntegerType() || 298 E->getSubExpr()->getType()->isPointerType()) && 299 "Unknown scalar type to convert"); 300 // Compare against an integer or pointer null. 301 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 302 SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr, 303 Zero); 304 } 305 306 return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType())); 307 } 308 llvm::Constant *VisitUnarySizeOf(const UnaryOperator *E) { 309 return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true); 310 } 311 llvm::Constant *VisitUnaryAlignOf(const UnaryOperator *E) { 312 return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false); 313 } 314 llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) { 315 return EmitLValue(E->getSubExpr()); 316 } 317 llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) { 318 int64_t Val = E->evaluateOffsetOf(CGM.getContext()); 319 320 assert(E->getType()->isIntegerType() && "Result type must be an integer!"); 321 322 uint32_t ResultWidth = 323 static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType())); 324 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 325 } 326 327 // Binary operators 328 llvm::Constant *VisitBinOr(const BinaryOperator *E) { 329 llvm::Constant *LHS = Visit(E->getLHS()); 330 llvm::Constant *RHS = Visit(E->getRHS()); 331 332 return llvm::ConstantExpr::getOr(LHS, RHS); 333 } 334 llvm::Constant *VisitBinSub(const BinaryOperator *E) { 335 llvm::Constant *LHS = Visit(E->getLHS()); 336 llvm::Constant *RHS = Visit(E->getRHS()); 337 338 if (!isa<llvm::PointerType>(RHS->getType())) { 339 // pointer - int 340 if (isa<llvm::PointerType>(LHS->getType())) { 341 llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS); 342 343 return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1); 344 } 345 346 // int - int 347 return llvm::ConstantExpr::getSub(LHS, RHS); 348 } 349 350 assert(0 && "Unhandled bin sub case!"); 351 return 0; 352 } 353 354 llvm::Constant *VisitBinShl(const BinaryOperator *E) { 355 llvm::Constant *LHS = Visit(E->getLHS()); 356 llvm::Constant *RHS = Visit(E->getRHS()); 357 358 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 359 // RHS to the same size as the LHS. 360 if (LHS->getType() != RHS->getType()) 361 RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false); 362 363 return llvm::ConstantExpr::getShl(LHS, RHS); 364 } 365 366 llvm::Constant *VisitBinMul(const BinaryOperator *E) { 367 llvm::Constant *LHS = Visit(E->getLHS()); 368 llvm::Constant *RHS = Visit(E->getRHS()); 369 370 return llvm::ConstantExpr::getMul(LHS, RHS); 371 } 372 373 llvm::Constant *VisitBinDiv(const BinaryOperator *E) { 374 llvm::Constant *LHS = Visit(E->getLHS()); 375 llvm::Constant *RHS = Visit(E->getRHS()); 376 377 if (LHS->getType()->isFPOrFPVector()) 378 return llvm::ConstantExpr::getFDiv(LHS, RHS); 379 else if (E->getType()->isUnsignedIntegerType()) 380 return llvm::ConstantExpr::getUDiv(LHS, RHS); 381 else 382 return llvm::ConstantExpr::getSDiv(LHS, RHS); 383 } 384 385 llvm::Constant *VisitBinAdd(const BinaryOperator *E) { 386 llvm::Constant *LHS = Visit(E->getLHS()); 387 llvm::Constant *RHS = Visit(E->getRHS()); 388 389 if (!E->getType()->isPointerType()) 390 return llvm::ConstantExpr::getAdd(LHS, RHS); 391 392 llvm::Constant *Ptr, *Idx; 393 if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int 394 Ptr = LHS; 395 Idx = RHS; 396 } else { // int + pointer 397 Ptr = RHS; 398 Idx = LHS; 399 } 400 401 return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1); 402 } 403 404 llvm::Constant *VisitBinAnd(const BinaryOperator *E) { 405 llvm::Constant *LHS = Visit(E->getLHS()); 406 llvm::Constant *RHS = Visit(E->getRHS()); 407 408 return llvm::ConstantExpr::getAnd(LHS, RHS); 409 } 410 411 // Utility methods 412 const llvm::Type *ConvertType(QualType T) { 413 return CGM.getTypes().ConvertType(T); 414 } 415 416 llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) { 417 assert(SrcType->isCanonical() && "EmitConversion strips typedefs"); 418 419 if (SrcType->isRealFloatingType()) { 420 // Compare against 0.0 for fp scalars. 421 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 422 return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero); 423 } 424 425 assert((SrcType->isIntegerType() || SrcType->isPointerType()) && 426 "Unknown scalar type to convert"); 427 428 // Compare against an integer or pointer null. 429 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 430 return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero); 431 } 432 433 llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType, 434 QualType DstType) { 435 SrcType = SrcType.getCanonicalType(); 436 DstType = DstType.getCanonicalType(); 437 if (SrcType == DstType) return Src; 438 439 // Handle conversions to bool first, they are special: comparisons against 0. 440 if (DstType->isBooleanType()) 441 return EmitConversionToBool(Src, SrcType); 442 443 const llvm::Type *DstTy = ConvertType(DstType); 444 445 // Ignore conversions like int -> uint. 446 if (Src->getType() == DstTy) 447 return Src; 448 449 // Handle pointer conversions next: pointers can only be converted to/from 450 // other pointers and integers. 451 if (isa<PointerType>(DstType)) { 452 // The source value may be an integer, or a pointer. 453 if (isa<llvm::PointerType>(Src->getType())) 454 return llvm::ConstantExpr::getBitCast(Src, DstTy); 455 assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?"); 456 return llvm::ConstantExpr::getIntToPtr(Src, DstTy); 457 } 458 459 if (isa<PointerType>(SrcType)) { 460 // Must be an ptr to int cast. 461 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 462 return llvm::ConstantExpr::getPtrToInt(Src, DstTy); 463 } 464 465 // A scalar source can be splatted to a vector of the same element type 466 if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) { 467 const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy); 468 assert((VT->getElementType() == Src->getType()) && 469 "Vector element type must match scalar type to splat."); 470 unsigned NumElements = DstType->getAsVectorType()->getNumElements(); 471 llvm::SmallVector<llvm::Constant*, 16> Elements; 472 for (unsigned i = 0; i < NumElements; i++) 473 Elements.push_back(Src); 474 475 return llvm::ConstantVector::get(&Elements[0], NumElements); 476 } 477 478 if (isa<llvm::VectorType>(Src->getType()) || 479 isa<llvm::VectorType>(DstTy)) { 480 return llvm::ConstantExpr::getBitCast(Src, DstTy); 481 } 482 483 // Finally, we have the arithmetic types: real int/float. 484 if (isa<llvm::IntegerType>(Src->getType())) { 485 bool InputSigned = SrcType->isSignedIntegerType(); 486 if (isa<llvm::IntegerType>(DstTy)) 487 return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned); 488 else if (InputSigned) 489 return llvm::ConstantExpr::getSIToFP(Src, DstTy); 490 else 491 return llvm::ConstantExpr::getUIToFP(Src, DstTy); 492 } 493 494 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 495 if (isa<llvm::IntegerType>(DstTy)) { 496 if (DstType->isSignedIntegerType()) 497 return llvm::ConstantExpr::getFPToSI(Src, DstTy); 498 else 499 return llvm::ConstantExpr::getFPToUI(Src, DstTy); 500 } 501 502 assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 503 if (DstTy->getTypeID() < Src->getType()->getTypeID()) 504 return llvm::ConstantExpr::getFPTrunc(Src, DstTy); 505 else 506 return llvm::ConstantExpr::getFPExtend(Src, DstTy); 507 } 508 509 llvm::Constant *EmitSizeAlignOf(QualType TypeToSize, 510 QualType RetType, bool isSizeOf) { 511 std::pair<uint64_t, unsigned> Info = 512 CGM.getContext().getTypeInfo(TypeToSize); 513 514 uint64_t Val = isSizeOf ? Info.first : Info.second; 515 Val /= 8; // Return size in bytes, not bits. 516 517 assert(RetType->isIntegerType() && "Result type must be an integer!"); 518 519 uint32_t ResultWidth = 520 static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType)); 521 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 522 } 523 524 llvm::Constant *EmitLValue(Expr *E) { 525 switch (E->getStmtClass()) { 526 default: break; 527 case Expr::ParenExprClass: 528 // Elide parenthesis 529 return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 530 case Expr::CompoundLiteralExprClass: { 531 // Note that due to the nature of compound literals, this is guaranteed 532 // to be the only use of the variable, so we just generate it here. 533 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 534 llvm::Constant* C = Visit(CLE->getInitializer()); 535 C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(), 536 llvm::GlobalValue::InternalLinkage, 537 C, ".compoundliteral", &CGM.getModule()); 538 return C; 539 } 540 case Expr::DeclRefExprClass: { 541 ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 542 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 543 return CGM.GetAddrOfFunctionDecl(FD, false); 544 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 545 if (VD->isFileVarDecl()) 546 return CGM.GetAddrOfGlobalVar(VD, false); 547 else if (VD->isBlockVarDecl()) { 548 assert(CGF && "Can't access static local vars without CGF"); 549 return CGF->GetAddrOfStaticLocalVar(VD); 550 } 551 } 552 break; 553 } 554 case Expr::MemberExprClass: { 555 MemberExpr* ME = cast<MemberExpr>(E); 556 llvm::Constant *Base; 557 if (ME->isArrow()) 558 Base = Visit(ME->getBase()); 559 else 560 Base = EmitLValue(ME->getBase()); 561 562 unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl()); 563 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 564 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 565 FieldNumber); 566 llvm::Value *Ops[] = {Zero, Idx}; 567 return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2); 568 } 569 case Expr::ArraySubscriptExprClass: { 570 ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E); 571 llvm::Constant *Base = Visit(ASExpr->getBase()); 572 llvm::Constant *Index = Visit(ASExpr->getIdx()); 573 assert(!ASExpr->getBase()->getType()->isVectorType() && 574 "Taking the address of a vector component is illegal!"); 575 return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1); 576 } 577 case Expr::StringLiteralClass: { 578 StringLiteral *String = cast<StringLiteral>(E); 579 assert(!String->isWide() && "Cannot codegen wide strings yet"); 580 const char *StrData = String->getStrData(); 581 unsigned Len = String->getByteLength(); 582 583 return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len)); 584 } 585 case Expr::UnaryOperatorClass: { 586 UnaryOperator *Exp = cast<UnaryOperator>(E); 587 switch (Exp->getOpcode()) { 588 default: break; 589 case UnaryOperator::Extension: 590 // Extension is just a wrapper for expressions 591 return EmitLValue(Exp->getSubExpr()); 592 case UnaryOperator::Real: 593 case UnaryOperator::Imag: { 594 // The address of __real or __imag is just a GEP off the address 595 // of the internal expression 596 llvm::Constant* C = EmitLValue(Exp->getSubExpr()); 597 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 598 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 599 Exp->getOpcode() == UnaryOperator::Imag); 600 llvm::Value *Ops[] = {Zero, Idx}; 601 return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 602 } 603 case UnaryOperator::Deref: 604 // The address of a deref is just the value of the expression 605 return Visit(Exp->getSubExpr()); 606 } 607 break; 608 } 609 } 610 CGM.WarnUnsupported(E, "constant l-value expression"); 611 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 612 return llvm::UndefValue::get(Ty); 613 } 614 615}; 616 617} // end anonymous namespace. 618 619 620llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 621 CodeGenFunction *CGF) 622{ 623 QualType type = E->getType().getCanonicalType(); 624 625 if (type->isIntegerType()) { 626 llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type))); 627 if (E->isIntegerConstantExpr(Value, Context)) { 628 return llvm::ConstantInt::get(Value); 629 } 630 } 631 632 return ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 633} 634