blob: f4d6861c8b8bc4b32f3bfaf1ef6d01d07b5d9b44 [file] [log] [blame]
Anders Carlsson3b1d57b2008-01-26 01:36:00 +00001//===--- 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"
John McCall4c40d982010-08-31 07:33:07 +000015#include "CGCXXABI.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000016#include "CGObjCRuntime.h"
Daniel Dunbar2924ade2010-03-30 22:26:10 +000017#include "CGRecordLayout.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000018#include "CodeGenModule.h"
Chris Lattnerf6b24ea2008-10-06 05:59:01 +000019#include "clang/AST/APValue.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000020#include "clang/AST/ASTContext.h"
Anders Carlsson4c98efd2009-07-24 15:20:52 +000021#include "clang/AST/RecordLayout.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000022#include "clang/AST/StmtVisitor.h"
Chris Lattner1b63e4f2009-06-14 01:54:56 +000023#include "clang/Basic/Builtins.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000024#include "llvm/IR/Constants.h"
25#include "llvm/IR/DataLayout.h"
26#include "llvm/IR/Function.h"
27#include "llvm/IR/GlobalVariable.h"
Anders Carlsson3b1d57b2008-01-26 01:36:00 +000028using namespace clang;
29using namespace CodeGen;
30
Chris Lattnereba3e5a2010-04-13 17:45:57 +000031//===----------------------------------------------------------------------===//
32// ConstStructBuilder
33//===----------------------------------------------------------------------===//
34
35namespace {
Benjamin Kramer85b45212009-11-28 19:45:26 +000036class ConstStructBuilder {
Anders Carlsson4c98efd2009-07-24 15:20:52 +000037 CodeGenModule &CGM;
38 CodeGenFunction *CGF;
39
Mike Stump1eb44332009-09-09 15:08:12 +000040 bool Packed;
Ken Dyckdc496392011-03-17 01:33:18 +000041 CharUnits NextFieldOffsetInChars;
Ken Dyck7d2f9d52011-03-18 01:26:17 +000042 CharUnits LLVMStructAlignment;
Bill Wendlingcf6511b2012-02-07 00:54:58 +000043 SmallVector<llvm::Constant *, 32> Elements;
Chris Lattnereba3e5a2010-04-13 17:45:57 +000044public:
45 static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
46 InitListExpr *ILE);
Richard Smith2d6a5672012-01-14 04:30:29 +000047 static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
48 const APValue &Value, QualType ValTy);
49
50private:
Anders Carlsson4c98efd2009-07-24 15:20:52 +000051 ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF)
Ken Dyckdc496392011-03-17 01:33:18 +000052 : CGM(CGM), CGF(CGF), Packed(false),
53 NextFieldOffsetInChars(CharUnits::Zero()),
Ken Dyck7d2f9d52011-03-18 01:26:17 +000054 LLVMStructAlignment(CharUnits::One()) { }
Anders Carlsson4c98efd2009-07-24 15:20:52 +000055
Richard Smith2d6a5672012-01-14 04:30:29 +000056 void AppendField(const FieldDecl *Field, uint64_t FieldOffset,
Chris Lattner8ce9e452010-04-13 18:16:19 +000057 llvm::Constant *InitExpr);
Mike Stump1eb44332009-09-09 15:08:12 +000058
Richard Smithc22adbd2012-02-23 08:33:23 +000059 void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst);
60
Chris Lattner18806662010-07-05 17:04:23 +000061 void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
62 llvm::ConstantInt *InitExpr);
Mike Stump1eb44332009-09-09 15:08:12 +000063
Ken Dyckc29ea8f2011-03-11 23:42:54 +000064 void AppendPadding(CharUnits PadSize);
Mike Stump1eb44332009-09-09 15:08:12 +000065
Ken Dyck106ca042011-03-11 02:17:05 +000066 void AppendTailPadding(CharUnits RecordSize);
Anders Carlssond24393b2009-07-27 01:23:51 +000067
Chris Lattnereba3e5a2010-04-13 17:45:57 +000068 void ConvertStructToPacked();
Richard Smith2d6a5672012-01-14 04:30:29 +000069
Chris Lattnereba3e5a2010-04-13 17:45:57 +000070 bool Build(InitListExpr *ILE);
Richard Smithc22adbd2012-02-23 08:33:23 +000071 void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
Timur Iskhodzhanova53d7a02013-09-27 14:48:01 +000072 const CXXRecordDecl *VTableClass, CharUnits BaseOffset);
Richard Smith2d6a5672012-01-14 04:30:29 +000073 llvm::Constant *Finalize(QualType Ty);
Mike Stump1eb44332009-09-09 15:08:12 +000074
Ken Dyck7d2f9d52011-03-18 01:26:17 +000075 CharUnits getAlignment(const llvm::Constant *C) const {
76 if (Packed) return CharUnits::One();
77 return CharUnits::fromQuantity(
Micah Villmow25a6a842012-10-08 16:25:52 +000078 CGM.getDataLayout().getABITypeAlignment(C->getType()));
Anders Carlsson4c98efd2009-07-24 15:20:52 +000079 }
Mike Stump1eb44332009-09-09 15:08:12 +000080
Ken Dyck15c152e2011-03-18 01:12:13 +000081 CharUnits getSizeInChars(const llvm::Constant *C) const {
82 return CharUnits::fromQuantity(
Micah Villmow25a6a842012-10-08 16:25:52 +000083 CGM.getDataLayout().getTypeAllocSize(C->getType()));
Anders Carlsson4c98efd2009-07-24 15:20:52 +000084 }
Anders Carlsson4c98efd2009-07-24 15:20:52 +000085};
Mike Stump1eb44332009-09-09 15:08:12 +000086
Richard Smith2d6a5672012-01-14 04:30:29 +000087void ConstStructBuilder::
Chris Lattner8ce9e452010-04-13 18:16:19 +000088AppendField(const FieldDecl *Field, uint64_t FieldOffset,
89 llvm::Constant *InitCst) {
Ken Dyck6925cc42011-03-15 01:09:02 +000090 const ASTContext &Context = CGM.getContext();
91
92 CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
Chris Lattnereba3e5a2010-04-13 17:45:57 +000093
Richard Smithc22adbd2012-02-23 08:33:23 +000094 AppendBytes(FieldOffsetInChars, InitCst);
95}
96
97void ConstStructBuilder::
98AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) {
99
Ken Dyckdc496392011-03-17 01:33:18 +0000100 assert(NextFieldOffsetInChars <= FieldOffsetInChars
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000101 && "Field offset mismatch!");
102
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000103 CharUnits FieldAlignment = getAlignment(InitCst);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000104
105 // Round up the field offset to the alignment of the field type.
Ken Dyckdc496392011-03-17 01:33:18 +0000106 CharUnits AlignedNextFieldOffsetInChars =
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000107 NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000108
Ken Dyckdc496392011-03-17 01:33:18 +0000109 if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000110 assert(!Packed && "Alignment is wrong even with a packed struct!");
111
112 // Convert the struct to a packed struct.
113 ConvertStructToPacked();
Richard Smith2d6a5672012-01-14 04:30:29 +0000114
Ken Dyckdc496392011-03-17 01:33:18 +0000115 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000116 }
117
Ken Dyckdc496392011-03-17 01:33:18 +0000118 if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000119 // We need to append padding.
Richard Smith2d6a5672012-01-14 04:30:29 +0000120 AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000121
Ken Dyckdc496392011-03-17 01:33:18 +0000122 assert(NextFieldOffsetInChars == FieldOffsetInChars &&
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000123 "Did not add enough padding!");
124
Ken Dyckdc496392011-03-17 01:33:18 +0000125 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000126 }
127
128 // Add the field.
Chris Lattner8ce9e452010-04-13 18:16:19 +0000129 Elements.push_back(InitCst);
Ken Dyckdc496392011-03-17 01:33:18 +0000130 NextFieldOffsetInChars = AlignedNextFieldOffsetInChars +
Ken Dyck15c152e2011-03-18 01:12:13 +0000131 getSizeInChars(InitCst);
Richard Smith2d6a5672012-01-14 04:30:29 +0000132
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000133 if (Packed)
Richard Smith2d6a5672012-01-14 04:30:29 +0000134 assert(LLVMStructAlignment == CharUnits::One() &&
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000135 "Packed struct not byte-aligned!");
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000136 else
137 LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000138}
139
Chris Lattner18806662010-07-05 17:04:23 +0000140void ConstStructBuilder::AppendBitField(const FieldDecl *Field,
141 uint64_t FieldOffset,
142 llvm::ConstantInt *CI) {
Ken Dyckf004da42011-03-12 12:03:11 +0000143 const ASTContext &Context = CGM.getContext();
Ken Dyck4f318c02011-03-19 00:57:28 +0000144 const uint64_t CharWidth = Context.getCharWidth();
Ken Dyckdc496392011-03-17 01:33:18 +0000145 uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
146 if (FieldOffset > NextFieldOffsetInBits) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000147 // We need to add padding.
Ken Dyckf004da42011-03-12 12:03:11 +0000148 CharUnits PadSize = Context.toCharUnitsFromBits(
Ken Dyckdc496392011-03-17 01:33:18 +0000149 llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits,
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000150 Context.getTargetInfo().getCharAlign()));
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000151
Ken Dyckf004da42011-03-12 12:03:11 +0000152 AppendPadding(PadSize);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000153 }
154
Richard Smitha6b8b2c2011-10-10 18:28:20 +0000155 uint64_t FieldSize = Field->getBitWidthValue(Context);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000156
157 llvm::APInt FieldValue = CI->getValue();
158
159 // Promote the size of FieldValue if necessary
160 // FIXME: This should never occur, but currently it can because initializer
161 // constants are cast to bool, and because clang is not enforcing bitfield
162 // width limits.
163 if (FieldSize > FieldValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +0000164 FieldValue = FieldValue.zext(FieldSize);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000165
166 // Truncate the size of FieldValue to the bit field size.
167 if (FieldSize < FieldValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +0000168 FieldValue = FieldValue.trunc(FieldSize);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000169
Ken Dyckdc496392011-03-17 01:33:18 +0000170 NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
171 if (FieldOffset < NextFieldOffsetInBits) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000172 // Either part of the field or the entire field can go into the previous
173 // byte.
174 assert(!Elements.empty() && "Elements can't be empty!");
175
Ken Dyckdc496392011-03-17 01:33:18 +0000176 unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000177
178 bool FitsCompletelyInPreviousByte =
179 BitsInPreviousByte >= FieldValue.getBitWidth();
180
181 llvm::APInt Tmp = FieldValue;
182
183 if (!FitsCompletelyInPreviousByte) {
184 unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
185
Micah Villmow25a6a842012-10-08 16:25:52 +0000186 if (CGM.getDataLayout().isBigEndian()) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000187 Tmp = Tmp.lshr(NewFieldWidth);
Jay Foad9f71a8f2010-12-07 08:25:34 +0000188 Tmp = Tmp.trunc(BitsInPreviousByte);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000189
190 // We want the remaining high bits.
Jay Foad9f71a8f2010-12-07 08:25:34 +0000191 FieldValue = FieldValue.trunc(NewFieldWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000192 } else {
Jay Foad9f71a8f2010-12-07 08:25:34 +0000193 Tmp = Tmp.trunc(BitsInPreviousByte);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000194
195 // We want the remaining low bits.
196 FieldValue = FieldValue.lshr(BitsInPreviousByte);
Jay Foad9f71a8f2010-12-07 08:25:34 +0000197 FieldValue = FieldValue.trunc(NewFieldWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000198 }
199 }
200
Ken Dyck4f318c02011-03-19 00:57:28 +0000201 Tmp = Tmp.zext(CharWidth);
Micah Villmow25a6a842012-10-08 16:25:52 +0000202 if (CGM.getDataLayout().isBigEndian()) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000203 if (FitsCompletelyInPreviousByte)
204 Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
205 } else {
Ken Dyck4f318c02011-03-19 00:57:28 +0000206 Tmp = Tmp.shl(CharWidth - BitsInPreviousByte);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000207 }
208
Chris Lattner2bc00252010-07-05 18:03:30 +0000209 // 'or' in the bits that go into the previous byte.
210 llvm::Value *LastElt = Elements.back();
211 if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt))
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000212 Tmp |= Val->getValue();
Chris Lattner2bc00252010-07-05 18:03:30 +0000213 else {
214 assert(isa<llvm::UndefValue>(LastElt));
215 // If there is an undef field that we're adding to, it can either be a
216 // scalar undef (in which case, we just replace it with our field) or it
217 // is an array. If it is an array, we have to pull one byte off the
218 // array so that the other undef bytes stay around.
219 if (!isa<llvm::IntegerType>(LastElt->getType())) {
220 // The undef padding will be a multibyte array, create a new smaller
221 // padding and then an hole for our i8 to get plopped into.
222 assert(isa<llvm::ArrayType>(LastElt->getType()) &&
223 "Expected array padding of undefs");
Chris Lattner2acc6e32011-07-18 04:24:23 +0000224 llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType());
Ken Dyck4f318c02011-03-19 00:57:28 +0000225 assert(AT->getElementType()->isIntegerTy(CharWidth) &&
Chris Lattner2bc00252010-07-05 18:03:30 +0000226 AT->getNumElements() != 0 &&
227 "Expected non-empty array padding of undefs");
228
229 // Remove the padding array.
Ken Dyckdc496392011-03-17 01:33:18 +0000230 NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements());
Chris Lattner2bc00252010-07-05 18:03:30 +0000231 Elements.pop_back();
232
233 // Add the padding back in two chunks.
Ken Dyckc29ea8f2011-03-11 23:42:54 +0000234 AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1));
235 AppendPadding(CharUnits::One());
Chris Lattner2bc00252010-07-05 18:03:30 +0000236 assert(isa<llvm::UndefValue>(Elements.back()) &&
Ken Dyck4f318c02011-03-19 00:57:28 +0000237 Elements.back()->getType()->isIntegerTy(CharWidth) &&
Chris Lattner2bc00252010-07-05 18:03:30 +0000238 "Padding addition didn't work right");
239 }
240 }
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000241
242 Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
243
244 if (FitsCompletelyInPreviousByte)
Chris Lattner18806662010-07-05 17:04:23 +0000245 return;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000246 }
247
Ken Dyck4f318c02011-03-19 00:57:28 +0000248 while (FieldValue.getBitWidth() > CharWidth) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000249 llvm::APInt Tmp;
250
Micah Villmow25a6a842012-10-08 16:25:52 +0000251 if (CGM.getDataLayout().isBigEndian()) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000252 // We want the high bits.
Ken Dyck4f318c02011-03-19 00:57:28 +0000253 Tmp =
254 FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000255 } else {
256 // We want the low bits.
Ken Dyck4f318c02011-03-19 00:57:28 +0000257 Tmp = FieldValue.trunc(CharWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000258
Ken Dyck4f318c02011-03-19 00:57:28 +0000259 FieldValue = FieldValue.lshr(CharWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000260 }
261
262 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
Ken Dyck199c1892011-03-19 01:28:06 +0000263 ++NextFieldOffsetInChars;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000264
Ken Dyck4f318c02011-03-19 00:57:28 +0000265 FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000266 }
267
268 assert(FieldValue.getBitWidth() > 0 &&
269 "Should have at least one bit left!");
Ken Dyck4f318c02011-03-19 00:57:28 +0000270 assert(FieldValue.getBitWidth() <= CharWidth &&
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000271 "Should not have more than a byte left!");
272
Ken Dyck4f318c02011-03-19 00:57:28 +0000273 if (FieldValue.getBitWidth() < CharWidth) {
Micah Villmow25a6a842012-10-08 16:25:52 +0000274 if (CGM.getDataLayout().isBigEndian()) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000275 unsigned BitWidth = FieldValue.getBitWidth();
276
Ken Dyck4f318c02011-03-19 00:57:28 +0000277 FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000278 } else
Ken Dyck4f318c02011-03-19 00:57:28 +0000279 FieldValue = FieldValue.zext(CharWidth);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000280 }
281
282 // Append the last element.
283 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
284 FieldValue));
Ken Dyck199c1892011-03-19 01:28:06 +0000285 ++NextFieldOffsetInChars;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000286}
287
Ken Dyckc29ea8f2011-03-11 23:42:54 +0000288void ConstStructBuilder::AppendPadding(CharUnits PadSize) {
289 if (PadSize.isZero())
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000290 return;
291
Chris Lattner8b418682012-02-07 00:39:47 +0000292 llvm::Type *Ty = CGM.Int8Ty;
Ken Dyckc29ea8f2011-03-11 23:42:54 +0000293 if (PadSize > CharUnits::One())
294 Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000295
Nuno Lopescdb30b42010-04-16 20:56:35 +0000296 llvm::Constant *C = llvm::UndefValue::get(Ty);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000297 Elements.push_back(C);
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000298 assert(getAlignment(C) == CharUnits::One() &&
299 "Padding must have 1 byte alignment!");
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000300
Ken Dyck15c152e2011-03-18 01:12:13 +0000301 NextFieldOffsetInChars += getSizeInChars(C);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000302}
303
Ken Dyck106ca042011-03-11 02:17:05 +0000304void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) {
Ken Dyckdc496392011-03-17 01:33:18 +0000305 assert(NextFieldOffsetInChars <= RecordSize &&
Ken Dyck106ca042011-03-11 02:17:05 +0000306 "Size mismatch!");
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000307
Ken Dyckdc496392011-03-17 01:33:18 +0000308 AppendPadding(RecordSize - NextFieldOffsetInChars);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000309}
310
311void ConstStructBuilder::ConvertStructToPacked() {
Bill Wendling35f18a52012-02-07 00:04:27 +0000312 SmallVector<llvm::Constant *, 16> PackedElements;
Ken Dyck4a5c87e2011-03-18 00:55:06 +0000313 CharUnits ElementOffsetInChars = CharUnits::Zero();
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000314
315 for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
316 llvm::Constant *C = Elements[i];
317
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000318 CharUnits ElementAlign = CharUnits::fromQuantity(
Micah Villmow25a6a842012-10-08 16:25:52 +0000319 CGM.getDataLayout().getABITypeAlignment(C->getType()));
Ken Dyck4a5c87e2011-03-18 00:55:06 +0000320 CharUnits AlignedElementOffsetInChars =
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000321 ElementOffsetInChars.RoundUpToAlignment(ElementAlign);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000322
Ken Dyck4a5c87e2011-03-18 00:55:06 +0000323 if (AlignedElementOffsetInChars > ElementOffsetInChars) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000324 // We need some padding.
Ken Dyck4a5c87e2011-03-18 00:55:06 +0000325 CharUnits NumChars =
326 AlignedElementOffsetInChars - ElementOffsetInChars;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000327
Chris Lattner8b418682012-02-07 00:39:47 +0000328 llvm::Type *Ty = CGM.Int8Ty;
Ken Dyck4a5c87e2011-03-18 00:55:06 +0000329 if (NumChars > CharUnits::One())
330 Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity());
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000331
Nuno Lopescdb30b42010-04-16 20:56:35 +0000332 llvm::Constant *Padding = llvm::UndefValue::get(Ty);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000333 PackedElements.push_back(Padding);
Ken Dyck15c152e2011-03-18 01:12:13 +0000334 ElementOffsetInChars += getSizeInChars(Padding);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000335 }
336
337 PackedElements.push_back(C);
Ken Dyck15c152e2011-03-18 01:12:13 +0000338 ElementOffsetInChars += getSizeInChars(C);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000339 }
340
Ken Dyck4a5c87e2011-03-18 00:55:06 +0000341 assert(ElementOffsetInChars == NextFieldOffsetInChars &&
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000342 "Packing the struct changed its size!");
343
Bill Wendling35f18a52012-02-07 00:04:27 +0000344 Elements.swap(PackedElements);
Ken Dyck7d2f9d52011-03-18 01:26:17 +0000345 LLVMStructAlignment = CharUnits::One();
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000346 Packed = true;
347}
348
349bool ConstStructBuilder::Build(InitListExpr *ILE) {
350 RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
351 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
352
353 unsigned FieldNo = 0;
354 unsigned ElementNo = 0;
Fariborz Jahanian07a8a212011-04-28 22:49:46 +0000355
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000356 for (RecordDecl::field_iterator Field = RD->field_begin(),
Chris Lattner8ce9e452010-04-13 18:16:19 +0000357 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
Chris Lattner8ce9e452010-04-13 18:16:19 +0000358 // If this is a union, skip all the fields that aren't being initialized.
David Blaikie581deb32012-06-06 20:45:41 +0000359 if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000360 continue;
361
Chris Lattner8ce9e452010-04-13 18:16:19 +0000362 // Don't emit anonymous bitfields, they just affect layout.
Eli Friedmancd06f262013-06-26 20:50:34 +0000363 if (Field->isUnnamedBitfield())
Chris Lattner8ce9e452010-04-13 18:16:19 +0000364 continue;
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000365
Chris Lattner8ce9e452010-04-13 18:16:19 +0000366 // Get the initializer. A struct can include fields without initializers,
367 // we just use explicit null values for them.
368 llvm::Constant *EltInit;
369 if (ElementNo < ILE->getNumInits())
370 EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++),
371 Field->getType(), CGF);
372 else
373 EltInit = CGM.EmitNullConstant(Field->getType());
Eli Friedmanf0ca0ee2010-07-17 23:55:01 +0000374
375 if (!EltInit)
376 return false;
Chris Lattner8ce9e452010-04-13 18:16:19 +0000377
378 if (!Field->isBitField()) {
379 // Handle non-bitfield members.
David Blaikie581deb32012-06-06 20:45:41 +0000380 AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit);
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000381 } else {
Chris Lattner8ce9e452010-04-13 18:16:19 +0000382 // Otherwise we have a bitfield.
David Blaikie581deb32012-06-06 20:45:41 +0000383 AppendBitField(*Field, Layout.getFieldOffset(FieldNo),
Chris Lattner18806662010-07-05 17:04:23 +0000384 cast<llvm::ConstantInt>(EltInit));
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000385 }
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000386 }
387
Richard Smith2d6a5672012-01-14 04:30:29 +0000388 return true;
389}
390
Richard Smithc22adbd2012-02-23 08:33:23 +0000391namespace {
392struct BaseInfo {
393 BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
394 : Decl(Decl), Offset(Offset), Index(Index) {
395 }
396
397 const CXXRecordDecl *Decl;
398 CharUnits Offset;
399 unsigned Index;
400
401 bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
402};
403}
404
405void ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
Timur Iskhodzhanova53d7a02013-09-27 14:48:01 +0000406 bool IsPrimaryBase,
Richard Smithc22adbd2012-02-23 08:33:23 +0000407 const CXXRecordDecl *VTableClass,
408 CharUnits Offset) {
Richard Smith2d6a5672012-01-14 04:30:29 +0000409 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
410
Richard Smithc22adbd2012-02-23 08:33:23 +0000411 if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
412 // Add a vtable pointer, if we need one and it hasn't already been added.
Timur Iskhodzhanova53d7a02013-09-27 14:48:01 +0000413 if (CD->isDynamicClass() && !IsPrimaryBase) {
414 llvm::Constant *VTableAddressPoint =
415 CGM.getCXXABI().getVTableAddressPointForConstExpr(
416 BaseSubobject(CD, Offset), VTableClass);
417 AppendBytes(Offset, VTableAddressPoint);
418 }
Richard Smithc22adbd2012-02-23 08:33:23 +0000419
420 // Accumulate and sort bases, in order to visit them in address order, which
421 // may not be the same as declaration order.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000422 SmallVector<BaseInfo, 8> Bases;
Richard Smithc22adbd2012-02-23 08:33:23 +0000423 Bases.reserve(CD->getNumBases());
Richard Smith2d6a5672012-01-14 04:30:29 +0000424 unsigned BaseNo = 0;
Richard Smithc22adbd2012-02-23 08:33:23 +0000425 for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
Richard Smith2d6a5672012-01-14 04:30:29 +0000426 BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
Richard Smithc22adbd2012-02-23 08:33:23 +0000427 assert(!Base->isVirtual() && "should not have virtual bases here");
Richard Smith2d6a5672012-01-14 04:30:29 +0000428 const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
429 CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
Richard Smithc22adbd2012-02-23 08:33:23 +0000430 Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
431 }
432 std::stable_sort(Bases.begin(), Bases.end());
Richard Smith2d6a5672012-01-14 04:30:29 +0000433
Richard Smithc22adbd2012-02-23 08:33:23 +0000434 for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
435 BaseInfo &Base = Bases[I];
Richard Smith2d6a5672012-01-14 04:30:29 +0000436
Richard Smithc22adbd2012-02-23 08:33:23 +0000437 bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
438 Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
Timur Iskhodzhanova53d7a02013-09-27 14:48:01 +0000439 VTableClass, Offset + Base.Offset);
Richard Smith2d6a5672012-01-14 04:30:29 +0000440 }
441 }
442
443 unsigned FieldNo = 0;
Eli Friedman5fe61c62012-03-30 03:55:31 +0000444 uint64_t OffsetBits = CGM.getContext().toBits(Offset);
Richard Smith2d6a5672012-01-14 04:30:29 +0000445
446 for (RecordDecl::field_iterator Field = RD->field_begin(),
447 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
Richard Smith2d6a5672012-01-14 04:30:29 +0000448 // If this is a union, skip all the fields that aren't being initialized.
David Blaikie581deb32012-06-06 20:45:41 +0000449 if (RD->isUnion() && Val.getUnionField() != *Field)
Richard Smith2d6a5672012-01-14 04:30:29 +0000450 continue;
451
452 // Don't emit anonymous bitfields, they just affect layout.
Eli Friedmancd06f262013-06-26 20:50:34 +0000453 if (Field->isUnnamedBitfield())
Richard Smith2d6a5672012-01-14 04:30:29 +0000454 continue;
Richard Smith2d6a5672012-01-14 04:30:29 +0000455
456 // Emit the value of the initializer.
457 const APValue &FieldValue =
458 RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
459 llvm::Constant *EltInit =
Richard Smitha3ca41f2012-03-02 23:27:11 +0000460 CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF);
Richard Smith2d6a5672012-01-14 04:30:29 +0000461 assert(EltInit && "EmitConstantValue can't fail");
462
463 if (!Field->isBitField()) {
464 // Handle non-bitfield members.
David Blaikie581deb32012-06-06 20:45:41 +0000465 AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit);
Richard Smith2d6a5672012-01-14 04:30:29 +0000466 } else {
467 // Otherwise we have a bitfield.
David Blaikie581deb32012-06-06 20:45:41 +0000468 AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
Richard Smith2d6a5672012-01-14 04:30:29 +0000469 cast<llvm::ConstantInt>(EltInit));
470 }
471 }
472}
473
474llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) {
475 RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
476 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
477
Ken Dyckdc496392011-03-17 01:33:18 +0000478 CharUnits LayoutSizeInChars = Layout.getSize();
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000479
Ken Dyckdc496392011-03-17 01:33:18 +0000480 if (NextFieldOffsetInChars > LayoutSizeInChars) {
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000481 // If the struct is bigger than the size of the record type,
482 // we must have a flexible array member at the end.
483 assert(RD->hasFlexibleArrayMember() &&
484 "Must have flexible array member if struct is bigger than type!");
Richard Smith2d6a5672012-01-14 04:30:29 +0000485
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000486 // No tail padding is necessary.
Richard Smith2d6a5672012-01-14 04:30:29 +0000487 } else {
488 // Append tail padding if necessary.
489 AppendTailPadding(LayoutSizeInChars);
490
491 CharUnits LLVMSizeInChars =
492 NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment);
493
494 // Check if we need to convert the struct to a packed struct.
495 if (NextFieldOffsetInChars <= LayoutSizeInChars &&
496 LLVMSizeInChars > LayoutSizeInChars) {
497 assert(!Packed && "Size mismatch!");
498
499 ConvertStructToPacked();
500 assert(NextFieldOffsetInChars <= LayoutSizeInChars &&
501 "Converting to packed did not help!");
502 }
503
504 assert(LayoutSizeInChars == NextFieldOffsetInChars &&
505 "Tail padding mismatch!");
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000506 }
507
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000508 // Pick the type to use. If the type is layout identical to the ConvertType
509 // type then use it, otherwise use whatever the builder produced for us.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000510 llvm::StructType *STy =
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000511 llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(),
Richard Smith2d6a5672012-01-14 04:30:29 +0000512 Elements, Packed);
513 llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty);
514 if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) {
515 if (ValSTy->isLayoutIdentical(STy))
516 STy = ValSTy;
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000517 }
Richard Smith2d6a5672012-01-14 04:30:29 +0000518
519 llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements);
520
521 assert(NextFieldOffsetInChars.RoundUpToAlignment(getAlignment(Result)) ==
522 getSizeInChars(Result) && "Size mismatch!");
523
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000524 return Result;
525}
526
Richard Smith2d6a5672012-01-14 04:30:29 +0000527llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
528 CodeGenFunction *CGF,
529 InitListExpr *ILE) {
530 ConstStructBuilder Builder(CGM, CGF);
531
532 if (!Builder.Build(ILE))
533 return 0;
534
535 return Builder.Finalize(ILE->getType());
536}
537
538llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
539 CodeGenFunction *CGF,
540 const APValue &Val,
541 QualType ValTy) {
542 ConstStructBuilder Builder(CGM, CGF);
Richard Smithc22adbd2012-02-23 08:33:23 +0000543
544 const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
545 const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
Timur Iskhodzhanova53d7a02013-09-27 14:48:01 +0000546 Builder.Build(Val, RD, false, CD, CharUnits::Zero());
Richard Smithc22adbd2012-02-23 08:33:23 +0000547
Richard Smith2d6a5672012-01-14 04:30:29 +0000548 return Builder.Finalize(ValTy);
549}
550
551
Chris Lattnereba3e5a2010-04-13 17:45:57 +0000552//===----------------------------------------------------------------------===//
553// ConstExprEmitter
554//===----------------------------------------------------------------------===//
Richard Smithe7aa62d2012-01-17 21:42:19 +0000555
556/// This class only needs to handle two cases:
557/// 1) Literals (this is used by APValue emission to emit literals).
558/// 2) Arrays, structs and unions (outside C++11 mode, we don't currently
559/// constant fold these types).
Benjamin Kramer85b45212009-11-28 19:45:26 +0000560class ConstExprEmitter :
Anders Carlsson84005b42008-01-26 04:30:23 +0000561 public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000562 CodeGenModule &CGM;
Lauro Ramos Venancio81373352008-02-26 21:41:45 +0000563 CodeGenFunction *CGF;
Owen Andersona1cf15f2009-07-14 23:10:40 +0000564 llvm::LLVMContext &VMContext;
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000565public:
Lauro Ramos Venancio81373352008-02-26 21:41:45 +0000566 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
Owen Andersona1cf15f2009-07-14 23:10:40 +0000567 : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) {
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000568 }
Mike Stump1eb44332009-09-09 15:08:12 +0000569
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000570 //===--------------------------------------------------------------------===//
571 // Visitor Methods
572 //===--------------------------------------------------------------------===//
Mike Stump1eb44332009-09-09 15:08:12 +0000573
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000574 llvm::Constant *VisitStmt(Stmt *S) {
Anders Carlsson069880e2009-03-03 16:43:34 +0000575 return 0;
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000576 }
Mike Stump1eb44332009-09-09 15:08:12 +0000577
578 llvm::Constant *VisitParenExpr(ParenExpr *PE) {
579 return Visit(PE->getSubExpr());
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000580 }
Mike Stump1eb44332009-09-09 15:08:12 +0000581
John McCall91a57552011-07-15 05:09:51 +0000582 llvm::Constant *
583 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
584 return Visit(PE->getReplacement());
585 }
586
Peter Collingbournef111d932011-04-15 00:35:48 +0000587 llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
588 return Visit(GE->getResultExpr());
589 }
590
Eli Friedman21cde052013-07-16 22:40:53 +0000591 llvm::Constant *VisitChooseExpr(ChooseExpr *CE) {
Eli Friedmana5e66012013-07-20 00:40:58 +0000592 return Visit(CE->getChosenSubExpr());
Eli Friedman21cde052013-07-16 22:40:53 +0000593 }
594
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000595 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
596 return Visit(E->getInitializer());
597 }
John McCall5808ce42011-02-03 08:15:49 +0000598
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +0000599 llvm::Constant *VisitCastExpr(CastExpr* E) {
John McCall8bba1f42011-03-15 21:17:48 +0000600 Expr *subExpr = E->getSubExpr();
601 llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF);
602 if (!C) return 0;
603
Chris Lattner2acc6e32011-07-18 04:24:23 +0000604 llvm::Type *destType = ConvertType(E->getType());
John McCall8bba1f42011-03-15 21:17:48 +0000605
Anders Carlsson0086ccb2009-08-22 23:54:44 +0000606 switch (E->getCastKind()) {
John McCall2de56d12010-08-25 11:45:40 +0000607 case CK_ToUnion: {
Anders Carlsson0086ccb2009-08-22 23:54:44 +0000608 // GCC cast to union extension
609 assert(E->getType()->isUnionType() &&
610 "Destination type is not union type!");
Mike Stump1eb44332009-09-09 15:08:12 +0000611
Anders Carlssonaaed50d2009-07-31 21:38:39 +0000612 // Build a struct with the union sub-element as the first member,
613 // and padded to the appropriate size
Bill Wendlingf9ea9532012-02-07 00:13:27 +0000614 SmallVector<llvm::Constant*, 2> Elts;
615 SmallVector<llvm::Type*, 2> Types;
Anders Carlssonaaed50d2009-07-31 21:38:39 +0000616 Elts.push_back(C);
617 Types.push_back(C->getType());
Micah Villmow25a6a842012-10-08 16:25:52 +0000618 unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType());
619 unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destType);
Mike Stump1eb44332009-09-09 15:08:12 +0000620
Anders Carlssonaaed50d2009-07-31 21:38:39 +0000621 assert(CurSize <= TotalSize && "Union size mismatch!");
622 if (unsigned NumPadBytes = TotalSize - CurSize) {
Chris Lattner8b418682012-02-07 00:39:47 +0000623 llvm::Type *Ty = CGM.Int8Ty;
Anders Carlssonaaed50d2009-07-31 21:38:39 +0000624 if (NumPadBytes > 1)
625 Ty = llvm::ArrayType::get(Ty, NumPadBytes);
Anders Carlsson0086ccb2009-08-22 23:54:44 +0000626
Nuno Lopescdb30b42010-04-16 20:56:35 +0000627 Elts.push_back(llvm::UndefValue::get(Ty));
Anders Carlssonaaed50d2009-07-31 21:38:39 +0000628 Types.push_back(Ty);
629 }
Mike Stump1eb44332009-09-09 15:08:12 +0000630
Anders Carlsson0086ccb2009-08-22 23:54:44 +0000631 llvm::StructType* STy =
632 llvm::StructType::get(C->getType()->getContext(), Types, false);
Anders Carlssonaaed50d2009-07-31 21:38:39 +0000633 return llvm::ConstantStruct::get(STy, Elts);
Nuno Lopes81e51e22009-01-17 00:48:48 +0000634 }
Anders Carlssonbb378cb2009-10-18 20:31:03 +0000635
John McCall8bba1f42011-03-15 21:17:48 +0000636 case CK_LValueToRValue:
David Chisnall7a7ee302012-01-16 17:27:18 +0000637 case CK_AtomicToNonAtomic:
638 case CK_NonAtomicToAtomic:
John McCall8bba1f42011-03-15 21:17:48 +0000639 case CK_NoOp:
Eli Friedman21cde052013-07-16 22:40:53 +0000640 case CK_ConstructorConversion:
John McCall8bba1f42011-03-15 21:17:48 +0000641 return C;
Anders Carlssonbb378cb2009-10-18 20:31:03 +0000642
John McCall8bba1f42011-03-15 21:17:48 +0000643 case CK_Dependent: llvm_unreachable("saw dependent cast!");
644
Eli Friedmana6c66ce2012-08-31 00:14:07 +0000645 case CK_BuiltinFnToFnPtr:
646 llvm_unreachable("builtin functions are handled elsewhere");
647
John McCall4d4e5c12012-02-15 01:22:51 +0000648 case CK_ReinterpretMemberPointer:
649 case CK_DerivedToBaseMemberPointer:
650 case CK_BaseToDerivedMemberPointer:
651 return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
652
John McCall8bba1f42011-03-15 21:17:48 +0000653 // These will never be supported.
654 case CK_ObjCObjectLValueCast:
John McCall33e56f32011-09-10 06:18:15 +0000655 case CK_ARCProduceObject:
656 case CK_ARCConsumeObject:
657 case CK_ARCReclaimReturnedObject:
658 case CK_ARCExtendBlockObject:
Douglas Gregorac1303e2012-02-22 05:02:47 +0000659 case CK_CopyAndAutoreleaseBlockObject:
John McCall8bba1f42011-03-15 21:17:48 +0000660 return 0;
661
Eli Friedman65639282012-01-04 23:13:47 +0000662 // These don't need to be handled here because Evaluate knows how to
Richard Smithe7aa62d2012-01-17 21:42:19 +0000663 // evaluate them in the cases where they can be folded.
John McCall4d4e5c12012-02-15 01:22:51 +0000664 case CK_BitCast:
Richard Smithe7aa62d2012-01-17 21:42:19 +0000665 case CK_ToVoid:
666 case CK_Dynamic:
667 case CK_LValueBitCast:
668 case CK_NullToMemberPointer:
Richard Smithe7aa62d2012-01-17 21:42:19 +0000669 case CK_UserDefinedConversion:
Eli Friedman65639282012-01-04 23:13:47 +0000670 case CK_CPointerToObjCPointerCast:
671 case CK_BlockPointerToObjCPointerCast:
672 case CK_AnyPointerToBlockPointerCast:
John McCall8bba1f42011-03-15 21:17:48 +0000673 case CK_ArrayToPointerDecay:
674 case CK_FunctionToPointerDecay:
675 case CK_BaseToDerived:
676 case CK_DerivedToBase:
677 case CK_UncheckedDerivedToBase:
678 case CK_MemberPointerToBoolean:
679 case CK_VectorSplat:
680 case CK_FloatingRealToComplex:
681 case CK_FloatingComplexToReal:
682 case CK_FloatingComplexToBoolean:
683 case CK_FloatingComplexCast:
684 case CK_FloatingComplexToIntegralComplex:
685 case CK_IntegralRealToComplex:
686 case CK_IntegralComplexToReal:
687 case CK_IntegralComplexToBoolean:
688 case CK_IntegralComplexCast:
689 case CK_IntegralComplexToFloatingComplex:
John McCall8bba1f42011-03-15 21:17:48 +0000690 case CK_PointerToIntegral:
John McCall8bba1f42011-03-15 21:17:48 +0000691 case CK_PointerToBoolean:
John McCall8bba1f42011-03-15 21:17:48 +0000692 case CK_NullToPointer:
Eli Friedman65639282012-01-04 23:13:47 +0000693 case CK_IntegralCast:
694 case CK_IntegralToPointer:
John McCall8bba1f42011-03-15 21:17:48 +0000695 case CK_IntegralToBoolean:
John McCall8bba1f42011-03-15 21:17:48 +0000696 case CK_IntegralToFloating:
John McCall8bba1f42011-03-15 21:17:48 +0000697 case CK_FloatingToIntegral:
John McCall8bba1f42011-03-15 21:17:48 +0000698 case CK_FloatingToBoolean:
John McCall8bba1f42011-03-15 21:17:48 +0000699 case CK_FloatingCast:
Guy Benyeie6b9d802013-01-20 12:31:11 +0000700 case CK_ZeroToOCLEvent:
Eli Friedman65639282012-01-04 23:13:47 +0000701 return 0;
Anders Carlsson0086ccb2009-08-22 23:54:44 +0000702 }
Matt Beaumont-Gay17d12fe2011-03-17 00:46:34 +0000703 llvm_unreachable("Invalid CastKind");
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000704 }
Devang Pateleae15602008-02-05 02:39:50 +0000705
Chris Lattner04421082008-04-08 04:40:51 +0000706 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
707 return Visit(DAE->getExpr());
708 }
709
Richard Smithc3bf52c2013-04-20 22:23:05 +0000710 llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
711 // No need for a DefaultInitExprScope: we don't handle 'this' in a
712 // constant expression.
713 return Visit(DIE->getExpr());
714 }
715
Douglas Gregor03e80032011-06-21 17:03:29 +0000716 llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
717 return Visit(E->GetTemporaryExpr());
718 }
719
Eli Friedmana8234002008-05-30 10:24:46 +0000720 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
Richard Smithfe587202012-04-15 02:50:59 +0000721 if (ILE->isStringLiteralInit())
Nuno Lopesa75b71f2010-04-18 19:06:43 +0000722 return Visit(ILE->getInit(0));
723
Chris Lattner2acc6e32011-07-18 04:24:23 +0000724 llvm::ArrayType *AType =
Nuno Lopes67847042010-04-16 23:19:41 +0000725 cast<llvm::ArrayType>(ConvertType(ILE->getType()));
Chris Lattner2acc6e32011-07-18 04:24:23 +0000726 llvm::Type *ElemTy = AType->getElementType();
Richard Smithfe587202012-04-15 02:50:59 +0000727 unsigned NumInitElements = ILE->getNumInits();
Devang Pateleae15602008-02-05 02:39:50 +0000728 unsigned NumElements = AType->getNumElements();
729
Mike Stump1eb44332009-09-09 15:08:12 +0000730 // Initialising an array requires us to automatically
Devang Pateleae15602008-02-05 02:39:50 +0000731 // initialise any elements that have not been initialised explicitly
732 unsigned NumInitableElts = std::min(NumInitElements, NumElements);
733
734 // Copy initializer elements.
Bill Wendlingf9ea9532012-02-07 00:13:27 +0000735 std::vector<llvm::Constant*> Elts;
736 Elts.reserve(NumInitableElts + NumElements);
Benjamin Kramer14c59822012-02-14 12:06:21 +0000737
Eli Friedmana04a1532008-05-30 19:58:50 +0000738 bool RewriteType = false;
Benjamin Kramer14c59822012-02-14 12:06:21 +0000739 for (unsigned i = 0; i < NumInitableElts; ++i) {
Anders Carlssone9352cc2009-04-08 04:48:15 +0000740 Expr *Init = ILE->getInit(i);
741 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
Daniel Dunbard60f2fb2009-02-17 18:43:32 +0000742 if (!C)
743 return 0;
Eli Friedmana04a1532008-05-30 19:58:50 +0000744 RewriteType |= (C->getType() != ElemTy);
Devang Pateleae15602008-02-05 02:39:50 +0000745 Elts.push_back(C);
746 }
Eli Friedmana04a1532008-05-30 19:58:50 +0000747
Devang Pateleae15602008-02-05 02:39:50 +0000748 // Initialize remaining array elements.
Eli Friedman0f593122009-04-13 21:47:26 +0000749 // FIXME: This doesn't handle member pointers correctly!
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000750 llvm::Constant *fillC;
751 if (Expr *filler = ILE->getArrayFiller())
752 fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF);
753 else
754 fillC = llvm::Constant::getNullValue(ElemTy);
755 if (!fillC)
756 return 0;
757 RewriteType |= (fillC->getType() != ElemTy);
Benjamin Kramer14c59822012-02-14 12:06:21 +0000758 Elts.resize(NumElements, fillC);
Devang Pateleae15602008-02-05 02:39:50 +0000759
Eli Friedmana04a1532008-05-30 19:58:50 +0000760 if (RewriteType) {
761 // FIXME: Try to avoid packing the array
Jay Foadef6de3d2011-07-11 09:56:20 +0000762 std::vector<llvm::Type*> Types;
Bill Wendlingf9ea9532012-02-07 00:13:27 +0000763 Types.reserve(NumInitableElts + NumElements);
Bill Wendlingfd3e5ef2012-02-06 23:46:08 +0000764 for (unsigned i = 0, e = Elts.size(); i < e; ++i)
Eli Friedmana04a1532008-05-30 19:58:50 +0000765 Types.push_back(Elts[i]->getType());
Chris Lattner2acc6e32011-07-18 04:24:23 +0000766 llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
Owen Anderson47a434f2009-08-05 23:18:46 +0000767 Types, true);
Owen Anderson08e25242009-07-27 22:29:56 +0000768 return llvm::ConstantStruct::get(SType, Elts);
Eli Friedmana04a1532008-05-30 19:58:50 +0000769 }
770
Mike Stump1eb44332009-09-09 15:08:12 +0000771 return llvm::ConstantArray::get(AType, Elts);
Devang Pateleae15602008-02-05 02:39:50 +0000772 }
773
Richard Smith1b5c3362012-09-11 05:51:06 +0000774 llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) {
Anders Carlssonf6c43962009-07-31 21:34:04 +0000775 return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
Eli Friedmana8234002008-05-30 10:24:46 +0000776 }
777
Anders Carlsson7d801ea2009-01-30 06:13:25 +0000778 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
Eli Friedman0f593122009-04-13 21:47:26 +0000779 return CGM.EmitNullConstant(E->getType());
Anders Carlsson7d801ea2009-01-30 06:13:25 +0000780 }
Mike Stump1eb44332009-09-09 15:08:12 +0000781
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000782 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
Eli Friedmana8234002008-05-30 10:24:46 +0000783 if (ILE->getType()->isArrayType())
784 return EmitArrayInitialization(ILE);
Devang Patel47fb6972008-01-29 23:23:18 +0000785
Jin-Gu Kang45e4e082012-09-05 08:37:43 +0000786 if (ILE->getType()->isRecordType())
Richard Smith1b5c3362012-09-11 05:51:06 +0000787 return EmitRecordInitialization(ILE);
Jin-Gu Kang45e4e082012-09-05 08:37:43 +0000788
Eli Friedman7ead5c72012-01-10 04:58:17 +0000789 return 0;
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000790 }
Eli Friedman3b707e72008-02-21 17:57:49 +0000791
John McCallfb8b69a2010-02-02 08:02:49 +0000792 llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
793 if (!E->getConstructor()->isTrivial())
794 return 0;
795
Anders Carlsson2ca4f632010-02-05 18:38:45 +0000796 QualType Ty = E->getType();
797
798 // FIXME: We should not have to call getBaseElementType here.
799 const RecordType *RT =
800 CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>();
801 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
802
803 // If the class doesn't have a trivial destructor, we can't emit it as a
804 // constant expr.
805 if (!RD->hasTrivialDestructor())
806 return 0;
807
John McCallfb8b69a2010-02-02 08:02:49 +0000808 // Only copy and default constructors can be trivial.
809
John McCallfb8b69a2010-02-02 08:02:49 +0000810
811 if (E->getNumArgs()) {
812 assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
Sebastian Redl85ea7aa2011-08-30 19:58:05 +0000813 assert(E->getConstructor()->isCopyOrMoveConstructor() &&
814 "trivial ctor has argument but isn't a copy/move ctor");
John McCallfb8b69a2010-02-02 08:02:49 +0000815
816 Expr *Arg = E->getArg(0);
817 assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
818 "argument to copy ctor is of wrong type");
819
Chandler Carruth878b55c2010-02-02 12:15:55 +0000820 return Visit(Arg);
John McCallfb8b69a2010-02-02 08:02:49 +0000821 }
822
823 return CGM.EmitNullConstant(Ty);
824 }
825
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000826 llvm::Constant *VisitStringLiteral(StringLiteral *E) {
Eli Friedman64f45a22011-11-01 02:23:42 +0000827 return CGM.GetConstantArrayFromStringLiteral(E);
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000828 }
829
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000830 llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
831 // This must be an @encode initializing an array in a static initializer.
832 // Don't emit it as the address of the string, emit the string data itself
833 // as an inline array.
834 std::string Str;
835 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
836 const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
Mike Stump1eb44332009-09-09 15:08:12 +0000837
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000838 // Resize the string to the right size, adding zeros at the end, or
839 // truncating as needed.
840 Str.resize(CAT->getSize().getZExtValue(), '\0');
Chris Lattner94010692012-02-05 02:30:40 +0000841 return llvm::ConstantDataArray::getString(VMContext, Str, false);
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000842 }
Mike Stump1eb44332009-09-09 15:08:12 +0000843
Eli Friedmanbc5ed6e2008-05-29 11:22:45 +0000844 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
845 return Visit(E->getSubExpr());
846 }
Mike Stumpb83d2872009-02-19 22:01:56 +0000847
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000848 // Utility methods
Chris Lattner2acc6e32011-07-18 04:24:23 +0000849 llvm::Type *ConvertType(QualType T) {
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000850 return CGM.getTypes().ConvertType(T);
851 }
Anders Carlsson84005b42008-01-26 04:30:23 +0000852
Anders Carlsson5ea7d072008-11-16 06:23:45 +0000853public:
Richard Smith1bf9a9e2011-11-12 22:28:03 +0000854 llvm::Constant *EmitLValue(APValue::LValueBase LVBase) {
855 if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) {
Rafael Espindolada182612010-03-04 21:26:03 +0000856 if (Decl->hasAttr<WeakRefAttr>())
Eli Friedmana7e68452010-08-22 01:00:03 +0000857 return CGM.GetWeakRefReference(Decl);
Anders Carlssone3d3b7d2008-01-26 02:08:50 +0000858 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
Anders Carlsson555b4bb2009-09-10 23:43:36 +0000859 return CGM.GetAddrOfFunction(FD);
Steve Naroff248a7532008-04-15 22:42:06 +0000860 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
Daniel Dunbard01b6692009-02-24 18:41:57 +0000861 // We can never refer to a variable with local storage.
Mike Stump1eb44332009-09-09 15:08:12 +0000862 if (!VD->hasLocalStorage()) {
Daniel Dunbard01b6692009-02-24 18:41:57 +0000863 if (VD->isFileVarDecl() || VD->hasExternalStorage())
864 return CGM.GetAddrOfGlobalVar(VD);
Eli Friedman89e19b42013-01-03 00:39:26 +0000865 else if (VD->isLocalVarDecl())
866 return CGM.getStaticLocalDeclAddress(VD);
Steve Naroff248a7532008-04-15 22:42:06 +0000867 }
Lauro Ramos Venancio81373352008-02-26 21:41:45 +0000868 }
Richard Smith1bf9a9e2011-11-12 22:28:03 +0000869 return 0;
870 }
871
872 Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>());
873 switch (E->getStmtClass()) {
874 default: break;
875 case Expr::CompoundLiteralExprClass: {
876 // Note that due to the nature of compound literals, this is guaranteed
877 // to be the only use of the variable, so we just generate it here.
878 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
Eli Friedman58c65fc2011-12-22 00:04:00 +0000879 llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(),
880 CLE->getType(), CGF);
Richard Smith1bf9a9e2011-11-12 22:28:03 +0000881 // FIXME: "Leaked" on failure.
882 if (C)
883 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
884 E->getType().isConstant(CGM.getContext()),
885 llvm::GlobalValue::InternalLinkage,
Hans Wennborg5e2d5de2012-06-23 11:51:46 +0000886 C, ".compoundliteral", 0,
887 llvm::GlobalVariable::NotThreadLocal,
Richard Smith1bf9a9e2011-11-12 22:28:03 +0000888 CGM.getContext().getTargetAddressSpace(E->getType()));
889 return C;
Anders Carlssone3d3b7d2008-01-26 02:08:50 +0000890 }
Daniel Dunbar61432932008-08-13 23:20:05 +0000891 case Expr::StringLiteralClass:
892 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000893 case Expr::ObjCEncodeExprClass:
894 return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
Anders Carlsson5ea7d072008-11-16 06:23:45 +0000895 case Expr::ObjCStringLiteralClass: {
896 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
David Chisnall0d13f6f2010-01-23 02:40:42 +0000897 llvm::Constant *C =
898 CGM.getObjCRuntime().GenerateConstantString(SL->getString());
Owen Anderson3c4972d2009-07-29 18:54:39 +0000899 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
Anders Carlsson5ea7d072008-11-16 06:23:45 +0000900 }
Chris Lattner35345642008-12-12 05:18:02 +0000901 case Expr::PredefinedExprClass: {
Eli Friedmanf70b24e2009-11-14 08:37:13 +0000902 unsigned Type = cast<PredefinedExpr>(E)->getIdentType();
903 if (CGF) {
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +0000904 LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E));
Eli Friedmanf70b24e2009-11-14 08:37:13 +0000905 return cast<llvm::Constant>(Res.getAddress());
906 } else if (Type == PredefinedExpr::PrettyFunction) {
907 return CGM.GetAddrOfConstantCString("top level", ".tmp");
908 }
Mike Stump1eb44332009-09-09 15:08:12 +0000909
Eli Friedmanf70b24e2009-11-14 08:37:13 +0000910 return CGM.GetAddrOfConstantCString("", ".tmp");
Chris Lattner35345642008-12-12 05:18:02 +0000911 }
Eli Friedmanf0115892009-01-25 01:21:06 +0000912 case Expr::AddrLabelExprClass: {
913 assert(CGF && "Invalid address of label expression outside function.");
Chris Lattnerd9becd12009-10-28 23:59:40 +0000914 llvm::Constant *Ptr =
915 CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
916 return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType()));
Eli Friedmanf0115892009-01-25 01:21:06 +0000917 }
Eli Friedman3941b182009-01-25 01:54:01 +0000918 case Expr::CallExprClass: {
919 CallExpr* CE = cast<CallExpr>(E);
Richard Smith180f4792011-11-10 06:34:14 +0000920 unsigned builtin = CE->isBuiltinCall();
David Chisnall0d13f6f2010-01-23 02:40:42 +0000921 if (builtin !=
922 Builtin::BI__builtin___CFStringMakeConstantString &&
923 builtin !=
924 Builtin::BI__builtin___NSStringMakeConstantString)
Eli Friedman3941b182009-01-25 01:54:01 +0000925 break;
926 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
927 const StringLiteral *Literal = cast<StringLiteral>(Arg);
David Chisnall0d13f6f2010-01-23 02:40:42 +0000928 if (builtin ==
929 Builtin::BI__builtin___NSStringMakeConstantString) {
930 return CGM.getObjCRuntime().GenerateConstantString(Literal);
931 }
Steve Naroff33fdb732009-03-31 16:53:37 +0000932 // FIXME: need to deal with UCN conversion issues.
Steve Naroff8d4141f2009-04-01 13:55:36 +0000933 return CGM.GetAddrOfConstantCFString(Literal);
Eli Friedman3941b182009-01-25 01:54:01 +0000934 }
Mike Stumpbd65cac2009-02-19 01:01:04 +0000935 case Expr::BlockExprClass: {
Anders Carlsson4de9fce2009-03-01 01:09:12 +0000936 std::string FunctionName;
937 if (CGF)
938 FunctionName = CGF->CurFn->getName();
939 else
940 FunctionName = "global";
941
942 return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
Mike Stumpbd65cac2009-02-19 01:01:04 +0000943 }
Richard Smith47d21452011-12-27 12:18:28 +0000944 case Expr::CXXTypeidExprClass: {
945 CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E);
946 QualType T;
947 if (Typeid->isTypeOperand())
David Majnemerfe16aa32013-09-27 07:04:31 +0000948 T = Typeid->getTypeOperand(CGM.getContext());
Richard Smith47d21452011-12-27 12:18:28 +0000949 else
950 T = Typeid->getExprOperand()->getType();
951 return CGM.GetAddrOfRTTIDescriptor(T);
952 }
Nico Weberc5f80462012-10-11 10:13:44 +0000953 case Expr::CXXUuidofExprClass: {
954 return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E));
955 }
Richard Smith211c8dd2013-06-05 00:46:14 +0000956 case Expr::MaterializeTemporaryExprClass: {
957 MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E);
958 assert(MTE->getStorageDuration() == SD_Static);
959 SmallVector<const Expr *, 2> CommaLHSs;
960 SmallVector<SubobjectAdjustment, 2> Adjustments;
961 const Expr *Inner = MTE->GetTemporaryExpr()
962 ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
963 return CGM.GetAddrOfGlobalTemporary(MTE, Inner);
964 }
Eli Friedman546d94c2008-02-11 00:23:10 +0000965 }
Daniel Dunbard60f2fb2009-02-17 18:43:32 +0000966
967 return 0;
Anders Carlssone3d3b7d2008-01-26 02:08:50 +0000968 }
Anders Carlssone3d3b7d2008-01-26 02:08:50 +0000969};
Mike Stump1eb44332009-09-09 15:08:12 +0000970
Anders Carlsson3b1d57b2008-01-26 01:36:00 +0000971} // end anonymous namespace.
972
Richard Smith2d6a5672012-01-14 04:30:29 +0000973llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D,
974 CodeGenFunction *CGF) {
Fariborz Jahanianc2316db2013-01-10 23:28:43 +0000975 // Make a quick check if variable can be default NULL initialized
976 // and avoid going through rest of code which may do, for c++11,
977 // initialization of memory to all NULLs.
978 if (!D.hasLocalStorage()) {
979 QualType Ty = D.getType();
980 if (Ty->isArrayType())
981 Ty = Context.getBaseElementType(Ty);
982 if (Ty->isRecordType())
983 if (const CXXConstructExpr *E =
984 dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
985 const CXXConstructorDecl *CD = E->getConstructor();
Alexey Samsonov50f9de52013-04-05 07:47:28 +0000986 if (CD->isTrivial() && CD->isDefaultConstructor())
Fariborz Jahanianc2316db2013-01-10 23:28:43 +0000987 return EmitNullConstant(D.getType());
988 }
989 }
990
Richard Smith2d6a5672012-01-14 04:30:29 +0000991 if (const APValue *Value = D.evaluateValue())
Richard Smitha3ca41f2012-03-02 23:27:11 +0000992 return EmitConstantValueForMemory(*Value, D.getType(), CGF);
Richard Smith2d6a5672012-01-14 04:30:29 +0000993
Richard Smith7ca48502012-02-13 22:16:19 +0000994 // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
995 // reference is a constant expression, and the reference binds to a temporary,
996 // then constant initialization is performed. ConstExprEmitter will
997 // incorrectly emit a prvalue constant in this case, and the calling code
998 // interprets that as the (pointer) value of the reference, rather than the
999 // desired value of the referee.
1000 if (D.getType()->isReferenceType())
1001 return 0;
1002
Richard Smith2d6a5672012-01-14 04:30:29 +00001003 const Expr *E = D.getInit();
1004 assert(E && "No initializer to emit");
1005
1006 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1007 if (C && C->getType()->isIntegerTy(1)) {
1008 llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1009 C = llvm::ConstantExpr::getZExt(C, BoolTy);
1010 }
1011 return C;
1012}
1013
Lauro Ramos Venancio81373352008-02-26 21:41:45 +00001014llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
Anders Carlssone9352cc2009-04-08 04:48:15 +00001015 QualType DestType,
Chris Lattner96196622008-07-26 22:37:01 +00001016 CodeGenFunction *CGF) {
Anders Carlsson4b3f9c02008-12-01 02:42:14 +00001017 Expr::EvalResult Result;
Mike Stump1eb44332009-09-09 15:08:12 +00001018
Anders Carlsson1e5dc6e2009-04-11 01:08:03 +00001019 bool Success = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001020
Eli Friedman50c39ea2009-05-27 06:04:58 +00001021 if (DestType->isReferenceType())
1022 Success = E->EvaluateAsLValue(Result, Context);
Mike Stump1eb44332009-09-09 15:08:12 +00001023 else
Richard Smith51f47082011-10-29 00:50:52 +00001024 Success = E->EvaluateAsRValue(Result, Context);
Mike Stump1eb44332009-09-09 15:08:12 +00001025
Richard Smitha3ca41f2012-03-02 23:27:11 +00001026 llvm::Constant *C = 0;
Richard Smith2d6a5672012-01-14 04:30:29 +00001027 if (Success && !Result.HasSideEffects)
Richard Smitha3ca41f2012-03-02 23:27:11 +00001028 C = EmitConstantValue(Result.Val, DestType, CGF);
1029 else
1030 C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
Eli Friedman7dfa6392008-06-01 15:31:44 +00001031
Chris Lattner7f215c12010-06-26 21:52:32 +00001032 if (C && C->getType()->isIntegerTy(1)) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001033 llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
Owen Anderson3c4972d2009-07-29 18:54:39 +00001034 C = llvm::ConstantExpr::getZExt(C, BoolTy);
Eli Friedman7dfa6392008-06-01 15:31:44 +00001035 }
1036 return C;
Anders Carlsson3b1d57b2008-01-26 01:36:00 +00001037}
Eli Friedman0f593122009-04-13 21:47:26 +00001038
Richard Smith2d6a5672012-01-14 04:30:29 +00001039llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value,
1040 QualType DestType,
1041 CodeGenFunction *CGF) {
1042 switch (Value.getKind()) {
1043 case APValue::Uninitialized:
1044 llvm_unreachable("Constant expressions should be initialized.");
1045 case APValue::LValue: {
1046 llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
1047 llvm::Constant *Offset =
Chris Lattner8b418682012-02-07 00:39:47 +00001048 llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity());
Richard Smith2d6a5672012-01-14 04:30:29 +00001049
1050 llvm::Constant *C;
1051 if (APValue::LValueBase LVBase = Value.getLValueBase()) {
1052 // An array can be represented as an lvalue referring to the base.
1053 if (isa<llvm::ArrayType>(DestTy)) {
1054 assert(Offset->isNullValue() && "offset on array initializer");
1055 return ConstExprEmitter(*this, CGF).Visit(
1056 const_cast<Expr*>(LVBase.get<const Expr*>()));
1057 }
1058
1059 C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase);
1060
1061 // Apply offset if necessary.
1062 if (!Offset->isNullValue()) {
Chris Lattner8b418682012-02-07 00:39:47 +00001063 llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
Richard Smith2d6a5672012-01-14 04:30:29 +00001064 Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset);
1065 C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
1066 }
1067
1068 // Convert to the appropriate type; this could be an lvalue for
1069 // an integer.
1070 if (isa<llvm::PointerType>(DestTy))
1071 return llvm::ConstantExpr::getBitCast(C, DestTy);
1072
1073 return llvm::ConstantExpr::getPtrToInt(C, DestTy);
1074 } else {
1075 C = Offset;
1076
1077 // Convert to the appropriate type; this could be an lvalue for
1078 // an integer.
1079 if (isa<llvm::PointerType>(DestTy))
1080 return llvm::ConstantExpr::getIntToPtr(C, DestTy);
1081
1082 // If the types don't match this should only be a truncate.
1083 if (C->getType() != DestTy)
1084 return llvm::ConstantExpr::getTrunc(C, DestTy);
1085
1086 return C;
1087 }
1088 }
Richard Smitha3ca41f2012-03-02 23:27:11 +00001089 case APValue::Int:
1090 return llvm::ConstantInt::get(VMContext, Value.getInt());
Richard Smith2d6a5672012-01-14 04:30:29 +00001091 case APValue::ComplexInt: {
1092 llvm::Constant *Complex[2];
1093
1094 Complex[0] = llvm::ConstantInt::get(VMContext,
1095 Value.getComplexIntReal());
1096 Complex[1] = llvm::ConstantInt::get(VMContext,
1097 Value.getComplexIntImag());
1098
1099 // FIXME: the target may want to specify that this is packed.
1100 llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1101 Complex[1]->getType(),
1102 NULL);
1103 return llvm::ConstantStruct::get(STy, Complex);
1104 }
1105 case APValue::Float: {
1106 const llvm::APFloat &Init = Value.getFloat();
Joey Gouly19dbb202013-01-23 11:56:20 +00001107 if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf &&
1108 !Context.getLangOpts().NativeHalfType)
Richard Smith2d6a5672012-01-14 04:30:29 +00001109 return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt());
1110 else
1111 return llvm::ConstantFP::get(VMContext, Init);
1112 }
1113 case APValue::ComplexFloat: {
1114 llvm::Constant *Complex[2];
1115
1116 Complex[0] = llvm::ConstantFP::get(VMContext,
1117 Value.getComplexFloatReal());
1118 Complex[1] = llvm::ConstantFP::get(VMContext,
1119 Value.getComplexFloatImag());
1120
1121 // FIXME: the target may want to specify that this is packed.
1122 llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1123 Complex[1]->getType(),
1124 NULL);
1125 return llvm::ConstantStruct::get(STy, Complex);
1126 }
1127 case APValue::Vector: {
1128 SmallVector<llvm::Constant *, 4> Inits;
1129 unsigned NumElts = Value.getVectorLength();
1130
1131 for (unsigned i = 0; i != NumElts; ++i) {
1132 const APValue &Elt = Value.getVectorElt(i);
1133 if (Elt.isInt())
1134 Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt()));
1135 else
1136 Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat()));
1137 }
1138 return llvm::ConstantVector::get(Inits);
1139 }
1140 case APValue::AddrLabelDiff: {
1141 const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
1142 const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
1143 llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF);
1144 llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF);
1145
1146 // Compute difference
1147 llvm::Type *ResultType = getTypes().ConvertType(DestType);
1148 LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy);
1149 RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy);
1150 llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
1151
1152 // LLVM is a bit sensitive about the exact format of the
1153 // address-of-label difference; make sure to truncate after
1154 // the subtraction.
1155 return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
1156 }
1157 case APValue::Struct:
1158 case APValue::Union:
1159 return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType);
1160 case APValue::Array: {
1161 const ArrayType *CAT = Context.getAsArrayType(DestType);
1162 unsigned NumElements = Value.getArraySize();
1163 unsigned NumInitElts = Value.getArrayInitializedElts();
1164
1165 std::vector<llvm::Constant*> Elts;
1166 Elts.reserve(NumElements);
1167
1168 // Emit array filler, if there is one.
1169 llvm::Constant *Filler = 0;
1170 if (Value.hasArrayFiller())
Richard Smitha3ca41f2012-03-02 23:27:11 +00001171 Filler = EmitConstantValueForMemory(Value.getArrayFiller(),
1172 CAT->getElementType(), CGF);
Richard Smith2d6a5672012-01-14 04:30:29 +00001173
1174 // Emit initializer elements.
1175 llvm::Type *CommonElementType = 0;
1176 for (unsigned I = 0; I < NumElements; ++I) {
1177 llvm::Constant *C = Filler;
1178 if (I < NumInitElts)
Richard Smitha3ca41f2012-03-02 23:27:11 +00001179 C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I),
1180 CAT->getElementType(), CGF);
Jordan Rose41f3f3a2013-03-05 01:27:54 +00001181 else
1182 assert(Filler && "Missing filler for implicit elements of initializer");
Richard Smith2d6a5672012-01-14 04:30:29 +00001183 if (I == 0)
1184 CommonElementType = C->getType();
1185 else if (C->getType() != CommonElementType)
1186 CommonElementType = 0;
1187 Elts.push_back(C);
1188 }
1189
1190 if (!CommonElementType) {
1191 // FIXME: Try to avoid packing the array
1192 std::vector<llvm::Type*> Types;
Bill Wendlingf9ea9532012-02-07 00:13:27 +00001193 Types.reserve(NumElements);
Bill Wendlingfd3e5ef2012-02-06 23:46:08 +00001194 for (unsigned i = 0, e = Elts.size(); i < e; ++i)
Richard Smith2d6a5672012-01-14 04:30:29 +00001195 Types.push_back(Elts[i]->getType());
1196 llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true);
1197 return llvm::ConstantStruct::get(SType, Elts);
1198 }
1199
1200 llvm::ArrayType *AType =
1201 llvm::ArrayType::get(CommonElementType, NumElements);
1202 return llvm::ConstantArray::get(AType, Elts);
1203 }
1204 case APValue::MemberPointer:
1205 return getCXXABI().EmitMemberPointer(Value, DestType);
1206 }
1207 llvm_unreachable("Unknown APValue kind");
1208}
1209
Richard Smith7401cf52011-11-22 22:48:32 +00001210llvm::Constant *
Richard Smitha3ca41f2012-03-02 23:27:11 +00001211CodeGenModule::EmitConstantValueForMemory(const APValue &Value,
1212 QualType DestType,
1213 CodeGenFunction *CGF) {
1214 llvm::Constant *C = EmitConstantValue(Value, DestType, CGF);
1215 if (C->getType()->isIntegerTy(1)) {
1216 llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType);
1217 C = llvm::ConstantExpr::getZExt(C, BoolTy);
1218 }
1219 return C;
1220}
1221
1222llvm::Constant *
Richard Smith7401cf52011-11-22 22:48:32 +00001223CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) {
1224 assert(E->isFileScope() && "not a file-scope compound literal expr");
1225 return ConstExprEmitter(*this, 0).EmitLValue(E);
1226}
1227
John McCall5808ce42011-02-03 08:15:49 +00001228llvm::Constant *
1229CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) {
1230 // Member pointer constants always have a very particular form.
1231 const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
1232 const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
1233
1234 // A member function pointer.
1235 if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
1236 return getCXXABI().EmitMemberPointer(method);
1237
1238 // Otherwise, a member data pointer.
Richard Smith2d6a5672012-01-14 04:30:29 +00001239 uint64_t fieldOffset = getContext().getFieldOffset(decl);
John McCall5808ce42011-02-03 08:15:49 +00001240 CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
1241 return getCXXABI().EmitMemberDataPointer(type, chars);
1242}
1243
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001244static void
1245FillInNullDataMemberPointers(CodeGenModule &CGM, QualType T,
Bill Wendling35f18a52012-02-07 00:04:27 +00001246 SmallVectorImpl<llvm::Constant *> &Elements,
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001247 uint64_t StartOffset) {
Ken Dyckc4d68db2011-03-22 00:24:31 +00001248 assert(StartOffset % CGM.getContext().getCharWidth() == 0 &&
1249 "StartOffset not byte aligned!");
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001250
John McCallf16aa102010-08-22 21:01:12 +00001251 if (CGM.getTypes().isZeroInitializable(T))
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001252 return;
1253
1254 if (const ConstantArrayType *CAT =
1255 CGM.getContext().getAsConstantArrayType(T)) {
1256 QualType ElementTy = CAT->getElementType();
1257 uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy);
1258
1259 for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) {
1260 FillInNullDataMemberPointers(CGM, ElementTy, Elements,
1261 StartOffset + I * ElementSize);
1262 }
1263 } else if (const RecordType *RT = T->getAs<RecordType>()) {
1264 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1265 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1266
1267 // Go through all bases and fill in any null pointer to data members.
1268 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1269 E = RD->bases_end(); I != E; ++I) {
Anders Carlsson0a87b372010-05-27 18:51:01 +00001270 if (I->isVirtual()) {
Anders Carlssonada4b322010-11-22 18:42:14 +00001271 // Ignore virtual bases.
Anders Carlsson0a87b372010-05-27 18:51:01 +00001272 continue;
1273 }
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001274
1275 const CXXRecordDecl *BaseDecl =
1276 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1277
1278 // Ignore empty bases.
1279 if (BaseDecl->isEmpty())
1280 continue;
1281
1282 // Ignore bases that don't have any pointer to data members.
John McCallf16aa102010-08-22 21:01:12 +00001283 if (CGM.getTypes().isZeroInitializable(BaseDecl))
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001284 continue;
1285
Benjamin Kramerd4f51982012-07-04 18:45:14 +00001286 uint64_t BaseOffset =
1287 CGM.getContext().toBits(Layout.getBaseClassOffset(BaseDecl));
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001288 FillInNullDataMemberPointers(CGM, I->getType(),
1289 Elements, StartOffset + BaseOffset);
1290 }
1291
1292 // Visit all fields.
1293 unsigned FieldNo = 0;
1294 for (RecordDecl::field_iterator I = RD->field_begin(),
1295 E = RD->field_end(); I != E; ++I, ++FieldNo) {
1296 QualType FieldType = I->getType();
1297
John McCallf16aa102010-08-22 21:01:12 +00001298 if (CGM.getTypes().isZeroInitializable(FieldType))
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001299 continue;
1300
1301 uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo);
1302 FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset);
1303 }
1304 } else {
1305 assert(T->isMemberPointerType() && "Should only see member pointers here!");
1306 assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
1307 "Should only see pointers to data members here!");
1308
Ken Dyckc4d68db2011-03-22 00:24:31 +00001309 CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset);
1310 CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T);
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001311
John McCall5808ce42011-02-03 08:15:49 +00001312 // FIXME: hardcodes Itanium member pointer representation!
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001313 llvm::Constant *NegativeOne =
Chris Lattner8b418682012-02-07 00:39:47 +00001314 llvm::ConstantInt::get(CGM.Int8Ty, -1ULL, /*isSigned*/true);
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001315
1316 // Fill in the null data member pointer.
Ken Dyckc4d68db2011-03-22 00:24:31 +00001317 for (CharUnits I = StartIndex; I != EndIndex; ++I)
1318 Elements[I.getQuantity()] = NegativeOne;
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001319 }
1320}
1321
John McCall9b7da1c2011-02-15 06:40:56 +00001322static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001323 llvm::Type *baseType,
John McCall9b7da1c2011-02-15 06:40:56 +00001324 const CXXRecordDecl *base);
1325
Anders Carlssonada4b322010-11-22 18:42:14 +00001326static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
John McCall9b7da1c2011-02-15 06:40:56 +00001327 const CXXRecordDecl *record,
1328 bool asCompleteObject) {
1329 const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
Chris Lattner2acc6e32011-07-18 04:24:23 +00001330 llvm::StructType *structure =
John McCall9b7da1c2011-02-15 06:40:56 +00001331 (asCompleteObject ? layout.getLLVMType()
1332 : layout.getBaseSubobjectLLVMType());
Anders Carlssonada4b322010-11-22 18:42:14 +00001333
John McCall9b7da1c2011-02-15 06:40:56 +00001334 unsigned numElements = structure->getNumElements();
1335 std::vector<llvm::Constant *> elements(numElements);
Anders Carlssonada4b322010-11-22 18:42:14 +00001336
John McCall9b7da1c2011-02-15 06:40:56 +00001337 // Fill in all the bases.
1338 for (CXXRecordDecl::base_class_const_iterator
1339 I = record->bases_begin(), E = record->bases_end(); I != E; ++I) {
Anders Carlssonada4b322010-11-22 18:42:14 +00001340 if (I->isVirtual()) {
John McCall9b7da1c2011-02-15 06:40:56 +00001341 // Ignore virtual bases; if we're laying out for a complete
1342 // object, we'll lay these out later.
Anders Carlssonada4b322010-11-22 18:42:14 +00001343 continue;
1344 }
1345
John McCall9b7da1c2011-02-15 06:40:56 +00001346 const CXXRecordDecl *base =
1347 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
Anders Carlssonada4b322010-11-22 18:42:14 +00001348
1349 // Ignore empty bases.
John McCall9b7da1c2011-02-15 06:40:56 +00001350 if (base->isEmpty())
Anders Carlssonada4b322010-11-22 18:42:14 +00001351 continue;
1352
John McCall9b7da1c2011-02-15 06:40:56 +00001353 unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
Chris Lattner2acc6e32011-07-18 04:24:23 +00001354 llvm::Type *baseType = structure->getElementType(fieldIndex);
John McCall9b7da1c2011-02-15 06:40:56 +00001355 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
Anders Carlssonada4b322010-11-22 18:42:14 +00001356 }
1357
John McCall9b7da1c2011-02-15 06:40:56 +00001358 // Fill in all the fields.
1359 for (RecordDecl::field_iterator I = record->field_begin(),
1360 E = record->field_end(); I != E; ++I) {
David Blaikie581deb32012-06-06 20:45:41 +00001361 const FieldDecl *field = *I;
Eli Friedman26e80cd2011-12-07 01:30:11 +00001362
1363 // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
1364 // will fill in later.)
1365 if (!field->isBitField()) {
1366 unsigned fieldIndex = layout.getLLVMFieldNo(field);
1367 elements[fieldIndex] = CGM.EmitNullConstant(field->getType());
1368 }
1369
1370 // For unions, stop after the first named field.
1371 if (record->isUnion() && field->getDeclName())
1372 break;
John McCall9b7da1c2011-02-15 06:40:56 +00001373 }
1374
1375 // Fill in the virtual bases, if we're working with the complete object.
1376 if (asCompleteObject) {
1377 for (CXXRecordDecl::base_class_const_iterator
1378 I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) {
1379 const CXXRecordDecl *base =
1380 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
1381
1382 // Ignore empty bases.
1383 if (base->isEmpty())
1384 continue;
1385
1386 unsigned fieldIndex = layout.getVirtualBaseIndex(base);
1387
1388 // We might have already laid this field out.
1389 if (elements[fieldIndex]) continue;
1390
Chris Lattner2acc6e32011-07-18 04:24:23 +00001391 llvm::Type *baseType = structure->getElementType(fieldIndex);
John McCall9b7da1c2011-02-15 06:40:56 +00001392 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1393 }
Anders Carlssonada4b322010-11-22 18:42:14 +00001394 }
1395
1396 // Now go through all other fields and zero them out.
John McCall9b7da1c2011-02-15 06:40:56 +00001397 for (unsigned i = 0; i != numElements; ++i) {
1398 if (!elements[i])
1399 elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
Anders Carlssonada4b322010-11-22 18:42:14 +00001400 }
1401
John McCall9b7da1c2011-02-15 06:40:56 +00001402 return llvm::ConstantStruct::get(structure, elements);
1403}
1404
1405/// Emit the null constant for a base subobject.
1406static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001407 llvm::Type *baseType,
John McCall9b7da1c2011-02-15 06:40:56 +00001408 const CXXRecordDecl *base) {
1409 const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
1410
1411 // Just zero out bases that don't have any pointer to data members.
1412 if (baseLayout.isZeroInitializableAsBase())
1413 return llvm::Constant::getNullValue(baseType);
1414
1415 // If the base type is a struct, we can just use its null constant.
1416 if (isa<llvm::StructType>(baseType)) {
1417 return EmitNullConstant(CGM, base, /*complete*/ false);
1418 }
1419
1420 // Otherwise, some bases are represented as arrays of i8 if the size
1421 // of the base is smaller than its corresponding LLVM type. Figure
1422 // out how many elements this base array has.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001423 llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType);
John McCall9b7da1c2011-02-15 06:40:56 +00001424 unsigned numBaseElements = baseArrayType->getNumElements();
1425
1426 // Fill in null data member pointers.
Bill Wendling35f18a52012-02-07 00:04:27 +00001427 SmallVector<llvm::Constant *, 16> baseElements(numBaseElements);
John McCall9b7da1c2011-02-15 06:40:56 +00001428 FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base),
1429 baseElements, 0);
1430
1431 // Now go through all other elements and zero them out.
1432 if (numBaseElements) {
Chris Lattner8b418682012-02-07 00:39:47 +00001433 llvm::Constant *i8_zero = llvm::Constant::getNullValue(CGM.Int8Ty);
John McCall9b7da1c2011-02-15 06:40:56 +00001434 for (unsigned i = 0; i != numBaseElements; ++i) {
1435 if (!baseElements[i])
1436 baseElements[i] = i8_zero;
1437 }
1438 }
1439
1440 return llvm::ConstantArray::get(baseArrayType, baseElements);
Anders Carlssonada4b322010-11-22 18:42:14 +00001441}
1442
Eli Friedman0f593122009-04-13 21:47:26 +00001443llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
John McCallf16aa102010-08-22 21:01:12 +00001444 if (getTypes().isZeroInitializable(T))
Anders Carlssonad3e7112009-08-24 17:16:23 +00001445 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
Anders Carlsson2c12d032010-02-02 05:17:25 +00001446
Anders Carlsson237957c2009-08-09 18:26:27 +00001447 if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
Chris Lattner6ef016f2012-02-06 22:00:56 +00001448 llvm::ArrayType *ATy =
1449 cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
Mike Stump1eb44332009-09-09 15:08:12 +00001450
Anders Carlsson237957c2009-08-09 18:26:27 +00001451 QualType ElementTy = CAT->getElementType();
1452
Anders Carlsson2c12d032010-02-02 05:17:25 +00001453 llvm::Constant *Element = EmitNullConstant(ElementTy);
1454 unsigned NumElements = CAT->getSize().getZExtValue();
Chris Lattner6ef016f2012-02-06 22:00:56 +00001455
1456 if (Element->isNullValue())
1457 return llvm::ConstantAggregateZero::get(ATy);
1458
1459 SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
Anders Carlsson2c12d032010-02-02 05:17:25 +00001460 return llvm::ConstantArray::get(ATy, Array);
Anders Carlsson237957c2009-08-09 18:26:27 +00001461 }
Anders Carlssonfc3eaa42009-08-23 01:25:01 +00001462
1463 if (const RecordType *RT = T->getAs<RecordType>()) {
Anders Carlsson2c12d032010-02-02 05:17:25 +00001464 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
John McCall9b7da1c2011-02-15 06:40:56 +00001465 return ::EmitNullConstant(*this, RD, /*complete object*/ true);
Anders Carlssonfc3eaa42009-08-23 01:25:01 +00001466 }
Mike Stump1eb44332009-09-09 15:08:12 +00001467
Anders Carlssona83fb4b2010-05-18 16:51:41 +00001468 assert(T->isMemberPointerType() && "Should only see member pointers here!");
Anders Carlsson2c12d032010-02-02 05:17:25 +00001469 assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
1470 "Should only see pointers to data members here!");
1471
1472 // Itanium C++ ABI 2.3:
1473 // A NULL pointer is represented as -1.
John McCall5808ce42011-02-03 08:15:49 +00001474 return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
Eli Friedman0f593122009-04-13 21:47:26 +00001475}
Eli Friedman2ed7cb62011-10-14 02:27:24 +00001476
1477llvm::Constant *
1478CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
1479 return ::EmitNullConstant(*this, Record, false);
1480}