CGExprConstant.cpp revision 199482
10Sduke//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 2553Sohair// 30Sduke// The LLVM Compiler Infrastructure 40Sduke// 50Sduke// This file is distributed under the University of Illinois Open Source 60Sduke// License. See LICENSE.TXT for details. 70Sduke// 80Sduke//===----------------------------------------------------------------------===// 90Sduke// 100Sduke// This contains code to emit Constant Expr nodes as LLVM code. 110Sduke// 120Sduke//===----------------------------------------------------------------------===// 130Sduke 140Sduke#include "CodeGenFunction.h" 150Sduke#include "CodeGenModule.h" 160Sduke#include "CGObjCRuntime.h" 170Sduke#include "clang/AST/APValue.h" 180Sduke#include "clang/AST/ASTContext.h" 19553Sohair#include "clang/AST/RecordLayout.h" 20553Sohair#include "clang/AST/StmtVisitor.h" 21553Sohair#include "clang/Basic/Builtins.h" 220Sduke#include "llvm/Constants.h" 230Sduke#include "llvm/Function.h" 240Sduke#include "llvm/GlobalVariable.h" 250Sduke#include "llvm/Support/Compiler.h" 260Sduke#include "llvm/Target/TargetData.h" 270Sdukeusing namespace clang; 280Sdukeusing namespace CodeGen; 290Sduke 300Sdukenamespace { 310Sduke 320Sdukeclass VISIBILITY_HIDDEN ConstStructBuilder { 330Sduke CodeGenModule &CGM; 340Sduke CodeGenFunction *CGF; 350Sduke 360Sduke bool Packed; 370Sduke 380Sduke unsigned NextFieldOffsetInBytes; 390Sduke 400Sduke unsigned LLVMStructAlignment; 410Sduke 420Sduke std::vector<llvm::Constant *> Elements; 430Sduke 440Sduke ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) 450Sduke : CGM(CGM), CGF(CGF), Packed(false), NextFieldOffsetInBytes(0), 460Sduke LLVMStructAlignment(1) { } 470Sduke 480Sduke bool AppendField(const FieldDecl *Field, uint64_t FieldOffset, 490Sduke const Expr *InitExpr) { 500Sduke uint64_t FieldOffsetInBytes = FieldOffset / 8; 510Sduke 520Sduke assert(NextFieldOffsetInBytes <= FieldOffsetInBytes 530Sduke && "Field offset mismatch!"); 540Sduke 550Sduke // Emit the field. 560Sduke llvm::Constant *C = CGM.EmitConstantExpr(InitExpr, Field->getType(), CGF); 570Sduke if (!C) 580Sduke return false; 590Sduke 600Sduke unsigned FieldAlignment = getAlignment(C); 610Sduke 620Sduke // Round up the field offset to the alignment of the field type. 630Sduke uint64_t AlignedNextFieldOffsetInBytes = 640Sduke llvm::RoundUpToAlignment(NextFieldOffsetInBytes, FieldAlignment); 650Sduke 660Sduke if (AlignedNextFieldOffsetInBytes > FieldOffsetInBytes) { 670Sduke assert(!Packed && "Alignment is wrong even with a packed struct!"); 680Sduke 690Sduke // Convert the struct to a packed struct. 700Sduke ConvertStructToPacked(); 710Sduke 720Sduke AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes; 730Sduke } 740Sduke 750Sduke if (AlignedNextFieldOffsetInBytes < FieldOffsetInBytes) { 760Sduke // We need to append padding. 770Sduke AppendPadding(FieldOffsetInBytes - NextFieldOffsetInBytes); 780Sduke 790Sduke assert(NextFieldOffsetInBytes == FieldOffsetInBytes && 800Sduke "Did not add enough padding!"); 810Sduke 820Sduke AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes; 830Sduke } 840Sduke 850Sduke // Add the field. 860Sduke Elements.push_back(C); 870Sduke NextFieldOffsetInBytes = AlignedNextFieldOffsetInBytes + getSizeInBytes(C); 880Sduke 890Sduke if (Packed) 900Sduke assert(LLVMStructAlignment == 1 && "Packed struct not byte-aligned!"); 910Sduke else 920Sduke LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); 930Sduke 940Sduke return true; 950Sduke } 960Sduke 970Sduke bool AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, 980Sduke const Expr *InitExpr) { 990Sduke llvm::ConstantInt *CI = 1000Sduke cast_or_null<llvm::ConstantInt>(CGM.EmitConstantExpr(InitExpr, 1010Sduke Field->getType(), 1020Sduke CGF)); 1030Sduke // FIXME: Can this ever happen? 1040Sduke if (!CI) 1050Sduke return false; 1060Sduke 1070Sduke if (FieldOffset > NextFieldOffsetInBytes * 8) { 1080Sduke // We need to add padding. 1090Sduke uint64_t NumBytes = 1100Sduke llvm::RoundUpToAlignment(FieldOffset - 1110Sduke NextFieldOffsetInBytes * 8, 8) / 8; 1120Sduke 1130Sduke AppendPadding(NumBytes); 1140Sduke } 1150Sduke 1160Sduke uint64_t FieldSize = 1170Sduke Field->getBitWidth()->EvaluateAsInt(CGM.getContext()).getZExtValue(); 1180Sduke 1190Sduke llvm::APInt FieldValue = CI->getValue(); 1200Sduke 1210Sduke // Promote the size of FieldValue if necessary 1220Sduke // FIXME: This should never occur, but currently it can because initializer 1230Sduke // constants are cast to bool, and because clang is not enforcing bitfield 1240Sduke // width limits. 1250Sduke if (FieldSize > FieldValue.getBitWidth()) 1260Sduke FieldValue.zext(FieldSize); 1270Sduke 1280Sduke // Truncate the size of FieldValue to the bit field size. 1290Sduke if (FieldSize < FieldValue.getBitWidth()) 1300Sduke FieldValue.trunc(FieldSize); 1310Sduke 1320Sduke if (FieldOffset < NextFieldOffsetInBytes * 8) { 1330Sduke // Either part of the field or the entire field can go into the previous 1340Sduke // byte. 1350Sduke assert(!Elements.empty() && "Elements can't be empty!"); 1360Sduke 1370Sduke unsigned BitsInPreviousByte = 1380Sduke NextFieldOffsetInBytes * 8 - FieldOffset; 1390Sduke 1400Sduke bool FitsCompletelyInPreviousByte = 1410Sduke BitsInPreviousByte >= FieldValue.getBitWidth(); 1420Sduke 1430Sduke llvm::APInt Tmp = FieldValue; 1440Sduke 1450Sduke if (!FitsCompletelyInPreviousByte) { 1460Sduke unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; 1470Sduke 1480Sduke if (CGM.getTargetData().isBigEndian()) { 1490Sduke Tmp = Tmp.lshr(NewFieldWidth); 1500Sduke Tmp.trunc(BitsInPreviousByte); 1510Sduke 1520Sduke // We want the remaining high bits. 1530Sduke FieldValue.trunc(NewFieldWidth); 1540Sduke } else { 1550Sduke Tmp.trunc(BitsInPreviousByte); 1560Sduke 1570Sduke // We want the remaining low bits. 1580Sduke FieldValue = FieldValue.lshr(BitsInPreviousByte); 1590Sduke FieldValue.trunc(NewFieldWidth); 1600Sduke } 1610Sduke } 1620Sduke 1630Sduke Tmp.zext(8); 1640Sduke if (CGM.getTargetData().isBigEndian()) { 1650Sduke if (FitsCompletelyInPreviousByte) 1660Sduke Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); 1670Sduke } else { 1680Sduke Tmp = Tmp.shl(8 - BitsInPreviousByte); 1690Sduke } 1700Sduke 1710Sduke // Or in the bits that go into the previous byte. 1720Sduke Tmp |= cast<llvm::ConstantInt>(Elements.back())->getValue(); 1730Sduke Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); 1740Sduke 1750Sduke if (FitsCompletelyInPreviousByte) 1760Sduke return true; 1770Sduke } 1780Sduke 1790Sduke while (FieldValue.getBitWidth() > 8) { 1800Sduke llvm::APInt Tmp; 1810Sduke 1820Sduke if (CGM.getTargetData().isBigEndian()) { 1830Sduke // We want the high bits. 1840Sduke Tmp = FieldValue; 1850Sduke Tmp = Tmp.lshr(Tmp.getBitWidth() - 8); 1860Sduke Tmp.trunc(8); 1870Sduke } else { 1880Sduke // We want the low bits. 1890Sduke Tmp = FieldValue; 1900Sduke Tmp.trunc(8); 1910Sduke 1920Sduke FieldValue = FieldValue.lshr(8); 1930Sduke } 1940Sduke 1950Sduke Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); 1960Sduke NextFieldOffsetInBytes++; 1970Sduke 1980Sduke FieldValue.trunc(FieldValue.getBitWidth() - 8); 1990Sduke } 2000Sduke 2010Sduke assert(FieldValue.getBitWidth() > 0 && 2020Sduke "Should have at least one bit left!"); 2030Sduke assert(FieldValue.getBitWidth() <= 8 && 2040Sduke "Should not have more than a byte left!"); 2050Sduke 2060Sduke if (FieldValue.getBitWidth() < 8) { 2070Sduke if (CGM.getTargetData().isBigEndian()) { 2080Sduke unsigned BitWidth = FieldValue.getBitWidth(); 2090Sduke 2100Sduke FieldValue.zext(8); 2110Sduke FieldValue = FieldValue << (8 - BitWidth); 2120Sduke } else 2130Sduke FieldValue.zext(8); 2140Sduke } 2150Sduke 2160Sduke // Append the last element. 2170Sduke Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), 2180Sduke FieldValue)); 2190Sduke NextFieldOffsetInBytes++; 2200Sduke return true; 2210Sduke } 2220Sduke 2230Sduke void AppendPadding(uint64_t NumBytes) { 2240Sduke if (!NumBytes) 2250Sduke return; 2260Sduke 2270Sduke const llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 2280Sduke if (NumBytes > 1) 2290Sduke Ty = llvm::ArrayType::get(Ty, NumBytes); 2300Sduke 2310Sduke llvm::Constant *C = llvm::UndefValue::get(Ty); 2320Sduke Elements.push_back(C); 2330Sduke assert(getAlignment(C) == 1 && "Padding must have 1 byte alignment!"); 2340Sduke 2350Sduke NextFieldOffsetInBytes += getSizeInBytes(C); 2360Sduke } 2370Sduke 2380Sduke void AppendTailPadding(uint64_t RecordSize) { 2390Sduke assert(RecordSize % 8 == 0 && "Invalid record size!"); 2400Sduke 2410Sduke uint64_t RecordSizeInBytes = RecordSize / 8; 2420Sduke assert(NextFieldOffsetInBytes <= RecordSizeInBytes && "Size mismatch!"); 2430Sduke 2440Sduke unsigned NumPadBytes = RecordSizeInBytes - NextFieldOffsetInBytes; 2450Sduke AppendPadding(NumPadBytes); 2460Sduke } 2470Sduke 2480Sduke void ConvertStructToPacked() { 2490Sduke std::vector<llvm::Constant *> PackedElements; 2500Sduke uint64_t ElementOffsetInBytes = 0; 2510Sduke 2520Sduke for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 2530Sduke llvm::Constant *C = Elements[i]; 2540Sduke 2550Sduke unsigned ElementAlign = 2560Sduke CGM.getTargetData().getABITypeAlignment(C->getType()); 2570Sduke uint64_t AlignedElementOffsetInBytes = 2580Sduke llvm::RoundUpToAlignment(ElementOffsetInBytes, ElementAlign); 2590Sduke 2600Sduke if (AlignedElementOffsetInBytes > ElementOffsetInBytes) { 2610Sduke // We need some padding. 2620Sduke uint64_t NumBytes = 2630Sduke AlignedElementOffsetInBytes - ElementOffsetInBytes; 2640Sduke 2650Sduke const llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 2660Sduke if (NumBytes > 1) 2670Sduke Ty = llvm::ArrayType::get(Ty, NumBytes); 2680Sduke 2690Sduke llvm::Constant *Padding = llvm::UndefValue::get(Ty); 2700Sduke PackedElements.push_back(Padding); 2710Sduke ElementOffsetInBytes += getSizeInBytes(Padding); 2720Sduke } 2730Sduke 2740Sduke PackedElements.push_back(C); 2750Sduke ElementOffsetInBytes += getSizeInBytes(C); 2760Sduke } 2770Sduke 2780Sduke assert(ElementOffsetInBytes == NextFieldOffsetInBytes && 2790Sduke "Packing the struct changed its size!"); 2800Sduke 2810Sduke Elements = PackedElements; 2820Sduke LLVMStructAlignment = 1; 2830Sduke Packed = true; 2840Sduke } 2850Sduke 2860Sduke bool Build(InitListExpr *ILE) { 2870Sduke RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 2880Sduke const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 2890Sduke 2900Sduke unsigned FieldNo = 0; 2910Sduke unsigned ElementNo = 0; 2920Sduke for (RecordDecl::field_iterator Field = RD->field_begin(), 2930Sduke FieldEnd = RD->field_end(); 2940Sduke ElementNo < ILE->getNumInits() && Field != FieldEnd; 2950Sduke ++Field, ++FieldNo) { 2960Sduke if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 2970Sduke continue; 2980Sduke 2990Sduke if (Field->isBitField()) { 3000Sduke if (!Field->getIdentifier()) 3010Sduke continue; 3020Sduke 3030Sduke if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo), 3040Sduke ILE->getInit(ElementNo))) 3050Sduke return false; 3060Sduke } else { 3070Sduke if (!AppendField(*Field, Layout.getFieldOffset(FieldNo), 3080Sduke ILE->getInit(ElementNo))) 3090Sduke return false; 3100Sduke } 3110Sduke 3120Sduke ElementNo++; 3130Sduke } 3140Sduke 3150Sduke uint64_t LayoutSizeInBytes = Layout.getSize() / 8; 3160Sduke 3170Sduke if (NextFieldOffsetInBytes > LayoutSizeInBytes) { 3180Sduke // If the struct is bigger than the size of the record type, 3190Sduke // we must have a flexible array member at the end. 3200Sduke assert(RD->hasFlexibleArrayMember() && 3210Sduke "Must have flexible array member if struct is bigger than type!"); 3220Sduke 3230Sduke // No tail padding is necessary. 3240Sduke return true; 3250Sduke } 3260Sduke 3270Sduke uint64_t LLVMSizeInBytes = llvm::RoundUpToAlignment(NextFieldOffsetInBytes, 3280Sduke LLVMStructAlignment); 3290Sduke 3300Sduke // Check if we need to convert the struct to a packed struct. 3310Sduke if (NextFieldOffsetInBytes <= LayoutSizeInBytes && 3320Sduke LLVMSizeInBytes > LayoutSizeInBytes) { 3330Sduke assert(!Packed && "Size mismatch!"); 3340Sduke 3350Sduke ConvertStructToPacked(); 3360Sduke assert(NextFieldOffsetInBytes == LayoutSizeInBytes && 3370Sduke "Converting to packed did not help!"); 3380Sduke } 3390Sduke 3400Sduke // Append tail padding if necessary. 3410Sduke AppendTailPadding(Layout.getSize()); 3420Sduke 3430Sduke assert(Layout.getSize() / 8 == NextFieldOffsetInBytes && 3440Sduke "Tail padding mismatch!"); 3450Sduke 3460Sduke return true; 3470Sduke } 3480Sduke 3490Sduke unsigned getAlignment(const llvm::Constant *C) const { 3500Sduke if (Packed) 3510Sduke return 1; 3520Sduke 3530Sduke return CGM.getTargetData().getABITypeAlignment(C->getType()); 3540Sduke } 3550Sduke 3560Sduke uint64_t getSizeInBytes(const llvm::Constant *C) const { 3570Sduke return CGM.getTargetData().getTypeAllocSize(C->getType()); 3580Sduke } 3590Sduke 3600Sdukepublic: 3610Sduke static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 3620Sduke InitListExpr *ILE) { 3630Sduke ConstStructBuilder Builder(CGM, CGF); 3640Sduke 3650Sduke if (!Builder.Build(ILE)) 3660Sduke return 0; 3670Sduke 3680Sduke llvm::Constant *Result = 3690Sduke llvm::ConstantStruct::get(CGM.getLLVMContext(), 3700Sduke Builder.Elements, Builder.Packed); 3710Sduke 3720Sduke assert(llvm::RoundUpToAlignment(Builder.NextFieldOffsetInBytes, 3730Sduke Builder.getAlignment(Result)) == 3740Sduke Builder.getSizeInBytes(Result) && "Size mismatch!"); 375 376 return Result; 377 } 378}; 379 380class VISIBILITY_HIDDEN ConstExprEmitter : 381 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 382 CodeGenModule &CGM; 383 CodeGenFunction *CGF; 384 llvm::LLVMContext &VMContext; 385public: 386 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 387 : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { 388 } 389 390 //===--------------------------------------------------------------------===// 391 // Visitor Methods 392 //===--------------------------------------------------------------------===// 393 394 llvm::Constant *VisitStmt(Stmt *S) { 395 return 0; 396 } 397 398 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 399 return Visit(PE->getSubExpr()); 400 } 401 402 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 403 return Visit(E->getInitializer()); 404 } 405 406 llvm::Constant *EmitMemberFunctionPointer(CXXMethodDecl *MD) { 407 assert(MD->isInstance() && "Member function must not be static!"); 408 409 const llvm::Type *PtrDiffTy = 410 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); 411 412 llvm::Constant *Values[2]; 413 414 // Get the function pointer (or index if this is a virtual function). 415 if (MD->isVirtual()) { 416 int64_t Index = CGM.getVtableInfo().getMethodVtableIndex(MD); 417 418 Values[0] = llvm::ConstantInt::get(PtrDiffTy, Index + 1); 419 } else { 420 llvm::Constant *FuncPtr = CGM.GetAddrOfFunction(MD); 421 422 Values[0] = llvm::ConstantExpr::getPtrToInt(FuncPtr, PtrDiffTy); 423 } 424 425 // The adjustment will always be 0. 426 Values[1] = llvm::ConstantInt::get(PtrDiffTy, 0); 427 428 return llvm::ConstantStruct::get(CGM.getLLVMContext(), 429 Values, 2, /*Packed=*/false); 430 } 431 432 llvm::Constant *VisitUnaryAddrOf(UnaryOperator *E) { 433 if (const MemberPointerType *MPT = 434 E->getType()->getAs<MemberPointerType>()) { 435 QualType T = MPT->getPointeeType(); 436 if (T->isFunctionProtoType()) { 437 DeclRefExpr *DRE = cast<DeclRefExpr>(E->getSubExpr()); 438 439 return EmitMemberFunctionPointer(cast<CXXMethodDecl>(DRE->getDecl())); 440 } 441 442 // FIXME: Should we handle other member pointer types here too, 443 // or should they be handled by Expr::Evaluate? 444 } 445 446 return 0; 447 } 448 449 llvm::Constant *VisitBinSub(BinaryOperator *E) { 450 // This must be a pointer/pointer subtraction. This only happens for 451 // address of label. 452 if (!isa<AddrLabelExpr>(E->getLHS()->IgnoreParenNoopCasts(CGM.getContext())) || 453 !isa<AddrLabelExpr>(E->getRHS()->IgnoreParenNoopCasts(CGM.getContext()))) 454 return 0; 455 456 llvm::Constant *LHS = CGM.EmitConstantExpr(E->getLHS(), 457 E->getLHS()->getType(), CGF); 458 llvm::Constant *RHS = CGM.EmitConstantExpr(E->getRHS(), 459 E->getRHS()->getType(), CGF); 460 461 const llvm::Type *ResultType = ConvertType(E->getType()); 462 LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType); 463 RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType); 464 465 // No need to divide by element size, since addr of label is always void*, 466 // which has size 1 in GNUish. 467 return llvm::ConstantExpr::getSub(LHS, RHS); 468 } 469 470 llvm::Constant *VisitCastExpr(CastExpr* E) { 471 switch (E->getCastKind()) { 472 case CastExpr::CK_ToUnion: { 473 // GCC cast to union extension 474 assert(E->getType()->isUnionType() && 475 "Destination type is not union type!"); 476 const llvm::Type *Ty = ConvertType(E->getType()); 477 Expr *SubExpr = E->getSubExpr(); 478 479 llvm::Constant *C = 480 CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF); 481 if (!C) 482 return 0; 483 484 // Build a struct with the union sub-element as the first member, 485 // and padded to the appropriate size 486 std::vector<llvm::Constant*> Elts; 487 std::vector<const llvm::Type*> Types; 488 Elts.push_back(C); 489 Types.push_back(C->getType()); 490 unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType()); 491 unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(Ty); 492 493 assert(CurSize <= TotalSize && "Union size mismatch!"); 494 if (unsigned NumPadBytes = TotalSize - CurSize) { 495 const llvm::Type *Ty = llvm::Type::getInt8Ty(VMContext); 496 if (NumPadBytes > 1) 497 Ty = llvm::ArrayType::get(Ty, NumPadBytes); 498 499 Elts.push_back(llvm::UndefValue::get(Ty)); 500 Types.push_back(Ty); 501 } 502 503 llvm::StructType* STy = 504 llvm::StructType::get(C->getType()->getContext(), Types, false); 505 return llvm::ConstantStruct::get(STy, Elts); 506 } 507 case CastExpr::CK_NullToMemberPointer: 508 return CGM.EmitNullConstant(E->getType()); 509 510 case CastExpr::CK_BaseToDerivedMemberPointer: { 511 Expr *SubExpr = E->getSubExpr(); 512 513 const MemberPointerType *SrcTy = 514 SubExpr->getType()->getAs<MemberPointerType>(); 515 const MemberPointerType *DestTy = 516 E->getType()->getAs<MemberPointerType>(); 517 518 const CXXRecordDecl *BaseClass = 519 cast<CXXRecordDecl>(cast<RecordType>(SrcTy->getClass())->getDecl()); 520 const CXXRecordDecl *DerivedClass = 521 cast<CXXRecordDecl>(cast<RecordType>(DestTy->getClass())->getDecl()); 522 523 if (SrcTy->getPointeeType()->isFunctionProtoType()) { 524 llvm::Constant *C = 525 CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF); 526 if (!C) 527 return 0; 528 529 llvm::ConstantStruct *CS = cast<llvm::ConstantStruct>(C); 530 531 // Check if we need to update the adjustment. 532 if (llvm::Constant *Offset = CGM.GetCXXBaseClassOffset(DerivedClass, 533 BaseClass)) { 534 llvm::Constant *Values[2]; 535 536 Values[0] = CS->getOperand(0); 537 Values[1] = llvm::ConstantExpr::getAdd(CS->getOperand(1), Offset); 538 return llvm::ConstantStruct::get(CGM.getLLVMContext(), Values, 2, 539 /*Packed=*/false); 540 } 541 542 return CS; 543 } 544 } 545 546 case CastExpr::CK_BitCast: 547 // This must be a member function pointer cast. 548 return Visit(E->getSubExpr()); 549 550 default: { 551 // FIXME: This should be handled by the CK_NoOp cast kind. 552 // Explicit and implicit no-op casts 553 QualType Ty = E->getType(), SubTy = E->getSubExpr()->getType(); 554 if (CGM.getContext().hasSameUnqualifiedType(Ty, SubTy)) 555 return Visit(E->getSubExpr()); 556 557 // Handle integer->integer casts for address-of-label differences. 558 if (Ty->isIntegerType() && SubTy->isIntegerType() && 559 CGF) { 560 llvm::Value *Src = Visit(E->getSubExpr()); 561 if (Src == 0) return 0; 562 563 // Use EmitScalarConversion to perform the conversion. 564 return cast<llvm::Constant>(CGF->EmitScalarConversion(Src, SubTy, Ty)); 565 } 566 567 return 0; 568 } 569 } 570 } 571 572 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 573 return Visit(DAE->getExpr()); 574 } 575 576 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 577 std::vector<llvm::Constant*> Elts; 578 const llvm::ArrayType *AType = 579 cast<llvm::ArrayType>(ConvertType(ILE->getType())); 580 unsigned NumInitElements = ILE->getNumInits(); 581 // FIXME: Check for wide strings 582 // FIXME: Check for NumInitElements exactly equal to 1?? 583 if (NumInitElements > 0 && 584 (isa<StringLiteral>(ILE->getInit(0)) || 585 isa<ObjCEncodeExpr>(ILE->getInit(0))) && 586 ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 587 return Visit(ILE->getInit(0)); 588 const llvm::Type *ElemTy = AType->getElementType(); 589 unsigned NumElements = AType->getNumElements(); 590 591 // Initialising an array requires us to automatically 592 // initialise any elements that have not been initialised explicitly 593 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 594 595 // Copy initializer elements. 596 unsigned i = 0; 597 bool RewriteType = false; 598 for (; i < NumInitableElts; ++i) { 599 Expr *Init = ILE->getInit(i); 600 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 601 if (!C) 602 return 0; 603 RewriteType |= (C->getType() != ElemTy); 604 Elts.push_back(C); 605 } 606 607 // Initialize remaining array elements. 608 // FIXME: This doesn't handle member pointers correctly! 609 for (; i < NumElements; ++i) 610 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 611 612 if (RewriteType) { 613 // FIXME: Try to avoid packing the array 614 std::vector<const llvm::Type*> Types; 615 for (unsigned i = 0; i < Elts.size(); ++i) 616 Types.push_back(Elts[i]->getType()); 617 const llvm::StructType *SType = llvm::StructType::get(AType->getContext(), 618 Types, true); 619 return llvm::ConstantStruct::get(SType, Elts); 620 } 621 622 return llvm::ConstantArray::get(AType, Elts); 623 } 624 625 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 626 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 627 } 628 629 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 630 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 631 } 632 633 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 634 const llvm::VectorType *VType = 635 cast<llvm::VectorType>(ConvertType(ILE->getType())); 636 const llvm::Type *ElemTy = VType->getElementType(); 637 std::vector<llvm::Constant*> Elts; 638 unsigned NumElements = VType->getNumElements(); 639 unsigned NumInitElements = ILE->getNumInits(); 640 641 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 642 643 // Copy initializer elements. 644 unsigned i = 0; 645 for (; i < NumInitableElts; ++i) { 646 Expr *Init = ILE->getInit(i); 647 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 648 if (!C) 649 return 0; 650 Elts.push_back(C); 651 } 652 653 for (; i < NumElements; ++i) 654 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 655 656 return llvm::ConstantVector::get(VType, Elts); 657 } 658 659 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 660 return CGM.EmitNullConstant(E->getType()); 661 } 662 663 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 664 if (ILE->getType()->isScalarType()) { 665 // We have a scalar in braces. Just use the first element. 666 if (ILE->getNumInits() > 0) { 667 Expr *Init = ILE->getInit(0); 668 return CGM.EmitConstantExpr(Init, Init->getType(), CGF); 669 } 670 return CGM.EmitNullConstant(ILE->getType()); 671 } 672 673 if (ILE->getType()->isArrayType()) 674 return EmitArrayInitialization(ILE); 675 676 if (ILE->getType()->isStructureType()) 677 return EmitStructInitialization(ILE); 678 679 if (ILE->getType()->isUnionType()) 680 return EmitUnionInitialization(ILE); 681 682 if (ILE->getType()->isVectorType()) 683 return EmitVectorInitialization(ILE); 684 685 assert(0 && "Unable to handle InitListExpr"); 686 // Get rid of control reaches end of void function warning. 687 // Not reached. 688 return 0; 689 } 690 691 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 692 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 693 694 // This must be a string initializing an array in a static initializer. 695 // Don't emit it as the address of the string, emit the string data itself 696 // as an inline array. 697 return llvm::ConstantArray::get(VMContext, 698 CGM.GetStringForStringLiteral(E), false); 699 } 700 701 llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 702 // This must be an @encode initializing an array in a static initializer. 703 // Don't emit it as the address of the string, emit the string data itself 704 // as an inline array. 705 std::string Str; 706 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 707 const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 708 709 // Resize the string to the right size, adding zeros at the end, or 710 // truncating as needed. 711 Str.resize(CAT->getSize().getZExtValue(), '\0'); 712 return llvm::ConstantArray::get(VMContext, Str, false); 713 } 714 715 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 716 return Visit(E->getSubExpr()); 717 } 718 719 // Utility methods 720 const llvm::Type *ConvertType(QualType T) { 721 return CGM.getTypes().ConvertType(T); 722 } 723 724public: 725 llvm::Constant *EmitLValue(Expr *E) { 726 switch (E->getStmtClass()) { 727 default: break; 728 case Expr::CompoundLiteralExprClass: { 729 // Note that due to the nature of compound literals, this is guaranteed 730 // to be the only use of the variable, so we just generate it here. 731 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 732 llvm::Constant* C = Visit(CLE->getInitializer()); 733 // FIXME: "Leaked" on failure. 734 if (C) 735 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 736 E->getType().isConstant(CGM.getContext()), 737 llvm::GlobalValue::InternalLinkage, 738 C, ".compoundliteral", 0, false, 739 E->getType().getAddressSpace()); 740 return C; 741 } 742 case Expr::DeclRefExprClass: { 743 NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 744 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 745 return CGM.GetAddrOfFunction(FD); 746 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 747 // We can never refer to a variable with local storage. 748 if (!VD->hasLocalStorage()) { 749 if (VD->isFileVarDecl() || VD->hasExternalStorage()) 750 return CGM.GetAddrOfGlobalVar(VD); 751 else if (VD->isBlockVarDecl()) { 752 assert(CGF && "Can't access static local vars without CGF"); 753 return CGF->GetAddrOfStaticLocalVar(VD); 754 } 755 } 756 } 757 break; 758 } 759 case Expr::StringLiteralClass: 760 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 761 case Expr::ObjCEncodeExprClass: 762 return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 763 case Expr::ObjCStringLiteralClass: { 764 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 765 llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(SL); 766 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 767 } 768 case Expr::PredefinedExprClass: { 769 unsigned Type = cast<PredefinedExpr>(E)->getIdentType(); 770 if (CGF) { 771 LValue Res = CGF->EmitPredefinedFunctionName(Type); 772 return cast<llvm::Constant>(Res.getAddress()); 773 } else if (Type == PredefinedExpr::PrettyFunction) { 774 return CGM.GetAddrOfConstantCString("top level", ".tmp"); 775 } 776 777 return CGM.GetAddrOfConstantCString("", ".tmp"); 778 } 779 case Expr::AddrLabelExprClass: { 780 assert(CGF && "Invalid address of label expression outside function."); 781 llvm::Constant *Ptr = 782 CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 783 return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); 784 } 785 case Expr::CallExprClass: { 786 CallExpr* CE = cast<CallExpr>(E); 787 if (CE->isBuiltinCall(CGM.getContext()) != 788 Builtin::BI__builtin___CFStringMakeConstantString) 789 break; 790 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 791 const StringLiteral *Literal = cast<StringLiteral>(Arg); 792 // FIXME: need to deal with UCN conversion issues. 793 return CGM.GetAddrOfConstantCFString(Literal); 794 } 795 case Expr::BlockExprClass: { 796 std::string FunctionName; 797 if (CGF) 798 FunctionName = CGF->CurFn->getName(); 799 else 800 FunctionName = "global"; 801 802 return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 803 } 804 } 805 806 return 0; 807 } 808}; 809 810} // end anonymous namespace. 811 812llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 813 QualType DestType, 814 CodeGenFunction *CGF) { 815 Expr::EvalResult Result; 816 817 bool Success = false; 818 819 if (DestType->isReferenceType()) 820 Success = E->EvaluateAsLValue(Result, Context); 821 else 822 Success = E->Evaluate(Result, Context); 823 824 if (Success && !Result.HasSideEffects) { 825 switch (Result.Val.getKind()) { 826 case APValue::Uninitialized: 827 assert(0 && "Constant expressions should be initialized."); 828 return 0; 829 case APValue::LValue: { 830 const llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); 831 llvm::Constant *Offset = 832 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 833 Result.Val.getLValueOffset()); 834 835 llvm::Constant *C; 836 if (const Expr *LVBase = Result.Val.getLValueBase()) { 837 C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 838 839 // Apply offset if necessary. 840 if (!Offset->isNullValue()) { 841 const llvm::Type *Type = llvm::Type::getInt8PtrTy(VMContext); 842 llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type); 843 Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1); 844 C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 845 } 846 847 // Convert to the appropriate type; this could be an lvalue for 848 // an integer. 849 if (isa<llvm::PointerType>(DestTy)) 850 return llvm::ConstantExpr::getBitCast(C, DestTy); 851 852 return llvm::ConstantExpr::getPtrToInt(C, DestTy); 853 } else { 854 C = Offset; 855 856 // Convert to the appropriate type; this could be an lvalue for 857 // an integer. 858 if (isa<llvm::PointerType>(DestTy)) 859 return llvm::ConstantExpr::getIntToPtr(C, DestTy); 860 861 // If the types don't match this should only be a truncate. 862 if (C->getType() != DestTy) 863 return llvm::ConstantExpr::getTrunc(C, DestTy); 864 865 return C; 866 } 867 } 868 case APValue::Int: { 869 llvm::Constant *C = llvm::ConstantInt::get(VMContext, 870 Result.Val.getInt()); 871 872 if (C->getType() == llvm::Type::getInt1Ty(VMContext)) { 873 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 874 C = llvm::ConstantExpr::getZExt(C, BoolTy); 875 } 876 return C; 877 } 878 case APValue::ComplexInt: { 879 llvm::Constant *Complex[2]; 880 881 Complex[0] = llvm::ConstantInt::get(VMContext, 882 Result.Val.getComplexIntReal()); 883 Complex[1] = llvm::ConstantInt::get(VMContext, 884 Result.Val.getComplexIntImag()); 885 886 // FIXME: the target may want to specify that this is packed. 887 return llvm::ConstantStruct::get(VMContext, Complex, 2, false); 888 } 889 case APValue::Float: 890 return llvm::ConstantFP::get(VMContext, Result.Val.getFloat()); 891 case APValue::ComplexFloat: { 892 llvm::Constant *Complex[2]; 893 894 Complex[0] = llvm::ConstantFP::get(VMContext, 895 Result.Val.getComplexFloatReal()); 896 Complex[1] = llvm::ConstantFP::get(VMContext, 897 Result.Val.getComplexFloatImag()); 898 899 // FIXME: the target may want to specify that this is packed. 900 return llvm::ConstantStruct::get(VMContext, Complex, 2, false); 901 } 902 case APValue::Vector: { 903 llvm::SmallVector<llvm::Constant *, 4> Inits; 904 unsigned NumElts = Result.Val.getVectorLength(); 905 906 for (unsigned i = 0; i != NumElts; ++i) { 907 APValue &Elt = Result.Val.getVectorElt(i); 908 if (Elt.isInt()) 909 Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt())); 910 else 911 Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat())); 912 } 913 return llvm::ConstantVector::get(&Inits[0], Inits.size()); 914 } 915 } 916 } 917 918 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 919 if (C && C->getType() == llvm::Type::getInt1Ty(VMContext)) { 920 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 921 C = llvm::ConstantExpr::getZExt(C, BoolTy); 922 } 923 return C; 924} 925 926static inline bool isDataMemberPointerType(QualType T) { 927 if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) 928 return !MPT->getPointeeType()->isFunctionType(); 929 930 return false; 931} 932 933llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 934 // No need to check for member pointers when not compiling C++. 935 if (!getContext().getLangOptions().CPlusPlus) 936 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 937 938 if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { 939 940 QualType ElementTy = CAT->getElementType(); 941 942 // FIXME: Handle arrays of structs that contain member pointers. 943 if (isDataMemberPointerType(Context.getBaseElementType(ElementTy))) { 944 llvm::Constant *Element = EmitNullConstant(ElementTy); 945 uint64_t NumElements = CAT->getSize().getZExtValue(); 946 std::vector<llvm::Constant *> Array(NumElements); 947 for (uint64_t i = 0; i != NumElements; ++i) 948 Array[i] = Element; 949 950 const llvm::ArrayType *ATy = 951 cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); 952 return llvm::ConstantArray::get(ATy, Array); 953 } 954 } 955 956 if (const RecordType *RT = T->getAs<RecordType>()) { 957 const RecordDecl *RD = RT->getDecl(); 958 // FIXME: It would be better if there was a way to explicitly compute the 959 // record layout instead of converting to a type. 960 Types.ConvertTagDeclType(RD); 961 962 const CGRecordLayout &Layout = Types.getCGRecordLayout(RD); 963 if (Layout.containsMemberPointer()) { 964 assert(0 && "FIXME: No support for structs with member pointers yet!"); 965 } 966 } 967 968 // FIXME: Handle structs that contain member pointers. 969 if (isDataMemberPointerType(T)) 970 return llvm::Constant::getAllOnesValue(getTypes().ConvertTypeForMem(T)); 971 972 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 973} 974