CGExprConstant.cpp revision b83d287bc7f47d36fb0751a481e2ef9308b37252
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 "CGObjCRuntime.h" 17#include "clang/AST/APValue.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/StmtVisitor.h" 20#include "llvm/Constants.h" 21#include "llvm/Function.h" 22#include "llvm/GlobalVariable.h" 23#include "llvm/Support/Compiler.h" 24#include "llvm/Target/TargetData.h" 25using namespace clang; 26using namespace CodeGen; 27 28namespace { 29class VISIBILITY_HIDDEN ConstExprEmitter : 30 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 31 CodeGenModule &CGM; 32 CodeGenFunction *CGF; 33public: 34 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 35 : CGM(cgm), CGF(cgf) { 36 } 37 38 //===--------------------------------------------------------------------===// 39 // Visitor Methods 40 //===--------------------------------------------------------------------===// 41 42 llvm::Constant *VisitStmt(Stmt *S) { 43 CGM.ErrorUnsupported(S, "constant expression"); 44 QualType T = cast<Expr>(S)->getType(); 45 return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); 46 } 47 48 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 49 return Visit(PE->getSubExpr()); 50 } 51 52 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 53 return Visit(E->getInitializer()); 54 } 55 56 llvm::Constant *VisitCastExpr(CastExpr* E) { 57 // GCC cast to union extension 58 if (E->getType()->isUnionType()) { 59 const llvm::Type *Ty = ConvertType(E->getType()); 60 return EmitUnion(CGM.EmitConstantExpr(E->getSubExpr(), CGF), Ty); 61 } 62 63 llvm::Constant *C = Visit(E->getSubExpr()); 64 return EmitConversion(C, E->getSubExpr()->getType(), E->getType()); 65 } 66 67 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 68 return Visit(DAE->getExpr()); 69 } 70 71 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 72 std::vector<llvm::Constant*> Elts; 73 const llvm::ArrayType *AType = 74 cast<llvm::ArrayType>(ConvertType(ILE->getType())); 75 unsigned NumInitElements = ILE->getNumInits(); 76 // FIXME: Check for wide strings 77 if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) && 78 ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 79 return Visit(ILE->getInit(0)); 80 const llvm::Type *ElemTy = AType->getElementType(); 81 unsigned NumElements = AType->getNumElements(); 82 83 // Initialising an array requires us to automatically 84 // initialise any elements that have not been initialised explicitly 85 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 86 87 // Copy initializer elements. 88 unsigned i = 0; 89 bool RewriteType = false; 90 for (; i < NumInitableElts; ++i) { 91 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF); 92 if (!C) 93 return 0; 94 RewriteType |= (C->getType() != ElemTy); 95 Elts.push_back(C); 96 } 97 98 // Initialize remaining array elements. 99 for (; i < NumElements; ++i) 100 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 101 102 if (RewriteType) { 103 // FIXME: Try to avoid packing the array 104 std::vector<const llvm::Type*> Types; 105 for (unsigned i = 0; i < Elts.size(); ++i) 106 Types.push_back(Elts[i]->getType()); 107 const llvm::StructType *SType = llvm::StructType::get(Types, true); 108 return llvm::ConstantStruct::get(SType, Elts); 109 } 110 111 return llvm::ConstantArray::get(AType, Elts); 112 } 113 114 void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts, 115 FieldDecl* Field, Expr* E) { 116 // Calculate the value to insert 117 llvm::Constant *C = CGM.EmitConstantExpr(E, CGF); 118 if (!C) 119 return; 120 121 llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C); 122 if (!CI) { 123 CGM.ErrorUnsupported(E, "bitfield initialization"); 124 return; 125 } 126 llvm::APInt V = CI->getValue(); 127 128 // Calculate information about the relevant field 129 const llvm::Type* Ty = CI->getType(); 130 const llvm::TargetData &TD = CGM.getTypes().getTargetData(); 131 unsigned size = TD.getTypePaddedSizeInBits(Ty); 132 unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size; 133 CodeGenTypes::BitFieldInfo bitFieldInfo = 134 CGM.getTypes().getBitFieldInfo(Field); 135 fieldOffset += bitFieldInfo.Begin; 136 137 // Find where to start the insertion 138 // FIXME: This is O(n^2) in the number of bit-fields! 139 // FIXME: This won't work if the struct isn't completely packed! 140 unsigned offset = 0, i = 0; 141 while (offset < (fieldOffset & -8)) 142 offset += TD.getTypePaddedSizeInBits(Elts[i++]->getType()); 143 144 // Advance over 0 sized elements (must terminate in bounds since 145 // the bitfield must have a size). 146 while (TD.getTypePaddedSizeInBits(Elts[i]->getType()) == 0) 147 ++i; 148 149 // Promote the size of V if necessary 150 // FIXME: This should never occur, but currently it can because 151 // initializer constants are cast to bool, and because clang is 152 // not enforcing bitfield width limits. 153 if (bitFieldInfo.Size > V.getBitWidth()) 154 V.zext(bitFieldInfo.Size); 155 156 // Insert the bits into the struct 157 // FIXME: This algorthm is only correct on X86! 158 // FIXME: THis algorthm assumes bit-fields only have byte-size elements! 159 unsigned bitsToInsert = bitFieldInfo.Size; 160 unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert); 161 unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7); 162 do { 163 llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte); 164 Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC); 165 ++i; 166 V = V.lshr(curBits); 167 bitsToInsert -= curBits; 168 169 if (!bitsToInsert) 170 break; 171 172 curBits = bitsToInsert > 8 ? 8 : bitsToInsert; 173 byte = V.getLoBits(curBits).getZExtValue(); 174 } while (true); 175 } 176 177 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 178 const llvm::StructType *SType = 179 cast<llvm::StructType>(ConvertType(ILE->getType())); 180 RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 181 std::vector<llvm::Constant*> Elts; 182 183 // Initialize the whole structure to zero. 184 for (unsigned i = 0; i < SType->getNumElements(); ++i) { 185 const llvm::Type *FieldTy = SType->getElementType(i); 186 Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 187 } 188 189 // Copy initializer elements. Skip padding fields. 190 unsigned EltNo = 0; // Element no in ILE 191 int FieldNo = 0; // Field no in RecordDecl 192 bool RewriteType = false; 193 for (RecordDecl::field_iterator Field = RD->field_begin(), 194 FieldEnd = RD->field_end(); 195 EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) { 196 FieldNo++; 197 if (!Field->getIdentifier()) 198 continue; 199 200 if (Field->isBitField()) { 201 InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo)); 202 } else { 203 unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field); 204 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF); 205 if (!C) return 0; 206 RewriteType |= (C->getType() != Elts[FieldNo]->getType()); 207 Elts[FieldNo] = C; 208 } 209 EltNo++; 210 } 211 212 if (RewriteType) { 213 // FIXME: Make this work for non-packed structs 214 assert(SType->isPacked() && "Cannot recreate unpacked structs"); 215 std::vector<const llvm::Type*> Types; 216 for (unsigned i = 0; i < Elts.size(); ++i) 217 Types.push_back(Elts[i]->getType()); 218 SType = llvm::StructType::get(Types, true); 219 } 220 221 return llvm::ConstantStruct::get(SType, Elts); 222 } 223 224 llvm::Constant *EmitUnion(llvm::Constant *C, const llvm::Type *Ty) { 225 if (!C) 226 return 0; 227 228 // Build a struct with the union sub-element as the first member, 229 // and padded to the appropriate size 230 std::vector<llvm::Constant*> Elts; 231 std::vector<const llvm::Type*> Types; 232 Elts.push_back(C); 233 Types.push_back(C->getType()); 234 unsigned CurSize = CGM.getTargetData().getTypePaddedSize(C->getType()); 235 unsigned TotalSize = CGM.getTargetData().getTypePaddedSize(Ty); 236 while (CurSize < TotalSize) { 237 Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty)); 238 Types.push_back(llvm::Type::Int8Ty); 239 CurSize++; 240 } 241 242 // This always generates a packed struct 243 // FIXME: Try to generate an unpacked struct when we can 244 llvm::StructType* STy = llvm::StructType::get(Types, true); 245 return llvm::ConstantStruct::get(STy, Elts); 246 } 247 248 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 249 const llvm::Type *Ty = ConvertType(ILE->getType()); 250 251 // If this is an empty initializer list, we value-initialize the 252 // union. 253 if (ILE->getNumInits() == 0) 254 return llvm::Constant::getNullValue(Ty); 255 256 FieldDecl* curField = ILE->getInitializedFieldInUnion(); 257 if (!curField) { 258 // There's no field to initialize, so value-initialize the union. 259#ifndef NDEBUG 260 // Make sure that it's really an empty and not a failure of 261 // semantic analysis. 262 RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 263 for (RecordDecl::field_iterator Field = RD->field_begin(), 264 FieldEnd = RD->field_end(); 265 Field != FieldEnd; ++Field) 266 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed"); 267#endif 268 return llvm::Constant::getNullValue(Ty); 269 } 270 271 if (curField->isBitField()) { 272 // Create a dummy struct for bit-field insertion 273 unsigned NumElts = CGM.getTargetData().getTypePaddedSize(Ty) / 8; 274 llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty); 275 std::vector<llvm::Constant*> Elts(NumElts, NV); 276 277 InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0)); 278 const llvm::ArrayType *RetTy = 279 llvm::ArrayType::get(NV->getType(), NumElts); 280 return llvm::ConstantArray::get(RetTy, Elts); 281 } 282 283 return EmitUnion(CGM.EmitConstantExpr(ILE->getInit(0), CGF), Ty); 284 } 285 286 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 287 const llvm::VectorType *VType = 288 cast<llvm::VectorType>(ConvertType(ILE->getType())); 289 const llvm::Type *ElemTy = VType->getElementType(); 290 std::vector<llvm::Constant*> Elts; 291 unsigned NumElements = VType->getNumElements(); 292 unsigned NumInitElements = ILE->getNumInits(); 293 294 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 295 296 // Copy initializer elements. 297 unsigned i = 0; 298 for (; i < NumInitableElts; ++i) { 299 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF); 300 if (!C) 301 return 0; 302 Elts.push_back(C); 303 } 304 305 for (; i < NumElements; ++i) 306 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 307 308 return llvm::ConstantVector::get(VType, Elts); 309 } 310 311 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 312 const llvm::Type* RetTy = CGM.getTypes().ConvertType(E->getType()); 313 return llvm::Constant::getNullValue(RetTy); 314 } 315 316 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 317 if (ILE->getType()->isScalarType()) { 318 // We have a scalar in braces. Just use the first element. 319 if (ILE->getNumInits() > 0) 320 return CGM.EmitConstantExpr(ILE->getInit(0), CGF); 321 322 const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType()); 323 return llvm::Constant::getNullValue(RetTy); 324 } 325 326 if (ILE->getType()->isArrayType()) 327 return EmitArrayInitialization(ILE); 328 329 if (ILE->getType()->isStructureType()) 330 return EmitStructInitialization(ILE); 331 332 if (ILE->getType()->isUnionType()) 333 return EmitUnionInitialization(ILE); 334 335 if (ILE->getType()->isVectorType()) 336 return EmitVectorInitialization(ILE); 337 338 assert(0 && "Unable to handle InitListExpr"); 339 // Get rid of control reaches end of void function warning. 340 // Not reached. 341 return 0; 342 } 343 344 llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) { 345 Expr* SExpr = ICExpr->getSubExpr(); 346 QualType SType = SExpr->getType(); 347 llvm::Constant *C; // the intermediate expression 348 QualType T; // the type of the intermediate expression 349 if (SType->isArrayType()) { 350 // Arrays decay to a pointer to the first element 351 // VLAs would require special handling, but they can't occur here 352 C = EmitLValue(SExpr); 353 llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 354 llvm::Constant *Ops[] = {Idx0, Idx0}; 355 C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 356 T = CGM.getContext().getArrayDecayedType(SType); 357 } else if (SType->isFunctionType()) { 358 // Function types decay to a pointer to the function 359 C = EmitLValue(SExpr); 360 T = CGM.getContext().getPointerType(SType); 361 } else { 362 C = Visit(SExpr); 363 T = SType; 364 } 365 366 // Perform the conversion; note that an implicit cast can both promote 367 // and convert an array/function 368 return EmitConversion(C, T, ICExpr->getType()); 369 } 370 371 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 372 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 373 374 // Otherwise this must be a string initializing an array in a static 375 // initializer. Don't emit it as the address of the string, emit the string 376 // data itself as an inline array. 377 return llvm::ConstantArray::get(CGM.GetStringForStringLiteral(E), false); 378 } 379 380 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 381 return Visit(E->getSubExpr()); 382 } 383 384 llvm::Constant *VisitBlockExpr(const BlockExpr *E) { 385 assert (!E->hasBlockDeclRefExprs() && "global block with BlockDeclRefs"); 386 387 const char *Name = ""; 388 if (const NamedDecl *ND = dyn_cast<NamedDecl>(CGF->CurFuncDecl)) 389 Name = ND->getNameAsString().c_str(); 390 return CGM.GetAddrOfGlobalBlock(E, Name); 391 } 392 393 // Utility methods 394 const llvm::Type *ConvertType(QualType T) { 395 return CGM.getTypes().ConvertType(T); 396 } 397 398 llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) { 399 assert(SrcType->isCanonical() && "EmitConversion strips typedefs"); 400 401 if (SrcType->isRealFloatingType()) { 402 // Compare against 0.0 for fp scalars. 403 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 404 return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero); 405 } 406 407 assert((SrcType->isIntegerType() || SrcType->isPointerType()) && 408 "Unknown scalar type to convert"); 409 410 // Compare against an integer or pointer null. 411 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 412 return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero); 413 } 414 415 llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType, 416 QualType DstType) { 417 if (!Src) 418 return 0; 419 420 SrcType = CGM.getContext().getCanonicalType(SrcType); 421 DstType = CGM.getContext().getCanonicalType(DstType); 422 if (SrcType == DstType) return Src; 423 424 // Handle conversions to bool first, they are special: comparisons against 0. 425 if (DstType->isBooleanType()) 426 return EmitConversionToBool(Src, SrcType); 427 428 const llvm::Type *DstTy = ConvertType(DstType); 429 430 // Ignore conversions like int -> uint. 431 if (Src->getType() == DstTy) 432 return Src; 433 434 // Handle pointer conversions next: pointers can only be converted to/from 435 // other pointers and integers. 436 if (isa<llvm::PointerType>(DstTy)) { 437 // The source value may be an integer, or a pointer. 438 if (isa<llvm::PointerType>(Src->getType())) 439 return llvm::ConstantExpr::getBitCast(Src, DstTy); 440 assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?"); 441 return llvm::ConstantExpr::getIntToPtr(Src, DstTy); 442 } 443 444 if (isa<llvm::PointerType>(Src->getType())) { 445 // Must be an ptr to int cast. 446 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 447 return llvm::ConstantExpr::getPtrToInt(Src, DstTy); 448 } 449 450 // A scalar source can be splatted to a vector of the same element type 451 if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) { 452 assert((cast<llvm::VectorType>(DstTy)->getElementType() 453 == Src->getType()) && 454 "Vector element type must match scalar type to splat."); 455 unsigned NumElements = DstType->getAsVectorType()->getNumElements(); 456 llvm::SmallVector<llvm::Constant*, 16> Elements; 457 for (unsigned i = 0; i < NumElements; i++) 458 Elements.push_back(Src); 459 460 return llvm::ConstantVector::get(&Elements[0], NumElements); 461 } 462 463 if (isa<llvm::VectorType>(Src->getType()) || 464 isa<llvm::VectorType>(DstTy)) { 465 return llvm::ConstantExpr::getBitCast(Src, DstTy); 466 } 467 468 // Finally, we have the arithmetic types: real int/float. 469 if (isa<llvm::IntegerType>(Src->getType())) { 470 bool InputSigned = SrcType->isSignedIntegerType(); 471 if (isa<llvm::IntegerType>(DstTy)) 472 return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned); 473 else if (InputSigned) 474 return llvm::ConstantExpr::getSIToFP(Src, DstTy); 475 else 476 return llvm::ConstantExpr::getUIToFP(Src, DstTy); 477 } 478 479 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 480 if (isa<llvm::IntegerType>(DstTy)) { 481 if (DstType->isSignedIntegerType()) 482 return llvm::ConstantExpr::getFPToSI(Src, DstTy); 483 else 484 return llvm::ConstantExpr::getFPToUI(Src, DstTy); 485 } 486 487 assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 488 if (DstTy->getTypeID() < Src->getType()->getTypeID()) 489 return llvm::ConstantExpr::getFPTrunc(Src, DstTy); 490 else 491 return llvm::ConstantExpr::getFPExtend(Src, DstTy); 492 } 493 494public: 495 llvm::Constant *EmitLValue(Expr *E) { 496 switch (E->getStmtClass()) { 497 default: break; 498 case Expr::ParenExprClass: 499 // Elide parenthesis 500 return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 501 case Expr::CompoundLiteralExprClass: { 502 // Note that due to the nature of compound literals, this is guaranteed 503 // to be the only use of the variable, so we just generate it here. 504 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 505 llvm::Constant* C = Visit(CLE->getInitializer()); 506 // FIXME: "Leaked" on failure. 507 if (C) 508 C = new llvm::GlobalVariable(C->getType(), 509 E->getType().isConstQualified(), 510 llvm::GlobalValue::InternalLinkage, 511 C, ".compoundliteral", &CGM.getModule()); 512 return C; 513 } 514 case Expr::DeclRefExprClass: 515 case Expr::QualifiedDeclRefExprClass: { 516 NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 517 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 518 return CGM.GetAddrOfFunction(FD); 519 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 520 if (VD->isFileVarDecl()) 521 return CGM.GetAddrOfGlobalVar(VD); 522 else if (VD->isBlockVarDecl()) { 523 assert(CGF && "Can't access static local vars without CGF"); 524 return CGF->GetAddrOfStaticLocalVar(VD); 525 } 526 } 527 break; 528 } 529 case Expr::MemberExprClass: { 530 MemberExpr* ME = cast<MemberExpr>(E); 531 llvm::Constant *Base; 532 if (ME->isArrow()) 533 Base = Visit(ME->getBase()); 534 else 535 Base = EmitLValue(ME->getBase()); 536 if (!Base) 537 return 0; 538 539 FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl()); 540 // FIXME: Handle other kinds of member expressions. 541 assert(Field && "No code generation for non-field member expressions"); 542 unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(Field); 543 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 544 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 545 FieldNumber); 546 llvm::Value *Ops[] = {Zero, Idx}; 547 return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2); 548 } 549 case Expr::ArraySubscriptExprClass: { 550 ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E); 551 assert(!ASExpr->getBase()->getType()->isVectorType() && 552 "Taking the address of a vector component is illegal!"); 553 554 llvm::Constant *Base = Visit(ASExpr->getBase()); 555 llvm::Constant *Index = Visit(ASExpr->getIdx()); 556 if (!Base || !Index) 557 return 0; 558 return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1); 559 } 560 case Expr::StringLiteralClass: 561 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 562 case Expr::ObjCStringLiteralClass: { 563 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 564 std::string S(SL->getString()->getStrData(), 565 SL->getString()->getByteLength()); 566 llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S); 567 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 568 } 569 case Expr::UnaryOperatorClass: { 570 UnaryOperator *Exp = cast<UnaryOperator>(E); 571 switch (Exp->getOpcode()) { 572 default: break; 573 case UnaryOperator::Extension: 574 // Extension is just a wrapper for expressions 575 return EmitLValue(Exp->getSubExpr()); 576 case UnaryOperator::Real: 577 case UnaryOperator::Imag: { 578 // The address of __real or __imag is just a GEP off the address 579 // of the internal expression 580 llvm::Constant* C = EmitLValue(Exp->getSubExpr()); 581 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 582 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 583 Exp->getOpcode() == UnaryOperator::Imag); 584 llvm::Value *Ops[] = {Zero, Idx}; 585 return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 586 } 587 case UnaryOperator::Deref: 588 // The address of a deref is just the value of the expression 589 return Visit(Exp->getSubExpr()); 590 } 591 break; 592 } 593 594 case Expr::PredefinedExprClass: { 595 // __func__/__FUNCTION__ -> "". __PRETTY_FUNCTION__ -> "top level". 596 std::string Str; 597 if (cast<PredefinedExpr>(E)->getIdentType() == 598 PredefinedExpr::PrettyFunction) 599 Str = "top level"; 600 601 return CGM.GetAddrOfConstantCString(Str, ".tmp"); 602 } 603 case Expr::AddrLabelExprClass: { 604 assert(CGF && "Invalid address of label expression outside function."); 605 unsigned id = CGF->GetIDForAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 606 llvm::Constant *C = llvm::ConstantInt::get(llvm::Type::Int32Ty, id); 607 return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType())); 608 } 609 case Expr::CallExprClass: { 610 CallExpr* CE = cast<CallExpr>(E); 611 if (CE->isBuiltinCall(CGM.getContext()) != 612 Builtin::BI__builtin___CFStringMakeConstantString) 613 break; 614 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 615 const StringLiteral *Literal = cast<StringLiteral>(Arg); 616 std::string S(Literal->getStrData(), Literal->getByteLength()); 617 return CGM.GetAddrOfConstantCFString(S); 618 } 619 case Expr::BlockExprClass: { 620 BlockExpr *B = cast<BlockExpr>(E); 621 if (!B->hasBlockDeclRefExprs()) 622 return CGF->BuildBlockLiteralTmp(B); 623 } 624 } 625 626 return 0; 627 } 628}; 629 630} // end anonymous namespace. 631 632llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 633 CodeGenFunction *CGF) { 634 Expr::EvalResult Result; 635 636 if (E->Evaluate(Result, Context)) { 637 assert(!Result.HasSideEffects && 638 "Constant expr should not have any side effects!"); 639 switch (Result.Val.getKind()) { 640 case APValue::Uninitialized: 641 assert(0 && "Constant expressions should be initialized."); 642 return 0; 643 case APValue::LValue: { 644 const llvm::Type *DestType = getTypes().ConvertTypeForMem(E->getType()); 645 llvm::Constant *Offset = 646 llvm::ConstantInt::get(llvm::Type::Int64Ty, 647 Result.Val.getLValueOffset()); 648 649 llvm::Constant *C; 650 if (const Expr *LVBase = Result.Val.getLValueBase()) { 651 C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 652 653 // Apply offset if necessary. 654 if (!Offset->isNullValue()) { 655 const llvm::Type *Type = 656 llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 657 llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type); 658 Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1); 659 C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 660 } 661 662 // Convert to the appropriate type; this could be an lvalue for 663 // an integer. 664 if (isa<llvm::PointerType>(DestType)) 665 return llvm::ConstantExpr::getBitCast(C, DestType); 666 667 return llvm::ConstantExpr::getPtrToInt(C, DestType); 668 } else { 669 C = Offset; 670 671 // Convert to the appropriate type; this could be an lvalue for 672 // an integer. 673 if (isa<llvm::PointerType>(DestType)) 674 return llvm::ConstantExpr::getIntToPtr(C, DestType); 675 676 // If the types don't match this should only be a truncate. 677 if (C->getType() != DestType) 678 return llvm::ConstantExpr::getTrunc(C, DestType); 679 680 return C; 681 } 682 } 683 case APValue::Int: { 684 llvm::Constant *C = llvm::ConstantInt::get(Result.Val.getInt()); 685 686 if (C->getType() == llvm::Type::Int1Ty) { 687 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 688 C = llvm::ConstantExpr::getZExt(C, BoolTy); 689 } 690 return C; 691 } 692 case APValue::ComplexInt: { 693 llvm::Constant *Complex[2]; 694 695 Complex[0] = llvm::ConstantInt::get(Result.Val.getComplexIntReal()); 696 Complex[1] = llvm::ConstantInt::get(Result.Val.getComplexIntImag()); 697 698 return llvm::ConstantStruct::get(Complex, 2); 699 } 700 case APValue::Float: 701 return llvm::ConstantFP::get(Result.Val.getFloat()); 702 case APValue::ComplexFloat: { 703 llvm::Constant *Complex[2]; 704 705 Complex[0] = llvm::ConstantFP::get(Result.Val.getComplexFloatReal()); 706 Complex[1] = llvm::ConstantFP::get(Result.Val.getComplexFloatImag()); 707 708 return llvm::ConstantStruct::get(Complex, 2); 709 } 710 case APValue::Vector: { 711 llvm::SmallVector<llvm::Constant *, 4> Inits; 712 unsigned NumElts = Result.Val.getVectorLength(); 713 714 for (unsigned i = 0; i != NumElts; ++i) { 715 APValue &Elt = Result.Val.getVectorElt(i); 716 if (Elt.isInt()) 717 Inits.push_back(llvm::ConstantInt::get(Elt.getInt())); 718 else 719 Inits.push_back(llvm::ConstantFP::get(Elt.getFloat())); 720 } 721 return llvm::ConstantVector::get(&Inits[0], Inits.size()); 722 } 723 } 724 } 725 726 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 727 if (C && C->getType() == llvm::Type::Int1Ty) { 728 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 729 C = llvm::ConstantExpr::getZExt(C, BoolTy); 730 } 731 return C; 732} 733