Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 1 | //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This contains code to emit Constant Expr nodes as LLVM code. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "CodeGenFunction.h" |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 15 | #include "CGCXXABI.h" |
Daniel Dunbar | af2f62c | 2008-08-13 00:59:25 +0000 | [diff] [blame] | 16 | #include "CGObjCRuntime.h" |
Daniel Dunbar | 2924ade | 2010-03-30 22:26:10 +0000 | [diff] [blame] | 17 | #include "CGRecordLayout.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 18 | #include "CodeGenModule.h" |
Chris Lattner | f6b24ea | 2008-10-06 05:59:01 +0000 | [diff] [blame] | 19 | #include "clang/AST/APValue.h" |
Daniel Dunbar | de7fb84 | 2008-08-11 05:00:27 +0000 | [diff] [blame] | 20 | #include "clang/AST/ASTContext.h" |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 21 | #include "clang/AST/RecordLayout.h" |
Daniel Dunbar | de7fb84 | 2008-08-11 05:00:27 +0000 | [diff] [blame] | 22 | #include "clang/AST/StmtVisitor.h" |
Chris Lattner | 1b63e4f | 2009-06-14 01:54:56 +0000 | [diff] [blame] | 23 | #include "clang/Basic/Builtins.h" |
Chandler Carruth | 3b844ba | 2013-01-02 11:45:17 +0000 | [diff] [blame] | 24 | #include "llvm/IR/Constants.h" |
| 25 | #include "llvm/IR/DataLayout.h" |
| 26 | #include "llvm/IR/Function.h" |
| 27 | #include "llvm/IR/GlobalVariable.h" |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 28 | using namespace clang; |
| 29 | using namespace CodeGen; |
| 30 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 31 | //===----------------------------------------------------------------------===// |
| 32 | // ConstStructBuilder |
| 33 | //===----------------------------------------------------------------------===// |
| 34 | |
| 35 | namespace { |
Benjamin Kramer | 85b4521 | 2009-11-28 19:45:26 +0000 | [diff] [blame] | 36 | class ConstStructBuilder { |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 37 | CodeGenModule &CGM; |
| 38 | CodeGenFunction *CGF; |
| 39 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 40 | bool Packed; |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 41 | CharUnits NextFieldOffsetInChars; |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 42 | CharUnits LLVMStructAlignment; |
Bill Wendling | cf6511b | 2012-02-07 00:54:58 +0000 | [diff] [blame] | 43 | SmallVector<llvm::Constant *, 32> Elements; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 44 | public: |
| 45 | static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, |
| 46 | InitListExpr *ILE); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 47 | static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, |
| 48 | const APValue &Value, QualType ValTy); |
| 49 | |
| 50 | private: |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 51 | ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 52 | : CGM(CGM), CGF(CGF), Packed(false), |
| 53 | NextFieldOffsetInChars(CharUnits::Zero()), |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 54 | LLVMStructAlignment(CharUnits::One()) { } |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 55 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 56 | void AppendField(const FieldDecl *Field, uint64_t FieldOffset, |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 57 | llvm::Constant *InitExpr); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 58 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 59 | void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst); |
| 60 | |
Chris Lattner | 1880666 | 2010-07-05 17:04:23 +0000 | [diff] [blame] | 61 | void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, |
| 62 | llvm::ConstantInt *InitExpr); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 63 | |
Ken Dyck | c29ea8f | 2011-03-11 23:42:54 +0000 | [diff] [blame] | 64 | void AppendPadding(CharUnits PadSize); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 65 | |
Ken Dyck | 106ca04 | 2011-03-11 02:17:05 +0000 | [diff] [blame] | 66 | void AppendTailPadding(CharUnits RecordSize); |
Anders Carlsson | d24393b | 2009-07-27 01:23:51 +0000 | [diff] [blame] | 67 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 68 | void ConvertStructToPacked(); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 69 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 70 | bool Build(InitListExpr *ILE); |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 71 | void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase, |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 72 | const CXXRecordDecl *VTableClass, CharUnits BaseOffset); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 73 | llvm::Constant *Finalize(QualType Ty); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 74 | |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 75 | CharUnits getAlignment(const llvm::Constant *C) const { |
| 76 | if (Packed) return CharUnits::One(); |
| 77 | return CharUnits::fromQuantity( |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 78 | CGM.getDataLayout().getABITypeAlignment(C->getType())); |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 79 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 80 | |
Ken Dyck | 15c152e | 2011-03-18 01:12:13 +0000 | [diff] [blame] | 81 | CharUnits getSizeInChars(const llvm::Constant *C) const { |
| 82 | return CharUnits::fromQuantity( |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 83 | CGM.getDataLayout().getTypeAllocSize(C->getType())); |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 84 | } |
Anders Carlsson | 4c98efd | 2009-07-24 15:20:52 +0000 | [diff] [blame] | 85 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 86 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 87 | void ConstStructBuilder:: |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 88 | AppendField(const FieldDecl *Field, uint64_t FieldOffset, |
| 89 | llvm::Constant *InitCst) { |
Ken Dyck | 6925cc4 | 2011-03-15 01:09:02 +0000 | [diff] [blame] | 90 | const ASTContext &Context = CGM.getContext(); |
| 91 | |
| 92 | CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 93 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 94 | AppendBytes(FieldOffsetInChars, InitCst); |
| 95 | } |
| 96 | |
| 97 | void ConstStructBuilder:: |
| 98 | AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) { |
| 99 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 100 | assert(NextFieldOffsetInChars <= FieldOffsetInChars |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 101 | && "Field offset mismatch!"); |
| 102 | |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 103 | CharUnits FieldAlignment = getAlignment(InitCst); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 104 | |
| 105 | // Round up the field offset to the alignment of the field type. |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 106 | CharUnits AlignedNextFieldOffsetInChars = |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 107 | NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 108 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 109 | if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 110 | // We need to append padding. |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 111 | AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 112 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 113 | assert(NextFieldOffsetInChars == FieldOffsetInChars && |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 114 | "Did not add enough padding!"); |
| 115 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 116 | AlignedNextFieldOffsetInChars = |
| 117 | NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment); |
| 118 | } |
| 119 | |
| 120 | if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) { |
| 121 | assert(!Packed && "Alignment is wrong even with a packed struct!"); |
| 122 | |
| 123 | // Convert the struct to a packed struct. |
| 124 | ConvertStructToPacked(); |
| 125 | |
| 126 | // After we pack the struct, we may need to insert padding. |
| 127 | if (NextFieldOffsetInChars < FieldOffsetInChars) { |
| 128 | // We need to append padding. |
| 129 | AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars); |
| 130 | |
| 131 | assert(NextFieldOffsetInChars == FieldOffsetInChars && |
| 132 | "Did not add enough padding!"); |
| 133 | } |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 134 | AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | // Add the field. |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 138 | Elements.push_back(InitCst); |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 139 | NextFieldOffsetInChars = AlignedNextFieldOffsetInChars + |
Ken Dyck | 15c152e | 2011-03-18 01:12:13 +0000 | [diff] [blame] | 140 | getSizeInChars(InitCst); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 141 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 142 | if (Packed) |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 143 | assert(LLVMStructAlignment == CharUnits::One() && |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 144 | "Packed struct not byte-aligned!"); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 145 | else |
| 146 | LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 147 | } |
| 148 | |
Chris Lattner | 1880666 | 2010-07-05 17:04:23 +0000 | [diff] [blame] | 149 | void ConstStructBuilder::AppendBitField(const FieldDecl *Field, |
| 150 | uint64_t FieldOffset, |
| 151 | llvm::ConstantInt *CI) { |
Ken Dyck | f004da4 | 2011-03-12 12:03:11 +0000 | [diff] [blame] | 152 | const ASTContext &Context = CGM.getContext(); |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 153 | const uint64_t CharWidth = Context.getCharWidth(); |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 154 | uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); |
| 155 | if (FieldOffset > NextFieldOffsetInBits) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 156 | // We need to add padding. |
Ken Dyck | f004da4 | 2011-03-12 12:03:11 +0000 | [diff] [blame] | 157 | CharUnits PadSize = Context.toCharUnitsFromBits( |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 158 | llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits, |
Douglas Gregor | bcfd1f5 | 2011-09-02 00:18:52 +0000 | [diff] [blame] | 159 | Context.getTargetInfo().getCharAlign())); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 160 | |
Ken Dyck | f004da4 | 2011-03-12 12:03:11 +0000 | [diff] [blame] | 161 | AppendPadding(PadSize); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 162 | } |
| 163 | |
Richard Smith | a6b8b2c | 2011-10-10 18:28:20 +0000 | [diff] [blame] | 164 | uint64_t FieldSize = Field->getBitWidthValue(Context); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 165 | |
| 166 | llvm::APInt FieldValue = CI->getValue(); |
| 167 | |
| 168 | // Promote the size of FieldValue if necessary |
| 169 | // FIXME: This should never occur, but currently it can because initializer |
| 170 | // constants are cast to bool, and because clang is not enforcing bitfield |
| 171 | // width limits. |
| 172 | if (FieldSize > FieldValue.getBitWidth()) |
Jay Foad | 9f71a8f | 2010-12-07 08:25:34 +0000 | [diff] [blame] | 173 | FieldValue = FieldValue.zext(FieldSize); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 174 | |
| 175 | // Truncate the size of FieldValue to the bit field size. |
| 176 | if (FieldSize < FieldValue.getBitWidth()) |
Jay Foad | 9f71a8f | 2010-12-07 08:25:34 +0000 | [diff] [blame] | 177 | FieldValue = FieldValue.trunc(FieldSize); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 178 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 179 | NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); |
| 180 | if (FieldOffset < NextFieldOffsetInBits) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 181 | // Either part of the field or the entire field can go into the previous |
| 182 | // byte. |
| 183 | assert(!Elements.empty() && "Elements can't be empty!"); |
| 184 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 185 | unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 186 | |
| 187 | bool FitsCompletelyInPreviousByte = |
| 188 | BitsInPreviousByte >= FieldValue.getBitWidth(); |
| 189 | |
| 190 | llvm::APInt Tmp = FieldValue; |
| 191 | |
| 192 | if (!FitsCompletelyInPreviousByte) { |
| 193 | unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; |
| 194 | |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 195 | if (CGM.getDataLayout().isBigEndian()) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 196 | Tmp = Tmp.lshr(NewFieldWidth); |
Jay Foad | 9f71a8f | 2010-12-07 08:25:34 +0000 | [diff] [blame] | 197 | Tmp = Tmp.trunc(BitsInPreviousByte); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 198 | |
| 199 | // We want the remaining high bits. |
Jay Foad | 9f71a8f | 2010-12-07 08:25:34 +0000 | [diff] [blame] | 200 | FieldValue = FieldValue.trunc(NewFieldWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 201 | } else { |
Jay Foad | 9f71a8f | 2010-12-07 08:25:34 +0000 | [diff] [blame] | 202 | Tmp = Tmp.trunc(BitsInPreviousByte); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 203 | |
| 204 | // We want the remaining low bits. |
| 205 | FieldValue = FieldValue.lshr(BitsInPreviousByte); |
Jay Foad | 9f71a8f | 2010-12-07 08:25:34 +0000 | [diff] [blame] | 206 | FieldValue = FieldValue.trunc(NewFieldWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 210 | Tmp = Tmp.zext(CharWidth); |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 211 | if (CGM.getDataLayout().isBigEndian()) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 212 | if (FitsCompletelyInPreviousByte) |
| 213 | Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); |
| 214 | } else { |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 215 | Tmp = Tmp.shl(CharWidth - BitsInPreviousByte); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 216 | } |
| 217 | |
Chris Lattner | 2bc0025 | 2010-07-05 18:03:30 +0000 | [diff] [blame] | 218 | // 'or' in the bits that go into the previous byte. |
| 219 | llvm::Value *LastElt = Elements.back(); |
| 220 | if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt)) |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 221 | Tmp |= Val->getValue(); |
Chris Lattner | 2bc0025 | 2010-07-05 18:03:30 +0000 | [diff] [blame] | 222 | else { |
| 223 | assert(isa<llvm::UndefValue>(LastElt)); |
| 224 | // If there is an undef field that we're adding to, it can either be a |
| 225 | // scalar undef (in which case, we just replace it with our field) or it |
| 226 | // is an array. If it is an array, we have to pull one byte off the |
| 227 | // array so that the other undef bytes stay around. |
| 228 | if (!isa<llvm::IntegerType>(LastElt->getType())) { |
| 229 | // The undef padding will be a multibyte array, create a new smaller |
| 230 | // padding and then an hole for our i8 to get plopped into. |
| 231 | assert(isa<llvm::ArrayType>(LastElt->getType()) && |
| 232 | "Expected array padding of undefs"); |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 233 | llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType()); |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 234 | assert(AT->getElementType()->isIntegerTy(CharWidth) && |
Chris Lattner | 2bc0025 | 2010-07-05 18:03:30 +0000 | [diff] [blame] | 235 | AT->getNumElements() != 0 && |
| 236 | "Expected non-empty array padding of undefs"); |
| 237 | |
| 238 | // Remove the padding array. |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 239 | NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements()); |
Chris Lattner | 2bc0025 | 2010-07-05 18:03:30 +0000 | [diff] [blame] | 240 | Elements.pop_back(); |
| 241 | |
| 242 | // Add the padding back in two chunks. |
Ken Dyck | c29ea8f | 2011-03-11 23:42:54 +0000 | [diff] [blame] | 243 | AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1)); |
| 244 | AppendPadding(CharUnits::One()); |
Chris Lattner | 2bc0025 | 2010-07-05 18:03:30 +0000 | [diff] [blame] | 245 | assert(isa<llvm::UndefValue>(Elements.back()) && |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 246 | Elements.back()->getType()->isIntegerTy(CharWidth) && |
Chris Lattner | 2bc0025 | 2010-07-05 18:03:30 +0000 | [diff] [blame] | 247 | "Padding addition didn't work right"); |
| 248 | } |
| 249 | } |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 250 | |
| 251 | Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); |
| 252 | |
| 253 | if (FitsCompletelyInPreviousByte) |
Chris Lattner | 1880666 | 2010-07-05 17:04:23 +0000 | [diff] [blame] | 254 | return; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 255 | } |
| 256 | |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 257 | while (FieldValue.getBitWidth() > CharWidth) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 258 | llvm::APInt Tmp; |
| 259 | |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 260 | if (CGM.getDataLayout().isBigEndian()) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 261 | // We want the high bits. |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 262 | Tmp = |
| 263 | FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 264 | } else { |
| 265 | // We want the low bits. |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 266 | Tmp = FieldValue.trunc(CharWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 267 | |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 268 | FieldValue = FieldValue.lshr(CharWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); |
Ken Dyck | 199c189 | 2011-03-19 01:28:06 +0000 | [diff] [blame] | 272 | ++NextFieldOffsetInChars; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 273 | |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 274 | FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | assert(FieldValue.getBitWidth() > 0 && |
| 278 | "Should have at least one bit left!"); |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 279 | assert(FieldValue.getBitWidth() <= CharWidth && |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 280 | "Should not have more than a byte left!"); |
| 281 | |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 282 | if (FieldValue.getBitWidth() < CharWidth) { |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 283 | if (CGM.getDataLayout().isBigEndian()) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 284 | unsigned BitWidth = FieldValue.getBitWidth(); |
| 285 | |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 286 | FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 287 | } else |
Ken Dyck | 4f318c0 | 2011-03-19 00:57:28 +0000 | [diff] [blame] | 288 | FieldValue = FieldValue.zext(CharWidth); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 289 | } |
| 290 | |
| 291 | // Append the last element. |
| 292 | Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), |
| 293 | FieldValue)); |
Ken Dyck | 199c189 | 2011-03-19 01:28:06 +0000 | [diff] [blame] | 294 | ++NextFieldOffsetInChars; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 295 | } |
| 296 | |
Ken Dyck | c29ea8f | 2011-03-11 23:42:54 +0000 | [diff] [blame] | 297 | void ConstStructBuilder::AppendPadding(CharUnits PadSize) { |
| 298 | if (PadSize.isZero()) |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 299 | return; |
| 300 | |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 301 | llvm::Type *Ty = CGM.Int8Ty; |
Ken Dyck | c29ea8f | 2011-03-11 23:42:54 +0000 | [diff] [blame] | 302 | if (PadSize > CharUnits::One()) |
| 303 | Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity()); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 304 | |
Nuno Lopes | cdb30b4 | 2010-04-16 20:56:35 +0000 | [diff] [blame] | 305 | llvm::Constant *C = llvm::UndefValue::get(Ty); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 306 | Elements.push_back(C); |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 307 | assert(getAlignment(C) == CharUnits::One() && |
| 308 | "Padding must have 1 byte alignment!"); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 309 | |
Ken Dyck | 15c152e | 2011-03-18 01:12:13 +0000 | [diff] [blame] | 310 | NextFieldOffsetInChars += getSizeInChars(C); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 311 | } |
| 312 | |
Ken Dyck | 106ca04 | 2011-03-11 02:17:05 +0000 | [diff] [blame] | 313 | void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) { |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 314 | assert(NextFieldOffsetInChars <= RecordSize && |
Ken Dyck | 106ca04 | 2011-03-11 02:17:05 +0000 | [diff] [blame] | 315 | "Size mismatch!"); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 316 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 317 | AppendPadding(RecordSize - NextFieldOffsetInChars); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 318 | } |
| 319 | |
| 320 | void ConstStructBuilder::ConvertStructToPacked() { |
Bill Wendling | 35f18a5 | 2012-02-07 00:04:27 +0000 | [diff] [blame] | 321 | SmallVector<llvm::Constant *, 16> PackedElements; |
Ken Dyck | 4a5c87e | 2011-03-18 00:55:06 +0000 | [diff] [blame] | 322 | CharUnits ElementOffsetInChars = CharUnits::Zero(); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 323 | |
| 324 | for (unsigned i = 0, e = Elements.size(); i != e; ++i) { |
| 325 | llvm::Constant *C = Elements[i]; |
| 326 | |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 327 | CharUnits ElementAlign = CharUnits::fromQuantity( |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 328 | CGM.getDataLayout().getABITypeAlignment(C->getType())); |
Ken Dyck | 4a5c87e | 2011-03-18 00:55:06 +0000 | [diff] [blame] | 329 | CharUnits AlignedElementOffsetInChars = |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 330 | ElementOffsetInChars.RoundUpToAlignment(ElementAlign); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 331 | |
Ken Dyck | 4a5c87e | 2011-03-18 00:55:06 +0000 | [diff] [blame] | 332 | if (AlignedElementOffsetInChars > ElementOffsetInChars) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 333 | // We need some padding. |
Ken Dyck | 4a5c87e | 2011-03-18 00:55:06 +0000 | [diff] [blame] | 334 | CharUnits NumChars = |
| 335 | AlignedElementOffsetInChars - ElementOffsetInChars; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 336 | |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 337 | llvm::Type *Ty = CGM.Int8Ty; |
Ken Dyck | 4a5c87e | 2011-03-18 00:55:06 +0000 | [diff] [blame] | 338 | if (NumChars > CharUnits::One()) |
| 339 | Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity()); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 340 | |
Nuno Lopes | cdb30b4 | 2010-04-16 20:56:35 +0000 | [diff] [blame] | 341 | llvm::Constant *Padding = llvm::UndefValue::get(Ty); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 342 | PackedElements.push_back(Padding); |
Ken Dyck | 15c152e | 2011-03-18 01:12:13 +0000 | [diff] [blame] | 343 | ElementOffsetInChars += getSizeInChars(Padding); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | PackedElements.push_back(C); |
Ken Dyck | 15c152e | 2011-03-18 01:12:13 +0000 | [diff] [blame] | 347 | ElementOffsetInChars += getSizeInChars(C); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 348 | } |
| 349 | |
Ken Dyck | 4a5c87e | 2011-03-18 00:55:06 +0000 | [diff] [blame] | 350 | assert(ElementOffsetInChars == NextFieldOffsetInChars && |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 351 | "Packing the struct changed its size!"); |
| 352 | |
Bill Wendling | 35f18a5 | 2012-02-07 00:04:27 +0000 | [diff] [blame] | 353 | Elements.swap(PackedElements); |
Ken Dyck | 7d2f9d5 | 2011-03-18 01:26:17 +0000 | [diff] [blame] | 354 | LLVMStructAlignment = CharUnits::One(); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 355 | Packed = true; |
| 356 | } |
| 357 | |
| 358 | bool ConstStructBuilder::Build(InitListExpr *ILE) { |
| 359 | RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); |
| 360 | const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); |
| 361 | |
| 362 | unsigned FieldNo = 0; |
| 363 | unsigned ElementNo = 0; |
Fariborz Jahanian | 07a8a21 | 2011-04-28 22:49:46 +0000 | [diff] [blame] | 364 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 365 | for (RecordDecl::field_iterator Field = RD->field_begin(), |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 366 | FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 367 | // If this is a union, skip all the fields that aren't being initialized. |
David Blaikie | 581deb3 | 2012-06-06 20:45:41 +0000 | [diff] [blame] | 368 | if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 369 | continue; |
| 370 | |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 371 | // Don't emit anonymous bitfields, they just affect layout. |
Eli Friedman | cd06f26 | 2013-06-26 20:50:34 +0000 | [diff] [blame] | 372 | if (Field->isUnnamedBitfield()) |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 373 | continue; |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 374 | |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 375 | // Get the initializer. A struct can include fields without initializers, |
| 376 | // we just use explicit null values for them. |
| 377 | llvm::Constant *EltInit; |
| 378 | if (ElementNo < ILE->getNumInits()) |
| 379 | EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++), |
| 380 | Field->getType(), CGF); |
| 381 | else |
| 382 | EltInit = CGM.EmitNullConstant(Field->getType()); |
Eli Friedman | f0ca0ee | 2010-07-17 23:55:01 +0000 | [diff] [blame] | 383 | |
| 384 | if (!EltInit) |
| 385 | return false; |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 386 | |
| 387 | if (!Field->isBitField()) { |
| 388 | // Handle non-bitfield members. |
David Blaikie | 581deb3 | 2012-06-06 20:45:41 +0000 | [diff] [blame] | 389 | AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 390 | } else { |
Chris Lattner | 8ce9e45 | 2010-04-13 18:16:19 +0000 | [diff] [blame] | 391 | // Otherwise we have a bitfield. |
David Blaikie | 581deb3 | 2012-06-06 20:45:41 +0000 | [diff] [blame] | 392 | AppendBitField(*Field, Layout.getFieldOffset(FieldNo), |
Chris Lattner | 1880666 | 2010-07-05 17:04:23 +0000 | [diff] [blame] | 393 | cast<llvm::ConstantInt>(EltInit)); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 394 | } |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 395 | } |
| 396 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 397 | return true; |
| 398 | } |
| 399 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 400 | namespace { |
| 401 | struct BaseInfo { |
| 402 | BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index) |
| 403 | : Decl(Decl), Offset(Offset), Index(Index) { |
| 404 | } |
| 405 | |
| 406 | const CXXRecordDecl *Decl; |
| 407 | CharUnits Offset; |
| 408 | unsigned Index; |
| 409 | |
| 410 | bool operator<(const BaseInfo &O) const { return Offset < O.Offset; } |
| 411 | }; |
| 412 | } |
| 413 | |
| 414 | void ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD, |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 415 | bool IsPrimaryBase, |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 416 | const CXXRecordDecl *VTableClass, |
| 417 | CharUnits Offset) { |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 418 | const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); |
| 419 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 420 | if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { |
| 421 | // Add a vtable pointer, if we need one and it hasn't already been added. |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 422 | if (CD->isDynamicClass() && !IsPrimaryBase) { |
| 423 | llvm::Constant *VTableAddressPoint = |
| 424 | CGM.getCXXABI().getVTableAddressPointForConstExpr( |
| 425 | BaseSubobject(CD, Offset), VTableClass); |
| 426 | AppendBytes(Offset, VTableAddressPoint); |
| 427 | } |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 428 | |
| 429 | // Accumulate and sort bases, in order to visit them in address order, which |
| 430 | // may not be the same as declaration order. |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 431 | SmallVector<BaseInfo, 8> Bases; |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 432 | Bases.reserve(CD->getNumBases()); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 433 | unsigned BaseNo = 0; |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 434 | for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(), |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 435 | BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) { |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 436 | assert(!Base->isVirtual() && "should not have virtual bases here"); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 437 | const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl(); |
| 438 | CharUnits BaseOffset = Layout.getBaseClassOffset(BD); |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 439 | Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo)); |
| 440 | } |
| 441 | std::stable_sort(Bases.begin(), Bases.end()); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 442 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 443 | for (unsigned I = 0, N = Bases.size(); I != N; ++I) { |
| 444 | BaseInfo &Base = Bases[I]; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 445 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 446 | bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl; |
| 447 | Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase, |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 448 | VTableClass, Offset + Base.Offset); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 449 | } |
| 450 | } |
| 451 | |
| 452 | unsigned FieldNo = 0; |
Eli Friedman | 5fe61c6 | 2012-03-30 03:55:31 +0000 | [diff] [blame] | 453 | uint64_t OffsetBits = CGM.getContext().toBits(Offset); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 454 | |
| 455 | for (RecordDecl::field_iterator Field = RD->field_begin(), |
| 456 | FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 457 | // If this is a union, skip all the fields that aren't being initialized. |
David Blaikie | 581deb3 | 2012-06-06 20:45:41 +0000 | [diff] [blame] | 458 | if (RD->isUnion() && Val.getUnionField() != *Field) |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 459 | continue; |
| 460 | |
| 461 | // Don't emit anonymous bitfields, they just affect layout. |
Eli Friedman | cd06f26 | 2013-06-26 20:50:34 +0000 | [diff] [blame] | 462 | if (Field->isUnnamedBitfield()) |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 463 | continue; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 464 | |
| 465 | // Emit the value of the initializer. |
| 466 | const APValue &FieldValue = |
| 467 | RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo); |
| 468 | llvm::Constant *EltInit = |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 469 | CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 470 | assert(EltInit && "EmitConstantValue can't fail"); |
| 471 | |
| 472 | if (!Field->isBitField()) { |
| 473 | // Handle non-bitfield members. |
David Blaikie | 581deb3 | 2012-06-06 20:45:41 +0000 | [diff] [blame] | 474 | AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 475 | } else { |
| 476 | // Otherwise we have a bitfield. |
David Blaikie | 581deb3 | 2012-06-06 20:45:41 +0000 | [diff] [blame] | 477 | AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 478 | cast<llvm::ConstantInt>(EltInit)); |
| 479 | } |
| 480 | } |
| 481 | } |
| 482 | |
| 483 | llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) { |
| 484 | RecordDecl *RD = Ty->getAs<RecordType>()->getDecl(); |
| 485 | const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); |
| 486 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 487 | CharUnits LayoutSizeInChars = Layout.getSize(); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 488 | |
Ken Dyck | dc49639 | 2011-03-17 01:33:18 +0000 | [diff] [blame] | 489 | if (NextFieldOffsetInChars > LayoutSizeInChars) { |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 490 | // If the struct is bigger than the size of the record type, |
| 491 | // we must have a flexible array member at the end. |
| 492 | assert(RD->hasFlexibleArrayMember() && |
| 493 | "Must have flexible array member if struct is bigger than type!"); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 494 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 495 | // No tail padding is necessary. |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 496 | } else { |
| 497 | // Append tail padding if necessary. |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 498 | CharUnits LLVMSizeInChars = |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 499 | NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment); |
| 500 | |
| 501 | if (LLVMSizeInChars != LayoutSizeInChars) |
| 502 | AppendTailPadding(LayoutSizeInChars); |
| 503 | |
| 504 | LLVMSizeInChars = |
| 505 | NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 506 | |
| 507 | // Check if we need to convert the struct to a packed struct. |
| 508 | if (NextFieldOffsetInChars <= LayoutSizeInChars && |
| 509 | LLVMSizeInChars > LayoutSizeInChars) { |
| 510 | assert(!Packed && "Size mismatch!"); |
| 511 | |
| 512 | ConvertStructToPacked(); |
| 513 | assert(NextFieldOffsetInChars <= LayoutSizeInChars && |
| 514 | "Converting to packed did not help!"); |
| 515 | } |
| 516 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 517 | LLVMSizeInChars = |
| 518 | NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment); |
| 519 | |
| 520 | assert(LayoutSizeInChars == LLVMSizeInChars && |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 521 | "Tail padding mismatch!"); |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 522 | } |
| 523 | |
Chris Lattner | c5cbb90 | 2011-06-20 04:01:35 +0000 | [diff] [blame] | 524 | // Pick the type to use. If the type is layout identical to the ConvertType |
| 525 | // type then use it, otherwise use whatever the builder produced for us. |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 526 | llvm::StructType *STy = |
Chris Lattner | c5cbb90 | 2011-06-20 04:01:35 +0000 | [diff] [blame] | 527 | llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(), |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 528 | Elements, Packed); |
| 529 | llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty); |
| 530 | if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) { |
| 531 | if (ValSTy->isLayoutIdentical(STy)) |
| 532 | STy = ValSTy; |
Chris Lattner | c5cbb90 | 2011-06-20 04:01:35 +0000 | [diff] [blame] | 533 | } |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 534 | |
| 535 | llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements); |
| 536 | |
| 537 | assert(NextFieldOffsetInChars.RoundUpToAlignment(getAlignment(Result)) == |
| 538 | getSizeInChars(Result) && "Size mismatch!"); |
| 539 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 540 | return Result; |
| 541 | } |
| 542 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 543 | llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, |
| 544 | CodeGenFunction *CGF, |
| 545 | InitListExpr *ILE) { |
| 546 | ConstStructBuilder Builder(CGM, CGF); |
| 547 | |
| 548 | if (!Builder.Build(ILE)) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 549 | return nullptr; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 550 | |
| 551 | return Builder.Finalize(ILE->getType()); |
| 552 | } |
| 553 | |
| 554 | llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, |
| 555 | CodeGenFunction *CGF, |
| 556 | const APValue &Val, |
| 557 | QualType ValTy) { |
| 558 | ConstStructBuilder Builder(CGM, CGF); |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 559 | |
| 560 | const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl(); |
| 561 | const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 562 | Builder.Build(Val, RD, false, CD, CharUnits::Zero()); |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 563 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 564 | return Builder.Finalize(ValTy); |
| 565 | } |
| 566 | |
| 567 | |
Chris Lattner | eba3e5a | 2010-04-13 17:45:57 +0000 | [diff] [blame] | 568 | //===----------------------------------------------------------------------===// |
| 569 | // ConstExprEmitter |
| 570 | //===----------------------------------------------------------------------===// |
Richard Smith | e7aa62d | 2012-01-17 21:42:19 +0000 | [diff] [blame] | 571 | |
| 572 | /// This class only needs to handle two cases: |
| 573 | /// 1) Literals (this is used by APValue emission to emit literals). |
| 574 | /// 2) Arrays, structs and unions (outside C++11 mode, we don't currently |
| 575 | /// constant fold these types). |
Benjamin Kramer | 85b4521 | 2009-11-28 19:45:26 +0000 | [diff] [blame] | 576 | class ConstExprEmitter : |
Anders Carlsson | 84005b4 | 2008-01-26 04:30:23 +0000 | [diff] [blame] | 577 | public StmtVisitor<ConstExprEmitter, llvm::Constant*> { |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 578 | CodeGenModule &CGM; |
Lauro Ramos Venancio | 8137335 | 2008-02-26 21:41:45 +0000 | [diff] [blame] | 579 | CodeGenFunction *CGF; |
Owen Anderson | a1cf15f | 2009-07-14 23:10:40 +0000 | [diff] [blame] | 580 | llvm::LLVMContext &VMContext; |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 581 | public: |
Lauro Ramos Venancio | 8137335 | 2008-02-26 21:41:45 +0000 | [diff] [blame] | 582 | ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) |
Owen Anderson | a1cf15f | 2009-07-14 23:10:40 +0000 | [diff] [blame] | 583 | : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 584 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 585 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 586 | //===--------------------------------------------------------------------===// |
| 587 | // Visitor Methods |
| 588 | //===--------------------------------------------------------------------===// |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 589 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 590 | llvm::Constant *VisitStmt(Stmt *S) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 591 | return nullptr; |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 592 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 593 | |
| 594 | llvm::Constant *VisitParenExpr(ParenExpr *PE) { |
| 595 | return Visit(PE->getSubExpr()); |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 596 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 597 | |
John McCall | 91a5755 | 2011-07-15 05:09:51 +0000 | [diff] [blame] | 598 | llvm::Constant * |
| 599 | VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { |
| 600 | return Visit(PE->getReplacement()); |
| 601 | } |
| 602 | |
Peter Collingbourne | f111d93 | 2011-04-15 00:35:48 +0000 | [diff] [blame] | 603 | llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { |
| 604 | return Visit(GE->getResultExpr()); |
| 605 | } |
| 606 | |
Eli Friedman | 21cde05 | 2013-07-16 22:40:53 +0000 | [diff] [blame] | 607 | llvm::Constant *VisitChooseExpr(ChooseExpr *CE) { |
Eli Friedman | a5e6601 | 2013-07-20 00:40:58 +0000 | [diff] [blame] | 608 | return Visit(CE->getChosenSubExpr()); |
Eli Friedman | 21cde05 | 2013-07-16 22:40:53 +0000 | [diff] [blame] | 609 | } |
| 610 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 611 | llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { |
| 612 | return Visit(E->getInitializer()); |
| 613 | } |
John McCall | 5808ce4 | 2011-02-03 08:15:49 +0000 | [diff] [blame] | 614 | |
Argyrios Kyrtzidis | 0835a3c | 2008-08-18 23:01:59 +0000 | [diff] [blame] | 615 | llvm::Constant *VisitCastExpr(CastExpr* E) { |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 616 | Expr *subExpr = E->getSubExpr(); |
| 617 | llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 618 | if (!C) return nullptr; |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 619 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 620 | llvm::Type *destType = ConvertType(E->getType()); |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 621 | |
Anders Carlsson | 0086ccb | 2009-08-22 23:54:44 +0000 | [diff] [blame] | 622 | switch (E->getCastKind()) { |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 623 | case CK_ToUnion: { |
Anders Carlsson | 0086ccb | 2009-08-22 23:54:44 +0000 | [diff] [blame] | 624 | // GCC cast to union extension |
| 625 | assert(E->getType()->isUnionType() && |
| 626 | "Destination type is not union type!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 627 | |
Anders Carlsson | aaed50d | 2009-07-31 21:38:39 +0000 | [diff] [blame] | 628 | // Build a struct with the union sub-element as the first member, |
| 629 | // and padded to the appropriate size |
Bill Wendling | f9ea953 | 2012-02-07 00:13:27 +0000 | [diff] [blame] | 630 | SmallVector<llvm::Constant*, 2> Elts; |
| 631 | SmallVector<llvm::Type*, 2> Types; |
Anders Carlsson | aaed50d | 2009-07-31 21:38:39 +0000 | [diff] [blame] | 632 | Elts.push_back(C); |
| 633 | Types.push_back(C->getType()); |
Micah Villmow | 25a6a84 | 2012-10-08 16:25:52 +0000 | [diff] [blame] | 634 | unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType()); |
| 635 | unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destType); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 636 | |
Anders Carlsson | aaed50d | 2009-07-31 21:38:39 +0000 | [diff] [blame] | 637 | assert(CurSize <= TotalSize && "Union size mismatch!"); |
| 638 | if (unsigned NumPadBytes = TotalSize - CurSize) { |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 639 | llvm::Type *Ty = CGM.Int8Ty; |
Anders Carlsson | aaed50d | 2009-07-31 21:38:39 +0000 | [diff] [blame] | 640 | if (NumPadBytes > 1) |
| 641 | Ty = llvm::ArrayType::get(Ty, NumPadBytes); |
Anders Carlsson | 0086ccb | 2009-08-22 23:54:44 +0000 | [diff] [blame] | 642 | |
Nuno Lopes | cdb30b4 | 2010-04-16 20:56:35 +0000 | [diff] [blame] | 643 | Elts.push_back(llvm::UndefValue::get(Ty)); |
Anders Carlsson | aaed50d | 2009-07-31 21:38:39 +0000 | [diff] [blame] | 644 | Types.push_back(Ty); |
| 645 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 646 | |
Anders Carlsson | 0086ccb | 2009-08-22 23:54:44 +0000 | [diff] [blame] | 647 | llvm::StructType* STy = |
| 648 | llvm::StructType::get(C->getType()->getContext(), Types, false); |
Anders Carlsson | aaed50d | 2009-07-31 21:38:39 +0000 | [diff] [blame] | 649 | return llvm::ConstantStruct::get(STy, Elts); |
Nuno Lopes | 81e51e2 | 2009-01-17 00:48:48 +0000 | [diff] [blame] | 650 | } |
Anders Carlsson | bb378cb | 2009-10-18 20:31:03 +0000 | [diff] [blame] | 651 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 652 | case CK_AddressSpaceConversion: |
| 653 | return llvm::ConstantExpr::getAddrSpaceCast(C, destType); |
| 654 | |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 655 | case CK_LValueToRValue: |
David Chisnall | 7a7ee30 | 2012-01-16 17:27:18 +0000 | [diff] [blame] | 656 | case CK_AtomicToNonAtomic: |
| 657 | case CK_NonAtomicToAtomic: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 658 | case CK_NoOp: |
Eli Friedman | 21cde05 | 2013-07-16 22:40:53 +0000 | [diff] [blame] | 659 | case CK_ConstructorConversion: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 660 | return C; |
Anders Carlsson | bb378cb | 2009-10-18 20:31:03 +0000 | [diff] [blame] | 661 | |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 662 | case CK_Dependent: llvm_unreachable("saw dependent cast!"); |
| 663 | |
Eli Friedman | a6c66ce | 2012-08-31 00:14:07 +0000 | [diff] [blame] | 664 | case CK_BuiltinFnToFnPtr: |
| 665 | llvm_unreachable("builtin functions are handled elsewhere"); |
| 666 | |
John McCall | 4d4e5c1 | 2012-02-15 01:22:51 +0000 | [diff] [blame] | 667 | case CK_ReinterpretMemberPointer: |
| 668 | case CK_DerivedToBaseMemberPointer: |
| 669 | case CK_BaseToDerivedMemberPointer: |
| 670 | return CGM.getCXXABI().EmitMemberPointerConversion(E, C); |
| 671 | |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 672 | // These will never be supported. |
| 673 | case CK_ObjCObjectLValueCast: |
John McCall | 33e56f3 | 2011-09-10 06:18:15 +0000 | [diff] [blame] | 674 | case CK_ARCProduceObject: |
| 675 | case CK_ARCConsumeObject: |
| 676 | case CK_ARCReclaimReturnedObject: |
| 677 | case CK_ARCExtendBlockObject: |
Douglas Gregor | ac1303e | 2012-02-22 05:02:47 +0000 | [diff] [blame] | 678 | case CK_CopyAndAutoreleaseBlockObject: |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 679 | return nullptr; |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 680 | |
Eli Friedman | 6563928 | 2012-01-04 23:13:47 +0000 | [diff] [blame] | 681 | // These don't need to be handled here because Evaluate knows how to |
Richard Smith | e7aa62d | 2012-01-17 21:42:19 +0000 | [diff] [blame] | 682 | // evaluate them in the cases where they can be folded. |
John McCall | 4d4e5c1 | 2012-02-15 01:22:51 +0000 | [diff] [blame] | 683 | case CK_BitCast: |
Richard Smith | e7aa62d | 2012-01-17 21:42:19 +0000 | [diff] [blame] | 684 | case CK_ToVoid: |
| 685 | case CK_Dynamic: |
| 686 | case CK_LValueBitCast: |
| 687 | case CK_NullToMemberPointer: |
Richard Smith | e7aa62d | 2012-01-17 21:42:19 +0000 | [diff] [blame] | 688 | case CK_UserDefinedConversion: |
Eli Friedman | 6563928 | 2012-01-04 23:13:47 +0000 | [diff] [blame] | 689 | case CK_CPointerToObjCPointerCast: |
| 690 | case CK_BlockPointerToObjCPointerCast: |
| 691 | case CK_AnyPointerToBlockPointerCast: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 692 | case CK_ArrayToPointerDecay: |
| 693 | case CK_FunctionToPointerDecay: |
| 694 | case CK_BaseToDerived: |
| 695 | case CK_DerivedToBase: |
| 696 | case CK_UncheckedDerivedToBase: |
| 697 | case CK_MemberPointerToBoolean: |
| 698 | case CK_VectorSplat: |
| 699 | case CK_FloatingRealToComplex: |
| 700 | case CK_FloatingComplexToReal: |
| 701 | case CK_FloatingComplexToBoolean: |
| 702 | case CK_FloatingComplexCast: |
| 703 | case CK_FloatingComplexToIntegralComplex: |
| 704 | case CK_IntegralRealToComplex: |
| 705 | case CK_IntegralComplexToReal: |
| 706 | case CK_IntegralComplexToBoolean: |
| 707 | case CK_IntegralComplexCast: |
| 708 | case CK_IntegralComplexToFloatingComplex: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 709 | case CK_PointerToIntegral: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 710 | case CK_PointerToBoolean: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 711 | case CK_NullToPointer: |
Eli Friedman | 6563928 | 2012-01-04 23:13:47 +0000 | [diff] [blame] | 712 | case CK_IntegralCast: |
| 713 | case CK_IntegralToPointer: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 714 | case CK_IntegralToBoolean: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 715 | case CK_IntegralToFloating: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 716 | case CK_FloatingToIntegral: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 717 | case CK_FloatingToBoolean: |
John McCall | 8bba1f4 | 2011-03-15 21:17:48 +0000 | [diff] [blame] | 718 | case CK_FloatingCast: |
Guy Benyei | e6b9d80 | 2013-01-20 12:31:11 +0000 | [diff] [blame] | 719 | case CK_ZeroToOCLEvent: |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 720 | return nullptr; |
Anders Carlsson | 0086ccb | 2009-08-22 23:54:44 +0000 | [diff] [blame] | 721 | } |
Matt Beaumont-Gay | 17d12fe | 2011-03-17 00:46:34 +0000 | [diff] [blame] | 722 | llvm_unreachable("Invalid CastKind"); |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 723 | } |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 724 | |
Chris Lattner | 0442108 | 2008-04-08 04:40:51 +0000 | [diff] [blame] | 725 | llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { |
| 726 | return Visit(DAE->getExpr()); |
| 727 | } |
| 728 | |
Richard Smith | c3bf52c | 2013-04-20 22:23:05 +0000 | [diff] [blame] | 729 | llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { |
| 730 | // No need for a DefaultInitExprScope: we don't handle 'this' in a |
| 731 | // constant expression. |
| 732 | return Visit(DIE->getExpr()); |
| 733 | } |
| 734 | |
Douglas Gregor | 03e8003 | 2011-06-21 17:03:29 +0000 | [diff] [blame] | 735 | llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { |
| 736 | return Visit(E->GetTemporaryExpr()); |
| 737 | } |
| 738 | |
Eli Friedman | a823400 | 2008-05-30 10:24:46 +0000 | [diff] [blame] | 739 | llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { |
Richard Smith | fe58720 | 2012-04-15 02:50:59 +0000 | [diff] [blame] | 740 | if (ILE->isStringLiteralInit()) |
Nuno Lopes | a75b71f | 2010-04-18 19:06:43 +0000 | [diff] [blame] | 741 | return Visit(ILE->getInit(0)); |
| 742 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 743 | llvm::ArrayType *AType = |
Nuno Lopes | 6784704 | 2010-04-16 23:19:41 +0000 | [diff] [blame] | 744 | cast<llvm::ArrayType>(ConvertType(ILE->getType())); |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 745 | llvm::Type *ElemTy = AType->getElementType(); |
Richard Smith | fe58720 | 2012-04-15 02:50:59 +0000 | [diff] [blame] | 746 | unsigned NumInitElements = ILE->getNumInits(); |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 747 | unsigned NumElements = AType->getNumElements(); |
| 748 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 749 | // Initialising an array requires us to automatically |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 750 | // initialise any elements that have not been initialised explicitly |
| 751 | unsigned NumInitableElts = std::min(NumInitElements, NumElements); |
| 752 | |
| 753 | // Copy initializer elements. |
Bill Wendling | f9ea953 | 2012-02-07 00:13:27 +0000 | [diff] [blame] | 754 | std::vector<llvm::Constant*> Elts; |
| 755 | Elts.reserve(NumInitableElts + NumElements); |
Benjamin Kramer | 14c5982 | 2012-02-14 12:06:21 +0000 | [diff] [blame] | 756 | |
Eli Friedman | a04a153 | 2008-05-30 19:58:50 +0000 | [diff] [blame] | 757 | bool RewriteType = false; |
Benjamin Kramer | 14c5982 | 2012-02-14 12:06:21 +0000 | [diff] [blame] | 758 | for (unsigned i = 0; i < NumInitableElts; ++i) { |
Anders Carlsson | e9352cc | 2009-04-08 04:48:15 +0000 | [diff] [blame] | 759 | Expr *Init = ILE->getInit(i); |
| 760 | llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); |
Daniel Dunbar | d60f2fb | 2009-02-17 18:43:32 +0000 | [diff] [blame] | 761 | if (!C) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 762 | return nullptr; |
Eli Friedman | a04a153 | 2008-05-30 19:58:50 +0000 | [diff] [blame] | 763 | RewriteType |= (C->getType() != ElemTy); |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 764 | Elts.push_back(C); |
| 765 | } |
Eli Friedman | a04a153 | 2008-05-30 19:58:50 +0000 | [diff] [blame] | 766 | |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 767 | // Initialize remaining array elements. |
Eli Friedman | 0f59312 | 2009-04-13 21:47:26 +0000 | [diff] [blame] | 768 | // FIXME: This doesn't handle member pointers correctly! |
Argyrios Kyrtzidis | 4423ac0 | 2011-04-21 00:27:41 +0000 | [diff] [blame] | 769 | llvm::Constant *fillC; |
| 770 | if (Expr *filler = ILE->getArrayFiller()) |
| 771 | fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF); |
| 772 | else |
| 773 | fillC = llvm::Constant::getNullValue(ElemTy); |
| 774 | if (!fillC) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 775 | return nullptr; |
Argyrios Kyrtzidis | 4423ac0 | 2011-04-21 00:27:41 +0000 | [diff] [blame] | 776 | RewriteType |= (fillC->getType() != ElemTy); |
Benjamin Kramer | 14c5982 | 2012-02-14 12:06:21 +0000 | [diff] [blame] | 777 | Elts.resize(NumElements, fillC); |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 778 | |
Eli Friedman | a04a153 | 2008-05-30 19:58:50 +0000 | [diff] [blame] | 779 | if (RewriteType) { |
| 780 | // FIXME: Try to avoid packing the array |
Jay Foad | ef6de3d | 2011-07-11 09:56:20 +0000 | [diff] [blame] | 781 | std::vector<llvm::Type*> Types; |
Bill Wendling | f9ea953 | 2012-02-07 00:13:27 +0000 | [diff] [blame] | 782 | Types.reserve(NumInitableElts + NumElements); |
Bill Wendling | fd3e5ef | 2012-02-06 23:46:08 +0000 | [diff] [blame] | 783 | for (unsigned i = 0, e = Elts.size(); i < e; ++i) |
Eli Friedman | a04a153 | 2008-05-30 19:58:50 +0000 | [diff] [blame] | 784 | Types.push_back(Elts[i]->getType()); |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 785 | llvm::StructType *SType = llvm::StructType::get(AType->getContext(), |
Owen Anderson | 47a434f | 2009-08-05 23:18:46 +0000 | [diff] [blame] | 786 | Types, true); |
Owen Anderson | 08e2524 | 2009-07-27 22:29:56 +0000 | [diff] [blame] | 787 | return llvm::ConstantStruct::get(SType, Elts); |
Eli Friedman | a04a153 | 2008-05-30 19:58:50 +0000 | [diff] [blame] | 788 | } |
| 789 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 790 | return llvm::ConstantArray::get(AType, Elts); |
Devang Patel | eae1560 | 2008-02-05 02:39:50 +0000 | [diff] [blame] | 791 | } |
| 792 | |
Richard Smith | 1b5c336 | 2012-09-11 05:51:06 +0000 | [diff] [blame] | 793 | llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) { |
Anders Carlsson | f6c4396 | 2009-07-31 21:34:04 +0000 | [diff] [blame] | 794 | return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); |
Eli Friedman | a823400 | 2008-05-30 10:24:46 +0000 | [diff] [blame] | 795 | } |
| 796 | |
Anders Carlsson | 7d801ea | 2009-01-30 06:13:25 +0000 | [diff] [blame] | 797 | llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { |
Eli Friedman | 0f59312 | 2009-04-13 21:47:26 +0000 | [diff] [blame] | 798 | return CGM.EmitNullConstant(E->getType()); |
Anders Carlsson | 7d801ea | 2009-01-30 06:13:25 +0000 | [diff] [blame] | 799 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 800 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 801 | llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { |
Eli Friedman | a823400 | 2008-05-30 10:24:46 +0000 | [diff] [blame] | 802 | if (ILE->getType()->isArrayType()) |
| 803 | return EmitArrayInitialization(ILE); |
Devang Patel | 47fb697 | 2008-01-29 23:23:18 +0000 | [diff] [blame] | 804 | |
Jin-Gu Kang | 45e4e08 | 2012-09-05 08:37:43 +0000 | [diff] [blame] | 805 | if (ILE->getType()->isRecordType()) |
Richard Smith | 1b5c336 | 2012-09-11 05:51:06 +0000 | [diff] [blame] | 806 | return EmitRecordInitialization(ILE); |
Jin-Gu Kang | 45e4e08 | 2012-09-05 08:37:43 +0000 | [diff] [blame] | 807 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 808 | return nullptr; |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 809 | } |
Eli Friedman | 3b707e7 | 2008-02-21 17:57:49 +0000 | [diff] [blame] | 810 | |
John McCall | fb8b69a | 2010-02-02 08:02:49 +0000 | [diff] [blame] | 811 | llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) { |
| 812 | if (!E->getConstructor()->isTrivial()) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 813 | return nullptr; |
John McCall | fb8b69a | 2010-02-02 08:02:49 +0000 | [diff] [blame] | 814 | |
Anders Carlsson | 2ca4f63 | 2010-02-05 18:38:45 +0000 | [diff] [blame] | 815 | QualType Ty = E->getType(); |
| 816 | |
| 817 | // FIXME: We should not have to call getBaseElementType here. |
| 818 | const RecordType *RT = |
| 819 | CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>(); |
| 820 | const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); |
| 821 | |
| 822 | // If the class doesn't have a trivial destructor, we can't emit it as a |
| 823 | // constant expr. |
| 824 | if (!RD->hasTrivialDestructor()) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 825 | return nullptr; |
| 826 | |
John McCall | fb8b69a | 2010-02-02 08:02:49 +0000 | [diff] [blame] | 827 | // Only copy and default constructors can be trivial. |
| 828 | |
John McCall | fb8b69a | 2010-02-02 08:02:49 +0000 | [diff] [blame] | 829 | |
| 830 | if (E->getNumArgs()) { |
| 831 | assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument"); |
Sebastian Redl | 85ea7aa | 2011-08-30 19:58:05 +0000 | [diff] [blame] | 832 | assert(E->getConstructor()->isCopyOrMoveConstructor() && |
| 833 | "trivial ctor has argument but isn't a copy/move ctor"); |
John McCall | fb8b69a | 2010-02-02 08:02:49 +0000 | [diff] [blame] | 834 | |
| 835 | Expr *Arg = E->getArg(0); |
| 836 | assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) && |
| 837 | "argument to copy ctor is of wrong type"); |
| 838 | |
Chandler Carruth | 878b55c | 2010-02-02 12:15:55 +0000 | [diff] [blame] | 839 | return Visit(Arg); |
John McCall | fb8b69a | 2010-02-02 08:02:49 +0000 | [diff] [blame] | 840 | } |
| 841 | |
| 842 | return CGM.EmitNullConstant(Ty); |
| 843 | } |
| 844 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 845 | llvm::Constant *VisitStringLiteral(StringLiteral *E) { |
Eli Friedman | 64f45a2 | 2011-11-01 02:23:42 +0000 | [diff] [blame] | 846 | return CGM.GetConstantArrayFromStringLiteral(E); |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 847 | } |
| 848 | |
Chris Lattner | eaf2bb8 | 2009-02-24 22:18:39 +0000 | [diff] [blame] | 849 | llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { |
| 850 | // This must be an @encode initializing an array in a static initializer. |
| 851 | // Don't emit it as the address of the string, emit the string data itself |
| 852 | // as an inline array. |
| 853 | std::string Str; |
| 854 | CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 855 | QualType T = E->getType(); |
| 856 | if (T->getTypeClass() == Type::TypeOfExpr) |
| 857 | T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType(); |
| 858 | const ConstantArrayType *CAT = cast<ConstantArrayType>(T); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 859 | |
Chris Lattner | eaf2bb8 | 2009-02-24 22:18:39 +0000 | [diff] [blame] | 860 | // Resize the string to the right size, adding zeros at the end, or |
| 861 | // truncating as needed. |
| 862 | Str.resize(CAT->getSize().getZExtValue(), '\0'); |
Chris Lattner | 9401069 | 2012-02-05 02:30:40 +0000 | [diff] [blame] | 863 | return llvm::ConstantDataArray::getString(VMContext, Str, false); |
Chris Lattner | eaf2bb8 | 2009-02-24 22:18:39 +0000 | [diff] [blame] | 864 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 865 | |
Eli Friedman | bc5ed6e | 2008-05-29 11:22:45 +0000 | [diff] [blame] | 866 | llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { |
| 867 | return Visit(E->getSubExpr()); |
| 868 | } |
Mike Stump | b83d287 | 2009-02-19 22:01:56 +0000 | [diff] [blame] | 869 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 870 | // Utility methods |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 871 | llvm::Type *ConvertType(QualType T) { |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 872 | return CGM.getTypes().ConvertType(T); |
| 873 | } |
Anders Carlsson | 84005b4 | 2008-01-26 04:30:23 +0000 | [diff] [blame] | 874 | |
Anders Carlsson | 5ea7d07 | 2008-11-16 06:23:45 +0000 | [diff] [blame] | 875 | public: |
Richard Smith | 1bf9a9e | 2011-11-12 22:28:03 +0000 | [diff] [blame] | 876 | llvm::Constant *EmitLValue(APValue::LValueBase LVBase) { |
| 877 | if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) { |
Rafael Espindola | da18261 | 2010-03-04 21:26:03 +0000 | [diff] [blame] | 878 | if (Decl->hasAttr<WeakRefAttr>()) |
Eli Friedman | a7e6845 | 2010-08-22 01:00:03 +0000 | [diff] [blame] | 879 | return CGM.GetWeakRefReference(Decl); |
Anders Carlsson | e3d3b7d | 2008-01-26 02:08:50 +0000 | [diff] [blame] | 880 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) |
Anders Carlsson | 555b4bb | 2009-09-10 23:43:36 +0000 | [diff] [blame] | 881 | return CGM.GetAddrOfFunction(FD); |
Steve Naroff | 248a753 | 2008-04-15 22:42:06 +0000 | [diff] [blame] | 882 | if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { |
Daniel Dunbar | d01b669 | 2009-02-24 18:41:57 +0000 | [diff] [blame] | 883 | // We can never refer to a variable with local storage. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 884 | if (!VD->hasLocalStorage()) { |
Daniel Dunbar | d01b669 | 2009-02-24 18:41:57 +0000 | [diff] [blame] | 885 | if (VD->isFileVarDecl() || VD->hasExternalStorage()) |
| 886 | return CGM.GetAddrOfGlobalVar(VD); |
Eli Friedman | 89e19b4 | 2013-01-03 00:39:26 +0000 | [diff] [blame] | 887 | else if (VD->isLocalVarDecl()) |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 888 | return CGM.getOrCreateStaticVarDecl( |
| 889 | *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false)); |
Steve Naroff | 248a753 | 2008-04-15 22:42:06 +0000 | [diff] [blame] | 890 | } |
Lauro Ramos Venancio | 8137335 | 2008-02-26 21:41:45 +0000 | [diff] [blame] | 891 | } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 892 | return nullptr; |
Richard Smith | 1bf9a9e | 2011-11-12 22:28:03 +0000 | [diff] [blame] | 893 | } |
| 894 | |
| 895 | Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>()); |
| 896 | switch (E->getStmtClass()) { |
| 897 | default: break; |
| 898 | case Expr::CompoundLiteralExprClass: { |
| 899 | // Note that due to the nature of compound literals, this is guaranteed |
| 900 | // to be the only use of the variable, so we just generate it here. |
| 901 | CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); |
Eli Friedman | 58c65fc | 2011-12-22 00:04:00 +0000 | [diff] [blame] | 902 | llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(), |
| 903 | CLE->getType(), CGF); |
Richard Smith | 1bf9a9e | 2011-11-12 22:28:03 +0000 | [diff] [blame] | 904 | // FIXME: "Leaked" on failure. |
| 905 | if (C) |
| 906 | C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), |
| 907 | E->getType().isConstant(CGM.getContext()), |
| 908 | llvm::GlobalValue::InternalLinkage, |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 909 | C, ".compoundliteral", nullptr, |
Hans Wennborg | 5e2d5de | 2012-06-23 11:51:46 +0000 | [diff] [blame] | 910 | llvm::GlobalVariable::NotThreadLocal, |
Richard Smith | 1bf9a9e | 2011-11-12 22:28:03 +0000 | [diff] [blame] | 911 | CGM.getContext().getTargetAddressSpace(E->getType())); |
| 912 | return C; |
Anders Carlsson | e3d3b7d | 2008-01-26 02:08:50 +0000 | [diff] [blame] | 913 | } |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 914 | case Expr::StringLiteralClass: |
| 915 | return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); |
Chris Lattner | eaf2bb8 | 2009-02-24 22:18:39 +0000 | [diff] [blame] | 916 | case Expr::ObjCEncodeExprClass: |
| 917 | return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); |
Anders Carlsson | 5ea7d07 | 2008-11-16 06:23:45 +0000 | [diff] [blame] | 918 | case Expr::ObjCStringLiteralClass: { |
| 919 | ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); |
David Chisnall | 0d13f6f | 2010-01-23 02:40:42 +0000 | [diff] [blame] | 920 | llvm::Constant *C = |
| 921 | CGM.getObjCRuntime().GenerateConstantString(SL->getString()); |
Owen Anderson | 3c4972d | 2009-07-29 18:54:39 +0000 | [diff] [blame] | 922 | return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); |
Anders Carlsson | 5ea7d07 | 2008-11-16 06:23:45 +0000 | [diff] [blame] | 923 | } |
Chris Lattner | 3534564 | 2008-12-12 05:18:02 +0000 | [diff] [blame] | 924 | case Expr::PredefinedExprClass: { |
Eli Friedman | f70b24e | 2009-11-14 08:37:13 +0000 | [diff] [blame] | 925 | unsigned Type = cast<PredefinedExpr>(E)->getIdentType(); |
| 926 | if (CGF) { |
Daniel Dunbar | 3ec0baf | 2010-08-21 03:01:12 +0000 | [diff] [blame] | 927 | LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E)); |
Eli Friedman | f70b24e | 2009-11-14 08:37:13 +0000 | [diff] [blame] | 928 | return cast<llvm::Constant>(Res.getAddress()); |
| 929 | } else if (Type == PredefinedExpr::PrettyFunction) { |
| 930 | return CGM.GetAddrOfConstantCString("top level", ".tmp"); |
| 931 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 932 | |
Eli Friedman | f70b24e | 2009-11-14 08:37:13 +0000 | [diff] [blame] | 933 | return CGM.GetAddrOfConstantCString("", ".tmp"); |
Chris Lattner | 3534564 | 2008-12-12 05:18:02 +0000 | [diff] [blame] | 934 | } |
Eli Friedman | f011589 | 2009-01-25 01:21:06 +0000 | [diff] [blame] | 935 | case Expr::AddrLabelExprClass: { |
| 936 | assert(CGF && "Invalid address of label expression outside function."); |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 937 | llvm::Constant *Ptr = |
| 938 | CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); |
| 939 | return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); |
Eli Friedman | f011589 | 2009-01-25 01:21:06 +0000 | [diff] [blame] | 940 | } |
Eli Friedman | 3941b18 | 2009-01-25 01:54:01 +0000 | [diff] [blame] | 941 | case Expr::CallExprClass: { |
| 942 | CallExpr* CE = cast<CallExpr>(E); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 943 | unsigned builtin = CE->getBuiltinCallee(); |
David Chisnall | 0d13f6f | 2010-01-23 02:40:42 +0000 | [diff] [blame] | 944 | if (builtin != |
| 945 | Builtin::BI__builtin___CFStringMakeConstantString && |
| 946 | builtin != |
| 947 | Builtin::BI__builtin___NSStringMakeConstantString) |
Eli Friedman | 3941b18 | 2009-01-25 01:54:01 +0000 | [diff] [blame] | 948 | break; |
| 949 | const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); |
| 950 | const StringLiteral *Literal = cast<StringLiteral>(Arg); |
David Chisnall | 0d13f6f | 2010-01-23 02:40:42 +0000 | [diff] [blame] | 951 | if (builtin == |
| 952 | Builtin::BI__builtin___NSStringMakeConstantString) { |
| 953 | return CGM.getObjCRuntime().GenerateConstantString(Literal); |
| 954 | } |
Steve Naroff | 33fdb73 | 2009-03-31 16:53:37 +0000 | [diff] [blame] | 955 | // FIXME: need to deal with UCN conversion issues. |
Steve Naroff | 8d4141f | 2009-04-01 13:55:36 +0000 | [diff] [blame] | 956 | return CGM.GetAddrOfConstantCFString(Literal); |
Eli Friedman | 3941b18 | 2009-01-25 01:54:01 +0000 | [diff] [blame] | 957 | } |
Mike Stump | bd65cac | 2009-02-19 01:01:04 +0000 | [diff] [blame] | 958 | case Expr::BlockExprClass: { |
Anders Carlsson | 4de9fce | 2009-03-01 01:09:12 +0000 | [diff] [blame] | 959 | std::string FunctionName; |
| 960 | if (CGF) |
| 961 | FunctionName = CGF->CurFn->getName(); |
| 962 | else |
| 963 | FunctionName = "global"; |
| 964 | |
| 965 | return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); |
Mike Stump | bd65cac | 2009-02-19 01:01:04 +0000 | [diff] [blame] | 966 | } |
Richard Smith | 47d2145 | 2011-12-27 12:18:28 +0000 | [diff] [blame] | 967 | case Expr::CXXTypeidExprClass: { |
| 968 | CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E); |
| 969 | QualType T; |
| 970 | if (Typeid->isTypeOperand()) |
David Majnemer | fe16aa3 | 2013-09-27 07:04:31 +0000 | [diff] [blame] | 971 | T = Typeid->getTypeOperand(CGM.getContext()); |
Richard Smith | 47d2145 | 2011-12-27 12:18:28 +0000 | [diff] [blame] | 972 | else |
| 973 | T = Typeid->getExprOperand()->getType(); |
| 974 | return CGM.GetAddrOfRTTIDescriptor(T); |
| 975 | } |
Nico Weber | c5f8046 | 2012-10-11 10:13:44 +0000 | [diff] [blame] | 976 | case Expr::CXXUuidofExprClass: { |
| 977 | return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E)); |
| 978 | } |
Richard Smith | 211c8dd | 2013-06-05 00:46:14 +0000 | [diff] [blame] | 979 | case Expr::MaterializeTemporaryExprClass: { |
| 980 | MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E); |
| 981 | assert(MTE->getStorageDuration() == SD_Static); |
| 982 | SmallVector<const Expr *, 2> CommaLHSs; |
| 983 | SmallVector<SubobjectAdjustment, 2> Adjustments; |
| 984 | const Expr *Inner = MTE->GetTemporaryExpr() |
| 985 | ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); |
| 986 | return CGM.GetAddrOfGlobalTemporary(MTE, Inner); |
| 987 | } |
Eli Friedman | 546d94c | 2008-02-11 00:23:10 +0000 | [diff] [blame] | 988 | } |
Daniel Dunbar | d60f2fb | 2009-02-17 18:43:32 +0000 | [diff] [blame] | 989 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 990 | return nullptr; |
Anders Carlsson | e3d3b7d | 2008-01-26 02:08:50 +0000 | [diff] [blame] | 991 | } |
Anders Carlsson | e3d3b7d | 2008-01-26 02:08:50 +0000 | [diff] [blame] | 992 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 993 | |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 994 | } // end anonymous namespace. |
| 995 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 996 | llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D, |
| 997 | CodeGenFunction *CGF) { |
Fariborz Jahanian | c2316db | 2013-01-10 23:28:43 +0000 | [diff] [blame] | 998 | // Make a quick check if variable can be default NULL initialized |
| 999 | // and avoid going through rest of code which may do, for c++11, |
| 1000 | // initialization of memory to all NULLs. |
| 1001 | if (!D.hasLocalStorage()) { |
| 1002 | QualType Ty = D.getType(); |
| 1003 | if (Ty->isArrayType()) |
| 1004 | Ty = Context.getBaseElementType(Ty); |
| 1005 | if (Ty->isRecordType()) |
| 1006 | if (const CXXConstructExpr *E = |
| 1007 | dyn_cast_or_null<CXXConstructExpr>(D.getInit())) { |
| 1008 | const CXXConstructorDecl *CD = E->getConstructor(); |
Alexey Samsonov | 50f9de5 | 2013-04-05 07:47:28 +0000 | [diff] [blame] | 1009 | if (CD->isTrivial() && CD->isDefaultConstructor()) |
Fariborz Jahanian | c2316db | 2013-01-10 23:28:43 +0000 | [diff] [blame] | 1010 | return EmitNullConstant(D.getType()); |
| 1011 | } |
| 1012 | } |
| 1013 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1014 | if (const APValue *Value = D.evaluateValue()) |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 1015 | return EmitConstantValueForMemory(*Value, D.getType(), CGF); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1016 | |
Richard Smith | 7ca4850 | 2012-02-13 22:16:19 +0000 | [diff] [blame] | 1017 | // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a |
| 1018 | // reference is a constant expression, and the reference binds to a temporary, |
| 1019 | // then constant initialization is performed. ConstExprEmitter will |
| 1020 | // incorrectly emit a prvalue constant in this case, and the calling code |
| 1021 | // interprets that as the (pointer) value of the reference, rather than the |
| 1022 | // desired value of the referee. |
| 1023 | if (D.getType()->isReferenceType()) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1024 | return nullptr; |
Richard Smith | 7ca4850 | 2012-02-13 22:16:19 +0000 | [diff] [blame] | 1025 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1026 | const Expr *E = D.getInit(); |
| 1027 | assert(E && "No initializer to emit"); |
| 1028 | |
| 1029 | llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); |
| 1030 | if (C && C->getType()->isIntegerTy(1)) { |
| 1031 | llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); |
| 1032 | C = llvm::ConstantExpr::getZExt(C, BoolTy); |
| 1033 | } |
| 1034 | return C; |
| 1035 | } |
| 1036 | |
Lauro Ramos Venancio | 8137335 | 2008-02-26 21:41:45 +0000 | [diff] [blame] | 1037 | llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, |
Anders Carlsson | e9352cc | 2009-04-08 04:48:15 +0000 | [diff] [blame] | 1038 | QualType DestType, |
Chris Lattner | 9619662 | 2008-07-26 22:37:01 +0000 | [diff] [blame] | 1039 | CodeGenFunction *CGF) { |
Anders Carlsson | 4b3f9c0 | 2008-12-01 02:42:14 +0000 | [diff] [blame] | 1040 | Expr::EvalResult Result; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1041 | |
Anders Carlsson | 1e5dc6e | 2009-04-11 01:08:03 +0000 | [diff] [blame] | 1042 | bool Success = false; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1043 | |
Eli Friedman | 50c39ea | 2009-05-27 06:04:58 +0000 | [diff] [blame] | 1044 | if (DestType->isReferenceType()) |
| 1045 | Success = E->EvaluateAsLValue(Result, Context); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1046 | else |
Richard Smith | 51f4708 | 2011-10-29 00:50:52 +0000 | [diff] [blame] | 1047 | Success = E->EvaluateAsRValue(Result, Context); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1048 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1049 | llvm::Constant *C = nullptr; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1050 | if (Success && !Result.HasSideEffects) |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 1051 | C = EmitConstantValue(Result.Val, DestType, CGF); |
| 1052 | else |
| 1053 | C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); |
Eli Friedman | 7dfa639 | 2008-06-01 15:31:44 +0000 | [diff] [blame] | 1054 | |
Chris Lattner | 7f215c1 | 2010-06-26 21:52:32 +0000 | [diff] [blame] | 1055 | if (C && C->getType()->isIntegerTy(1)) { |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 1056 | llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); |
Owen Anderson | 3c4972d | 2009-07-29 18:54:39 +0000 | [diff] [blame] | 1057 | C = llvm::ConstantExpr::getZExt(C, BoolTy); |
Eli Friedman | 7dfa639 | 2008-06-01 15:31:44 +0000 | [diff] [blame] | 1058 | } |
| 1059 | return C; |
Anders Carlsson | 3b1d57b | 2008-01-26 01:36:00 +0000 | [diff] [blame] | 1060 | } |
Eli Friedman | 0f59312 | 2009-04-13 21:47:26 +0000 | [diff] [blame] | 1061 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1062 | llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value, |
| 1063 | QualType DestType, |
| 1064 | CodeGenFunction *CGF) { |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1065 | // For an _Atomic-qualified constant, we may need to add tail padding. |
| 1066 | if (auto *AT = DestType->getAs<AtomicType>()) { |
| 1067 | QualType InnerType = AT->getValueType(); |
| 1068 | auto *Inner = EmitConstantValue(Value, InnerType, CGF); |
| 1069 | |
| 1070 | uint64_t InnerSize = Context.getTypeSize(InnerType); |
| 1071 | uint64_t OuterSize = Context.getTypeSize(DestType); |
| 1072 | if (InnerSize == OuterSize) |
| 1073 | return Inner; |
| 1074 | |
| 1075 | assert(InnerSize < OuterSize && "emitted over-large constant for atomic"); |
| 1076 | llvm::Constant *Elts[] = { |
| 1077 | Inner, |
| 1078 | llvm::ConstantAggregateZero::get( |
| 1079 | llvm::ArrayType::get(Int8Ty, (OuterSize - InnerSize) / 8)) |
| 1080 | }; |
| 1081 | return llvm::ConstantStruct::getAnon(Elts); |
| 1082 | } |
| 1083 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1084 | switch (Value.getKind()) { |
| 1085 | case APValue::Uninitialized: |
| 1086 | llvm_unreachable("Constant expressions should be initialized."); |
| 1087 | case APValue::LValue: { |
| 1088 | llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); |
| 1089 | llvm::Constant *Offset = |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 1090 | llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity()); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1091 | |
| 1092 | llvm::Constant *C; |
| 1093 | if (APValue::LValueBase LVBase = Value.getLValueBase()) { |
| 1094 | // An array can be represented as an lvalue referring to the base. |
| 1095 | if (isa<llvm::ArrayType>(DestTy)) { |
| 1096 | assert(Offset->isNullValue() && "offset on array initializer"); |
| 1097 | return ConstExprEmitter(*this, CGF).Visit( |
| 1098 | const_cast<Expr*>(LVBase.get<const Expr*>())); |
| 1099 | } |
| 1100 | |
| 1101 | C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase); |
| 1102 | |
| 1103 | // Apply offset if necessary. |
| 1104 | if (!Offset->isNullValue()) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1105 | unsigned AS = C->getType()->getPointerAddressSpace(); |
| 1106 | llvm::Type *CharPtrTy = Int8Ty->getPointerTo(AS); |
| 1107 | llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, CharPtrTy); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1108 | Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1109 | C = llvm::ConstantExpr::getPointerCast(Casted, C->getType()); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1110 | } |
| 1111 | |
| 1112 | // Convert to the appropriate type; this could be an lvalue for |
| 1113 | // an integer. |
| 1114 | if (isa<llvm::PointerType>(DestTy)) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1115 | return llvm::ConstantExpr::getPointerCast(C, DestTy); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1116 | |
| 1117 | return llvm::ConstantExpr::getPtrToInt(C, DestTy); |
| 1118 | } else { |
| 1119 | C = Offset; |
| 1120 | |
| 1121 | // Convert to the appropriate type; this could be an lvalue for |
| 1122 | // an integer. |
| 1123 | if (isa<llvm::PointerType>(DestTy)) |
| 1124 | return llvm::ConstantExpr::getIntToPtr(C, DestTy); |
| 1125 | |
| 1126 | // If the types don't match this should only be a truncate. |
| 1127 | if (C->getType() != DestTy) |
| 1128 | return llvm::ConstantExpr::getTrunc(C, DestTy); |
| 1129 | |
| 1130 | return C; |
| 1131 | } |
| 1132 | } |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 1133 | case APValue::Int: |
| 1134 | return llvm::ConstantInt::get(VMContext, Value.getInt()); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1135 | case APValue::ComplexInt: { |
| 1136 | llvm::Constant *Complex[2]; |
| 1137 | |
| 1138 | Complex[0] = llvm::ConstantInt::get(VMContext, |
| 1139 | Value.getComplexIntReal()); |
| 1140 | Complex[1] = llvm::ConstantInt::get(VMContext, |
| 1141 | Value.getComplexIntImag()); |
| 1142 | |
| 1143 | // FIXME: the target may want to specify that this is packed. |
| 1144 | llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), |
| 1145 | Complex[1]->getType(), |
| 1146 | NULL); |
| 1147 | return llvm::ConstantStruct::get(STy, Complex); |
| 1148 | } |
| 1149 | case APValue::Float: { |
| 1150 | const llvm::APFloat &Init = Value.getFloat(); |
Joey Gouly | 19dbb20 | 2013-01-23 11:56:20 +0000 | [diff] [blame] | 1151 | if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1152 | !Context.getLangOpts().NativeHalfType && |
| 1153 | !Context.getLangOpts().HalfArgsAndReturns) |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1154 | return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt()); |
| 1155 | else |
| 1156 | return llvm::ConstantFP::get(VMContext, Init); |
| 1157 | } |
| 1158 | case APValue::ComplexFloat: { |
| 1159 | llvm::Constant *Complex[2]; |
| 1160 | |
| 1161 | Complex[0] = llvm::ConstantFP::get(VMContext, |
| 1162 | Value.getComplexFloatReal()); |
| 1163 | Complex[1] = llvm::ConstantFP::get(VMContext, |
| 1164 | Value.getComplexFloatImag()); |
| 1165 | |
| 1166 | // FIXME: the target may want to specify that this is packed. |
| 1167 | llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), |
| 1168 | Complex[1]->getType(), |
| 1169 | NULL); |
| 1170 | return llvm::ConstantStruct::get(STy, Complex); |
| 1171 | } |
| 1172 | case APValue::Vector: { |
| 1173 | SmallVector<llvm::Constant *, 4> Inits; |
| 1174 | unsigned NumElts = Value.getVectorLength(); |
| 1175 | |
| 1176 | for (unsigned i = 0; i != NumElts; ++i) { |
| 1177 | const APValue &Elt = Value.getVectorElt(i); |
| 1178 | if (Elt.isInt()) |
| 1179 | Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt())); |
| 1180 | else |
| 1181 | Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat())); |
| 1182 | } |
| 1183 | return llvm::ConstantVector::get(Inits); |
| 1184 | } |
| 1185 | case APValue::AddrLabelDiff: { |
| 1186 | const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS(); |
| 1187 | const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS(); |
| 1188 | llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF); |
| 1189 | llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF); |
| 1190 | |
| 1191 | // Compute difference |
| 1192 | llvm::Type *ResultType = getTypes().ConvertType(DestType); |
| 1193 | LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy); |
| 1194 | RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy); |
| 1195 | llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS); |
| 1196 | |
| 1197 | // LLVM is a bit sensitive about the exact format of the |
| 1198 | // address-of-label difference; make sure to truncate after |
| 1199 | // the subtraction. |
| 1200 | return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType); |
| 1201 | } |
| 1202 | case APValue::Struct: |
| 1203 | case APValue::Union: |
| 1204 | return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType); |
| 1205 | case APValue::Array: { |
| 1206 | const ArrayType *CAT = Context.getAsArrayType(DestType); |
| 1207 | unsigned NumElements = Value.getArraySize(); |
| 1208 | unsigned NumInitElts = Value.getArrayInitializedElts(); |
| 1209 | |
| 1210 | std::vector<llvm::Constant*> Elts; |
| 1211 | Elts.reserve(NumElements); |
| 1212 | |
| 1213 | // Emit array filler, if there is one. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1214 | llvm::Constant *Filler = nullptr; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1215 | if (Value.hasArrayFiller()) |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 1216 | Filler = EmitConstantValueForMemory(Value.getArrayFiller(), |
| 1217 | CAT->getElementType(), CGF); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1218 | |
| 1219 | // Emit initializer elements. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1220 | llvm::Type *CommonElementType = nullptr; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1221 | for (unsigned I = 0; I < NumElements; ++I) { |
| 1222 | llvm::Constant *C = Filler; |
| 1223 | if (I < NumInitElts) |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 1224 | C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I), |
| 1225 | CAT->getElementType(), CGF); |
Jordan Rose | 41f3f3a | 2013-03-05 01:27:54 +0000 | [diff] [blame] | 1226 | else |
| 1227 | assert(Filler && "Missing filler for implicit elements of initializer"); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1228 | if (I == 0) |
| 1229 | CommonElementType = C->getType(); |
| 1230 | else if (C->getType() != CommonElementType) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1231 | CommonElementType = nullptr; |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1232 | Elts.push_back(C); |
| 1233 | } |
| 1234 | |
| 1235 | if (!CommonElementType) { |
| 1236 | // FIXME: Try to avoid packing the array |
| 1237 | std::vector<llvm::Type*> Types; |
Bill Wendling | f9ea953 | 2012-02-07 00:13:27 +0000 | [diff] [blame] | 1238 | Types.reserve(NumElements); |
Bill Wendling | fd3e5ef | 2012-02-06 23:46:08 +0000 | [diff] [blame] | 1239 | for (unsigned i = 0, e = Elts.size(); i < e; ++i) |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1240 | Types.push_back(Elts[i]->getType()); |
| 1241 | llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true); |
| 1242 | return llvm::ConstantStruct::get(SType, Elts); |
| 1243 | } |
| 1244 | |
| 1245 | llvm::ArrayType *AType = |
| 1246 | llvm::ArrayType::get(CommonElementType, NumElements); |
| 1247 | return llvm::ConstantArray::get(AType, Elts); |
| 1248 | } |
| 1249 | case APValue::MemberPointer: |
| 1250 | return getCXXABI().EmitMemberPointer(Value, DestType); |
| 1251 | } |
| 1252 | llvm_unreachable("Unknown APValue kind"); |
| 1253 | } |
| 1254 | |
Richard Smith | 7401cf5 | 2011-11-22 22:48:32 +0000 | [diff] [blame] | 1255 | llvm::Constant * |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 1256 | CodeGenModule::EmitConstantValueForMemory(const APValue &Value, |
| 1257 | QualType DestType, |
| 1258 | CodeGenFunction *CGF) { |
| 1259 | llvm::Constant *C = EmitConstantValue(Value, DestType, CGF); |
| 1260 | if (C->getType()->isIntegerTy(1)) { |
| 1261 | llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType); |
| 1262 | C = llvm::ConstantExpr::getZExt(C, BoolTy); |
| 1263 | } |
| 1264 | return C; |
| 1265 | } |
| 1266 | |
| 1267 | llvm::Constant * |
Richard Smith | 7401cf5 | 2011-11-22 22:48:32 +0000 | [diff] [blame] | 1268 | CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) { |
| 1269 | assert(E->isFileScope() && "not a file-scope compound literal expr"); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1270 | return ConstExprEmitter(*this, nullptr).EmitLValue(E); |
Richard Smith | 7401cf5 | 2011-11-22 22:48:32 +0000 | [diff] [blame] | 1271 | } |
| 1272 | |
John McCall | 5808ce4 | 2011-02-03 08:15:49 +0000 | [diff] [blame] | 1273 | llvm::Constant * |
| 1274 | CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { |
| 1275 | // Member pointer constants always have a very particular form. |
| 1276 | const MemberPointerType *type = cast<MemberPointerType>(uo->getType()); |
| 1277 | const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl(); |
| 1278 | |
| 1279 | // A member function pointer. |
| 1280 | if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) |
| 1281 | return getCXXABI().EmitMemberPointer(method); |
| 1282 | |
| 1283 | // Otherwise, a member data pointer. |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 1284 | uint64_t fieldOffset = getContext().getFieldOffset(decl); |
John McCall | 5808ce4 | 2011-02-03 08:15:49 +0000 | [diff] [blame] | 1285 | CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset); |
| 1286 | return getCXXABI().EmitMemberDataPointer(type, chars); |
| 1287 | } |
| 1288 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1289 | static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 1290 | llvm::Type *baseType, |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1291 | const CXXRecordDecl *base); |
| 1292 | |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1293 | static llvm::Constant *EmitNullConstant(CodeGenModule &CGM, |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1294 | const CXXRecordDecl *record, |
| 1295 | bool asCompleteObject) { |
| 1296 | const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record); |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 1297 | llvm::StructType *structure = |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1298 | (asCompleteObject ? layout.getLLVMType() |
| 1299 | : layout.getBaseSubobjectLLVMType()); |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1300 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1301 | unsigned numElements = structure->getNumElements(); |
| 1302 | std::vector<llvm::Constant *> elements(numElements); |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1303 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1304 | // Fill in all the bases. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1305 | for (const auto &I : record->bases()) { |
| 1306 | if (I.isVirtual()) { |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1307 | // Ignore virtual bases; if we're laying out for a complete |
| 1308 | // object, we'll lay these out later. |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1309 | continue; |
| 1310 | } |
| 1311 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1312 | const CXXRecordDecl *base = |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1313 | cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1314 | |
| 1315 | // Ignore empty bases. |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1316 | if (base->isEmpty()) |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1317 | continue; |
| 1318 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1319 | unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base); |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 1320 | llvm::Type *baseType = structure->getElementType(fieldIndex); |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1321 | elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1322 | } |
| 1323 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1324 | // Fill in all the fields. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1325 | for (const auto *Field : record->fields()) { |
Eli Friedman | 26e80cd | 2011-12-07 01:30:11 +0000 | [diff] [blame] | 1326 | // Fill in non-bitfields. (Bitfields always use a zero pattern, which we |
| 1327 | // will fill in later.) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1328 | if (!Field->isBitField()) { |
| 1329 | unsigned fieldIndex = layout.getLLVMFieldNo(Field); |
| 1330 | elements[fieldIndex] = CGM.EmitNullConstant(Field->getType()); |
Eli Friedman | 26e80cd | 2011-12-07 01:30:11 +0000 | [diff] [blame] | 1331 | } |
| 1332 | |
| 1333 | // For unions, stop after the first named field. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1334 | if (record->isUnion() && Field->getDeclName()) |
Eli Friedman | 26e80cd | 2011-12-07 01:30:11 +0000 | [diff] [blame] | 1335 | break; |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1336 | } |
| 1337 | |
| 1338 | // Fill in the virtual bases, if we're working with the complete object. |
| 1339 | if (asCompleteObject) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1340 | for (const auto &I : record->vbases()) { |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1341 | const CXXRecordDecl *base = |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1342 | cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1343 | |
| 1344 | // Ignore empty bases. |
| 1345 | if (base->isEmpty()) |
| 1346 | continue; |
| 1347 | |
| 1348 | unsigned fieldIndex = layout.getVirtualBaseIndex(base); |
| 1349 | |
| 1350 | // We might have already laid this field out. |
| 1351 | if (elements[fieldIndex]) continue; |
| 1352 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 1353 | llvm::Type *baseType = structure->getElementType(fieldIndex); |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1354 | elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); |
| 1355 | } |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1356 | } |
| 1357 | |
| 1358 | // Now go through all other fields and zero them out. |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1359 | for (unsigned i = 0; i != numElements; ++i) { |
| 1360 | if (!elements[i]) |
| 1361 | elements[i] = llvm::Constant::getNullValue(structure->getElementType(i)); |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1362 | } |
| 1363 | |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1364 | return llvm::ConstantStruct::get(structure, elements); |
| 1365 | } |
| 1366 | |
| 1367 | /// Emit the null constant for a base subobject. |
| 1368 | static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 1369 | llvm::Type *baseType, |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1370 | const CXXRecordDecl *base) { |
| 1371 | const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base); |
| 1372 | |
| 1373 | // Just zero out bases that don't have any pointer to data members. |
| 1374 | if (baseLayout.isZeroInitializableAsBase()) |
| 1375 | return llvm::Constant::getNullValue(baseType); |
| 1376 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1377 | // Otherwise, we can just use its null constant. |
| 1378 | return EmitNullConstant(CGM, base, /*asCompleteObject=*/false); |
Anders Carlsson | ada4b32 | 2010-11-22 18:42:14 +0000 | [diff] [blame] | 1379 | } |
| 1380 | |
Eli Friedman | 0f59312 | 2009-04-13 21:47:26 +0000 | [diff] [blame] | 1381 | llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { |
John McCall | f16aa10 | 2010-08-22 21:01:12 +0000 | [diff] [blame] | 1382 | if (getTypes().isZeroInitializable(T)) |
Anders Carlsson | ad3e711 | 2009-08-24 17:16:23 +0000 | [diff] [blame] | 1383 | return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); |
Anders Carlsson | 2c12d03 | 2010-02-02 05:17:25 +0000 | [diff] [blame] | 1384 | |
Anders Carlsson | 237957c | 2009-08-09 18:26:27 +0000 | [diff] [blame] | 1385 | if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { |
Chris Lattner | 6ef016f | 2012-02-06 22:00:56 +0000 | [diff] [blame] | 1386 | llvm::ArrayType *ATy = |
| 1387 | cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1388 | |
Anders Carlsson | 237957c | 2009-08-09 18:26:27 +0000 | [diff] [blame] | 1389 | QualType ElementTy = CAT->getElementType(); |
| 1390 | |
Anders Carlsson | 2c12d03 | 2010-02-02 05:17:25 +0000 | [diff] [blame] | 1391 | llvm::Constant *Element = EmitNullConstant(ElementTy); |
| 1392 | unsigned NumElements = CAT->getSize().getZExtValue(); |
Chris Lattner | 6ef016f | 2012-02-06 22:00:56 +0000 | [diff] [blame] | 1393 | |
| 1394 | if (Element->isNullValue()) |
| 1395 | return llvm::ConstantAggregateZero::get(ATy); |
| 1396 | |
| 1397 | SmallVector<llvm::Constant *, 8> Array(NumElements, Element); |
Anders Carlsson | 2c12d03 | 2010-02-02 05:17:25 +0000 | [diff] [blame] | 1398 | return llvm::ConstantArray::get(ATy, Array); |
Anders Carlsson | 237957c | 2009-08-09 18:26:27 +0000 | [diff] [blame] | 1399 | } |
Anders Carlsson | fc3eaa4 | 2009-08-23 01:25:01 +0000 | [diff] [blame] | 1400 | |
| 1401 | if (const RecordType *RT = T->getAs<RecordType>()) { |
Anders Carlsson | 2c12d03 | 2010-02-02 05:17:25 +0000 | [diff] [blame] | 1402 | const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); |
John McCall | 9b7da1c | 2011-02-15 06:40:56 +0000 | [diff] [blame] | 1403 | return ::EmitNullConstant(*this, RD, /*complete object*/ true); |
Anders Carlsson | fc3eaa4 | 2009-08-23 01:25:01 +0000 | [diff] [blame] | 1404 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1405 | |
Anders Carlsson | a83fb4b | 2010-05-18 16:51:41 +0000 | [diff] [blame] | 1406 | assert(T->isMemberPointerType() && "Should only see member pointers here!"); |
Anders Carlsson | 2c12d03 | 2010-02-02 05:17:25 +0000 | [diff] [blame] | 1407 | assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && |
| 1408 | "Should only see pointers to data members here!"); |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1409 | |
John McCall | 5808ce4 | 2011-02-03 08:15:49 +0000 | [diff] [blame] | 1410 | return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>()); |
Eli Friedman | 0f59312 | 2009-04-13 21:47:26 +0000 | [diff] [blame] | 1411 | } |
Eli Friedman | 2ed7cb6 | 2011-10-14 02:27:24 +0000 | [diff] [blame] | 1412 | |
| 1413 | llvm::Constant * |
| 1414 | CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) { |
| 1415 | return ::EmitNullConstant(*this, Record, false); |
| 1416 | } |