CGExprConstant.cpp revision 85b4521e34dcd4a0a4a1f0819e1123128e5a3125
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/RecordLayout.h" 20#include "clang/AST/StmtVisitor.h" 21#include "clang/Basic/Builtins.h" 22#include "llvm/Constants.h" 23#include "llvm/Function.h" 24#include "llvm/GlobalVariable.h" 25#include "llvm/Target/TargetData.h" 26using namespace clang; 27using namespace CodeGen; 28 29namespace { 30class ConstStructBuilder { 31 CodeGenModule &CGM; 32 CodeGenFunction *CGF; 33 34 bool Packed; 35 36 unsigned NextFieldOffsetInBytes; 37 38 unsigned LLVMStructAlignment; 39 40 std::vector<llvm::Constant *> Elements; 41 42 ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) 43 : CGM(CGM), CGF(CGF), Packed(false), NextFieldOffsetInBytes(0), 44 LLVMStructAlignment(1) { } 45 46 bool AppendField(const FieldDecl *Field, uint64_t FieldOffset, 47 const Expr *InitExpr) { 48 uint64_t FieldOffsetInBytes = FieldOffset / 8; 49 50 assert(NextFieldOffsetInBytes <= FieldOffsetInBytes 51 && "Field offset mismatch!"); 52 53 // Emit the field. 54 llvm::Constant *C = CGM.EmitConstantExpr(InitExpr, Field->getType(), CGF); 55 if (!C) 56 return false; 57 58 unsigned FieldAlignment = getAlignment(C); 59 60 // Round up the field offset to the alignment of the field type. 61 uint64_t AlignedNextFieldOffsetInBytes = 62 llvm::RoundUpToAlignment(NextFieldOffsetInBytes, FieldAlignment); 63 64 if (AlignedNextFieldOffsetInBytes > FieldOffsetInBytes) { 65 assert(!Packed && "Alignment is wrong even with a packed struct!"); 66 67 // Convert the struct to a packed struct. 68 ConvertStructToPacked(); 69 70 AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes; 71 } 72 73 if (AlignedNextFieldOffsetInBytes < FieldOffsetInBytes) { 74 // We need to append padding. 75 AppendPadding(FieldOffsetInBytes - NextFieldOffsetInBytes); 76 77 assert(NextFieldOffsetInBytes == FieldOffsetInBytes && 78 "Did not add enough padding!"); 79 80 AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes; 81 } 82 83 // Add the field. 84 Elements.push_back(C); 85 NextFieldOffsetInBytes = AlignedNextFieldOffsetInBytes + getSizeInBytes(C); 86 87 if (Packed) 88 assert(LLVMStructAlignment == 1 && "Packed struct not byte-aligned!"); 89 else 90 LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); 91 92 return true; 93 } 94 95 bool AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, 96 const Expr *InitExpr) { 97 llvm::ConstantInt *CI = 98 cast_or_null<llvm::ConstantInt>(CGM.EmitConstantExpr(InitExpr, 99 Field->getType(), 100 CGF)); 101 // FIXME: Can this ever happen? 102 if (!CI) 103 return false; 104 105 if (FieldOffset > NextFieldOffsetInBytes * 8) { 106 // We need to add padding. 107 uint64_t NumBytes = 108 llvm::RoundUpToAlignment(FieldOffset - 109 NextFieldOffsetInBytes * 8, 8) / 8; 110 111 AppendPadding(NumBytes); 112 } 113 114 uint64_t FieldSize = 115 Field->getBitWidth()->EvaluateAsInt(CGM.getContext()).getZExtValue(); 116 117 llvm::APInt FieldValue = CI->getValue(); 118 119 // Promote the size of FieldValue if necessary 120 // FIXME: This should never occur, but currently it can because initializer 121 // constants are cast to bool, and because clang is not enforcing bitfield 122 // width limits. 123 if (FieldSize > FieldValue.getBitWidth()) 124 FieldValue.zext(FieldSize); 125 126 // Truncate the size of FieldValue to the bit field size. 127 if (FieldSize < FieldValue.getBitWidth()) 128 FieldValue.trunc(FieldSize); 129 130 if (FieldOffset < NextFieldOffsetInBytes * 8) { 131 // Either part of the field or the entire field can go into the previous 132 // byte. 133 assert(!Elements.empty() && "Elements can't be empty!"); 134 135 unsigned BitsInPreviousByte = 136 NextFieldOffsetInBytes * 8 - FieldOffset; 137 138 bool FitsCompletelyInPreviousByte = 139 BitsInPreviousByte >= FieldValue.getBitWidth(); 140 141 llvm::APInt Tmp = FieldValue; 142 143 if (!FitsCompletelyInPreviousByte) { 144 unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; 145 146 if (CGM.getTargetData().isBigEndian()) { 147 Tmp = Tmp.lshr(NewFieldWidth); 148 Tmp.trunc(BitsInPreviousByte); 149 150 // We want the remaining high bits. 151 FieldValue.trunc(NewFieldWidth); 152 } else { 153 Tmp.trunc(BitsInPreviousByte); 154 155 // We want the remaining low bits. 156 FieldValue = FieldValue.lshr(BitsInPreviousByte); 157 FieldValue.trunc(NewFieldWidth); 158 } 159 } 160 161 Tmp.zext(8); 162 if (CGM.getTargetData().isBigEndian()) { 163 if (FitsCompletelyInPreviousByte) 164 Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); 165 } else { 166 Tmp = Tmp.shl(8 - BitsInPreviousByte); 167 } 168 169 // Or in the bits that go into the previous byte. 170 Tmp |= cast<llvm::ConstantInt>(Elements.back())->getValue(); 171 Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); 172 173 if (FitsCompletelyInPreviousByte) 174 return true; 175 } 176 177 while (FieldValue.getBitWidth() > 8) { 178 llvm::APInt Tmp; 179 180 if (CGM.getTargetData().isBigEndian()) { 181 // We want the high bits. 182 Tmp = FieldValue; 183 Tmp = Tmp.lshr(Tmp.getBitWidth() - 8); 184 Tmp.trunc(8); 185 } else { 186 // We want the low bits. 187 Tmp = FieldValue; 188 Tmp.trunc(8); 189 190 FieldValue = FieldValue.lshr(8); 191 } 192 193 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); 194 NextFieldOffsetInBytes++; 195 196 FieldValue.trunc(FieldValue.getBitWidth() - 8); 197 } 198 199 assert(FieldValue.getBitWidth() > 0 && 200 "Should have at least one bit left!"); 201 assert(FieldValue.getBitWidth() <= 8 && 202 "Should not have more than a byte left!"); 203 204 if (FieldValue.getBitWidth() < 8) { 205 if (CGM.getTargetData().isBigEndian()) { 206 unsigned BitWidth = FieldValue.getBitWidth(); 207 208 FieldValue.zext(8); 209 FieldValue = FieldValue << (8 - BitWidth); 210 } else 211 FieldValue.zext(8); 212 } 213 214 // Append the last element. 215 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), 216 FieldValue)); 217 NextFieldOffsetInBytes++; 218 return true; 219 } 220 221 void AppendPadding(uint64_t NumBytes) { 222 if (!NumBytes) 223 return; 224 225 const llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 226 if (NumBytes > 1) 227 Ty = llvm::ArrayType::get(Ty, NumBytes); 228 229 llvm::Constant *C = llvm::UndefValue::get(Ty); 230 Elements.push_back(C); 231 assert(getAlignment(C) == 1 && "Padding must have 1 byte alignment!"); 232 233 NextFieldOffsetInBytes += getSizeInBytes(C); 234 } 235 236 void AppendTailPadding(uint64_t RecordSize) { 237 assert(RecordSize % 8 == 0 && "Invalid record size!"); 238 239 uint64_t RecordSizeInBytes = RecordSize / 8; 240 assert(NextFieldOffsetInBytes <= RecordSizeInBytes && "Size mismatch!"); 241 242 unsigned NumPadBytes = RecordSizeInBytes - NextFieldOffsetInBytes; 243 AppendPadding(NumPadBytes); 244 } 245 246 void ConvertStructToPacked() { 247 std::vector<llvm::Constant *> PackedElements; 248 uint64_t ElementOffsetInBytes = 0; 249 250 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 251 llvm::Constant *C = Elements[i]; 252 253 unsigned ElementAlign = 254 CGM.getTargetData().getABITypeAlignment(C->getType()); 255 uint64_t AlignedElementOffsetInBytes = 256 llvm::RoundUpToAlignment(ElementOffsetInBytes, ElementAlign); 257 258 if (AlignedElementOffsetInBytes > ElementOffsetInBytes) { 259 // We need some padding. 260 uint64_t NumBytes = 261 AlignedElementOffsetInBytes - ElementOffsetInBytes; 262 263 const llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 264 if (NumBytes > 1) 265 Ty = llvm::ArrayType::get(Ty, NumBytes); 266 267 llvm::Constant *Padding = llvm::UndefValue::get(Ty); 268 PackedElements.push_back(Padding); 269 ElementOffsetInBytes += getSizeInBytes(Padding); 270 } 271 272 PackedElements.push_back(C); 273 ElementOffsetInBytes += getSizeInBytes(C); 274 } 275 276 assert(ElementOffsetInBytes == NextFieldOffsetInBytes && 277 "Packing the struct changed its size!"); 278 279 Elements = PackedElements; 280 LLVMStructAlignment = 1; 281 Packed = true; 282 } 283 284 bool Build(InitListExpr *ILE) { 285 RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 286 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 287 288 unsigned FieldNo = 0; 289 unsigned ElementNo = 0; 290 for (RecordDecl::field_iterator Field = RD->field_begin(), 291 FieldEnd = RD->field_end(); 292 ElementNo < ILE->getNumInits() && Field != FieldEnd; 293 ++Field, ++FieldNo) { 294 if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 295 continue; 296 297 if (Field->isBitField()) { 298 if (!Field->getIdentifier()) 299 continue; 300 301 if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo), 302 ILE->getInit(ElementNo))) 303 return false; 304 } else { 305 if (!AppendField(*Field, Layout.getFieldOffset(FieldNo), 306 ILE->getInit(ElementNo))) 307 return false; 308 } 309 310 ElementNo++; 311 } 312 313 uint64_t LayoutSizeInBytes = Layout.getSize() / 8; 314 315 if (NextFieldOffsetInBytes > LayoutSizeInBytes) { 316 // If the struct is bigger than the size of the record type, 317 // we must have a flexible array member at the end. 318 assert(RD->hasFlexibleArrayMember() && 319 "Must have flexible array member if struct is bigger than type!"); 320 321 // No tail padding is necessary. 322 return true; 323 } 324 325 uint64_t LLVMSizeInBytes = llvm::RoundUpToAlignment(NextFieldOffsetInBytes, 326 LLVMStructAlignment); 327 328 // Check if we need to convert the struct to a packed struct. 329 if (NextFieldOffsetInBytes <= LayoutSizeInBytes && 330 LLVMSizeInBytes > LayoutSizeInBytes) { 331 assert(!Packed && "Size mismatch!"); 332 333 ConvertStructToPacked(); 334 assert(NextFieldOffsetInBytes == LayoutSizeInBytes && 335 "Converting to packed did not help!"); 336 } 337 338 // Append tail padding if necessary. 339 AppendTailPadding(Layout.getSize()); 340 341 assert(Layout.getSize() / 8 == NextFieldOffsetInBytes && 342 "Tail padding mismatch!"); 343 344 return true; 345 } 346 347 unsigned getAlignment(const llvm::Constant *C) const { 348 if (Packed) 349 return 1; 350 351 return CGM.getTargetData().getABITypeAlignment(C->getType()); 352 } 353 354 uint64_t getSizeInBytes(const llvm::Constant *C) const { 355 return CGM.getTargetData().getTypeAllocSize(C->getType()); 356 } 357 358public: 359 static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 360 InitListExpr *ILE) { 361 ConstStructBuilder Builder(CGM, CGF); 362 363 if (!Builder.Build(ILE)) 364 return 0; 365 366 llvm::Constant *Result = 367 llvm::ConstantStruct::get(CGM.getLLVMContext(), 368 Builder.Elements, Builder.Packed); 369 370 assert(llvm::RoundUpToAlignment(Builder.NextFieldOffsetInBytes, 371 Builder.getAlignment(Result)) == 372 Builder.getSizeInBytes(Result) && "Size mismatch!"); 373 374 return Result; 375 } 376}; 377 378class ConstExprEmitter : 379 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 380 CodeGenModule &CGM; 381 CodeGenFunction *CGF; 382 llvm::LLVMContext &VMContext; 383public: 384 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 385 : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { 386 } 387 388 //===--------------------------------------------------------------------===// 389 // Visitor Methods 390 //===--------------------------------------------------------------------===// 391 392 llvm::Constant *VisitStmt(Stmt *S) { 393 return 0; 394 } 395 396 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 397 return Visit(PE->getSubExpr()); 398 } 399 400 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 401 return Visit(E->getInitializer()); 402 } 403 404 llvm::Constant *EmitMemberFunctionPointer(CXXMethodDecl *MD) { 405 assert(MD->isInstance() && "Member function must not be static!"); 406 407 const llvm::Type *PtrDiffTy = 408 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); 409 410 llvm::Constant *Values[2]; 411 412 // Get the function pointer (or index if this is a virtual function). 413 if (MD->isVirtual()) { 414 uint64_t Index = CGM.getVtableInfo().getMethodVtableIndex(MD); 415 416 // The pointer is 1 + the virtual table offset in bytes. 417 Values[0] = llvm::ConstantInt::get(PtrDiffTy, (Index * 8) + 1); 418 } else { 419 llvm::Constant *FuncPtr = CGM.GetAddrOfFunction(MD); 420 421 Values[0] = llvm::ConstantExpr::getPtrToInt(FuncPtr, PtrDiffTy); 422 } 423 424 // The adjustment will always be 0. 425 Values[1] = llvm::ConstantInt::get(PtrDiffTy, 0); 426 427 return llvm::ConstantStruct::get(CGM.getLLVMContext(), 428 Values, 2, /*Packed=*/false); 429 } 430 431 llvm::Constant *VisitUnaryAddrOf(UnaryOperator *E) { 432 if (const MemberPointerType *MPT = 433 E->getType()->getAs<MemberPointerType>()) { 434 QualType T = MPT->getPointeeType(); 435 if (T->isFunctionProtoType()) { 436 DeclRefExpr *DRE = cast<DeclRefExpr>(E->getSubExpr()); 437 438 return EmitMemberFunctionPointer(cast<CXXMethodDecl>(DRE->getDecl())); 439 } 440 441 // FIXME: Should we handle other member pointer types here too, 442 // or should they be handled by Expr::Evaluate? 443 } 444 445 return 0; 446 } 447 448 llvm::Constant *VisitBinSub(BinaryOperator *E) { 449 // This must be a pointer/pointer subtraction. This only happens for 450 // address of label. 451 if (!isa<AddrLabelExpr>(E->getLHS()->IgnoreParenNoopCasts(CGM.getContext())) || 452 !isa<AddrLabelExpr>(E->getRHS()->IgnoreParenNoopCasts(CGM.getContext()))) 453 return 0; 454 455 llvm::Constant *LHS = CGM.EmitConstantExpr(E->getLHS(), 456 E->getLHS()->getType(), CGF); 457 llvm::Constant *RHS = CGM.EmitConstantExpr(E->getRHS(), 458 E->getRHS()->getType(), CGF); 459 460 const llvm::Type *ResultType = ConvertType(E->getType()); 461 LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType); 462 RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType); 463 464 // No need to divide by element size, since addr of label is always void*, 465 // which has size 1 in GNUish. 466 return llvm::ConstantExpr::getSub(LHS, RHS); 467 } 468 469 llvm::Constant *VisitCastExpr(CastExpr* E) { 470 switch (E->getCastKind()) { 471 case CastExpr::CK_ToUnion: { 472 // GCC cast to union extension 473 assert(E->getType()->isUnionType() && 474 "Destination type is not union type!"); 475 const llvm::Type *Ty = ConvertType(E->getType()); 476 Expr *SubExpr = E->getSubExpr(); 477 478 llvm::Constant *C = 479 CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF); 480 if (!C) 481 return 0; 482 483 // Build a struct with the union sub-element as the first member, 484 // and padded to the appropriate size 485 std::vector<llvm::Constant*> Elts; 486 std::vector<const llvm::Type*> Types; 487 Elts.push_back(C); 488 Types.push_back(C->getType()); 489 unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType()); 490 unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(Ty); 491 492 assert(CurSize <= TotalSize && "Union size mismatch!"); 493 if (unsigned NumPadBytes = TotalSize - CurSize) { 494 const llvm::Type *Ty = llvm::Type::getInt8Ty(VMContext); 495 if (NumPadBytes > 1) 496 Ty = llvm::ArrayType::get(Ty, NumPadBytes); 497 498 Elts.push_back(llvm::UndefValue::get(Ty)); 499 Types.push_back(Ty); 500 } 501 502 llvm::StructType* STy = 503 llvm::StructType::get(C->getType()->getContext(), Types, false); 504 return llvm::ConstantStruct::get(STy, Elts); 505 } 506 case CastExpr::CK_NullToMemberPointer: 507 return CGM.EmitNullConstant(E->getType()); 508 509 case CastExpr::CK_BaseToDerivedMemberPointer: { 510 Expr *SubExpr = E->getSubExpr(); 511 512 const MemberPointerType *SrcTy = 513 SubExpr->getType()->getAs<MemberPointerType>(); 514 const MemberPointerType *DestTy = 515 E->getType()->getAs<MemberPointerType>(); 516 517 const CXXRecordDecl *BaseClass = 518 cast<CXXRecordDecl>(cast<RecordType>(SrcTy->getClass())->getDecl()); 519 const CXXRecordDecl *DerivedClass = 520 cast<CXXRecordDecl>(cast<RecordType>(DestTy->getClass())->getDecl()); 521 522 if (SrcTy->getPointeeType()->isFunctionProtoType()) { 523 llvm::Constant *C = 524 CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF); 525 if (!C) 526 return 0; 527 528 llvm::ConstantStruct *CS = cast<llvm::ConstantStruct>(C); 529 530 // Check if we need to update the adjustment. 531 if (llvm::Constant *Offset = CGM.GetCXXBaseClassOffset(DerivedClass, 532 BaseClass)) { 533 llvm::Constant *Values[2]; 534 535 Values[0] = CS->getOperand(0); 536 Values[1] = llvm::ConstantExpr::getAdd(CS->getOperand(1), Offset); 537 return llvm::ConstantStruct::get(CGM.getLLVMContext(), Values, 2, 538 /*Packed=*/false); 539 } 540 541 return CS; 542 } 543 } 544 545 case CastExpr::CK_BitCast: 546 // This must be a member function pointer cast. 547 return Visit(E->getSubExpr()); 548 549 default: { 550 // FIXME: This should be handled by the CK_NoOp cast kind. 551 // Explicit and implicit no-op casts 552 QualType Ty = E->getType(), SubTy = E->getSubExpr()->getType(); 553 if (CGM.getContext().hasSameUnqualifiedType(Ty, SubTy)) 554 return Visit(E->getSubExpr()); 555 556 // Handle integer->integer casts for address-of-label differences. 557 if (Ty->isIntegerType() && SubTy->isIntegerType() && 558 CGF) { 559 llvm::Value *Src = Visit(E->getSubExpr()); 560 if (Src == 0) return 0; 561 562 // Use EmitScalarConversion to perform the conversion. 563 return cast<llvm::Constant>(CGF->EmitScalarConversion(Src, SubTy, Ty)); 564 } 565 566 return 0; 567 } 568 } 569 } 570 571 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 572 return Visit(DAE->getExpr()); 573 } 574 575 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 576 std::vector<llvm::Constant*> Elts; 577 const llvm::ArrayType *AType = 578 cast<llvm::ArrayType>(ConvertType(ILE->getType())); 579 unsigned NumInitElements = ILE->getNumInits(); 580 // FIXME: Check for wide strings 581 // FIXME: Check for NumInitElements exactly equal to 1?? 582 if (NumInitElements > 0 && 583 (isa<StringLiteral>(ILE->getInit(0)) || 584 isa<ObjCEncodeExpr>(ILE->getInit(0))) && 585 ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 586 return Visit(ILE->getInit(0)); 587 const llvm::Type *ElemTy = AType->getElementType(); 588 unsigned NumElements = AType->getNumElements(); 589 590 // Initialising an array requires us to automatically 591 // initialise any elements that have not been initialised explicitly 592 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 593 594 // Copy initializer elements. 595 unsigned i = 0; 596 bool RewriteType = false; 597 for (; i < NumInitableElts; ++i) { 598 Expr *Init = ILE->getInit(i); 599 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 600 if (!C) 601 return 0; 602 RewriteType |= (C->getType() != ElemTy); 603 Elts.push_back(C); 604 } 605 606 // Initialize remaining array elements. 607 // FIXME: This doesn't handle member pointers correctly! 608 for (; i < NumElements; ++i) 609 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 610 611 if (RewriteType) { 612 // FIXME: Try to avoid packing the array 613 std::vector<const llvm::Type*> Types; 614 for (unsigned i = 0; i < Elts.size(); ++i) 615 Types.push_back(Elts[i]->getType()); 616 const llvm::StructType *SType = llvm::StructType::get(AType->getContext(), 617 Types, true); 618 return llvm::ConstantStruct::get(SType, Elts); 619 } 620 621 return llvm::ConstantArray::get(AType, Elts); 622 } 623 624 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 625 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 626 } 627 628 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 629 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 630 } 631 632 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 633 const llvm::VectorType *VType = 634 cast<llvm::VectorType>(ConvertType(ILE->getType())); 635 const llvm::Type *ElemTy = VType->getElementType(); 636 std::vector<llvm::Constant*> Elts; 637 unsigned NumElements = VType->getNumElements(); 638 unsigned NumInitElements = ILE->getNumInits(); 639 640 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 641 642 // Copy initializer elements. 643 unsigned i = 0; 644 for (; i < NumInitableElts; ++i) { 645 Expr *Init = ILE->getInit(i); 646 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 647 if (!C) 648 return 0; 649 Elts.push_back(C); 650 } 651 652 for (; i < NumElements; ++i) 653 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 654 655 return llvm::ConstantVector::get(VType, Elts); 656 } 657 658 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 659 return CGM.EmitNullConstant(E->getType()); 660 } 661 662 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 663 if (ILE->getType()->isScalarType()) { 664 // We have a scalar in braces. Just use the first element. 665 if (ILE->getNumInits() > 0) { 666 Expr *Init = ILE->getInit(0); 667 return CGM.EmitConstantExpr(Init, Init->getType(), CGF); 668 } 669 return CGM.EmitNullConstant(ILE->getType()); 670 } 671 672 if (ILE->getType()->isArrayType()) 673 return EmitArrayInitialization(ILE); 674 675 if (ILE->getType()->isRecordType()) 676 return EmitStructInitialization(ILE); 677 678 if (ILE->getType()->isUnionType()) 679 return EmitUnionInitialization(ILE); 680 681 if (ILE->getType()->isVectorType()) 682 return EmitVectorInitialization(ILE); 683 684 assert(0 && "Unable to handle InitListExpr"); 685 // Get rid of control reaches end of void function warning. 686 // Not reached. 687 return 0; 688 } 689 690 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 691 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 692 693 // This must be a string initializing an array in a static initializer. 694 // Don't emit it as the address of the string, emit the string data itself 695 // as an inline array. 696 return llvm::ConstantArray::get(VMContext, 697 CGM.GetStringForStringLiteral(E), false); 698 } 699 700 llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 701 // This must be an @encode initializing an array in a static initializer. 702 // Don't emit it as the address of the string, emit the string data itself 703 // as an inline array. 704 std::string Str; 705 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 706 const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 707 708 // Resize the string to the right size, adding zeros at the end, or 709 // truncating as needed. 710 Str.resize(CAT->getSize().getZExtValue(), '\0'); 711 return llvm::ConstantArray::get(VMContext, Str, false); 712 } 713 714 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 715 return Visit(E->getSubExpr()); 716 } 717 718 // Utility methods 719 const llvm::Type *ConvertType(QualType T) { 720 return CGM.getTypes().ConvertType(T); 721 } 722 723public: 724 llvm::Constant *EmitLValue(Expr *E) { 725 switch (E->getStmtClass()) { 726 default: break; 727 case Expr::CompoundLiteralExprClass: { 728 // Note that due to the nature of compound literals, this is guaranteed 729 // to be the only use of the variable, so we just generate it here. 730 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 731 llvm::Constant* C = Visit(CLE->getInitializer()); 732 // FIXME: "Leaked" on failure. 733 if (C) 734 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 735 E->getType().isConstant(CGM.getContext()), 736 llvm::GlobalValue::InternalLinkage, 737 C, ".compoundliteral", 0, false, 738 E->getType().getAddressSpace()); 739 return C; 740 } 741 case Expr::DeclRefExprClass: { 742 NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 743 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 744 return CGM.GetAddrOfFunction(FD); 745 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 746 // We can never refer to a variable with local storage. 747 if (!VD->hasLocalStorage()) { 748 if (VD->isFileVarDecl() || VD->hasExternalStorage()) 749 return CGM.GetAddrOfGlobalVar(VD); 750 else if (VD->isBlockVarDecl()) { 751 assert(CGF && "Can't access static local vars without CGF"); 752 return CGF->GetAddrOfStaticLocalVar(VD); 753 } 754 } 755 } 756 break; 757 } 758 case Expr::StringLiteralClass: 759 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 760 case Expr::ObjCEncodeExprClass: 761 return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 762 case Expr::ObjCStringLiteralClass: { 763 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 764 llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(SL); 765 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 766 } 767 case Expr::PredefinedExprClass: { 768 unsigned Type = cast<PredefinedExpr>(E)->getIdentType(); 769 if (CGF) { 770 LValue Res = CGF->EmitPredefinedFunctionName(Type); 771 return cast<llvm::Constant>(Res.getAddress()); 772 } else if (Type == PredefinedExpr::PrettyFunction) { 773 return CGM.GetAddrOfConstantCString("top level", ".tmp"); 774 } 775 776 return CGM.GetAddrOfConstantCString("", ".tmp"); 777 } 778 case Expr::AddrLabelExprClass: { 779 assert(CGF && "Invalid address of label expression outside function."); 780 llvm::Constant *Ptr = 781 CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 782 return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); 783 } 784 case Expr::CallExprClass: { 785 CallExpr* CE = cast<CallExpr>(E); 786 if (CE->isBuiltinCall(CGM.getContext()) != 787 Builtin::BI__builtin___CFStringMakeConstantString) 788 break; 789 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 790 const StringLiteral *Literal = cast<StringLiteral>(Arg); 791 // FIXME: need to deal with UCN conversion issues. 792 return CGM.GetAddrOfConstantCFString(Literal); 793 } 794 case Expr::BlockExprClass: { 795 std::string FunctionName; 796 if (CGF) 797 FunctionName = CGF->CurFn->getName(); 798 else 799 FunctionName = "global"; 800 801 return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 802 } 803 } 804 805 return 0; 806 } 807}; 808 809} // end anonymous namespace. 810 811llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 812 QualType DestType, 813 CodeGenFunction *CGF) { 814 Expr::EvalResult Result; 815 816 bool Success = false; 817 818 if (DestType->isReferenceType()) 819 Success = E->EvaluateAsLValue(Result, Context); 820 else 821 Success = E->Evaluate(Result, Context); 822 823 if (Success && !Result.HasSideEffects) { 824 switch (Result.Val.getKind()) { 825 case APValue::Uninitialized: 826 assert(0 && "Constant expressions should be initialized."); 827 return 0; 828 case APValue::LValue: { 829 const llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); 830 llvm::Constant *Offset = 831 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 832 Result.Val.getLValueOffset()); 833 834 llvm::Constant *C; 835 if (const Expr *LVBase = Result.Val.getLValueBase()) { 836 C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 837 838 // Apply offset if necessary. 839 if (!Offset->isNullValue()) { 840 const llvm::Type *Type = llvm::Type::getInt8PtrTy(VMContext); 841 llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type); 842 Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1); 843 C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 844 } 845 846 // Convert to the appropriate type; this could be an lvalue for 847 // an integer. 848 if (isa<llvm::PointerType>(DestTy)) 849 return llvm::ConstantExpr::getBitCast(C, DestTy); 850 851 return llvm::ConstantExpr::getPtrToInt(C, DestTy); 852 } else { 853 C = Offset; 854 855 // Convert to the appropriate type; this could be an lvalue for 856 // an integer. 857 if (isa<llvm::PointerType>(DestTy)) 858 return llvm::ConstantExpr::getIntToPtr(C, DestTy); 859 860 // If the types don't match this should only be a truncate. 861 if (C->getType() != DestTy) 862 return llvm::ConstantExpr::getTrunc(C, DestTy); 863 864 return C; 865 } 866 } 867 case APValue::Int: { 868 llvm::Constant *C = llvm::ConstantInt::get(VMContext, 869 Result.Val.getInt()); 870 871 if (C->getType() == llvm::Type::getInt1Ty(VMContext)) { 872 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 873 C = llvm::ConstantExpr::getZExt(C, BoolTy); 874 } 875 return C; 876 } 877 case APValue::ComplexInt: { 878 llvm::Constant *Complex[2]; 879 880 Complex[0] = llvm::ConstantInt::get(VMContext, 881 Result.Val.getComplexIntReal()); 882 Complex[1] = llvm::ConstantInt::get(VMContext, 883 Result.Val.getComplexIntImag()); 884 885 // FIXME: the target may want to specify that this is packed. 886 return llvm::ConstantStruct::get(VMContext, Complex, 2, false); 887 } 888 case APValue::Float: 889 return llvm::ConstantFP::get(VMContext, Result.Val.getFloat()); 890 case APValue::ComplexFloat: { 891 llvm::Constant *Complex[2]; 892 893 Complex[0] = llvm::ConstantFP::get(VMContext, 894 Result.Val.getComplexFloatReal()); 895 Complex[1] = llvm::ConstantFP::get(VMContext, 896 Result.Val.getComplexFloatImag()); 897 898 // FIXME: the target may want to specify that this is packed. 899 return llvm::ConstantStruct::get(VMContext, Complex, 2, false); 900 } 901 case APValue::Vector: { 902 llvm::SmallVector<llvm::Constant *, 4> Inits; 903 unsigned NumElts = Result.Val.getVectorLength(); 904 905 for (unsigned i = 0; i != NumElts; ++i) { 906 APValue &Elt = Result.Val.getVectorElt(i); 907 if (Elt.isInt()) 908 Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt())); 909 else 910 Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat())); 911 } 912 return llvm::ConstantVector::get(&Inits[0], Inits.size()); 913 } 914 } 915 } 916 917 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 918 if (C && C->getType() == llvm::Type::getInt1Ty(VMContext)) { 919 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 920 C = llvm::ConstantExpr::getZExt(C, BoolTy); 921 } 922 return C; 923} 924 925static inline bool isDataMemberPointerType(QualType T) { 926 if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) 927 return !MPT->getPointeeType()->isFunctionType(); 928 929 return false; 930} 931 932llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 933 // No need to check for member pointers when not compiling C++. 934 if (!getContext().getLangOptions().CPlusPlus) 935 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 936 937 if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { 938 939 QualType ElementTy = CAT->getElementType(); 940 941 // FIXME: Handle arrays of structs that contain member pointers. 942 if (isDataMemberPointerType(Context.getBaseElementType(ElementTy))) { 943 llvm::Constant *Element = EmitNullConstant(ElementTy); 944 uint64_t NumElements = CAT->getSize().getZExtValue(); 945 std::vector<llvm::Constant *> Array(NumElements); 946 for (uint64_t i = 0; i != NumElements; ++i) 947 Array[i] = Element; 948 949 const llvm::ArrayType *ATy = 950 cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); 951 return llvm::ConstantArray::get(ATy, Array); 952 } 953 } 954 955 if (const RecordType *RT = T->getAs<RecordType>()) { 956 const RecordDecl *RD = RT->getDecl(); 957 // FIXME: It would be better if there was a way to explicitly compute the 958 // record layout instead of converting to a type. 959 Types.ConvertTagDeclType(RD); 960 961 const CGRecordLayout &Layout = Types.getCGRecordLayout(RD); 962 if (Layout.containsMemberPointer()) { 963 assert(0 && "FIXME: No support for structs with member pointers yet!"); 964 } 965 } 966 967 // FIXME: Handle structs that contain member pointers. 968 if (isDataMemberPointerType(T)) 969 return llvm::Constant::getAllOnesValue(getTypes().ConvertTypeForMem(T)); 970 971 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 972} 973