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 "CGCXXABI.h" 17 #include "CGObjCRuntime.h" 18 #include "CGRecordLayout.h" 19 #include "clang/AST/APValue.h" 20 #include "clang/AST/ASTContext.h" 21 #include "clang/AST/RecordLayout.h" 22 #include "clang/AST/StmtVisitor.h" 23 #include "clang/Basic/Builtins.h" 24 #include "llvm/Constants.h" 25 #include "llvm/Function.h" 26 #include "llvm/GlobalVariable.h" 27 #include "llvm/Target/TargetData.h" 28 using namespace clang; 29 using namespace CodeGen; 30 31 //===----------------------------------------------------------------------===// 32 // ConstStructBuilder 33 //===----------------------------------------------------------------------===// 34 35 namespace { 36 class ConstStructBuilder { 37 CodeGenModule &CGM; 38 CodeGenFunction *CGF; 39 40 bool Packed; 41 CharUnits NextFieldOffsetInChars; 42 CharUnits LLVMStructAlignment; 43 std::vector<llvm::Constant *> Elements; 44 public: 45 static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 46 InitListExpr *ILE); 47 48 private: 49 ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) 50 : CGM(CGM), CGF(CGF), Packed(false), 51 NextFieldOffsetInChars(CharUnits::Zero()), 52 LLVMStructAlignment(CharUnits::One()) { } 53 54 bool AppendField(const FieldDecl *Field, uint64_t FieldOffset, 55 llvm::Constant *InitExpr); 56 57 void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, 58 llvm::ConstantInt *InitExpr); 59 60 void AppendPadding(CharUnits PadSize); 61 62 void AppendTailPadding(CharUnits RecordSize); 63 64 void ConvertStructToPacked(); 65 66 bool Build(InitListExpr *ILE); 67 68 CharUnits getAlignment(const llvm::Constant *C) const { 69 if (Packed) return CharUnits::One(); 70 return CharUnits::fromQuantity( 71 CGM.getTargetData().getABITypeAlignment(C->getType())); 72 } 73 74 CharUnits getSizeInChars(const llvm::Constant *C) const { 75 return CharUnits::fromQuantity( 76 CGM.getTargetData().getTypeAllocSize(C->getType())); 77 } 78 }; 79 80 bool ConstStructBuilder:: 81 AppendField(const FieldDecl *Field, uint64_t FieldOffset, 82 llvm::Constant *InitCst) { 83 84 const ASTContext &Context = CGM.getContext(); 85 86 CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset); 87 88 assert(NextFieldOffsetInChars <= FieldOffsetInChars 89 && "Field offset mismatch!"); 90 91 CharUnits FieldAlignment = getAlignment(InitCst); 92 93 // Round up the field offset to the alignment of the field type. 94 CharUnits AlignedNextFieldOffsetInChars = 95 NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment); 96 97 if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) { 98 assert(!Packed && "Alignment is wrong even with a packed struct!"); 99 100 // Convert the struct to a packed struct. 101 ConvertStructToPacked(); 102 103 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 104 } 105 106 if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) { 107 // We need to append padding. 108 AppendPadding( 109 FieldOffsetInChars - NextFieldOffsetInChars); 110 111 assert(NextFieldOffsetInChars == FieldOffsetInChars && 112 "Did not add enough padding!"); 113 114 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 115 } 116 117 // Add the field. 118 Elements.push_back(InitCst); 119 NextFieldOffsetInChars = AlignedNextFieldOffsetInChars + 120 getSizeInChars(InitCst); 121 122 if (Packed) 123 assert(LLVMStructAlignment == CharUnits::One() && 124 "Packed struct not byte-aligned!"); 125 else 126 LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); 127 128 return true; 129 } 130 131 void ConstStructBuilder::AppendBitField(const FieldDecl *Field, 132 uint64_t FieldOffset, 133 llvm::ConstantInt *CI) { 134 const ASTContext &Context = CGM.getContext(); 135 const uint64_t CharWidth = Context.getCharWidth(); 136 uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 137 if (FieldOffset > NextFieldOffsetInBits) { 138 // We need to add padding. 139 CharUnits PadSize = Context.toCharUnitsFromBits( 140 llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits, 141 Context.getTargetInfo().getCharAlign())); 142 143 AppendPadding(PadSize); 144 } 145 146 uint64_t FieldSize = Field->getBitWidthValue(Context); 147 148 llvm::APInt FieldValue = CI->getValue(); 149 150 // Promote the size of FieldValue if necessary 151 // FIXME: This should never occur, but currently it can because initializer 152 // constants are cast to bool, and because clang is not enforcing bitfield 153 // width limits. 154 if (FieldSize > FieldValue.getBitWidth()) 155 FieldValue = FieldValue.zext(FieldSize); 156 157 // Truncate the size of FieldValue to the bit field size. 158 if (FieldSize < FieldValue.getBitWidth()) 159 FieldValue = FieldValue.trunc(FieldSize); 160 161 NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 162 if (FieldOffset < NextFieldOffsetInBits) { 163 // Either part of the field or the entire field can go into the previous 164 // byte. 165 assert(!Elements.empty() && "Elements can't be empty!"); 166 167 unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset; 168 169 bool FitsCompletelyInPreviousByte = 170 BitsInPreviousByte >= FieldValue.getBitWidth(); 171 172 llvm::APInt Tmp = FieldValue; 173 174 if (!FitsCompletelyInPreviousByte) { 175 unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; 176 177 if (CGM.getTargetData().isBigEndian()) { 178 Tmp = Tmp.lshr(NewFieldWidth); 179 Tmp = Tmp.trunc(BitsInPreviousByte); 180 181 // We want the remaining high bits. 182 FieldValue = FieldValue.trunc(NewFieldWidth); 183 } else { 184 Tmp = Tmp.trunc(BitsInPreviousByte); 185 186 // We want the remaining low bits. 187 FieldValue = FieldValue.lshr(BitsInPreviousByte); 188 FieldValue = FieldValue.trunc(NewFieldWidth); 189 } 190 } 191 192 Tmp = Tmp.zext(CharWidth); 193 if (CGM.getTargetData().isBigEndian()) { 194 if (FitsCompletelyInPreviousByte) 195 Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); 196 } else { 197 Tmp = Tmp.shl(CharWidth - BitsInPreviousByte); 198 } 199 200 // 'or' in the bits that go into the previous byte. 201 llvm::Value *LastElt = Elements.back(); 202 if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt)) 203 Tmp |= Val->getValue(); 204 else { 205 assert(isa<llvm::UndefValue>(LastElt)); 206 // If there is an undef field that we're adding to, it can either be a 207 // scalar undef (in which case, we just replace it with our field) or it 208 // is an array. If it is an array, we have to pull one byte off the 209 // array so that the other undef bytes stay around. 210 if (!isa<llvm::IntegerType>(LastElt->getType())) { 211 // The undef padding will be a multibyte array, create a new smaller 212 // padding and then an hole for our i8 to get plopped into. 213 assert(isa<llvm::ArrayType>(LastElt->getType()) && 214 "Expected array padding of undefs"); 215 llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType()); 216 assert(AT->getElementType()->isIntegerTy(CharWidth) && 217 AT->getNumElements() != 0 && 218 "Expected non-empty array padding of undefs"); 219 220 // Remove the padding array. 221 NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements()); 222 Elements.pop_back(); 223 224 // Add the padding back in two chunks. 225 AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1)); 226 AppendPadding(CharUnits::One()); 227 assert(isa<llvm::UndefValue>(Elements.back()) && 228 Elements.back()->getType()->isIntegerTy(CharWidth) && 229 "Padding addition didn't work right"); 230 } 231 } 232 233 Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); 234 235 if (FitsCompletelyInPreviousByte) 236 return; 237 } 238 239 while (FieldValue.getBitWidth() > CharWidth) { 240 llvm::APInt Tmp; 241 242 if (CGM.getTargetData().isBigEndian()) { 243 // We want the high bits. 244 Tmp = 245 FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth); 246 } else { 247 // We want the low bits. 248 Tmp = FieldValue.trunc(CharWidth); 249 250 FieldValue = FieldValue.lshr(CharWidth); 251 } 252 253 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); 254 ++NextFieldOffsetInChars; 255 256 FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth); 257 } 258 259 assert(FieldValue.getBitWidth() > 0 && 260 "Should have at least one bit left!"); 261 assert(FieldValue.getBitWidth() <= CharWidth && 262 "Should not have more than a byte left!"); 263 264 if (FieldValue.getBitWidth() < CharWidth) { 265 if (CGM.getTargetData().isBigEndian()) { 266 unsigned BitWidth = FieldValue.getBitWidth(); 267 268 FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth); 269 } else 270 FieldValue = FieldValue.zext(CharWidth); 271 } 272 273 // Append the last element. 274 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), 275 FieldValue)); 276 ++NextFieldOffsetInChars; 277 } 278 279 void ConstStructBuilder::AppendPadding(CharUnits PadSize) { 280 if (PadSize.isZero()) 281 return; 282 283 llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 284 if (PadSize > CharUnits::One()) 285 Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity()); 286 287 llvm::Constant *C = llvm::UndefValue::get(Ty); 288 Elements.push_back(C); 289 assert(getAlignment(C) == CharUnits::One() && 290 "Padding must have 1 byte alignment!"); 291 292 NextFieldOffsetInChars += getSizeInChars(C); 293 } 294 295 void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) { 296 assert(NextFieldOffsetInChars <= RecordSize && 297 "Size mismatch!"); 298 299 AppendPadding(RecordSize - NextFieldOffsetInChars); 300 } 301 302 void ConstStructBuilder::ConvertStructToPacked() { 303 std::vector<llvm::Constant *> PackedElements; 304 CharUnits ElementOffsetInChars = CharUnits::Zero(); 305 306 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 307 llvm::Constant *C = Elements[i]; 308 309 CharUnits ElementAlign = CharUnits::fromQuantity( 310 CGM.getTargetData().getABITypeAlignment(C->getType())); 311 CharUnits AlignedElementOffsetInChars = 312 ElementOffsetInChars.RoundUpToAlignment(ElementAlign); 313 314 if (AlignedElementOffsetInChars > ElementOffsetInChars) { 315 // We need some padding. 316 CharUnits NumChars = 317 AlignedElementOffsetInChars - ElementOffsetInChars; 318 319 llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 320 if (NumChars > CharUnits::One()) 321 Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity()); 322 323 llvm::Constant *Padding = llvm::UndefValue::get(Ty); 324 PackedElements.push_back(Padding); 325 ElementOffsetInChars += getSizeInChars(Padding); 326 } 327 328 PackedElements.push_back(C); 329 ElementOffsetInChars += getSizeInChars(C); 330 } 331 332 assert(ElementOffsetInChars == NextFieldOffsetInChars && 333 "Packing the struct changed its size!"); 334 335 Elements = PackedElements; 336 LLVMStructAlignment = CharUnits::One(); 337 Packed = true; 338 } 339 340 bool ConstStructBuilder::Build(InitListExpr *ILE) { 341 RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 342 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 343 344 unsigned FieldNo = 0; 345 unsigned ElementNo = 0; 346 const FieldDecl *LastFD = 0; 347 bool IsMsStruct = RD->hasAttr<MsStructAttr>(); 348 349 for (RecordDecl::field_iterator Field = RD->field_begin(), 350 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 351 if (IsMsStruct) { 352 // Zero-length bitfields following non-bitfield members are 353 // ignored: 354 if (CGM.getContext().ZeroBitfieldFollowsNonBitfield((*Field), LastFD)) { 355 --FieldNo; 356 continue; 357 } 358 LastFD = (*Field); 359 } 360 361 // If this is a union, skip all the fields that aren't being initialized. 362 if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 363 continue; 364 365 // Don't emit anonymous bitfields, they just affect layout. 366 if (Field->isUnnamedBitfield()) { 367 LastFD = (*Field); 368 continue; 369 } 370 371 // Get the initializer. A struct can include fields without initializers, 372 // we just use explicit null values for them. 373 llvm::Constant *EltInit; 374 if (ElementNo < ILE->getNumInits()) 375 EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++), 376 Field->getType(), CGF); 377 else 378 EltInit = CGM.EmitNullConstant(Field->getType()); 379 380 if (!EltInit) 381 return false; 382 383 if (!Field->isBitField()) { 384 // Handle non-bitfield members. 385 if (!AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit)) 386 return false; 387 } else { 388 // Otherwise we have a bitfield. 389 AppendBitField(*Field, Layout.getFieldOffset(FieldNo), 390 cast<llvm::ConstantInt>(EltInit)); 391 } 392 } 393 394 CharUnits LayoutSizeInChars = Layout.getSize(); 395 396 if (NextFieldOffsetInChars > LayoutSizeInChars) { 397 // If the struct is bigger than the size of the record type, 398 // we must have a flexible array member at the end. 399 assert(RD->hasFlexibleArrayMember() && 400 "Must have flexible array member if struct is bigger than type!"); 401 402 // No tail padding is necessary. 403 return true; 404 } 405 406 CharUnits LLVMSizeInChars = 407 NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment); 408 409 // Check if we need to convert the struct to a packed struct. 410 if (NextFieldOffsetInChars <= LayoutSizeInChars && 411 LLVMSizeInChars > LayoutSizeInChars) { 412 assert(!Packed && "Size mismatch!"); 413 414 ConvertStructToPacked(); 415 assert(NextFieldOffsetInChars <= LayoutSizeInChars && 416 "Converting to packed did not help!"); 417 } 418 419 // Append tail padding if necessary. 420 AppendTailPadding(LayoutSizeInChars); 421 422 assert(LayoutSizeInChars == NextFieldOffsetInChars && 423 "Tail padding mismatch!"); 424 425 return true; 426 } 427 428 llvm::Constant *ConstStructBuilder:: 429 BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, InitListExpr *ILE) { 430 ConstStructBuilder Builder(CGM, CGF); 431 432 if (!Builder.Build(ILE)) 433 return 0; 434 435 // Pick the type to use. If the type is layout identical to the ConvertType 436 // type then use it, otherwise use whatever the builder produced for us. 437 llvm::StructType *STy = 438 llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(), 439 Builder.Elements,Builder.Packed); 440 llvm::Type *ILETy = CGM.getTypes().ConvertType(ILE->getType()); 441 if (llvm::StructType *ILESTy = dyn_cast<llvm::StructType>(ILETy)) { 442 if (ILESTy->isLayoutIdentical(STy)) 443 STy = ILESTy; 444 } 445 446 llvm::Constant *Result = 447 llvm::ConstantStruct::get(STy, Builder.Elements); 448 449 assert(Builder.NextFieldOffsetInChars.RoundUpToAlignment( 450 Builder.getAlignment(Result)) == 451 Builder.getSizeInChars(Result) && "Size mismatch!"); 452 453 return Result; 454 } 455 456 457 //===----------------------------------------------------------------------===// 458 // ConstExprEmitter 459 //===----------------------------------------------------------------------===// 460 461 class ConstExprEmitter : 462 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 463 CodeGenModule &CGM; 464 CodeGenFunction *CGF; 465 llvm::LLVMContext &VMContext; 466 public: 467 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 468 : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { 469 } 470 471 //===--------------------------------------------------------------------===// 472 // Visitor Methods 473 //===--------------------------------------------------------------------===// 474 475 llvm::Constant *VisitStmt(Stmt *S) { 476 return 0; 477 } 478 479 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 480 return Visit(PE->getSubExpr()); 481 } 482 483 llvm::Constant * 484 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 485 return Visit(PE->getReplacement()); 486 } 487 488 llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 489 return Visit(GE->getResultExpr()); 490 } 491 492 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 493 return Visit(E->getInitializer()); 494 } 495 496 llvm::Constant *VisitUnaryAddrOf(UnaryOperator *E) { 497 if (E->getType()->isMemberPointerType()) 498 return CGM.getMemberPointerConstant(E); 499 500 return 0; 501 } 502 503 llvm::Constant *VisitBinSub(BinaryOperator *E) { 504 // This must be a pointer/pointer subtraction. This only happens for 505 // address of label. 506 if (!isa<AddrLabelExpr>(E->getLHS()->IgnoreParenNoopCasts(CGM.getContext())) || 507 !isa<AddrLabelExpr>(E->getRHS()->IgnoreParenNoopCasts(CGM.getContext()))) 508 return 0; 509 510 llvm::Constant *LHS = CGM.EmitConstantExpr(E->getLHS(), 511 E->getLHS()->getType(), CGF); 512 llvm::Constant *RHS = CGM.EmitConstantExpr(E->getRHS(), 513 E->getRHS()->getType(), CGF); 514 515 llvm::Type *ResultType = ConvertType(E->getType()); 516 LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType); 517 RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType); 518 519 // No need to divide by element size, since addr of label is always void*, 520 // which has size 1 in GNUish. 521 return llvm::ConstantExpr::getSub(LHS, RHS); 522 } 523 524 llvm::Constant *VisitCastExpr(CastExpr* E) { 525 Expr *subExpr = E->getSubExpr(); 526 llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF); 527 if (!C) return 0; 528 529 llvm::Type *destType = ConvertType(E->getType()); 530 531 switch (E->getCastKind()) { 532 case CK_ToUnion: { 533 // GCC cast to union extension 534 assert(E->getType()->isUnionType() && 535 "Destination type is not union type!"); 536 537 // Build a struct with the union sub-element as the first member, 538 // and padded to the appropriate size 539 std::vector<llvm::Constant*> Elts; 540 std::vector<llvm::Type*> Types; 541 Elts.push_back(C); 542 Types.push_back(C->getType()); 543 unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType()); 544 unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(destType); 545 546 assert(CurSize <= TotalSize && "Union size mismatch!"); 547 if (unsigned NumPadBytes = TotalSize - CurSize) { 548 llvm::Type *Ty = llvm::Type::getInt8Ty(VMContext); 549 if (NumPadBytes > 1) 550 Ty = llvm::ArrayType::get(Ty, NumPadBytes); 551 552 Elts.push_back(llvm::UndefValue::get(Ty)); 553 Types.push_back(Ty); 554 } 555 556 llvm::StructType* STy = 557 llvm::StructType::get(C->getType()->getContext(), Types, false); 558 return llvm::ConstantStruct::get(STy, Elts); 559 } 560 case CK_NullToMemberPointer: { 561 const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 562 return CGM.getCXXABI().EmitNullMemberPointer(MPT); 563 } 564 565 case CK_DerivedToBaseMemberPointer: 566 case CK_BaseToDerivedMemberPointer: 567 return CGM.getCXXABI().EmitMemberPointerConversion(C, E); 568 569 case CK_LValueToRValue: 570 case CK_NoOp: 571 return C; 572 573 case CK_CPointerToObjCPointerCast: 574 case CK_BlockPointerToObjCPointerCast: 575 case CK_AnyPointerToBlockPointerCast: 576 case CK_LValueBitCast: 577 case CK_BitCast: 578 if (C->getType() == destType) return C; 579 return llvm::ConstantExpr::getBitCast(C, destType); 580 581 case CK_Dependent: llvm_unreachable("saw dependent cast!"); 582 583 // These will never be supported. 584 case CK_ObjCObjectLValueCast: 585 case CK_GetObjCProperty: 586 case CK_ToVoid: 587 case CK_Dynamic: 588 case CK_ARCProduceObject: 589 case CK_ARCConsumeObject: 590 case CK_ARCReclaimReturnedObject: 591 case CK_ARCExtendBlockObject: 592 return 0; 593 594 // These might need to be supported for constexpr. 595 case CK_UserDefinedConversion: 596 case CK_ConstructorConversion: 597 return 0; 598 599 // These should eventually be supported. 600 case CK_ArrayToPointerDecay: 601 case CK_FunctionToPointerDecay: 602 case CK_BaseToDerived: 603 case CK_DerivedToBase: 604 case CK_UncheckedDerivedToBase: 605 case CK_MemberPointerToBoolean: 606 case CK_VectorSplat: 607 case CK_FloatingRealToComplex: 608 case CK_FloatingComplexToReal: 609 case CK_FloatingComplexToBoolean: 610 case CK_FloatingComplexCast: 611 case CK_FloatingComplexToIntegralComplex: 612 case CK_IntegralRealToComplex: 613 case CK_IntegralComplexToReal: 614 case CK_IntegralComplexToBoolean: 615 case CK_IntegralComplexCast: 616 case CK_IntegralComplexToFloatingComplex: 617 return 0; 618 619 case CK_PointerToIntegral: 620 if (!E->getType()->isBooleanType()) 621 return llvm::ConstantExpr::getPtrToInt(C, destType); 622 // fallthrough 623 624 case CK_PointerToBoolean: 625 return llvm::ConstantExpr::getICmp(llvm::CmpInst::ICMP_EQ, C, 626 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(C->getType()))); 627 628 case CK_NullToPointer: 629 return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(destType)); 630 631 case CK_IntegralCast: { 632 bool isSigned = subExpr->getType()->isSignedIntegerOrEnumerationType(); 633 return llvm::ConstantExpr::getIntegerCast(C, destType, isSigned); 634 } 635 636 case CK_IntegralToPointer: { 637 bool isSigned = subExpr->getType()->isSignedIntegerOrEnumerationType(); 638 C = llvm::ConstantExpr::getIntegerCast(C, CGM.IntPtrTy, isSigned); 639 return llvm::ConstantExpr::getIntToPtr(C, destType); 640 } 641 642 case CK_IntegralToBoolean: 643 return llvm::ConstantExpr::getICmp(llvm::CmpInst::ICMP_EQ, C, 644 llvm::Constant::getNullValue(C->getType())); 645 646 case CK_IntegralToFloating: 647 if (subExpr->getType()->isSignedIntegerOrEnumerationType()) 648 return llvm::ConstantExpr::getSIToFP(C, destType); 649 else 650 return llvm::ConstantExpr::getUIToFP(C, destType); 651 652 case CK_FloatingToIntegral: 653 if (E->getType()->isSignedIntegerOrEnumerationType()) 654 return llvm::ConstantExpr::getFPToSI(C, destType); 655 else 656 return llvm::ConstantExpr::getFPToUI(C, destType); 657 658 case CK_FloatingToBoolean: 659 return llvm::ConstantExpr::getFCmp(llvm::CmpInst::FCMP_UNE, C, 660 llvm::Constant::getNullValue(C->getType())); 661 662 case CK_FloatingCast: 663 return llvm::ConstantExpr::getFPCast(C, destType); 664 } 665 llvm_unreachable("Invalid CastKind"); 666 } 667 668 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 669 return Visit(DAE->getExpr()); 670 } 671 672 llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 673 return Visit(E->GetTemporaryExpr()); 674 } 675 676 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 677 unsigned NumInitElements = ILE->getNumInits(); 678 if (NumInitElements == 1 && ILE->getType() == ILE->getInit(0)->getType() && 679 (isa<StringLiteral>(ILE->getInit(0)) || 680 isa<ObjCEncodeExpr>(ILE->getInit(0)))) 681 return Visit(ILE->getInit(0)); 682 683 std::vector<llvm::Constant*> Elts; 684 llvm::ArrayType *AType = 685 cast<llvm::ArrayType>(ConvertType(ILE->getType())); 686 llvm::Type *ElemTy = AType->getElementType(); 687 unsigned NumElements = AType->getNumElements(); 688 689 // Initialising an array requires us to automatically 690 // initialise any elements that have not been initialised explicitly 691 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 692 693 // Copy initializer elements. 694 unsigned i = 0; 695 bool RewriteType = false; 696 for (; i < NumInitableElts; ++i) { 697 Expr *Init = ILE->getInit(i); 698 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 699 if (!C) 700 return 0; 701 RewriteType |= (C->getType() != ElemTy); 702 Elts.push_back(C); 703 } 704 705 // Initialize remaining array elements. 706 // FIXME: This doesn't handle member pointers correctly! 707 llvm::Constant *fillC; 708 if (Expr *filler = ILE->getArrayFiller()) 709 fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF); 710 else 711 fillC = llvm::Constant::getNullValue(ElemTy); 712 if (!fillC) 713 return 0; 714 RewriteType |= (fillC->getType() != ElemTy); 715 for (; i < NumElements; ++i) 716 Elts.push_back(fillC); 717 718 if (RewriteType) { 719 // FIXME: Try to avoid packing the array 720 std::vector<llvm::Type*> Types; 721 for (unsigned i = 0; i < Elts.size(); ++i) 722 Types.push_back(Elts[i]->getType()); 723 llvm::StructType *SType = llvm::StructType::get(AType->getContext(), 724 Types, true); 725 return llvm::ConstantStruct::get(SType, Elts); 726 } 727 728 return llvm::ConstantArray::get(AType, Elts); 729 } 730 731 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 732 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 733 } 734 735 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 736 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 737 } 738 739 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 740 return CGM.EmitNullConstant(E->getType()); 741 } 742 743 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 744 if (ILE->getType()->isAnyComplexType() && ILE->getNumInits() == 2) { 745 // Complex type with element initializers 746 Expr *Real = ILE->getInit(0); 747 Expr *Imag = ILE->getInit(1); 748 llvm::Constant *Complex[2]; 749 Complex[0] = CGM.EmitConstantExpr(Real, Real->getType(), CGF); 750 if (!Complex[0]) 751 return 0; 752 Complex[1] = CGM.EmitConstantExpr(Imag, Imag->getType(), CGF); 753 if (!Complex[1]) 754 return 0; 755 llvm::StructType *STy = 756 cast<llvm::StructType>(ConvertType(ILE->getType())); 757 return llvm::ConstantStruct::get(STy, Complex); 758 } 759 760 if (ILE->getType()->isScalarType()) { 761 // We have a scalar in braces. Just use the first element. 762 if (ILE->getNumInits() > 0) { 763 Expr *Init = ILE->getInit(0); 764 return CGM.EmitConstantExpr(Init, Init->getType(), CGF); 765 } 766 return CGM.EmitNullConstant(ILE->getType()); 767 } 768 769 if (ILE->getType()->isArrayType()) 770 return EmitArrayInitialization(ILE); 771 772 if (ILE->getType()->isRecordType()) 773 return EmitStructInitialization(ILE); 774 775 if (ILE->getType()->isUnionType()) 776 return EmitUnionInitialization(ILE); 777 778 // If ILE was a constant vector, we would have handled it already. 779 if (ILE->getType()->isVectorType()) 780 return 0; 781 782 llvm_unreachable("Unable to handle InitListExpr"); 783 } 784 785 llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) { 786 if (!E->getConstructor()->isTrivial()) 787 return 0; 788 789 QualType Ty = E->getType(); 790 791 // FIXME: We should not have to call getBaseElementType here. 792 const RecordType *RT = 793 CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>(); 794 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 795 796 // If the class doesn't have a trivial destructor, we can't emit it as a 797 // constant expr. 798 if (!RD->hasTrivialDestructor()) 799 return 0; 800 801 // Only copy and default constructors can be trivial. 802 803 804 if (E->getNumArgs()) { 805 assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument"); 806 assert(E->getConstructor()->isCopyOrMoveConstructor() && 807 "trivial ctor has argument but isn't a copy/move ctor"); 808 809 Expr *Arg = E->getArg(0); 810 assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) && 811 "argument to copy ctor is of wrong type"); 812 813 return Visit(Arg); 814 } 815 816 return CGM.EmitNullConstant(Ty); 817 } 818 819 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 820 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 821 822 // This must be a string initializing an array in a static initializer. 823 // Don't emit it as the address of the string, emit the string data itself 824 // as an inline array. 825 return llvm::ConstantArray::get(VMContext, 826 CGM.GetStringForStringLiteral(E), false); 827 } 828 829 llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 830 // This must be an @encode initializing an array in a static initializer. 831 // Don't emit it as the address of the string, emit the string data itself 832 // as an inline array. 833 std::string Str; 834 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 835 const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 836 837 // Resize the string to the right size, adding zeros at the end, or 838 // truncating as needed. 839 Str.resize(CAT->getSize().getZExtValue(), '\0'); 840 return llvm::ConstantArray::get(VMContext, Str, false); 841 } 842 843 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 844 return Visit(E->getSubExpr()); 845 } 846 847 // Utility methods 848 llvm::Type *ConvertType(QualType T) { 849 return CGM.getTypes().ConvertType(T); 850 } 851 852 public: 853 llvm::Constant *EmitLValue(Expr *E) { 854 switch (E->getStmtClass()) { 855 default: break; 856 case Expr::CompoundLiteralExprClass: { 857 // Note that due to the nature of compound literals, this is guaranteed 858 // to be the only use of the variable, so we just generate it here. 859 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 860 llvm::Constant* C = Visit(CLE->getInitializer()); 861 // FIXME: "Leaked" on failure. 862 if (C) 863 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 864 E->getType().isConstant(CGM.getContext()), 865 llvm::GlobalValue::InternalLinkage, 866 C, ".compoundliteral", 0, false, 867 CGM.getContext().getTargetAddressSpace(E->getType())); 868 return C; 869 } 870 case Expr::DeclRefExprClass: { 871 ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 872 if (Decl->hasAttr<WeakRefAttr>()) 873 return CGM.GetWeakRefReference(Decl); 874 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 875 return CGM.GetAddrOfFunction(FD); 876 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 877 // We can never refer to a variable with local storage. 878 if (!VD->hasLocalStorage()) { 879 if (VD->isFileVarDecl() || VD->hasExternalStorage()) 880 return CGM.GetAddrOfGlobalVar(VD); 881 else if (VD->isLocalVarDecl()) { 882 assert(CGF && "Can't access static local vars without CGF"); 883 return CGF->GetAddrOfStaticLocalVar(VD); 884 } 885 } 886 } 887 break; 888 } 889 case Expr::StringLiteralClass: 890 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 891 case Expr::ObjCEncodeExprClass: 892 return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 893 case Expr::ObjCStringLiteralClass: { 894 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 895 llvm::Constant *C = 896 CGM.getObjCRuntime().GenerateConstantString(SL->getString()); 897 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 898 } 899 case Expr::PredefinedExprClass: { 900 unsigned Type = cast<PredefinedExpr>(E)->getIdentType(); 901 if (CGF) { 902 LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E)); 903 return cast<llvm::Constant>(Res.getAddress()); 904 } else if (Type == PredefinedExpr::PrettyFunction) { 905 return CGM.GetAddrOfConstantCString("top level", ".tmp"); 906 } 907 908 return CGM.GetAddrOfConstantCString("", ".tmp"); 909 } 910 case Expr::AddrLabelExprClass: { 911 assert(CGF && "Invalid address of label expression outside function."); 912 llvm::Constant *Ptr = 913 CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 914 return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); 915 } 916 case Expr::CallExprClass: { 917 CallExpr* CE = cast<CallExpr>(E); 918 unsigned builtin = CE->isBuiltinCall(CGM.getContext()); 919 if (builtin != 920 Builtin::BI__builtin___CFStringMakeConstantString && 921 builtin != 922 Builtin::BI__builtin___NSStringMakeConstantString) 923 break; 924 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 925 const StringLiteral *Literal = cast<StringLiteral>(Arg); 926 if (builtin == 927 Builtin::BI__builtin___NSStringMakeConstantString) { 928 return CGM.getObjCRuntime().GenerateConstantString(Literal); 929 } 930 // FIXME: need to deal with UCN conversion issues. 931 return CGM.GetAddrOfConstantCFString(Literal); 932 } 933 case Expr::BlockExprClass: { 934 std::string FunctionName; 935 if (CGF) 936 FunctionName = CGF->CurFn->getName(); 937 else 938 FunctionName = "global"; 939 940 return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 941 } 942 } 943 944 return 0; 945 } 946 }; 947 948 } // end anonymous namespace. 949 950 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 951 QualType DestType, 952 CodeGenFunction *CGF) { 953 Expr::EvalResult Result; 954 955 bool Success = false; 956 957 if (DestType->isReferenceType()) 958 Success = E->EvaluateAsLValue(Result, Context); 959 else 960 Success = E->Evaluate(Result, Context); 961 962 if (Success && !Result.HasSideEffects) { 963 switch (Result.Val.getKind()) { 964 case APValue::Uninitialized: 965 llvm_unreachable("Constant expressions should be initialized."); 966 case APValue::LValue: { 967 llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); 968 llvm::Constant *Offset = 969 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 970 Result.Val.getLValueOffset().getQuantity()); 971 972 llvm::Constant *C; 973 if (const Expr *LVBase = Result.Val.getLValueBase()) { 974 C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 975 976 // Apply offset if necessary. 977 if (!Offset->isNullValue()) { 978 llvm::Type *Type = llvm::Type::getInt8PtrTy(VMContext); 979 llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type); 980 Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset); 981 C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 982 } 983 984 // Convert to the appropriate type; this could be an lvalue for 985 // an integer. 986 if (isa<llvm::PointerType>(DestTy)) 987 return llvm::ConstantExpr::getBitCast(C, DestTy); 988 989 return llvm::ConstantExpr::getPtrToInt(C, DestTy); 990 } else { 991 C = Offset; 992 993 // Convert to the appropriate type; this could be an lvalue for 994 // an integer. 995 if (isa<llvm::PointerType>(DestTy)) 996 return llvm::ConstantExpr::getIntToPtr(C, DestTy); 997 998 // If the types don't match this should only be a truncate. 999 if (C->getType() != DestTy) 1000 return llvm::ConstantExpr::getTrunc(C, DestTy); 1001 1002 return C; 1003 } 1004 } 1005 case APValue::Int: { 1006 llvm::Constant *C = llvm::ConstantInt::get(VMContext, 1007 Result.Val.getInt()); 1008 1009 if (C->getType()->isIntegerTy(1)) { 1010 llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 1011 C = llvm::ConstantExpr::getZExt(C, BoolTy); 1012 } 1013 return C; 1014 } 1015 case APValue::ComplexInt: { 1016 llvm::Constant *Complex[2]; 1017 1018 Complex[0] = llvm::ConstantInt::get(VMContext, 1019 Result.Val.getComplexIntReal()); 1020 Complex[1] = llvm::ConstantInt::get(VMContext, 1021 Result.Val.getComplexIntImag()); 1022 1023 // FIXME: the target may want to specify that this is packed. 1024 llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), 1025 Complex[1]->getType(), 1026 NULL); 1027 return llvm::ConstantStruct::get(STy, Complex); 1028 } 1029 case APValue::Float: { 1030 const llvm::APFloat &Init = Result.Val.getFloat(); 1031 if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf) 1032 return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt()); 1033 else 1034 return llvm::ConstantFP::get(VMContext, Init); 1035 } 1036 case APValue::ComplexFloat: { 1037 llvm::Constant *Complex[2]; 1038 1039 Complex[0] = llvm::ConstantFP::get(VMContext, 1040 Result.Val.getComplexFloatReal()); 1041 Complex[1] = llvm::ConstantFP::get(VMContext, 1042 Result.Val.getComplexFloatImag()); 1043 1044 // FIXME: the target may want to specify that this is packed. 1045 llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), 1046 Complex[1]->getType(), 1047 NULL); 1048 return llvm::ConstantStruct::get(STy, Complex); 1049 } 1050 case APValue::Vector: { 1051 SmallVector<llvm::Constant *, 4> Inits; 1052 unsigned NumElts = Result.Val.getVectorLength(); 1053 1054 if (Context.getLangOptions().AltiVec && 1055 isa<CastExpr>(E) && 1056 cast<CastExpr>(E)->getCastKind() == CK_VectorSplat) { 1057 // AltiVec vector initialization with a single literal 1058 APValue &Elt = Result.Val.getVectorElt(0); 1059 1060 llvm::Constant* InitValue = Elt.isInt() 1061 ? cast<llvm::Constant> 1062 (llvm::ConstantInt::get(VMContext, Elt.getInt())) 1063 : cast<llvm::Constant> 1064 (llvm::ConstantFP::get(VMContext, Elt.getFloat())); 1065 1066 for (unsigned i = 0; i != NumElts; ++i) 1067 Inits.push_back(InitValue); 1068 1069 } else { 1070 for (unsigned i = 0; i != NumElts; ++i) { 1071 APValue &Elt = Result.Val.getVectorElt(i); 1072 if (Elt.isInt()) 1073 Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt())); 1074 else 1075 Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat())); 1076 } 1077 } 1078 return llvm::ConstantVector::get(Inits); 1079 } 1080 } 1081 } 1082 1083 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 1084 if (C && C->getType()->isIntegerTy(1)) { 1085 llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 1086 C = llvm::ConstantExpr::getZExt(C, BoolTy); 1087 } 1088 return C; 1089 } 1090 1091 static uint64_t getFieldOffset(ASTContext &C, const FieldDecl *field) { 1092 const ASTRecordLayout &layout = C.getASTRecordLayout(field->getParent()); 1093 return layout.getFieldOffset(field->getFieldIndex()); 1094 } 1095 1096 llvm::Constant * 1097 CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { 1098 // Member pointer constants always have a very particular form. 1099 const MemberPointerType *type = cast<MemberPointerType>(uo->getType()); 1100 const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl(); 1101 1102 // A member function pointer. 1103 if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) 1104 return getCXXABI().EmitMemberPointer(method); 1105 1106 // Otherwise, a member data pointer. 1107 uint64_t fieldOffset; 1108 if (const FieldDecl *field = dyn_cast<FieldDecl>(decl)) 1109 fieldOffset = getFieldOffset(getContext(), field); 1110 else { 1111 const IndirectFieldDecl *ifield = cast<IndirectFieldDecl>(decl); 1112 1113 fieldOffset = 0; 1114 for (IndirectFieldDecl::chain_iterator ci = ifield->chain_begin(), 1115 ce = ifield->chain_end(); ci != ce; ++ci) 1116 fieldOffset += getFieldOffset(getContext(), cast<FieldDecl>(*ci)); 1117 } 1118 1119 CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset); 1120 return getCXXABI().EmitMemberDataPointer(type, chars); 1121 } 1122 1123 static void 1124 FillInNullDataMemberPointers(CodeGenModule &CGM, QualType T, 1125 std::vector<llvm::Constant *> &Elements, 1126 uint64_t StartOffset) { 1127 assert(StartOffset % CGM.getContext().getCharWidth() == 0 && 1128 "StartOffset not byte aligned!"); 1129 1130 if (CGM.getTypes().isZeroInitializable(T)) 1131 return; 1132 1133 if (const ConstantArrayType *CAT = 1134 CGM.getContext().getAsConstantArrayType(T)) { 1135 QualType ElementTy = CAT->getElementType(); 1136 uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy); 1137 1138 for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) { 1139 FillInNullDataMemberPointers(CGM, ElementTy, Elements, 1140 StartOffset + I * ElementSize); 1141 } 1142 } else if (const RecordType *RT = T->getAs<RecordType>()) { 1143 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1144 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 1145 1146 // Go through all bases and fill in any null pointer to data members. 1147 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1148 E = RD->bases_end(); I != E; ++I) { 1149 if (I->isVirtual()) { 1150 // Ignore virtual bases. 1151 continue; 1152 } 1153 1154 const CXXRecordDecl *BaseDecl = 1155 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 1156 1157 // Ignore empty bases. 1158 if (BaseDecl->isEmpty()) 1159 continue; 1160 1161 // Ignore bases that don't have any pointer to data members. 1162 if (CGM.getTypes().isZeroInitializable(BaseDecl)) 1163 continue; 1164 1165 uint64_t BaseOffset = Layout.getBaseClassOffsetInBits(BaseDecl); 1166 FillInNullDataMemberPointers(CGM, I->getType(), 1167 Elements, StartOffset + BaseOffset); 1168 } 1169 1170 // Visit all fields. 1171 unsigned FieldNo = 0; 1172 for (RecordDecl::field_iterator I = RD->field_begin(), 1173 E = RD->field_end(); I != E; ++I, ++FieldNo) { 1174 QualType FieldType = I->getType(); 1175 1176 if (CGM.getTypes().isZeroInitializable(FieldType)) 1177 continue; 1178 1179 uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo); 1180 FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset); 1181 } 1182 } else { 1183 assert(T->isMemberPointerType() && "Should only see member pointers here!"); 1184 assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && 1185 "Should only see pointers to data members here!"); 1186 1187 CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset); 1188 CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T); 1189 1190 // FIXME: hardcodes Itanium member pointer representation! 1191 llvm::Constant *NegativeOne = 1192 llvm::ConstantInt::get(llvm::Type::getInt8Ty(CGM.getLLVMContext()), 1193 -1ULL, /*isSigned*/true); 1194 1195 // Fill in the null data member pointer. 1196 for (CharUnits I = StartIndex; I != EndIndex; ++I) 1197 Elements[I.getQuantity()] = NegativeOne; 1198 } 1199 } 1200 1201 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 1202 llvm::Type *baseType, 1203 const CXXRecordDecl *base); 1204 1205 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM, 1206 const CXXRecordDecl *record, 1207 bool asCompleteObject) { 1208 const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record); 1209 llvm::StructType *structure = 1210 (asCompleteObject ? layout.getLLVMType() 1211 : layout.getBaseSubobjectLLVMType()); 1212 1213 unsigned numElements = structure->getNumElements(); 1214 std::vector<llvm::Constant *> elements(numElements); 1215 1216 // Fill in all the bases. 1217 for (CXXRecordDecl::base_class_const_iterator 1218 I = record->bases_begin(), E = record->bases_end(); I != E; ++I) { 1219 if (I->isVirtual()) { 1220 // Ignore virtual bases; if we're laying out for a complete 1221 // object, we'll lay these out later. 1222 continue; 1223 } 1224 1225 const CXXRecordDecl *base = 1226 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1227 1228 // Ignore empty bases. 1229 if (base->isEmpty()) 1230 continue; 1231 1232 unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base); 1233 llvm::Type *baseType = structure->getElementType(fieldIndex); 1234 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 1235 } 1236 1237 // Fill in all the fields. 1238 for (RecordDecl::field_iterator I = record->field_begin(), 1239 E = record->field_end(); I != E; ++I) { 1240 const FieldDecl *field = *I; 1241 1242 // Ignore bit fields. 1243 if (field->isBitField()) 1244 continue; 1245 1246 unsigned fieldIndex = layout.getLLVMFieldNo(field); 1247 elements[fieldIndex] = CGM.EmitNullConstant(field->getType()); 1248 } 1249 1250 // Fill in the virtual bases, if we're working with the complete object. 1251 if (asCompleteObject) { 1252 for (CXXRecordDecl::base_class_const_iterator 1253 I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) { 1254 const CXXRecordDecl *base = 1255 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1256 1257 // Ignore empty bases. 1258 if (base->isEmpty()) 1259 continue; 1260 1261 unsigned fieldIndex = layout.getVirtualBaseIndex(base); 1262 1263 // We might have already laid this field out. 1264 if (elements[fieldIndex]) continue; 1265 1266 llvm::Type *baseType = structure->getElementType(fieldIndex); 1267 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 1268 } 1269 } 1270 1271 // Now go through all other fields and zero them out. 1272 for (unsigned i = 0; i != numElements; ++i) { 1273 if (!elements[i]) 1274 elements[i] = llvm::Constant::getNullValue(structure->getElementType(i)); 1275 } 1276 1277 return llvm::ConstantStruct::get(structure, elements); 1278 } 1279 1280 /// Emit the null constant for a base subobject. 1281 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 1282 llvm::Type *baseType, 1283 const CXXRecordDecl *base) { 1284 const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base); 1285 1286 // Just zero out bases that don't have any pointer to data members. 1287 if (baseLayout.isZeroInitializableAsBase()) 1288 return llvm::Constant::getNullValue(baseType); 1289 1290 // If the base type is a struct, we can just use its null constant. 1291 if (isa<llvm::StructType>(baseType)) { 1292 return EmitNullConstant(CGM, base, /*complete*/ false); 1293 } 1294 1295 // Otherwise, some bases are represented as arrays of i8 if the size 1296 // of the base is smaller than its corresponding LLVM type. Figure 1297 // out how many elements this base array has. 1298 llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType); 1299 unsigned numBaseElements = baseArrayType->getNumElements(); 1300 1301 // Fill in null data member pointers. 1302 std::vector<llvm::Constant *> baseElements(numBaseElements); 1303 FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base), 1304 baseElements, 0); 1305 1306 // Now go through all other elements and zero them out. 1307 if (numBaseElements) { 1308 llvm::Type *i8 = llvm::Type::getInt8Ty(CGM.getLLVMContext()); 1309 llvm::Constant *i8_zero = llvm::Constant::getNullValue(i8); 1310 for (unsigned i = 0; i != numBaseElements; ++i) { 1311 if (!baseElements[i]) 1312 baseElements[i] = i8_zero; 1313 } 1314 } 1315 1316 return llvm::ConstantArray::get(baseArrayType, baseElements); 1317 } 1318 1319 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 1320 if (getTypes().isZeroInitializable(T)) 1321 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 1322 1323 if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { 1324 1325 QualType ElementTy = CAT->getElementType(); 1326 1327 llvm::Constant *Element = EmitNullConstant(ElementTy); 1328 unsigned NumElements = CAT->getSize().getZExtValue(); 1329 std::vector<llvm::Constant *> Array(NumElements); 1330 for (unsigned i = 0; i != NumElements; ++i) 1331 Array[i] = Element; 1332 1333 llvm::ArrayType *ATy = 1334 cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); 1335 return llvm::ConstantArray::get(ATy, Array); 1336 } 1337 1338 if (const RecordType *RT = T->getAs<RecordType>()) { 1339 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1340 return ::EmitNullConstant(*this, RD, /*complete object*/ true); 1341 } 1342 1343 assert(T->isMemberPointerType() && "Should only see member pointers here!"); 1344 assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && 1345 "Should only see pointers to data members here!"); 1346 1347 // Itanium C++ ABI 2.3: 1348 // A NULL pointer is represented as -1. 1349 return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>()); 1350 } 1351 1352 llvm::Constant * 1353 CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) { 1354 return ::EmitNullConstant(*this, Record, false); 1355 } 1356
