1 //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code to emit Constant Expr nodes as LLVM code.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenFunction.h"
15 #include "CodeGenModule.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;
31 //===----------------------------------------------------------------------===//
33 //===----------------------------------------------------------------------===//
36 class ConstStructBuilder {
41 CharUnits NextFieldOffsetInChars;
42 CharUnits LLVMStructAlignment;
43 std::vector<llvm::Constant *> Elements;
45 static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
49 ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF)
50 : CGM(CGM), CGF(CGF), Packed(false),
51 NextFieldOffsetInChars(CharUnits::Zero()),
52 LLVMStructAlignment(CharUnits::One()) { }
54 bool AppendField(const FieldDecl *Field, uint64_t FieldOffset,
55 llvm::Constant *InitExpr);
57 void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
58 llvm::ConstantInt *InitExpr);
60 void AppendPadding(CharUnits PadSize);
62 void AppendTailPadding(CharUnits RecordSize);
64 void ConvertStructToPacked();
66 bool Build(InitListExpr *ILE);
68 CharUnits getAlignment(const llvm::Constant *C) const {
69 if (Packed) return CharUnits::One();
70 return CharUnits::fromQuantity(
71 CGM.getTargetData().getABITypeAlignment(C->getType()));
74 CharUnits getSizeInChars(const llvm::Constant *C) const {
75 return CharUnits::fromQuantity(
76 CGM.getTargetData().getTypeAllocSize(C->getType()));
80 bool ConstStructBuilder::
81 AppendField(const FieldDecl *Field, uint64_t FieldOffset,
82 llvm::Constant *InitCst) {
84 const ASTContext &Context = CGM.getContext();
86 CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
88 assert(NextFieldOffsetInChars <= FieldOffsetInChars
89 && "Field offset mismatch!");
91 CharUnits FieldAlignment = getAlignment(InitCst);
93 // Round up the field offset to the alignment of the field type.
94 CharUnits AlignedNextFieldOffsetInChars =
95 NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment);
97 if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) {
98 assert(!Packed && "Alignment is wrong even with a packed struct!");
100 // Convert the struct to a packed struct.
101 ConvertStructToPacked();
103 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
106 if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) {
107 // We need to append padding.
109 FieldOffsetInChars - NextFieldOffsetInChars);
111 assert(NextFieldOffsetInChars == FieldOffsetInChars &&
112 "Did not add enough padding!");
114 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
118 Elements.push_back(InitCst);
119 NextFieldOffsetInChars = AlignedNextFieldOffsetInChars +
120 getSizeInChars(InitCst);
123 assert(LLVMStructAlignment == CharUnits::One() &&
124 "Packed struct not byte-aligned!");
126 LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment);
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()));
143 AppendPadding(PadSize);
146 uint64_t FieldSize = Field->getBitWidthValue(Context);
148 llvm::APInt FieldValue = CI->getValue();
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
154 if (FieldSize > FieldValue.getBitWidth())
155 FieldValue = FieldValue.zext(FieldSize);
157 // Truncate the size of FieldValue to the bit field size.
158 if (FieldSize < FieldValue.getBitWidth())
159 FieldValue = FieldValue.trunc(FieldSize);
161 NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
162 if (FieldOffset < NextFieldOffsetInBits) {
163 // Either part of the field or the entire field can go into the previous
165 assert(!Elements.empty() && "Elements can't be empty!");
167 unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset;
169 bool FitsCompletelyInPreviousByte =
170 BitsInPreviousByte >= FieldValue.getBitWidth();
172 llvm::APInt Tmp = FieldValue;
174 if (!FitsCompletelyInPreviousByte) {
175 unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
177 if (CGM.getTargetData().isBigEndian()) {
178 Tmp = Tmp.lshr(NewFieldWidth);
179 Tmp = Tmp.trunc(BitsInPreviousByte);
181 // We want the remaining high bits.
182 FieldValue = FieldValue.trunc(NewFieldWidth);
184 Tmp = Tmp.trunc(BitsInPreviousByte);
186 // We want the remaining low bits.
187 FieldValue = FieldValue.lshr(BitsInPreviousByte);
188 FieldValue = FieldValue.trunc(NewFieldWidth);
192 Tmp = Tmp.zext(CharWidth);
193 if (CGM.getTargetData().isBigEndian()) {
194 if (FitsCompletelyInPreviousByte)
195 Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
197 Tmp = Tmp.shl(CharWidth - BitsInPreviousByte);
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();
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");
220 // Remove the padding array.
221 NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements());
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");
233 Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
235 if (FitsCompletelyInPreviousByte)
239 while (FieldValue.getBitWidth() > CharWidth) {
242 if (CGM.getTargetData().isBigEndian()) {
243 // We want the high bits.
245 FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth);
247 // We want the low bits.
248 Tmp = FieldValue.trunc(CharWidth);
250 FieldValue = FieldValue.lshr(CharWidth);
253 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
254 ++NextFieldOffsetInChars;
256 FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth);
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!");
264 if (FieldValue.getBitWidth() < CharWidth) {
265 if (CGM.getTargetData().isBigEndian()) {
266 unsigned BitWidth = FieldValue.getBitWidth();
268 FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth);
270 FieldValue = FieldValue.zext(CharWidth);
273 // Append the last element.
274 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
276 ++NextFieldOffsetInChars;
279 void ConstStructBuilder::AppendPadding(CharUnits PadSize) {
280 if (PadSize.isZero())
283 llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext());
284 if (PadSize > CharUnits::One())
285 Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
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!");
292 NextFieldOffsetInChars += getSizeInChars(C);
295 void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) {
296 assert(NextFieldOffsetInChars <= RecordSize &&
299 AppendPadding(RecordSize - NextFieldOffsetInChars);
302 void ConstStructBuilder::ConvertStructToPacked() {
303 std::vector<llvm::Constant *> PackedElements;
304 CharUnits ElementOffsetInChars = CharUnits::Zero();
306 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
307 llvm::Constant *C = Elements[i];
309 CharUnits ElementAlign = CharUnits::fromQuantity(
310 CGM.getTargetData().getABITypeAlignment(C->getType()));
311 CharUnits AlignedElementOffsetInChars =
312 ElementOffsetInChars.RoundUpToAlignment(ElementAlign);
314 if (AlignedElementOffsetInChars > ElementOffsetInChars) {
315 // We need some padding.
317 AlignedElementOffsetInChars - ElementOffsetInChars;
319 llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext());
320 if (NumChars > CharUnits::One())
321 Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity());
323 llvm::Constant *Padding = llvm::UndefValue::get(Ty);
324 PackedElements.push_back(Padding);
325 ElementOffsetInChars += getSizeInChars(Padding);
328 PackedElements.push_back(C);
329 ElementOffsetInChars += getSizeInChars(C);
332 assert(ElementOffsetInChars == NextFieldOffsetInChars &&
333 "Packing the struct changed its size!");
335 Elements = PackedElements;
336 LLVMStructAlignment = CharUnits::One();
340 bool ConstStructBuilder::Build(InitListExpr *ILE) {
341 RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
342 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
344 unsigned FieldNo = 0;
345 unsigned ElementNo = 0;
346 const FieldDecl *LastFD = 0;
347 bool IsMsStruct = RD->hasAttr<MsStructAttr>();
349 for (RecordDecl::field_iterator Field = RD->field_begin(),
350 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
352 // Zero-length bitfields following non-bitfield members are
354 if (CGM.getContext().ZeroBitfieldFollowsNonBitfield((*Field), LastFD)) {
361 // If this is a union, skip all the fields that aren't being initialized.
362 if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
365 // Don't emit anonymous bitfields, they just affect layout.
366 if (Field->isUnnamedBitfield()) {
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);
378 EltInit = CGM.EmitNullConstant(Field->getType());
383 if (!Field->isBitField()) {
384 // Handle non-bitfield members.
385 if (!AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit))
388 // Otherwise we have a bitfield.
389 AppendBitField(*Field, Layout.getFieldOffset(FieldNo),
390 cast<llvm::ConstantInt>(EltInit));
394 CharUnits LayoutSizeInChars = Layout.getSize();
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!");
402 // No tail padding is necessary.
406 CharUnits LLVMSizeInChars =
407 NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment);
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!");
414 ConvertStructToPacked();
415 assert(NextFieldOffsetInChars <= LayoutSizeInChars &&
416 "Converting to packed did not help!");
419 // Append tail padding if necessary.
420 AppendTailPadding(LayoutSizeInChars);
422 assert(LayoutSizeInChars == NextFieldOffsetInChars &&
423 "Tail padding mismatch!");
428 llvm::Constant *ConstStructBuilder::
429 BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, InitListExpr *ILE) {
430 ConstStructBuilder Builder(CGM, CGF);
432 if (!Builder.Build(ILE))
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))
446 llvm::Constant *Result =
447 llvm::ConstantStruct::get(STy, Builder.Elements);
449 assert(Builder.NextFieldOffsetInChars.RoundUpToAlignment(
450 Builder.getAlignment(Result)) ==
451 Builder.getSizeInChars(Result) && "Size mismatch!");
457 //===----------------------------------------------------------------------===//
459 //===----------------------------------------------------------------------===//
461 class ConstExprEmitter :
462 public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
464 CodeGenFunction *CGF;
465 llvm::LLVMContext &VMContext;
467 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
468 : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) {
471 //===--------------------------------------------------------------------===//
473 //===--------------------------------------------------------------------===//
475 llvm::Constant *VisitStmt(Stmt *S) {
479 llvm::Constant *VisitParenExpr(ParenExpr *PE) {
480 return Visit(PE->getSubExpr());
484 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
485 return Visit(PE->getReplacement());
488 llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
489 return Visit(GE->getResultExpr());
492 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
493 return Visit(E->getInitializer());
496 llvm::Constant *VisitUnaryAddrOf(UnaryOperator *E) {
497 if (E->getType()->isMemberPointerType())
498 return CGM.getMemberPointerConstant(E);
503 llvm::Constant *VisitBinSub(BinaryOperator *E) {
504 // This must be a pointer/pointer subtraction. This only happens for
506 if (!isa<AddrLabelExpr>(E->getLHS()->IgnoreParenNoopCasts(CGM.getContext())) ||
507 !isa<AddrLabelExpr>(E->getRHS()->IgnoreParenNoopCasts(CGM.getContext())))
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);
515 llvm::Type *ResultType = ConvertType(E->getType());
516 LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType);
517 RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType);
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);
524 llvm::Constant *VisitCastExpr(CastExpr* E) {
525 Expr *subExpr = E->getSubExpr();
526 llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF);
529 llvm::Type *destType = ConvertType(E->getType());
531 switch (E->getCastKind()) {
533 // GCC cast to union extension
534 assert(E->getType()->isUnionType() &&
535 "Destination type is not union type!");
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;
542 Types.push_back(C->getType());
543 unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType());
544 unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(destType);
546 assert(CurSize <= TotalSize && "Union size mismatch!");
547 if (unsigned NumPadBytes = TotalSize - CurSize) {
548 llvm::Type *Ty = llvm::Type::getInt8Ty(VMContext);
550 Ty = llvm::ArrayType::get(Ty, NumPadBytes);
552 Elts.push_back(llvm::UndefValue::get(Ty));
556 llvm::StructType* STy =
557 llvm::StructType::get(C->getType()->getContext(), Types, false);
558 return llvm::ConstantStruct::get(STy, Elts);
560 case CK_NullToMemberPointer: {
561 const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
562 return CGM.getCXXABI().EmitNullMemberPointer(MPT);
565 case CK_DerivedToBaseMemberPointer:
566 case CK_BaseToDerivedMemberPointer:
567 return CGM.getCXXABI().EmitMemberPointerConversion(C, E);
569 case CK_LValueToRValue:
573 case CK_CPointerToObjCPointerCast:
574 case CK_BlockPointerToObjCPointerCast:
575 case CK_AnyPointerToBlockPointerCast:
576 case CK_LValueBitCast:
578 if (C->getType() == destType) return C;
579 return llvm::ConstantExpr::getBitCast(C, destType);
581 case CK_Dependent: llvm_unreachable("saw dependent cast!");
583 // These will never be supported.
584 case CK_ObjCObjectLValueCast:
585 case CK_GetObjCProperty:
588 case CK_ARCProduceObject:
589 case CK_ARCConsumeObject:
590 case CK_ARCReclaimReturnedObject:
591 case CK_ARCExtendBlockObject:
594 // These might need to be supported for constexpr.
595 case CK_UserDefinedConversion:
596 case CK_ConstructorConversion:
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:
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:
619 case CK_PointerToIntegral:
620 if (!E->getType()->isBooleanType())
621 return llvm::ConstantExpr::getPtrToInt(C, destType);
624 case CK_PointerToBoolean:
625 return llvm::ConstantExpr::getICmp(llvm::CmpInst::ICMP_EQ, C,
626 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(C->getType())));
628 case CK_NullToPointer:
629 return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(destType));
631 case CK_IntegralCast: {
632 bool isSigned = subExpr->getType()->isSignedIntegerOrEnumerationType();
633 return llvm::ConstantExpr::getIntegerCast(C, destType, isSigned);
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);
642 case CK_IntegralToBoolean:
643 return llvm::ConstantExpr::getICmp(llvm::CmpInst::ICMP_EQ, C,
644 llvm::Constant::getNullValue(C->getType()));
646 case CK_IntegralToFloating:
647 if (subExpr->getType()->isSignedIntegerOrEnumerationType())
648 return llvm::ConstantExpr::getSIToFP(C, destType);
650 return llvm::ConstantExpr::getUIToFP(C, destType);
652 case CK_FloatingToIntegral:
653 if (E->getType()->isSignedIntegerOrEnumerationType())
654 return llvm::ConstantExpr::getFPToSI(C, destType);
656 return llvm::ConstantExpr::getFPToUI(C, destType);
658 case CK_FloatingToBoolean:
659 return llvm::ConstantExpr::getFCmp(llvm::CmpInst::FCMP_UNE, C,
660 llvm::Constant::getNullValue(C->getType()));
662 case CK_FloatingCast:
663 return llvm::ConstantExpr::getFPCast(C, destType);
665 llvm_unreachable("Invalid CastKind");
668 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
669 return Visit(DAE->getExpr());
672 llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
673 return Visit(E->GetTemporaryExpr());
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));
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();
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);
693 // Copy initializer elements.
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);
701 RewriteType |= (C->getType() != ElemTy);
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);
711 fillC = llvm::Constant::getNullValue(ElemTy);
714 RewriteType |= (fillC->getType() != ElemTy);
715 for (; i < NumElements; ++i)
716 Elts.push_back(fillC);
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(),
725 return llvm::ConstantStruct::get(SType, Elts);
728 return llvm::ConstantArray::get(AType, Elts);
731 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
732 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
735 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) {
736 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
739 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
740 return CGM.EmitNullConstant(E->getType());
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);
752 Complex[1] = CGM.EmitConstantExpr(Imag, Imag->getType(), CGF);
755 llvm::StructType *STy =
756 cast<llvm::StructType>(ConvertType(ILE->getType()));
757 return llvm::ConstantStruct::get(STy, Complex);
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);
766 return CGM.EmitNullConstant(ILE->getType());
769 if (ILE->getType()->isArrayType())
770 return EmitArrayInitialization(ILE);
772 if (ILE->getType()->isRecordType())
773 return EmitStructInitialization(ILE);
775 if (ILE->getType()->isUnionType())
776 return EmitUnionInitialization(ILE);
778 // If ILE was a constant vector, we would have handled it already.
779 if (ILE->getType()->isVectorType())
782 llvm_unreachable("Unable to handle InitListExpr");
785 llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
786 if (!E->getConstructor()->isTrivial())
789 QualType Ty = E->getType();
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());
796 // If the class doesn't have a trivial destructor, we can't emit it as a
798 if (!RD->hasTrivialDestructor())
801 // Only copy and default constructors can be trivial.
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");
809 Expr *Arg = E->getArg(0);
810 assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
811 "argument to copy ctor is of wrong type");
816 return CGM.EmitNullConstant(Ty);
819 llvm::Constant *VisitStringLiteral(StringLiteral *E) {
820 assert(!E->getType()->isPointerType() && "Strings are always arrays");
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);
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.
834 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
835 const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
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);
843 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
844 return Visit(E->getSubExpr());
848 llvm::Type *ConvertType(QualType T) {
849 return CGM.getTypes().ConvertType(T);
853 llvm::Constant *EmitLValue(Expr *E) {
854 switch (E->getStmtClass()) {
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.
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()));
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);
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);
896 CGM.getObjCRuntime().GenerateConstantString(SL->getString());
897 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
899 case Expr::PredefinedExprClass: {
900 unsigned Type = cast<PredefinedExpr>(E)->getIdentType();
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");
908 return CGM.GetAddrOfConstantCString("", ".tmp");
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()));
916 case Expr::CallExprClass: {
917 CallExpr* CE = cast<CallExpr>(E);
918 unsigned builtin = CE->isBuiltinCall(CGM.getContext());
920 Builtin::BI__builtin___CFStringMakeConstantString &&
922 Builtin::BI__builtin___NSStringMakeConstantString)
924 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
925 const StringLiteral *Literal = cast<StringLiteral>(Arg);
927 Builtin::BI__builtin___NSStringMakeConstantString) {
928 return CGM.getObjCRuntime().GenerateConstantString(Literal);
930 // FIXME: need to deal with UCN conversion issues.
931 return CGM.GetAddrOfConstantCFString(Literal);
933 case Expr::BlockExprClass: {
934 std::string FunctionName;
936 FunctionName = CGF->CurFn->getName();
938 FunctionName = "global";
940 return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
948 } // end anonymous namespace.
950 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
952 CodeGenFunction *CGF) {
953 Expr::EvalResult Result;
955 bool Success = false;
957 if (DestType->isReferenceType())
958 Success = E->EvaluateAsLValue(Result, Context);
960 Success = E->Evaluate(Result, Context);
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());
973 if (const Expr *LVBase = Result.Val.getLValueBase()) {
974 C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase));
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());
984 // Convert to the appropriate type; this could be an lvalue for
986 if (isa<llvm::PointerType>(DestTy))
987 return llvm::ConstantExpr::getBitCast(C, DestTy);
989 return llvm::ConstantExpr::getPtrToInt(C, DestTy);
993 // Convert to the appropriate type; this could be an lvalue for
995 if (isa<llvm::PointerType>(DestTy))
996 return llvm::ConstantExpr::getIntToPtr(C, DestTy);
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);
1005 case APValue::Int: {
1006 llvm::Constant *C = llvm::ConstantInt::get(VMContext,
1007 Result.Val.getInt());
1009 if (C->getType()->isIntegerTy(1)) {
1010 llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1011 C = llvm::ConstantExpr::getZExt(C, BoolTy);
1015 case APValue::ComplexInt: {
1016 llvm::Constant *Complex[2];
1018 Complex[0] = llvm::ConstantInt::get(VMContext,
1019 Result.Val.getComplexIntReal());
1020 Complex[1] = llvm::ConstantInt::get(VMContext,
1021 Result.Val.getComplexIntImag());
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(),
1027 return llvm::ConstantStruct::get(STy, Complex);
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());
1034 return llvm::ConstantFP::get(VMContext, Init);
1036 case APValue::ComplexFloat: {
1037 llvm::Constant *Complex[2];
1039 Complex[0] = llvm::ConstantFP::get(VMContext,
1040 Result.Val.getComplexFloatReal());
1041 Complex[1] = llvm::ConstantFP::get(VMContext,
1042 Result.Val.getComplexFloatImag());
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(),
1048 return llvm::ConstantStruct::get(STy, Complex);
1050 case APValue::Vector: {
1051 SmallVector<llvm::Constant *, 4> Inits;
1052 unsigned NumElts = Result.Val.getVectorLength();
1054 if (Context.getLangOptions().AltiVec &&
1056 cast<CastExpr>(E)->getCastKind() == CK_VectorSplat) {
1057 // AltiVec vector initialization with a single literal
1058 APValue &Elt = Result.Val.getVectorElt(0);
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()));
1066 for (unsigned i = 0; i != NumElts; ++i)
1067 Inits.push_back(InitValue);
1070 for (unsigned i = 0; i != NumElts; ++i) {
1071 APValue &Elt = Result.Val.getVectorElt(i);
1073 Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt()));
1075 Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat()));
1078 return llvm::ConstantVector::get(Inits);
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);
1091 static uint64_t getFieldOffset(ASTContext &C, const FieldDecl *field) {
1092 const ASTRecordLayout &layout = C.getASTRecordLayout(field->getParent());
1093 return layout.getFieldOffset(field->getFieldIndex());
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();
1102 // A member function pointer.
1103 if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
1104 return getCXXABI().EmitMemberPointer(method);
1106 // Otherwise, a member data pointer.
1107 uint64_t fieldOffset;
1108 if (const FieldDecl *field = dyn_cast<FieldDecl>(decl))
1109 fieldOffset = getFieldOffset(getContext(), field);
1111 const IndirectFieldDecl *ifield = cast<IndirectFieldDecl>(decl);
1114 for (IndirectFieldDecl::chain_iterator ci = ifield->chain_begin(),
1115 ce = ifield->chain_end(); ci != ce; ++ci)
1116 fieldOffset += getFieldOffset(getContext(), cast<FieldDecl>(*ci));
1119 CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
1120 return getCXXABI().EmitMemberDataPointer(type, chars);
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!");
1130 if (CGM.getTypes().isZeroInitializable(T))
1133 if (const ConstantArrayType *CAT =
1134 CGM.getContext().getAsConstantArrayType(T)) {
1135 QualType ElementTy = CAT->getElementType();
1136 uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy);
1138 for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) {
1139 FillInNullDataMemberPointers(CGM, ElementTy, Elements,
1140 StartOffset + I * ElementSize);
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);
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.
1154 const CXXRecordDecl *BaseDecl =
1155 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1157 // Ignore empty bases.
1158 if (BaseDecl->isEmpty())
1161 // Ignore bases that don't have any pointer to data members.
1162 if (CGM.getTypes().isZeroInitializable(BaseDecl))
1165 uint64_t BaseOffset = Layout.getBaseClassOffsetInBits(BaseDecl);
1166 FillInNullDataMemberPointers(CGM, I->getType(),
1167 Elements, StartOffset + BaseOffset);
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();
1176 if (CGM.getTypes().isZeroInitializable(FieldType))
1179 uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo);
1180 FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset);
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!");
1187 CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset);
1188 CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T);
1190 // FIXME: hardcodes Itanium member pointer representation!
1191 llvm::Constant *NegativeOne =
1192 llvm::ConstantInt::get(llvm::Type::getInt8Ty(CGM.getLLVMContext()),
1193 -1ULL, /*isSigned*/true);
1195 // Fill in the null data member pointer.
1196 for (CharUnits I = StartIndex; I != EndIndex; ++I)
1197 Elements[I.getQuantity()] = NegativeOne;
1201 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1202 llvm::Type *baseType,
1203 const CXXRecordDecl *base);
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());
1213 unsigned numElements = structure->getNumElements();
1214 std::vector<llvm::Constant *> elements(numElements);
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.
1225 const CXXRecordDecl *base =
1226 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
1228 // Ignore empty bases.
1229 if (base->isEmpty())
1232 unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
1233 llvm::Type *baseType = structure->getElementType(fieldIndex);
1234 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
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;
1242 // Ignore bit fields.
1243 if (field->isBitField())
1246 unsigned fieldIndex = layout.getLLVMFieldNo(field);
1247 elements[fieldIndex] = CGM.EmitNullConstant(field->getType());
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());
1257 // Ignore empty bases.
1258 if (base->isEmpty())
1261 unsigned fieldIndex = layout.getVirtualBaseIndex(base);
1263 // We might have already laid this field out.
1264 if (elements[fieldIndex]) continue;
1266 llvm::Type *baseType = structure->getElementType(fieldIndex);
1267 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1271 // Now go through all other fields and zero them out.
1272 for (unsigned i = 0; i != numElements; ++i) {
1274 elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
1277 return llvm::ConstantStruct::get(structure, elements);
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);
1286 // Just zero out bases that don't have any pointer to data members.
1287 if (baseLayout.isZeroInitializableAsBase())
1288 return llvm::Constant::getNullValue(baseType);
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);
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();
1301 // Fill in null data member pointers.
1302 std::vector<llvm::Constant *> baseElements(numBaseElements);
1303 FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base),
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;
1316 return llvm::ConstantArray::get(baseArrayType, baseElements);
1319 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
1320 if (getTypes().isZeroInitializable(T))
1321 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
1323 if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
1325 QualType ElementTy = CAT->getElementType();
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)
1333 llvm::ArrayType *ATy =
1334 cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
1335 return llvm::ConstantArray::get(ATy, Array);
1338 if (const RecordType *RT = T->getAs<RecordType>()) {
1339 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1340 return ::EmitNullConstant(*this, RD, /*complete object*/ true);
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!");
1347 // Itanium C++ ABI 2.3:
1348 // A NULL pointer is represented as -1.
1349 return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
1353 CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
1354 return ::EmitNullConstant(*this, Record, false);