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