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