Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1 | //===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | f3ebc3f | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 9 | |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 10 | #include "llvm/Bitcode/ReaderWriter.h" |
Benjamin Kramer | 0a446fd | 2015-03-01 21:28:53 +0000 | [diff] [blame] | 11 | #include "llvm/ADT/STLExtras.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/SmallString.h" |
| 13 | #include "llvm/ADT/SmallVector.h" |
David Majnemer | 3087b22 | 2015-01-20 05:58:07 +0000 | [diff] [blame] | 14 | #include "llvm/ADT/Triple.h" |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 15 | #include "llvm/Bitcode/BitstreamReader.h" |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 16 | #include "llvm/Bitcode/LLVMBitCodes.h" |
Chandler Carruth | 9106521 | 2014-03-05 10:34:14 +0000 | [diff] [blame] | 17 | #include "llvm/IR/AutoUpgrade.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 18 | #include "llvm/IR/Constants.h" |
Rafael Espindola | 0d68b4c | 2015-03-30 21:36:43 +0000 | [diff] [blame] | 19 | #include "llvm/IR/DebugInfo.h" |
Duncan P. N. Exon Smith | d9901ff | 2015-02-02 18:53:21 +0000 | [diff] [blame] | 20 | #include "llvm/IR/DebugInfoMetadata.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 21 | #include "llvm/IR/DerivedTypes.h" |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 22 | #include "llvm/IR/DiagnosticPrinter.h" |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 23 | #include "llvm/IR/GVMaterializer.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 24 | #include "llvm/IR/InlineAsm.h" |
| 25 | #include "llvm/IR/IntrinsicInst.h" |
Manman Ren | 209b17c | 2013-09-28 00:22:27 +0000 | [diff] [blame] | 26 | #include "llvm/IR/LLVMContext.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 27 | #include "llvm/IR/Module.h" |
| 28 | #include "llvm/IR/OperandTraits.h" |
| 29 | #include "llvm/IR/Operator.h" |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 30 | #include "llvm/IR/FunctionInfo.h" |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 31 | #include "llvm/IR/ValueHandle.h" |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 32 | #include "llvm/Support/DataStream.h" |
Chandler Carruth | d990388 | 2015-01-14 11:23:27 +0000 | [diff] [blame] | 33 | #include "llvm/Support/ManagedStatic.h" |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 34 | #include "llvm/Support/MathExtras.h" |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 35 | #include "llvm/Support/MemoryBuffer.h" |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 36 | #include "llvm/Support/raw_ostream.h" |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 37 | #include <deque> |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 38 | using namespace llvm; |
| 39 | |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 40 | namespace { |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 41 | enum { |
| 42 | SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex |
| 43 | }; |
| 44 | |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 45 | class BitcodeReaderValueList { |
| 46 | std::vector<WeakVH> ValuePtrs; |
| 47 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 48 | /// As we resolve forward-referenced constants, we add information about them |
| 49 | /// to this vector. This allows us to resolve them in bulk instead of |
| 50 | /// resolving each reference at a time. See the code in |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 51 | /// ResolveConstantForwardRefs for more information about this. |
| 52 | /// |
| 53 | /// The key of this vector is the placeholder constant, the value is the slot |
| 54 | /// number that holds the resolved value. |
| 55 | typedef std::vector<std::pair<Constant*, unsigned> > ResolveConstantsTy; |
| 56 | ResolveConstantsTy ResolveConstants; |
| 57 | LLVMContext &Context; |
| 58 | public: |
| 59 | BitcodeReaderValueList(LLVMContext &C) : Context(C) {} |
| 60 | ~BitcodeReaderValueList() { |
| 61 | assert(ResolveConstants.empty() && "Constants not resolved?"); |
| 62 | } |
| 63 | |
| 64 | // vector compatibility methods |
| 65 | unsigned size() const { return ValuePtrs.size(); } |
| 66 | void resize(unsigned N) { ValuePtrs.resize(N); } |
Benjamin Kramer | f5e2fc4 | 2015-05-29 19:43:39 +0000 | [diff] [blame] | 67 | void push_back(Value *V) { ValuePtrs.emplace_back(V); } |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 68 | |
| 69 | void clear() { |
| 70 | assert(ResolveConstants.empty() && "Constants not resolved?"); |
| 71 | ValuePtrs.clear(); |
| 72 | } |
| 73 | |
| 74 | Value *operator[](unsigned i) const { |
| 75 | assert(i < ValuePtrs.size()); |
| 76 | return ValuePtrs[i]; |
| 77 | } |
| 78 | |
| 79 | Value *back() const { return ValuePtrs.back(); } |
| 80 | void pop_back() { ValuePtrs.pop_back(); } |
| 81 | bool empty() const { return ValuePtrs.empty(); } |
| 82 | void shrinkTo(unsigned N) { |
| 83 | assert(N <= size() && "Invalid shrinkTo request!"); |
| 84 | ValuePtrs.resize(N); |
| 85 | } |
| 86 | |
| 87 | Constant *getConstantFwdRef(unsigned Idx, Type *Ty); |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 88 | Value *getValueFwdRef(unsigned Idx, Type *Ty); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 89 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 90 | void assignValue(Value *V, unsigned Idx); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 91 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 92 | /// Once all constants are read, this method bulk resolves any forward |
| 93 | /// references. |
| 94 | void resolveConstantForwardRefs(); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 95 | }; |
| 96 | |
| 97 | class BitcodeReaderMDValueList { |
| 98 | unsigned NumFwdRefs; |
| 99 | bool AnyFwdRefs; |
| 100 | unsigned MinFwdRef; |
| 101 | unsigned MaxFwdRef; |
| 102 | std::vector<TrackingMDRef> MDValuePtrs; |
| 103 | |
| 104 | LLVMContext &Context; |
| 105 | public: |
| 106 | BitcodeReaderMDValueList(LLVMContext &C) |
| 107 | : NumFwdRefs(0), AnyFwdRefs(false), Context(C) {} |
| 108 | |
| 109 | // vector compatibility methods |
| 110 | unsigned size() const { return MDValuePtrs.size(); } |
| 111 | void resize(unsigned N) { MDValuePtrs.resize(N); } |
| 112 | void push_back(Metadata *MD) { MDValuePtrs.emplace_back(MD); } |
| 113 | void clear() { MDValuePtrs.clear(); } |
| 114 | Metadata *back() const { return MDValuePtrs.back(); } |
| 115 | void pop_back() { MDValuePtrs.pop_back(); } |
| 116 | bool empty() const { return MDValuePtrs.empty(); } |
| 117 | |
| 118 | Metadata *operator[](unsigned i) const { |
| 119 | assert(i < MDValuePtrs.size()); |
| 120 | return MDValuePtrs[i]; |
| 121 | } |
| 122 | |
| 123 | void shrinkTo(unsigned N) { |
| 124 | assert(N <= size() && "Invalid shrinkTo request!"); |
| 125 | MDValuePtrs.resize(N); |
| 126 | } |
| 127 | |
| 128 | Metadata *getValueFwdRef(unsigned Idx); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 129 | void assignValue(Metadata *MD, unsigned Idx); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 130 | void tryToResolveCycles(); |
| 131 | }; |
| 132 | |
| 133 | class BitcodeReader : public GVMaterializer { |
| 134 | LLVMContext &Context; |
| 135 | DiagnosticHandlerFunction DiagnosticHandler; |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 136 | Module *TheModule = nullptr; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 137 | std::unique_ptr<MemoryBuffer> Buffer; |
| 138 | std::unique_ptr<BitstreamReader> StreamFile; |
| 139 | BitstreamCursor Stream; |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 140 | // Next offset to start scanning for lazy parsing of function bodies. |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 141 | uint64_t NextUnreadBit = 0; |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 142 | // Last function offset found in the VST. |
| 143 | uint64_t LastFunctionBlockBit = 0; |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 144 | bool SeenValueSymbolTable = false; |
Peter Collingbourne | 128a976 | 2015-10-27 23:01:25 +0000 | [diff] [blame] | 145 | uint64_t VSTOffset = 0; |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 146 | // Contains an arbitrary and optional string identifying the bitcode producer |
| 147 | std::string ProducerIdentification; |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 148 | // Number of module level metadata records specified by the |
| 149 | // MODULE_CODE_METADATA_VALUES record. |
| 150 | unsigned NumModuleMDs = 0; |
| 151 | // Support older bitcode without the MODULE_CODE_METADATA_VALUES record. |
| 152 | bool SeenModuleValuesRecord = false; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 153 | |
| 154 | std::vector<Type*> TypeList; |
| 155 | BitcodeReaderValueList ValueList; |
| 156 | BitcodeReaderMDValueList MDValueList; |
| 157 | std::vector<Comdat *> ComdatList; |
| 158 | SmallVector<Instruction *, 64> InstructionList; |
| 159 | |
| 160 | std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits; |
| 161 | std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits; |
| 162 | std::vector<std::pair<Function*, unsigned> > FunctionPrefixes; |
| 163 | std::vector<std::pair<Function*, unsigned> > FunctionPrologues; |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 164 | std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFns; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 165 | |
| 166 | SmallVector<Instruction*, 64> InstsWithTBAATag; |
| 167 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 168 | /// The set of attributes by index. Index zero in the file is for null, and |
| 169 | /// is thus not represented here. As such all indices are off by one. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 170 | std::vector<AttributeSet> MAttributes; |
| 171 | |
Karl Schimpf | 3644008 | 2015-08-31 16:43:55 +0000 | [diff] [blame] | 172 | /// The set of attribute groups. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 173 | std::map<unsigned, AttributeSet> MAttributeGroups; |
| 174 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 175 | /// While parsing a function body, this is a list of the basic blocks for the |
| 176 | /// function. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 177 | std::vector<BasicBlock*> FunctionBBs; |
| 178 | |
| 179 | // When reading the module header, this list is populated with functions that |
| 180 | // have bodies later in the file. |
| 181 | std::vector<Function*> FunctionsWithBodies; |
| 182 | |
| 183 | // When intrinsic functions are encountered which require upgrading they are |
| 184 | // stored here with their replacement function. |
Rafael Espindola | 4e72121 | 2015-07-02 16:22:40 +0000 | [diff] [blame] | 185 | typedef DenseMap<Function*, Function*> UpgradedIntrinsicMap; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 186 | UpgradedIntrinsicMap UpgradedIntrinsics; |
| 187 | |
| 188 | // Map the bitcode's custom MDKind ID to the Module's MDKind ID. |
| 189 | DenseMap<unsigned, unsigned> MDKindMap; |
| 190 | |
| 191 | // Several operations happen after the module header has been read, but |
| 192 | // before function bodies are processed. This keeps track of whether |
| 193 | // we've done this yet. |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 194 | bool SeenFirstFunctionBody = false; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 195 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 196 | /// When function bodies are initially scanned, this map contains info about |
| 197 | /// where to find deferred function body in the stream. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 198 | DenseMap<Function*, uint64_t> DeferredFunctionInfo; |
| 199 | |
| 200 | /// When Metadata block is initially scanned when parsing the module, we may |
| 201 | /// choose to defer parsing of the metadata. This vector contains info about |
| 202 | /// which Metadata blocks are deferred. |
| 203 | std::vector<uint64_t> DeferredMetadataInfo; |
| 204 | |
| 205 | /// These are basic blocks forward-referenced by block addresses. They are |
| 206 | /// inserted lazily into functions when they're loaded. The basic block ID is |
| 207 | /// its index into the vector. |
| 208 | DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs; |
| 209 | std::deque<Function *> BasicBlockFwdRefQueue; |
| 210 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 211 | /// Indicates that we are using a new encoding for instruction operands where |
| 212 | /// most operands in the current FUNCTION_BLOCK are encoded relative to the |
| 213 | /// instruction number, for a more compact encoding. Some instruction |
| 214 | /// operands are not relative to the instruction ID: basic block numbers, and |
| 215 | /// types. Once the old style function blocks have been phased out, we would |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 216 | /// not need this flag. |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 217 | bool UseRelativeIDs = false; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 218 | |
| 219 | /// True if all functions will be materialized, negating the need to process |
| 220 | /// (e.g.) blockaddress forward references. |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 221 | bool WillMaterializeAllForwardRefs = false; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 222 | |
| 223 | /// Functions that have block addresses taken. This is usually empty. |
| 224 | SmallPtrSet<const Function *, 4> BlockAddressesTaken; |
| 225 | |
| 226 | /// True if any Metadata block has been materialized. |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 227 | bool IsMetadataMaterialized = false; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 228 | |
Rafael Espindola | 0d68b4c | 2015-03-30 21:36:43 +0000 | [diff] [blame] | 229 | bool StripDebugInfo = false; |
| 230 | |
Peter Collingbourne | d4bff30 | 2015-11-05 22:03:56 +0000 | [diff] [blame] | 231 | /// Functions that need to be matched with subprograms when upgrading old |
| 232 | /// metadata. |
| 233 | SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs; |
| 234 | |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 235 | std::vector<std::string> BundleTags; |
| 236 | |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 237 | public: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 238 | std::error_code error(BitcodeError E, const Twine &Message); |
| 239 | std::error_code error(BitcodeError E); |
| 240 | std::error_code error(const Twine &Message); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 241 | |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 242 | BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context, |
| 243 | DiagnosticHandlerFunction DiagnosticHandler); |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 244 | BitcodeReader(LLVMContext &Context, |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 245 | DiagnosticHandlerFunction DiagnosticHandler); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 246 | ~BitcodeReader() override { freeState(); } |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 247 | |
| 248 | std::error_code materializeForwardReferencedFunctions(); |
| 249 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 250 | void freeState(); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 251 | |
| 252 | void releaseBuffer(); |
| 253 | |
| 254 | bool isDematerializable(const GlobalValue *GV) const override; |
| 255 | std::error_code materialize(GlobalValue *GV) override; |
Eric Christopher | 97cb565 | 2015-05-15 18:20:14 +0000 | [diff] [blame] | 256 | std::error_code materializeModule(Module *M) override; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 257 | std::vector<StructType *> getIdentifiedStructTypes() const override; |
Eric Christopher | 97cb565 | 2015-05-15 18:20:14 +0000 | [diff] [blame] | 258 | void dematerialize(GlobalValue *GV) override; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 259 | |
Rafael Espindola | 6ace685 | 2015-06-15 21:02:49 +0000 | [diff] [blame] | 260 | /// \brief Main interface to parsing a bitcode buffer. |
| 261 | /// \returns true if an error occurred. |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 262 | std::error_code parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer, |
| 263 | Module *M, |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 264 | bool ShouldLazyLoadMetadata = false); |
| 265 | |
Rafael Espindola | 6ace685 | 2015-06-15 21:02:49 +0000 | [diff] [blame] | 266 | /// \brief Cheap mechanism to just extract module triple |
| 267 | /// \returns true if an error occurred. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 268 | ErrorOr<std::string> parseTriple(); |
| 269 | |
Mehdi Amini | 3383ccc | 2015-11-09 02:46:41 +0000 | [diff] [blame] | 270 | /// Cheap mechanism to just extract the identification block out of bitcode. |
| 271 | ErrorOr<std::string> parseIdentificationBlock(); |
| 272 | |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 273 | static uint64_t decodeSignRotatedValue(uint64_t V); |
| 274 | |
| 275 | /// Materialize any deferred Metadata block. |
| 276 | std::error_code materializeMetadata() override; |
| 277 | |
Rafael Espindola | 0d68b4c | 2015-03-30 21:36:43 +0000 | [diff] [blame] | 278 | void setStripDebugInfo() override; |
| 279 | |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 280 | private: |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 281 | /// Parse the "IDENTIFICATION_BLOCK_ID" block, populate the |
| 282 | // ProducerIdentification data member, and do some basic enforcement on the |
| 283 | // "epoch" encoded in the bitcode. |
| 284 | std::error_code parseBitcodeVersion(); |
| 285 | |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 286 | std::vector<StructType *> IdentifiedStructTypes; |
| 287 | StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name); |
| 288 | StructType *createIdentifiedStructType(LLVMContext &Context); |
| 289 | |
| 290 | Type *getTypeByID(unsigned ID); |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 291 | Value *getFnValueByID(unsigned ID, Type *Ty) { |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 292 | if (Ty && Ty->isMetadataTy()) |
| 293 | return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID)); |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 294 | return ValueList.getValueFwdRef(ID, Ty); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 295 | } |
| 296 | Metadata *getFnMetadataByID(unsigned ID) { |
| 297 | return MDValueList.getValueFwdRef(ID); |
| 298 | } |
| 299 | BasicBlock *getBasicBlock(unsigned ID) const { |
| 300 | if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID |
| 301 | return FunctionBBs[ID]; |
| 302 | } |
| 303 | AttributeSet getAttributes(unsigned i) const { |
| 304 | if (i-1 < MAttributes.size()) |
| 305 | return MAttributes[i-1]; |
| 306 | return AttributeSet(); |
| 307 | } |
| 308 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 309 | /// Read a value/type pair out of the specified record from slot 'Slot'. |
| 310 | /// Increment Slot past the number of slots used in the record. Return true on |
| 311 | /// failure. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 312 | bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot, |
| 313 | unsigned InstNum, Value *&ResVal) { |
| 314 | if (Slot == Record.size()) return true; |
| 315 | unsigned ValNo = (unsigned)Record[Slot++]; |
| 316 | // Adjust the ValNo, if it was encoded relative to the InstNum. |
| 317 | if (UseRelativeIDs) |
| 318 | ValNo = InstNum - ValNo; |
| 319 | if (ValNo < InstNum) { |
| 320 | // If this is not a forward reference, just return the value we already |
| 321 | // have. |
| 322 | ResVal = getFnValueByID(ValNo, nullptr); |
| 323 | return ResVal == nullptr; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 324 | } |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 325 | if (Slot == Record.size()) |
| 326 | return true; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 327 | |
| 328 | unsigned TypeNo = (unsigned)Record[Slot++]; |
| 329 | ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo)); |
| 330 | return ResVal == nullptr; |
| 331 | } |
| 332 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 333 | /// Read a value out of the specified record from slot 'Slot'. Increment Slot |
| 334 | /// past the number of slots used by the value in the record. Return true if |
| 335 | /// there is an error. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 336 | bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot, |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 337 | unsigned InstNum, Type *Ty, Value *&ResVal) { |
| 338 | if (getValue(Record, Slot, InstNum, Ty, ResVal)) |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 339 | return true; |
| 340 | // All values currently take a single record slot. |
| 341 | ++Slot; |
| 342 | return false; |
| 343 | } |
| 344 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 345 | /// Like popValue, but does not increment the Slot number. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 346 | bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot, |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 347 | unsigned InstNum, Type *Ty, Value *&ResVal) { |
| 348 | ResVal = getValue(Record, Slot, InstNum, Ty); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 349 | return ResVal == nullptr; |
| 350 | } |
| 351 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 352 | /// Version of getValue that returns ResVal directly, or 0 if there is an |
| 353 | /// error. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 354 | Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot, |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 355 | unsigned InstNum, Type *Ty) { |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 356 | if (Slot == Record.size()) return nullptr; |
| 357 | unsigned ValNo = (unsigned)Record[Slot]; |
| 358 | // Adjust the ValNo, if it was encoded relative to the InstNum. |
| 359 | if (UseRelativeIDs) |
| 360 | ValNo = InstNum - ValNo; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 361 | return getFnValueByID(ValNo, Ty); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 362 | } |
| 363 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 364 | /// Like getValue, but decodes signed VBRs. |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 365 | Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot, |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 366 | unsigned InstNum, Type *Ty) { |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 367 | if (Slot == Record.size()) return nullptr; |
| 368 | unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]); |
| 369 | // Adjust the ValNo, if it was encoded relative to the InstNum. |
| 370 | if (UseRelativeIDs) |
| 371 | ValNo = InstNum - ValNo; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 372 | return getFnValueByID(ValNo, Ty); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | /// Converts alignment exponent (i.e. power of two (or zero)) to the |
| 376 | /// corresponding alignment to use. If alignment is too large, returns |
| 377 | /// a corresponding error code. |
| 378 | std::error_code parseAlignmentValue(uint64_t Exponent, unsigned &Alignment); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 379 | std::error_code parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind); |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 380 | std::error_code parseModule(uint64_t ResumeBit, |
| 381 | bool ShouldLazyLoadMetadata = false); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 382 | std::error_code parseAttributeBlock(); |
| 383 | std::error_code parseAttributeGroupBlock(); |
| 384 | std::error_code parseTypeTable(); |
| 385 | std::error_code parseTypeTableBody(); |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 386 | std::error_code parseOperandBundleTags(); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 387 | |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 388 | ErrorOr<Value *> recordValue(SmallVectorImpl<uint64_t> &Record, |
| 389 | unsigned NameIndex, Triple &TT); |
Peter Collingbourne | 128a976 | 2015-10-27 23:01:25 +0000 | [diff] [blame] | 390 | std::error_code parseValueSymbolTable(uint64_t Offset = 0); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 391 | std::error_code parseConstants(); |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 392 | std::error_code rememberAndSkipFunctionBodies(); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 393 | std::error_code rememberAndSkipFunctionBody(); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 394 | /// Save the positions of the Metadata blocks and skip parsing the blocks. |
| 395 | std::error_code rememberAndSkipMetadata(); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 396 | std::error_code parseFunctionBody(Function *F); |
| 397 | std::error_code globalCleanup(); |
| 398 | std::error_code resolveGlobalAndAliasInits(); |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 399 | std::error_code parseMetadata(bool ModuleLevel = false); |
Teresa Johnson | 1254507 | 2015-11-15 02:00:09 +0000 | [diff] [blame] | 400 | std::error_code parseMetadataKinds(); |
| 401 | std::error_code parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 402 | std::error_code parseMetadataAttachment(Function &F); |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 403 | ErrorOr<std::string> parseModuleTriple(); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 404 | std::error_code parseUseLists(); |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 405 | std::error_code initStream(std::unique_ptr<DataStreamer> Streamer); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 406 | std::error_code initStreamFromBuffer(); |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 407 | std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 408 | std::error_code findFunctionInStream( |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 409 | Function *F, |
| 410 | DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator); |
| 411 | }; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 412 | |
| 413 | /// Class to manage reading and parsing function summary index bitcode |
| 414 | /// files/sections. |
| 415 | class FunctionIndexBitcodeReader { |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 416 | DiagnosticHandlerFunction DiagnosticHandler; |
| 417 | |
| 418 | /// Eventually points to the function index built during parsing. |
| 419 | FunctionInfoIndex *TheIndex = nullptr; |
| 420 | |
| 421 | std::unique_ptr<MemoryBuffer> Buffer; |
| 422 | std::unique_ptr<BitstreamReader> StreamFile; |
| 423 | BitstreamCursor Stream; |
| 424 | |
| 425 | /// \brief Used to indicate whether we are doing lazy parsing of summary data. |
| 426 | /// |
| 427 | /// If false, the summary section is fully parsed into the index during |
| 428 | /// the initial parse. Otherwise, if true, the caller is expected to |
| 429 | /// invoke \a readFunctionSummary for each summary needed, and the summary |
| 430 | /// section is thus parsed lazily. |
| 431 | bool IsLazy = false; |
| 432 | |
| 433 | /// Used to indicate whether caller only wants to check for the presence |
| 434 | /// of the function summary bitcode section. All blocks are skipped, |
| 435 | /// but the SeenFuncSummary boolean is set. |
| 436 | bool CheckFuncSummaryPresenceOnly = false; |
| 437 | |
| 438 | /// Indicates whether we have encountered a function summary section |
| 439 | /// yet during parsing, used when checking if file contains function |
| 440 | /// summary section. |
| 441 | bool SeenFuncSummary = false; |
| 442 | |
| 443 | /// \brief Map populated during function summary section parsing, and |
| 444 | /// consumed during ValueSymbolTable parsing. |
| 445 | /// |
| 446 | /// Used to correlate summary records with VST entries. For the per-module |
| 447 | /// index this maps the ValueID to the parsed function summary, and |
| 448 | /// for the combined index this maps the summary record's bitcode |
| 449 | /// offset to the function summary (since in the combined index the |
| 450 | /// VST records do not hold value IDs but rather hold the function |
| 451 | /// summary record offset). |
| 452 | DenseMap<uint64_t, std::unique_ptr<FunctionSummary>> SummaryMap; |
| 453 | |
| 454 | /// Map populated during module path string table parsing, from the |
| 455 | /// module ID to a string reference owned by the index's module |
| 456 | /// path string table, used to correlate with combined index function |
| 457 | /// summary records. |
| 458 | DenseMap<uint64_t, StringRef> ModuleIdMap; |
| 459 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 460 | public: |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 461 | std::error_code error(BitcodeError E, const Twine &Message); |
| 462 | std::error_code error(BitcodeError E); |
| 463 | std::error_code error(const Twine &Message); |
| 464 | |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 465 | FunctionIndexBitcodeReader(MemoryBuffer *Buffer, |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 466 | DiagnosticHandlerFunction DiagnosticHandler, |
| 467 | bool IsLazy = false, |
| 468 | bool CheckFuncSummaryPresenceOnly = false); |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 469 | FunctionIndexBitcodeReader(DiagnosticHandlerFunction DiagnosticHandler, |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 470 | bool IsLazy = false, |
| 471 | bool CheckFuncSummaryPresenceOnly = false); |
| 472 | ~FunctionIndexBitcodeReader() { freeState(); } |
| 473 | |
| 474 | void freeState(); |
| 475 | |
| 476 | void releaseBuffer(); |
| 477 | |
| 478 | /// Check if the parser has encountered a function summary section. |
| 479 | bool foundFuncSummary() { return SeenFuncSummary; } |
| 480 | |
| 481 | /// \brief Main interface to parsing a bitcode buffer. |
| 482 | /// \returns true if an error occurred. |
| 483 | std::error_code parseSummaryIndexInto(std::unique_ptr<DataStreamer> Streamer, |
| 484 | FunctionInfoIndex *I); |
| 485 | |
| 486 | /// \brief Interface for parsing a function summary lazily. |
| 487 | std::error_code parseFunctionSummary(std::unique_ptr<DataStreamer> Streamer, |
| 488 | FunctionInfoIndex *I, |
| 489 | size_t FunctionSummaryOffset); |
| 490 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 491 | private: |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 492 | std::error_code parseModule(); |
| 493 | std::error_code parseValueSymbolTable(); |
| 494 | std::error_code parseEntireSummary(); |
| 495 | std::error_code parseModuleStringTable(); |
| 496 | std::error_code initStream(std::unique_ptr<DataStreamer> Streamer); |
| 497 | std::error_code initStreamFromBuffer(); |
| 498 | std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer); |
| 499 | }; |
Benjamin Kramer | cced8be | 2015-03-17 20:40:24 +0000 | [diff] [blame] | 500 | } // namespace |
| 501 | |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 502 | BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC, |
| 503 | DiagnosticSeverity Severity, |
| 504 | const Twine &Msg) |
| 505 | : DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {} |
| 506 | |
| 507 | void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; } |
| 508 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 509 | static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 510 | std::error_code EC, const Twine &Message) { |
| 511 | BitcodeDiagnosticInfo DI(EC, DS_Error, Message); |
| 512 | DiagnosticHandler(DI); |
| 513 | return EC; |
| 514 | } |
| 515 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 516 | static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 517 | std::error_code EC) { |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 518 | return error(DiagnosticHandler, EC, EC.message()); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 519 | } |
| 520 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 521 | static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 522 | const Twine &Message) { |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 523 | return error(DiagnosticHandler, |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 524 | make_error_code(BitcodeError::CorruptedBitcode), Message); |
| 525 | } |
| 526 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 527 | std::error_code BitcodeReader::error(BitcodeError E, const Twine &Message) { |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 528 | if (!ProducerIdentification.empty()) { |
Filipe Cabecinhas | f3e167a | 2015-11-03 13:48:21 +0000 | [diff] [blame] | 529 | return ::error(DiagnosticHandler, make_error_code(E), |
| 530 | Message + " (Producer: '" + ProducerIdentification + |
| 531 | "' Reader: 'LLVM " + LLVM_VERSION_STRING "')"); |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 532 | } |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 533 | return ::error(DiagnosticHandler, make_error_code(E), Message); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 534 | } |
| 535 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 536 | std::error_code BitcodeReader::error(const Twine &Message) { |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 537 | if (!ProducerIdentification.empty()) { |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 538 | return ::error(DiagnosticHandler, |
Filipe Cabecinhas | f3e167a | 2015-11-03 13:48:21 +0000 | [diff] [blame] | 539 | make_error_code(BitcodeError::CorruptedBitcode), |
| 540 | Message + " (Producer: '" + ProducerIdentification + |
| 541 | "' Reader: 'LLVM " + LLVM_VERSION_STRING "')"); |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 542 | } |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 543 | return ::error(DiagnosticHandler, |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 544 | make_error_code(BitcodeError::CorruptedBitcode), Message); |
| 545 | } |
| 546 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 547 | std::error_code BitcodeReader::error(BitcodeError E) { |
| 548 | return ::error(DiagnosticHandler, make_error_code(E)); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 549 | } |
| 550 | |
| 551 | static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F, |
| 552 | LLVMContext &C) { |
| 553 | if (F) |
| 554 | return F; |
| 555 | return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); }; |
| 556 | } |
| 557 | |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 558 | BitcodeReader::BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context, |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 559 | DiagnosticHandlerFunction DiagnosticHandler) |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 560 | : Context(Context), |
| 561 | DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), |
Rafael Espindola | 1c863ca | 2015-06-22 18:06:15 +0000 | [diff] [blame] | 562 | Buffer(Buffer), ValueList(Context), MDValueList(Context) {} |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 563 | |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 564 | BitcodeReader::BitcodeReader(LLVMContext &Context, |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 565 | DiagnosticHandlerFunction DiagnosticHandler) |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 566 | : Context(Context), |
| 567 | DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), |
Rafael Espindola | 1c863ca | 2015-06-22 18:06:15 +0000 | [diff] [blame] | 568 | Buffer(nullptr), ValueList(Context), MDValueList(Context) {} |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 569 | |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 570 | std::error_code BitcodeReader::materializeForwardReferencedFunctions() { |
| 571 | if (WillMaterializeAllForwardRefs) |
| 572 | return std::error_code(); |
| 573 | |
| 574 | // Prevent recursion. |
| 575 | WillMaterializeAllForwardRefs = true; |
| 576 | |
Duncan P. N. Exon Smith | 5a511b5 | 2014-08-05 17:49:48 +0000 | [diff] [blame] | 577 | while (!BasicBlockFwdRefQueue.empty()) { |
| 578 | Function *F = BasicBlockFwdRefQueue.front(); |
| 579 | BasicBlockFwdRefQueue.pop_front(); |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 580 | assert(F && "Expected valid function"); |
Duncan P. N. Exon Smith | 5a511b5 | 2014-08-05 17:49:48 +0000 | [diff] [blame] | 581 | if (!BasicBlockFwdRefs.count(F)) |
| 582 | // Already materialized. |
| 583 | continue; |
| 584 | |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 585 | // Check for a function that isn't materializable to prevent an infinite |
| 586 | // loop. When parsing a blockaddress stored in a global variable, there |
| 587 | // isn't a trivial way to check if a function will have a body without a |
| 588 | // linear search through FunctionsWithBodies, so just check it here. |
| 589 | if (!F->isMaterializable()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 590 | return error("Never resolved function from blockaddress"); |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 591 | |
| 592 | // Try to materialize F. |
Rafael Espindola | 5a52e6d | 2014-10-24 22:50:48 +0000 | [diff] [blame] | 593 | if (std::error_code EC = materialize(F)) |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 594 | return EC; |
Rafael Espindola | b799346 | 2012-01-02 07:49:53 +0000 | [diff] [blame] | 595 | } |
Duncan P. N. Exon Smith | 5a511b5 | 2014-08-05 17:49:48 +0000 | [diff] [blame] | 596 | assert(BasicBlockFwdRefs.empty() && "Function missing from queue"); |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 597 | |
| 598 | // Reset state. |
| 599 | WillMaterializeAllForwardRefs = false; |
| 600 | return std::error_code(); |
Rafael Espindola | b799346 | 2012-01-02 07:49:53 +0000 | [diff] [blame] | 601 | } |
| 602 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 603 | void BitcodeReader::freeState() { |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 604 | Buffer = nullptr; |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 605 | std::vector<Type*>().swap(TypeList); |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 606 | ValueList.clear(); |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 607 | MDValueList.clear(); |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 608 | std::vector<Comdat *>().swap(ComdatList); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 609 | |
Bill Wendling | e94d843 | 2012-12-07 23:16:57 +0000 | [diff] [blame] | 610 | std::vector<AttributeSet>().swap(MAttributes); |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 611 | std::vector<BasicBlock*>().swap(FunctionBBs); |
| 612 | std::vector<Function*>().swap(FunctionsWithBodies); |
| 613 | DeferredFunctionInfo.clear(); |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 614 | DeferredMetadataInfo.clear(); |
Dan Gohman | 43aa8f0 | 2010-07-20 21:42:28 +0000 | [diff] [blame] | 615 | MDKindMap.clear(); |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 616 | |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 617 | assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references"); |
Duncan P. N. Exon Smith | 5a511b5 | 2014-08-05 17:49:48 +0000 | [diff] [blame] | 618 | BasicBlockFwdRefQueue.clear(); |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 619 | } |
| 620 | |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 621 | //===----------------------------------------------------------------------===// |
| 622 | // Helper functions to implement forward reference resolution, etc. |
| 623 | //===----------------------------------------------------------------------===// |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 624 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 625 | /// Convert a string from a record into an std::string, return true on failure. |
| 626 | template <typename StrTy> |
| 627 | static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx, |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 628 | StrTy &Result) { |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 629 | if (Idx > Record.size()) |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 630 | return true; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 631 | |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 632 | for (unsigned i = Idx, e = Record.size(); i != e; ++i) |
| 633 | Result += (char)Record[i]; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 634 | return false; |
| 635 | } |
| 636 | |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 637 | static bool hasImplicitComdat(size_t Val) { |
| 638 | switch (Val) { |
| 639 | default: |
| 640 | return false; |
| 641 | case 1: // Old WeakAnyLinkage |
| 642 | case 4: // Old LinkOnceAnyLinkage |
| 643 | case 10: // Old WeakODRLinkage |
| 644 | case 11: // Old LinkOnceODRLinkage |
| 645 | return true; |
| 646 | } |
| 647 | } |
| 648 | |
Rafael Espindola | 7b4b2dc | 2015-01-08 15:36:32 +0000 | [diff] [blame] | 649 | static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) { |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 650 | switch (Val) { |
| 651 | default: // Map unknown/new linkages to external |
Rafael Espindola | 7b4b2dc | 2015-01-08 15:36:32 +0000 | [diff] [blame] | 652 | case 0: |
| 653 | return GlobalValue::ExternalLinkage; |
Rafael Espindola | 7b4b2dc | 2015-01-08 15:36:32 +0000 | [diff] [blame] | 654 | case 2: |
| 655 | return GlobalValue::AppendingLinkage; |
| 656 | case 3: |
| 657 | return GlobalValue::InternalLinkage; |
Rafael Espindola | 7b4b2dc | 2015-01-08 15:36:32 +0000 | [diff] [blame] | 658 | case 5: |
| 659 | return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage |
| 660 | case 6: |
| 661 | return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage |
| 662 | case 7: |
| 663 | return GlobalValue::ExternalWeakLinkage; |
| 664 | case 8: |
| 665 | return GlobalValue::CommonLinkage; |
| 666 | case 9: |
| 667 | return GlobalValue::PrivateLinkage; |
Rafael Espindola | 7b4b2dc | 2015-01-08 15:36:32 +0000 | [diff] [blame] | 668 | case 12: |
| 669 | return GlobalValue::AvailableExternallyLinkage; |
Rafael Espindola | 2fb5bc3 | 2014-03-13 23:18:37 +0000 | [diff] [blame] | 670 | case 13: |
| 671 | return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage |
| 672 | case 14: |
| 673 | return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage |
Rafael Espindola | bec6af6 | 2015-01-08 15:39:50 +0000 | [diff] [blame] | 674 | case 15: |
| 675 | return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 676 | case 1: // Old value with implicit comdat. |
| 677 | case 16: |
| 678 | return GlobalValue::WeakAnyLinkage; |
| 679 | case 10: // Old value with implicit comdat. |
| 680 | case 17: |
| 681 | return GlobalValue::WeakODRLinkage; |
| 682 | case 4: // Old value with implicit comdat. |
| 683 | case 18: |
| 684 | return GlobalValue::LinkOnceAnyLinkage; |
| 685 | case 11: // Old value with implicit comdat. |
| 686 | case 19: |
| 687 | return GlobalValue::LinkOnceODRLinkage; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 688 | } |
| 689 | } |
| 690 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 691 | static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) { |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 692 | switch (Val) { |
| 693 | default: // Map unknown visibilities to default. |
| 694 | case 0: return GlobalValue::DefaultVisibility; |
| 695 | case 1: return GlobalValue::HiddenVisibility; |
Anton Korobeynikov | 31fc4f9 | 2007-04-29 20:56:48 +0000 | [diff] [blame] | 696 | case 2: return GlobalValue::ProtectedVisibility; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 697 | } |
| 698 | } |
| 699 | |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 700 | static GlobalValue::DLLStorageClassTypes |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 701 | getDecodedDLLStorageClass(unsigned Val) { |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 702 | switch (Val) { |
| 703 | default: // Map unknown values to default. |
| 704 | case 0: return GlobalValue::DefaultStorageClass; |
| 705 | case 1: return GlobalValue::DLLImportStorageClass; |
| 706 | case 2: return GlobalValue::DLLExportStorageClass; |
| 707 | } |
| 708 | } |
| 709 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 710 | static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) { |
Hans Wennborg | cbe34b4 | 2012-06-23 11:37:03 +0000 | [diff] [blame] | 711 | switch (Val) { |
| 712 | case 0: return GlobalVariable::NotThreadLocal; |
| 713 | default: // Map unknown non-zero value to general dynamic. |
| 714 | case 1: return GlobalVariable::GeneralDynamicTLSModel; |
| 715 | case 2: return GlobalVariable::LocalDynamicTLSModel; |
| 716 | case 3: return GlobalVariable::InitialExecTLSModel; |
| 717 | case 4: return GlobalVariable::LocalExecTLSModel; |
| 718 | } |
| 719 | } |
| 720 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 721 | static int getDecodedCastOpcode(unsigned Val) { |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 722 | switch (Val) { |
| 723 | default: return -1; |
| 724 | case bitc::CAST_TRUNC : return Instruction::Trunc; |
| 725 | case bitc::CAST_ZEXT : return Instruction::ZExt; |
| 726 | case bitc::CAST_SEXT : return Instruction::SExt; |
| 727 | case bitc::CAST_FPTOUI : return Instruction::FPToUI; |
| 728 | case bitc::CAST_FPTOSI : return Instruction::FPToSI; |
| 729 | case bitc::CAST_UITOFP : return Instruction::UIToFP; |
| 730 | case bitc::CAST_SITOFP : return Instruction::SIToFP; |
| 731 | case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; |
| 732 | case bitc::CAST_FPEXT : return Instruction::FPExt; |
| 733 | case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; |
| 734 | case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; |
| 735 | case bitc::CAST_BITCAST : return Instruction::BitCast; |
Matt Arsenault | 3aa9b03 | 2013-11-18 02:51:33 +0000 | [diff] [blame] | 736 | case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast; |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 737 | } |
| 738 | } |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 739 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 740 | static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) { |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 741 | bool IsFP = Ty->isFPOrFPVectorTy(); |
| 742 | // BinOps are only valid for int/fp or vector of int/fp types |
| 743 | if (!IsFP && !Ty->isIntOrIntVectorTy()) |
| 744 | return -1; |
| 745 | |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 746 | switch (Val) { |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 747 | default: |
| 748 | return -1; |
Dan Gohman | a5b9645 | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 749 | case bitc::BINOP_ADD: |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 750 | return IsFP ? Instruction::FAdd : Instruction::Add; |
Dan Gohman | a5b9645 | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 751 | case bitc::BINOP_SUB: |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 752 | return IsFP ? Instruction::FSub : Instruction::Sub; |
Dan Gohman | a5b9645 | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 753 | case bitc::BINOP_MUL: |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 754 | return IsFP ? Instruction::FMul : Instruction::Mul; |
| 755 | case bitc::BINOP_UDIV: |
| 756 | return IsFP ? -1 : Instruction::UDiv; |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 757 | case bitc::BINOP_SDIV: |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 758 | return IsFP ? Instruction::FDiv : Instruction::SDiv; |
| 759 | case bitc::BINOP_UREM: |
| 760 | return IsFP ? -1 : Instruction::URem; |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 761 | case bitc::BINOP_SREM: |
Filipe Cabecinhas | ea79c5b | 2015-04-22 09:06:21 +0000 | [diff] [blame] | 762 | return IsFP ? Instruction::FRem : Instruction::SRem; |
| 763 | case bitc::BINOP_SHL: |
| 764 | return IsFP ? -1 : Instruction::Shl; |
| 765 | case bitc::BINOP_LSHR: |
| 766 | return IsFP ? -1 : Instruction::LShr; |
| 767 | case bitc::BINOP_ASHR: |
| 768 | return IsFP ? -1 : Instruction::AShr; |
| 769 | case bitc::BINOP_AND: |
| 770 | return IsFP ? -1 : Instruction::And; |
| 771 | case bitc::BINOP_OR: |
| 772 | return IsFP ? -1 : Instruction::Or; |
| 773 | case bitc::BINOP_XOR: |
| 774 | return IsFP ? -1 : Instruction::Xor; |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 775 | } |
| 776 | } |
| 777 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 778 | static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val) { |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 779 | switch (Val) { |
| 780 | default: return AtomicRMWInst::BAD_BINOP; |
| 781 | case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; |
| 782 | case bitc::RMW_ADD: return AtomicRMWInst::Add; |
| 783 | case bitc::RMW_SUB: return AtomicRMWInst::Sub; |
| 784 | case bitc::RMW_AND: return AtomicRMWInst::And; |
| 785 | case bitc::RMW_NAND: return AtomicRMWInst::Nand; |
| 786 | case bitc::RMW_OR: return AtomicRMWInst::Or; |
| 787 | case bitc::RMW_XOR: return AtomicRMWInst::Xor; |
| 788 | case bitc::RMW_MAX: return AtomicRMWInst::Max; |
| 789 | case bitc::RMW_MIN: return AtomicRMWInst::Min; |
| 790 | case bitc::RMW_UMAX: return AtomicRMWInst::UMax; |
| 791 | case bitc::RMW_UMIN: return AtomicRMWInst::UMin; |
| 792 | } |
| 793 | } |
| 794 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 795 | static AtomicOrdering getDecodedOrdering(unsigned Val) { |
Eli Friedman | fee02c6 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 796 | switch (Val) { |
| 797 | case bitc::ORDERING_NOTATOMIC: return NotAtomic; |
| 798 | case bitc::ORDERING_UNORDERED: return Unordered; |
| 799 | case bitc::ORDERING_MONOTONIC: return Monotonic; |
| 800 | case bitc::ORDERING_ACQUIRE: return Acquire; |
| 801 | case bitc::ORDERING_RELEASE: return Release; |
| 802 | case bitc::ORDERING_ACQREL: return AcquireRelease; |
| 803 | default: // Map unknown orderings to sequentially-consistent. |
| 804 | case bitc::ORDERING_SEQCST: return SequentiallyConsistent; |
| 805 | } |
| 806 | } |
| 807 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 808 | static SynchronizationScope getDecodedSynchScope(unsigned Val) { |
Eli Friedman | fee02c6 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 809 | switch (Val) { |
| 810 | case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; |
| 811 | default: // Map unknown scopes to cross-thread. |
| 812 | case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; |
| 813 | } |
| 814 | } |
| 815 | |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 816 | static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) { |
| 817 | switch (Val) { |
| 818 | default: // Map unknown selection kinds to any. |
| 819 | case bitc::COMDAT_SELECTION_KIND_ANY: |
| 820 | return Comdat::Any; |
| 821 | case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH: |
| 822 | return Comdat::ExactMatch; |
| 823 | case bitc::COMDAT_SELECTION_KIND_LARGEST: |
| 824 | return Comdat::Largest; |
| 825 | case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES: |
| 826 | return Comdat::NoDuplicates; |
| 827 | case bitc::COMDAT_SELECTION_KIND_SAME_SIZE: |
| 828 | return Comdat::SameSize; |
| 829 | } |
| 830 | } |
| 831 | |
James Molloy | 88eb535 | 2015-07-10 12:52:00 +0000 | [diff] [blame] | 832 | static FastMathFlags getDecodedFastMathFlags(unsigned Val) { |
| 833 | FastMathFlags FMF; |
| 834 | if (0 != (Val & FastMathFlags::UnsafeAlgebra)) |
| 835 | FMF.setUnsafeAlgebra(); |
| 836 | if (0 != (Val & FastMathFlags::NoNaNs)) |
| 837 | FMF.setNoNaNs(); |
| 838 | if (0 != (Val & FastMathFlags::NoInfs)) |
| 839 | FMF.setNoInfs(); |
| 840 | if (0 != (Val & FastMathFlags::NoSignedZeros)) |
| 841 | FMF.setNoSignedZeros(); |
| 842 | if (0 != (Val & FastMathFlags::AllowReciprocal)) |
| 843 | FMF.setAllowReciprocal(); |
| 844 | return FMF; |
| 845 | } |
| 846 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 847 | static void upgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) { |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 848 | switch (Val) { |
| 849 | case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break; |
| 850 | case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break; |
| 851 | } |
| 852 | } |
| 853 | |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 854 | namespace llvm { |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 855 | namespace { |
Rafael Espindola | 64a27fb | 2015-06-15 21:04:27 +0000 | [diff] [blame] | 856 | /// \brief A class for maintaining the slot number definition |
| 857 | /// as a placeholder for the actual definition for forward constants defs. |
| 858 | class ConstantPlaceHolder : public ConstantExpr { |
| 859 | void operator=(const ConstantPlaceHolder &) = delete; |
| 860 | |
| 861 | public: |
| 862 | // allocate space for exactly one operand |
| 863 | void *operator new(size_t s) { return User::operator new(s, 1); } |
| 864 | explicit ConstantPlaceHolder(Type *Ty, LLVMContext &Context) |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 865 | : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { |
Rafael Espindola | 64a27fb | 2015-06-15 21:04:27 +0000 | [diff] [blame] | 866 | Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); |
| 867 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 868 | |
Rafael Espindola | 64a27fb | 2015-06-15 21:04:27 +0000 | [diff] [blame] | 869 | /// \brief Methods to support type inquiry through isa, cast, and dyn_cast. |
| 870 | static bool classof(const Value *V) { |
| 871 | return isa<ConstantExpr>(V) && |
| 872 | cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; |
| 873 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 874 | |
Rafael Espindola | 64a27fb | 2015-06-15 21:04:27 +0000 | [diff] [blame] | 875 | /// Provide fast operand accessors |
| 876 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); |
| 877 | }; |
Alexander Kornienko | f00654e | 2015-06-23 09:49:53 +0000 | [diff] [blame] | 878 | } |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 879 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 880 | // FIXME: can we inherit this from ConstantExpr? |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 881 | template <> |
Jay Foad | c8adf5f | 2011-01-11 15:07:38 +0000 | [diff] [blame] | 882 | struct OperandTraits<ConstantPlaceHolder> : |
| 883 | public FixedNumOperandTraits<ConstantPlaceHolder, 1> { |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 884 | }; |
Richard Trieu | e3d126c | 2014-11-21 02:42:08 +0000 | [diff] [blame] | 885 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value) |
Alexander Kornienko | f00654e | 2015-06-23 09:49:53 +0000 | [diff] [blame] | 886 | } |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 887 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 888 | void BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) { |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 889 | if (Idx == size()) { |
| 890 | push_back(V); |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 891 | return; |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 892 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 893 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 894 | if (Idx >= size()) |
| 895 | resize(Idx+1); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 896 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 897 | WeakVH &OldV = ValuePtrs[Idx]; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 898 | if (!OldV) { |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 899 | OldV = V; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 900 | return; |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 901 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 902 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 903 | // Handle constants and non-constants (e.g. instrs) differently for |
| 904 | // efficiency. |
| 905 | if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { |
| 906 | ResolveConstants.push_back(std::make_pair(PHC, Idx)); |
| 907 | OldV = V; |
| 908 | } else { |
| 909 | // If there was a forward reference to this value, replace it. |
| 910 | Value *PrevVal = OldV; |
| 911 | OldV->replaceAllUsesWith(V); |
| 912 | delete PrevVal; |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 913 | } |
Joseph Tremoulet | 8220bcc | 2015-08-23 00:26:33 +0000 | [diff] [blame] | 914 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 915 | return; |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 916 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 917 | |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 918 | |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 919 | Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 920 | Type *Ty) { |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 921 | if (Idx >= size()) |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 922 | resize(Idx + 1); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 923 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 924 | if (Value *V = ValuePtrs[Idx]) { |
Filipe Cabecinhas | 6a92a3f | 2015-05-27 01:05:40 +0000 | [diff] [blame] | 925 | if (Ty != V->getType()) |
| 926 | report_fatal_error("Type mismatch in constant table!"); |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 927 | return cast<Constant>(V); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 928 | } |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 929 | |
| 930 | // Create and return a placeholder, which will later be RAUW'd. |
Owen Anderson | e9f9804 | 2009-07-07 20:18:58 +0000 | [diff] [blame] | 931 | Constant *C = new ConstantPlaceHolder(Ty, Context); |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 932 | ValuePtrs[Idx] = C; |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 933 | return C; |
| 934 | } |
| 935 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 936 | Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { |
Filipe Cabecinhas | bad0779 | 2015-04-30 00:52:42 +0000 | [diff] [blame] | 937 | // Bail out for a clearly invalid value. This would make us call resize(0) |
| 938 | if (Idx == UINT_MAX) |
| 939 | return nullptr; |
| 940 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 941 | if (Idx >= size()) |
Gabor Greif | f6caff66 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 942 | resize(Idx + 1); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 943 | |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 944 | if (Value *V = ValuePtrs[Idx]) { |
Filipe Cabecinhas | b435d0f | 2015-04-28 20:18:47 +0000 | [diff] [blame] | 945 | // If the types don't match, it's invalid. |
| 946 | if (Ty && Ty != V->getType()) |
| 947 | return nullptr; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 948 | return V; |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 949 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 950 | |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 951 | // No type specified, must be invalid reference. |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 952 | if (!Ty) return nullptr; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 953 | |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 954 | // Create and return a placeholder, which will later be RAUW'd. |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 955 | Value *V = new Argument(Ty); |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 956 | ValuePtrs[Idx] = V; |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 957 | return V; |
| 958 | } |
| 959 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 960 | /// Once all constants are read, this method bulk resolves any forward |
| 961 | /// references. The idea behind this is that we sometimes get constants (such |
| 962 | /// as large arrays) which reference *many* forward ref constants. Replacing |
| 963 | /// each of these causes a lot of thrashing when building/reuniquing the |
| 964 | /// constant. Instead of doing this, we look at all the uses and rewrite all |
| 965 | /// the place holders at once for any constant that uses a placeholder. |
| 966 | void BitcodeReaderValueList::resolveConstantForwardRefs() { |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 967 | // Sort the values by-pointer so that they are efficient to look up with a |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 968 | // binary search. |
| 969 | std::sort(ResolveConstants.begin(), ResolveConstants.end()); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 970 | |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 971 | SmallVector<Constant*, 64> NewOps; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 972 | |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 973 | while (!ResolveConstants.empty()) { |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 974 | Value *RealVal = operator[](ResolveConstants.back().second); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 975 | Constant *Placeholder = ResolveConstants.back().first; |
| 976 | ResolveConstants.pop_back(); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 977 | |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 978 | // Loop over all users of the placeholder, updating them to reference the |
| 979 | // new value. If they reference more than one placeholder, update them all |
| 980 | // at once. |
| 981 | while (!Placeholder->use_empty()) { |
Chandler Carruth | cdf4788 | 2014-03-09 03:16:01 +0000 | [diff] [blame] | 982 | auto UI = Placeholder->user_begin(); |
Gabor Greif | 2c0ab48 | 2010-07-09 16:01:21 +0000 | [diff] [blame] | 983 | User *U = *UI; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 984 | |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 985 | // If the using object isn't uniqued, just update the operands. This |
| 986 | // handles instructions and initializers for global variables. |
Gabor Greif | 2c0ab48 | 2010-07-09 16:01:21 +0000 | [diff] [blame] | 987 | if (!isa<Constant>(U) || isa<GlobalValue>(U)) { |
Chris Lattner | 479c5d9 | 2008-08-21 17:31:45 +0000 | [diff] [blame] | 988 | UI.getUse().set(RealVal); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 989 | continue; |
| 990 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 991 | |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 992 | // Otherwise, we have a constant that uses the placeholder. Replace that |
| 993 | // constant with a new constant that has *all* placeholder uses updated. |
Gabor Greif | 2c0ab48 | 2010-07-09 16:01:21 +0000 | [diff] [blame] | 994 | Constant *UserC = cast<Constant>(U); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 995 | for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); |
| 996 | I != E; ++I) { |
| 997 | Value *NewOp; |
| 998 | if (!isa<ConstantPlaceHolder>(*I)) { |
| 999 | // Not a placeholder reference. |
| 1000 | NewOp = *I; |
| 1001 | } else if (*I == Placeholder) { |
| 1002 | // Common case is that it just references this one placeholder. |
| 1003 | NewOp = RealVal; |
| 1004 | } else { |
| 1005 | // Otherwise, look up the placeholder in ResolveConstants. |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1006 | ResolveConstantsTy::iterator It = |
| 1007 | std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1008 | std::pair<Constant*, unsigned>(cast<Constant>(*I), |
| 1009 | 0)); |
| 1010 | assert(It != ResolveConstants.end() && It->first == *I); |
Chris Lattner | 2d8cd80 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 1011 | NewOp = operator[](It->second); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1012 | } |
| 1013 | |
| 1014 | NewOps.push_back(cast<Constant>(NewOp)); |
| 1015 | } |
| 1016 | |
| 1017 | // Make the new constant. |
| 1018 | Constant *NewC; |
| 1019 | if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { |
Jay Foad | 83be361 | 2011-06-22 09:24:39 +0000 | [diff] [blame] | 1020 | NewC = ConstantArray::get(UserCA->getType(), NewOps); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1021 | } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { |
Chris Lattner | cc19efa | 2011-06-20 04:01:31 +0000 | [diff] [blame] | 1022 | NewC = ConstantStruct::get(UserCS->getType(), NewOps); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1023 | } else if (isa<ConstantVector>(UserC)) { |
Chris Lattner | 6922931 | 2011-02-15 00:14:00 +0000 | [diff] [blame] | 1024 | NewC = ConstantVector::get(NewOps); |
Nick Lewycky | b8f9b7a | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 1025 | } else { |
| 1026 | assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); |
Jay Foad | 5c984e56 | 2011-04-13 13:46:01 +0000 | [diff] [blame] | 1027 | NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1028 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1029 | |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1030 | UserC->replaceAllUsesWith(NewC); |
| 1031 | UserC->destroyConstant(); |
| 1032 | NewOps.clear(); |
| 1033 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1034 | |
Nick Lewycky | b8f9b7a | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 1035 | // Update all ValueHandles, they should be the only users at this point. |
| 1036 | Placeholder->replaceAllUsesWith(RealVal); |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1037 | delete Placeholder; |
| 1038 | } |
| 1039 | } |
| 1040 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1041 | void BitcodeReaderMDValueList::assignValue(Metadata *MD, unsigned Idx) { |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1042 | if (Idx == size()) { |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1043 | push_back(MD); |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1044 | return; |
| 1045 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1046 | |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1047 | if (Idx >= size()) |
| 1048 | resize(Idx+1); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1049 | |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1050 | TrackingMDRef &OldMD = MDValuePtrs[Idx]; |
| 1051 | if (!OldMD) { |
| 1052 | OldMD.reset(MD); |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1053 | return; |
| 1054 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1055 | |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1056 | // If there was a forward reference to this value, replace it. |
Duncan P. N. Exon Smith | 7d82313 | 2015-01-19 21:30:18 +0000 | [diff] [blame] | 1057 | TempMDTuple PrevMD(cast<MDTuple>(OldMD.get())); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1058 | PrevMD->replaceAllUsesWith(MD); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1059 | --NumFwdRefs; |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1060 | } |
| 1061 | |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1062 | Metadata *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1063 | if (Idx >= size()) |
| 1064 | resize(Idx + 1); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1065 | |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1066 | if (Metadata *MD = MDValuePtrs[Idx]) |
| 1067 | return MD; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1068 | |
Duncan P. N. Exon Smith | 060ee62 | 2015-02-16 19:18:01 +0000 | [diff] [blame] | 1069 | // Track forward refs to be resolved later. |
| 1070 | if (AnyFwdRefs) { |
| 1071 | MinFwdRef = std::min(MinFwdRef, Idx); |
| 1072 | MaxFwdRef = std::max(MaxFwdRef, Idx); |
| 1073 | } else { |
| 1074 | AnyFwdRefs = true; |
| 1075 | MinFwdRef = MaxFwdRef = Idx; |
| 1076 | } |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1077 | ++NumFwdRefs; |
Duncan P. N. Exon Smith | 060ee62 | 2015-02-16 19:18:01 +0000 | [diff] [blame] | 1078 | |
| 1079 | // Create and return a placeholder, which will later be RAUW'd. |
Duncan P. N. Exon Smith | 7d82313 | 2015-01-19 21:30:18 +0000 | [diff] [blame] | 1080 | Metadata *MD = MDNode::getTemporary(Context, None).release(); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1081 | MDValuePtrs[Idx].reset(MD); |
| 1082 | return MD; |
| 1083 | } |
| 1084 | |
| 1085 | void BitcodeReaderMDValueList::tryToResolveCycles() { |
| 1086 | if (!AnyFwdRefs) |
| 1087 | // Nothing to do. |
| 1088 | return; |
| 1089 | |
| 1090 | if (NumFwdRefs) |
| 1091 | // Still forward references... can't resolve cycles. |
| 1092 | return; |
| 1093 | |
| 1094 | // Resolve any cycles. |
Duncan P. N. Exon Smith | 060ee62 | 2015-02-16 19:18:01 +0000 | [diff] [blame] | 1095 | for (unsigned I = MinFwdRef, E = MaxFwdRef + 1; I != E; ++I) { |
| 1096 | auto &MD = MDValuePtrs[I]; |
Duncan P. N. Exon Smith | 2bc00f4 | 2015-01-19 23:13:14 +0000 | [diff] [blame] | 1097 | auto *N = dyn_cast_or_null<MDNode>(MD); |
Duncan P. N. Exon Smith | 946fdcc | 2015-01-19 20:36:39 +0000 | [diff] [blame] | 1098 | if (!N) |
| 1099 | continue; |
| 1100 | |
| 1101 | assert(!N->isTemporary() && "Unexpected forward reference"); |
| 1102 | N->resolveCycles(); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1103 | } |
Duncan P. N. Exon Smith | 060ee62 | 2015-02-16 19:18:01 +0000 | [diff] [blame] | 1104 | |
| 1105 | // Make sure we return early again until there's another forward ref. |
| 1106 | AnyFwdRefs = false; |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1107 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1108 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1109 | Type *BitcodeReader::getTypeByID(unsigned ID) { |
| 1110 | // The type table size is always specified correctly. |
| 1111 | if (ID >= TypeList.size()) |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1112 | return nullptr; |
Derek Schuff | 206dddd | 2012-02-06 19:03:04 +0000 | [diff] [blame] | 1113 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1114 | if (Type *Ty = TypeList[ID]) |
| 1115 | return Ty; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1116 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1117 | // If we have a forward reference, the only possible case is when it is to a |
| 1118 | // named struct. Just create a placeholder for now. |
Rafael Espindola | 2fa1e43 | 2014-12-03 07:18:23 +0000 | [diff] [blame] | 1119 | return TypeList[ID] = createIdentifiedStructType(Context); |
| 1120 | } |
| 1121 | |
| 1122 | StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context, |
| 1123 | StringRef Name) { |
| 1124 | auto *Ret = StructType::create(Context, Name); |
| 1125 | IdentifiedStructTypes.push_back(Ret); |
| 1126 | return Ret; |
| 1127 | } |
| 1128 | |
| 1129 | StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) { |
| 1130 | auto *Ret = StructType::create(Context); |
| 1131 | IdentifiedStructTypes.push_back(Ret); |
| 1132 | return Ret; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1133 | } |
| 1134 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1135 | |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1136 | //===----------------------------------------------------------------------===// |
| 1137 | // Functions for parsing blocks from the bitcode file |
| 1138 | //===----------------------------------------------------------------------===// |
| 1139 | |
Bill Wendling | 56aeccc | 2013-02-04 23:32:23 +0000 | [diff] [blame] | 1140 | |
| 1141 | /// \brief This fills an AttrBuilder object with the LLVM attributes that have |
| 1142 | /// been decoded from the given integer. This function must stay in sync with |
| 1143 | /// 'encodeLLVMAttributesForBitcode'. |
| 1144 | static void decodeLLVMAttributesForBitcode(AttrBuilder &B, |
| 1145 | uint64_t EncodedAttrs) { |
| 1146 | // FIXME: Remove in 4.0. |
| 1147 | |
| 1148 | // The alignment is stored as a 16-bit raw value from bits 31--16. We shift |
| 1149 | // the bits above 31 down by 11 bits. |
| 1150 | unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; |
| 1151 | assert((!Alignment || isPowerOf2_32(Alignment)) && |
| 1152 | "Alignment must be a power of two."); |
| 1153 | |
| 1154 | if (Alignment) |
| 1155 | B.addAlignmentAttr(Alignment); |
Kostya Serebryany | d688bab | 2013-02-11 08:13:54 +0000 | [diff] [blame] | 1156 | B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | |
Bill Wendling | 56aeccc | 2013-02-04 23:32:23 +0000 | [diff] [blame] | 1157 | (EncodedAttrs & 0xffff)); |
| 1158 | } |
| 1159 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1160 | std::error_code BitcodeReader::parseAttributeBlock() { |
Chris Lattner | 982ec1e | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 1161 | if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1162 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1163 | |
Devang Patel | a05633e | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 1164 | if (!MAttributes.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1165 | return error("Invalid multiple blocks"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1166 | |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1167 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1168 | |
Bill Wendling | 71173cb | 2013-01-27 00:36:48 +0000 | [diff] [blame] | 1169 | SmallVector<AttributeSet, 8> Attrs; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1170 | |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1171 | // Read all the records. |
| 1172 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1173 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 1174 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1175 | switch (Entry.Kind) { |
| 1176 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 1177 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1178 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1179 | case BitstreamEntry::EndBlock: |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1180 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1181 | case BitstreamEntry::Record: |
| 1182 | // The interesting case. |
| 1183 | break; |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1184 | } |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 1185 | |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1186 | // Read a record. |
| 1187 | Record.clear(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1188 | switch (Stream.readRecord(Entry.ID, Record)) { |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1189 | default: // Default behavior: ignore. |
| 1190 | break; |
Bill Wendling | 56aeccc | 2013-02-04 23:32:23 +0000 | [diff] [blame] | 1191 | case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] |
| 1192 | // FIXME: Remove in 4.0. |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1193 | if (Record.size() & 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1194 | return error("Invalid record"); |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1195 | |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1196 | for (unsigned i = 0, e = Record.size(); i != e; i += 2) { |
Bill Wendling | 60011b8 | 2013-01-29 01:43:29 +0000 | [diff] [blame] | 1197 | AttrBuilder B; |
Bill Wendling | 56aeccc | 2013-02-04 23:32:23 +0000 | [diff] [blame] | 1198 | decodeLLVMAttributesForBitcode(B, Record[i+1]); |
Bill Wendling | 60011b8 | 2013-01-29 01:43:29 +0000 | [diff] [blame] | 1199 | Attrs.push_back(AttributeSet::get(Context, Record[i], B)); |
Devang Patel | a05633e | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 1200 | } |
Devang Patel | a05633e | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 1201 | |
Bill Wendling | e94d843 | 2012-12-07 23:16:57 +0000 | [diff] [blame] | 1202 | MAttributes.push_back(AttributeSet::get(Context, Attrs)); |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1203 | Attrs.clear(); |
| 1204 | break; |
| 1205 | } |
Bill Wendling | 0dc0891 | 2013-02-12 08:13:50 +0000 | [diff] [blame] | 1206 | case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] |
| 1207 | for (unsigned i = 0, e = Record.size(); i != e; ++i) |
| 1208 | Attrs.push_back(MAttributeGroups[Record[i]]); |
| 1209 | |
| 1210 | MAttributes.push_back(AttributeSet::get(Context, Attrs)); |
| 1211 | Attrs.clear(); |
| 1212 | break; |
| 1213 | } |
Duncan Sands | 04eb67e | 2007-11-20 14:09:29 +0000 | [diff] [blame] | 1214 | } |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1215 | } |
| 1216 | } |
| 1217 | |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1218 | // Returns Attribute::None on unrecognized codes. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1219 | static Attribute::AttrKind getAttrFromCode(uint64_t Code) { |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1220 | switch (Code) { |
| 1221 | default: |
| 1222 | return Attribute::None; |
| 1223 | case bitc::ATTR_KIND_ALIGNMENT: |
| 1224 | return Attribute::Alignment; |
| 1225 | case bitc::ATTR_KIND_ALWAYS_INLINE: |
| 1226 | return Attribute::AlwaysInline; |
Igor Laevsky | 39d662f | 2015-07-11 10:30:36 +0000 | [diff] [blame] | 1227 | case bitc::ATTR_KIND_ARGMEMONLY: |
| 1228 | return Attribute::ArgMemOnly; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1229 | case bitc::ATTR_KIND_BUILTIN: |
| 1230 | return Attribute::Builtin; |
| 1231 | case bitc::ATTR_KIND_BY_VAL: |
| 1232 | return Attribute::ByVal; |
Reid Kleckner | a534a38 | 2013-12-19 02:14:12 +0000 | [diff] [blame] | 1233 | case bitc::ATTR_KIND_IN_ALLOCA: |
| 1234 | return Attribute::InAlloca; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1235 | case bitc::ATTR_KIND_COLD: |
| 1236 | return Attribute::Cold; |
Owen Anderson | 85fa7d5 | 2015-05-26 23:48:40 +0000 | [diff] [blame] | 1237 | case bitc::ATTR_KIND_CONVERGENT: |
| 1238 | return Attribute::Convergent; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1239 | case bitc::ATTR_KIND_INLINE_HINT: |
| 1240 | return Attribute::InlineHint; |
| 1241 | case bitc::ATTR_KIND_IN_REG: |
| 1242 | return Attribute::InReg; |
Tom Roeder | 44cb65f | 2014-06-05 19:29:43 +0000 | [diff] [blame] | 1243 | case bitc::ATTR_KIND_JUMP_TABLE: |
| 1244 | return Attribute::JumpTable; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1245 | case bitc::ATTR_KIND_MIN_SIZE: |
| 1246 | return Attribute::MinSize; |
| 1247 | case bitc::ATTR_KIND_NAKED: |
| 1248 | return Attribute::Naked; |
| 1249 | case bitc::ATTR_KIND_NEST: |
| 1250 | return Attribute::Nest; |
| 1251 | case bitc::ATTR_KIND_NO_ALIAS: |
| 1252 | return Attribute::NoAlias; |
| 1253 | case bitc::ATTR_KIND_NO_BUILTIN: |
| 1254 | return Attribute::NoBuiltin; |
| 1255 | case bitc::ATTR_KIND_NO_CAPTURE: |
| 1256 | return Attribute::NoCapture; |
| 1257 | case bitc::ATTR_KIND_NO_DUPLICATE: |
| 1258 | return Attribute::NoDuplicate; |
| 1259 | case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT: |
| 1260 | return Attribute::NoImplicitFloat; |
| 1261 | case bitc::ATTR_KIND_NO_INLINE: |
| 1262 | return Attribute::NoInline; |
James Molloy | e6f87ca | 2015-11-06 10:32:53 +0000 | [diff] [blame] | 1263 | case bitc::ATTR_KIND_NO_RECURSE: |
| 1264 | return Attribute::NoRecurse; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1265 | case bitc::ATTR_KIND_NON_LAZY_BIND: |
| 1266 | return Attribute::NonLazyBind; |
Nick Lewycky | d52b152 | 2014-05-20 01:23:40 +0000 | [diff] [blame] | 1267 | case bitc::ATTR_KIND_NON_NULL: |
| 1268 | return Attribute::NonNull; |
Hal Finkel | b0407ba | 2014-07-18 15:51:28 +0000 | [diff] [blame] | 1269 | case bitc::ATTR_KIND_DEREFERENCEABLE: |
| 1270 | return Attribute::Dereferenceable; |
Sanjoy Das | 31ea6d1 | 2015-04-16 20:29:50 +0000 | [diff] [blame] | 1271 | case bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL: |
| 1272 | return Attribute::DereferenceableOrNull; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1273 | case bitc::ATTR_KIND_NO_RED_ZONE: |
| 1274 | return Attribute::NoRedZone; |
| 1275 | case bitc::ATTR_KIND_NO_RETURN: |
| 1276 | return Attribute::NoReturn; |
| 1277 | case bitc::ATTR_KIND_NO_UNWIND: |
| 1278 | return Attribute::NoUnwind; |
| 1279 | case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE: |
| 1280 | return Attribute::OptimizeForSize; |
| 1281 | case bitc::ATTR_KIND_OPTIMIZE_NONE: |
| 1282 | return Attribute::OptimizeNone; |
| 1283 | case bitc::ATTR_KIND_READ_NONE: |
| 1284 | return Attribute::ReadNone; |
| 1285 | case bitc::ATTR_KIND_READ_ONLY: |
| 1286 | return Attribute::ReadOnly; |
| 1287 | case bitc::ATTR_KIND_RETURNED: |
| 1288 | return Attribute::Returned; |
| 1289 | case bitc::ATTR_KIND_RETURNS_TWICE: |
| 1290 | return Attribute::ReturnsTwice; |
| 1291 | case bitc::ATTR_KIND_S_EXT: |
| 1292 | return Attribute::SExt; |
| 1293 | case bitc::ATTR_KIND_STACK_ALIGNMENT: |
| 1294 | return Attribute::StackAlignment; |
| 1295 | case bitc::ATTR_KIND_STACK_PROTECT: |
| 1296 | return Attribute::StackProtect; |
| 1297 | case bitc::ATTR_KIND_STACK_PROTECT_REQ: |
| 1298 | return Attribute::StackProtectReq; |
| 1299 | case bitc::ATTR_KIND_STACK_PROTECT_STRONG: |
| 1300 | return Attribute::StackProtectStrong; |
Peter Collingbourne | 82437bf | 2015-06-15 21:07:11 +0000 | [diff] [blame] | 1301 | case bitc::ATTR_KIND_SAFESTACK: |
| 1302 | return Attribute::SafeStack; |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1303 | case bitc::ATTR_KIND_STRUCT_RET: |
| 1304 | return Attribute::StructRet; |
| 1305 | case bitc::ATTR_KIND_SANITIZE_ADDRESS: |
| 1306 | return Attribute::SanitizeAddress; |
| 1307 | case bitc::ATTR_KIND_SANITIZE_THREAD: |
| 1308 | return Attribute::SanitizeThread; |
| 1309 | case bitc::ATTR_KIND_SANITIZE_MEMORY: |
| 1310 | return Attribute::SanitizeMemory; |
| 1311 | case bitc::ATTR_KIND_UW_TABLE: |
| 1312 | return Attribute::UWTable; |
| 1313 | case bitc::ATTR_KIND_Z_EXT: |
| 1314 | return Attribute::ZExt; |
| 1315 | } |
| 1316 | } |
| 1317 | |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 1318 | std::error_code BitcodeReader::parseAlignmentValue(uint64_t Exponent, |
| 1319 | unsigned &Alignment) { |
| 1320 | // Note: Alignment in bitcode files is incremented by 1, so that zero |
| 1321 | // can be used for default alignment. |
| 1322 | if (Exponent > Value::MaxAlignmentExponent + 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1323 | return error("Invalid alignment value"); |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 1324 | Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1; |
| 1325 | return std::error_code(); |
| 1326 | } |
| 1327 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1328 | std::error_code BitcodeReader::parseAttrKind(uint64_t Code, |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1329 | Attribute::AttrKind *Kind) { |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1330 | *Kind = getAttrFromCode(Code); |
Reid Kleckner | e9f36af | 2013-11-12 01:31:00 +0000 | [diff] [blame] | 1331 | if (*Kind == Attribute::None) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1332 | return error(BitcodeError::CorruptedBitcode, |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 1333 | "Unknown attribute kind (" + Twine(Code) + ")"); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1334 | return std::error_code(); |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 1335 | } |
| 1336 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1337 | std::error_code BitcodeReader::parseAttributeGroupBlock() { |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1338 | if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1339 | return error("Invalid record"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1340 | |
| 1341 | if (!MAttributeGroups.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1342 | return error("Invalid multiple blocks"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1343 | |
| 1344 | SmallVector<uint64_t, 64> Record; |
| 1345 | |
| 1346 | // Read all the records. |
| 1347 | while (1) { |
| 1348 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 1349 | |
| 1350 | switch (Entry.Kind) { |
| 1351 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 1352 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1353 | return error("Malformed block"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1354 | case BitstreamEntry::EndBlock: |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1355 | return std::error_code(); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1356 | case BitstreamEntry::Record: |
| 1357 | // The interesting case. |
| 1358 | break; |
| 1359 | } |
| 1360 | |
| 1361 | // Read a record. |
| 1362 | Record.clear(); |
| 1363 | switch (Stream.readRecord(Entry.ID, Record)) { |
| 1364 | default: // Default behavior: ignore. |
| 1365 | break; |
| 1366 | case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] |
| 1367 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1368 | return error("Invalid record"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1369 | |
Bill Wendling | e46707e | 2013-02-11 22:32:29 +0000 | [diff] [blame] | 1370 | uint64_t GrpID = Record[0]; |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1371 | uint64_t Idx = Record[1]; // Index of the object this attribute refers to. |
| 1372 | |
| 1373 | AttrBuilder B; |
| 1374 | for (unsigned i = 2, e = Record.size(); i != e; ++i) { |
| 1375 | if (Record[i] == 0) { // Enum attribute |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 1376 | Attribute::AttrKind Kind; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1377 | if (std::error_code EC = parseAttrKind(Record[++i], &Kind)) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 1378 | return EC; |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 1379 | |
| 1380 | B.addAttribute(Kind); |
Hal Finkel | e15442c | 2014-07-18 06:51:55 +0000 | [diff] [blame] | 1381 | } else if (Record[i] == 1) { // Integer attribute |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 1382 | Attribute::AttrKind Kind; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1383 | if (std::error_code EC = parseAttrKind(Record[++i], &Kind)) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 1384 | return EC; |
Tobias Grosser | 0a8e12f | 2013-07-26 04:16:55 +0000 | [diff] [blame] | 1385 | if (Kind == Attribute::Alignment) |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1386 | B.addAlignmentAttr(Record[++i]); |
Hal Finkel | b0407ba | 2014-07-18 15:51:28 +0000 | [diff] [blame] | 1387 | else if (Kind == Attribute::StackAlignment) |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1388 | B.addStackAlignmentAttr(Record[++i]); |
Hal Finkel | b0407ba | 2014-07-18 15:51:28 +0000 | [diff] [blame] | 1389 | else if (Kind == Attribute::Dereferenceable) |
| 1390 | B.addDereferenceableAttr(Record[++i]); |
Sanjoy Das | 31ea6d1 | 2015-04-16 20:29:50 +0000 | [diff] [blame] | 1391 | else if (Kind == Attribute::DereferenceableOrNull) |
| 1392 | B.addDereferenceableOrNullAttr(Record[++i]); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1393 | } else { // String attribute |
Bill Wendling | e46707e | 2013-02-11 22:32:29 +0000 | [diff] [blame] | 1394 | assert((Record[i] == 3 || Record[i] == 4) && |
| 1395 | "Invalid attribute group entry"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1396 | bool HasValue = (Record[i++] == 4); |
| 1397 | SmallString<64> KindStr; |
| 1398 | SmallString<64> ValStr; |
| 1399 | |
| 1400 | while (Record[i] != 0 && i != e) |
| 1401 | KindStr += Record[i++]; |
Bill Wendling | e46707e | 2013-02-11 22:32:29 +0000 | [diff] [blame] | 1402 | assert(Record[i] == 0 && "Kind string not null terminated"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1403 | |
| 1404 | if (HasValue) { |
| 1405 | // Has a value associated with it. |
Bill Wendling | e46707e | 2013-02-11 22:32:29 +0000 | [diff] [blame] | 1406 | ++i; // Skip the '0' that terminates the "kind" string. |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1407 | while (Record[i] != 0 && i != e) |
| 1408 | ValStr += Record[i++]; |
Bill Wendling | e46707e | 2013-02-11 22:32:29 +0000 | [diff] [blame] | 1409 | assert(Record[i] == 0 && "Value string not null terminated"); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1410 | } |
| 1411 | |
| 1412 | B.addAttribute(KindStr.str(), ValStr.str()); |
| 1413 | } |
| 1414 | } |
| 1415 | |
Bill Wendling | e46707e | 2013-02-11 22:32:29 +0000 | [diff] [blame] | 1416 | MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B); |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 1417 | break; |
| 1418 | } |
| 1419 | } |
| 1420 | } |
| 1421 | } |
| 1422 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1423 | std::error_code BitcodeReader::parseTypeTable() { |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1424 | if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1425 | return error("Invalid record"); |
Derek Schuff | 206dddd | 2012-02-06 19:03:04 +0000 | [diff] [blame] | 1426 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1427 | return parseTypeTableBody(); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1428 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1429 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1430 | std::error_code BitcodeReader::parseTypeTableBody() { |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1431 | if (!TypeList.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1432 | return error("Invalid multiple blocks"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1433 | |
| 1434 | SmallVector<uint64_t, 64> Record; |
| 1435 | unsigned NumRecords = 0; |
| 1436 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1437 | SmallString<64> TypeName; |
Derek Schuff | 206dddd | 2012-02-06 19:03:04 +0000 | [diff] [blame] | 1438 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1439 | // Read all the records for this type table. |
| 1440 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1441 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 1442 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1443 | switch (Entry.Kind) { |
| 1444 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 1445 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1446 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1447 | case BitstreamEntry::EndBlock: |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1448 | if (NumRecords != TypeList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1449 | return error("Malformed block"); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1450 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1451 | case BitstreamEntry::Record: |
| 1452 | // The interesting case. |
| 1453 | break; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1454 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1455 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1456 | // Read a record. |
| 1457 | Record.clear(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1458 | Type *ResultTy = nullptr; |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1459 | switch (Stream.readRecord(Entry.ID, Record)) { |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 1460 | default: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1461 | return error("Invalid value"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1462 | case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] |
| 1463 | // TYPE_CODE_NUMENTRY contains a count of the number of types in the |
| 1464 | // type list. This allows us to reserve space. |
| 1465 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1466 | return error("Invalid record"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1467 | TypeList.resize(Record[0]); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1468 | continue; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1469 | case bitc::TYPE_CODE_VOID: // VOID |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1470 | ResultTy = Type::getVoidTy(Context); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1471 | break; |
Dan Gohman | 518cda4 | 2011-12-17 00:04:22 +0000 | [diff] [blame] | 1472 | case bitc::TYPE_CODE_HALF: // HALF |
| 1473 | ResultTy = Type::getHalfTy(Context); |
| 1474 | break; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1475 | case bitc::TYPE_CODE_FLOAT: // FLOAT |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1476 | ResultTy = Type::getFloatTy(Context); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1477 | break; |
| 1478 | case bitc::TYPE_CODE_DOUBLE: // DOUBLE |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1479 | ResultTy = Type::getDoubleTy(Context); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1480 | break; |
Dale Johannesen | ff4c3be | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 1481 | case bitc::TYPE_CODE_X86_FP80: // X86_FP80 |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1482 | ResultTy = Type::getX86_FP80Ty(Context); |
Dale Johannesen | ff4c3be | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 1483 | break; |
| 1484 | case bitc::TYPE_CODE_FP128: // FP128 |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1485 | ResultTy = Type::getFP128Ty(Context); |
Dale Johannesen | ff4c3be | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 1486 | break; |
| 1487 | case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1488 | ResultTy = Type::getPPC_FP128Ty(Context); |
Dale Johannesen | ff4c3be | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 1489 | break; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1490 | case bitc::TYPE_CODE_LABEL: // LABEL |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1491 | ResultTy = Type::getLabelTy(Context); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1492 | break; |
Nick Lewycky | adbc284 | 2009-05-30 05:06:04 +0000 | [diff] [blame] | 1493 | case bitc::TYPE_CODE_METADATA: // METADATA |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1494 | ResultTy = Type::getMetadataTy(Context); |
Nick Lewycky | adbc284 | 2009-05-30 05:06:04 +0000 | [diff] [blame] | 1495 | break; |
Dale Johannesen | baa5d04 | 2010-09-10 20:55:01 +0000 | [diff] [blame] | 1496 | case bitc::TYPE_CODE_X86_MMX: // X86_MMX |
| 1497 | ResultTy = Type::getX86_MMXTy(Context); |
| 1498 | break; |
David Majnemer | b611e3f | 2015-08-14 05:09:07 +0000 | [diff] [blame] | 1499 | case bitc::TYPE_CODE_TOKEN: // TOKEN |
| 1500 | ResultTy = Type::getTokenTy(Context); |
| 1501 | break; |
Filipe Cabecinhas | fcd044b | 2015-01-30 18:13:50 +0000 | [diff] [blame] | 1502 | case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1503 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1504 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1505 | |
Filipe Cabecinhas | fcd044b | 2015-01-30 18:13:50 +0000 | [diff] [blame] | 1506 | uint64_t NumBits = Record[0]; |
| 1507 | if (NumBits < IntegerType::MIN_INT_BITS || |
| 1508 | NumBits > IntegerType::MAX_INT_BITS) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1509 | return error("Bitwidth for integer type out of range"); |
Filipe Cabecinhas | fcd044b | 2015-01-30 18:13:50 +0000 | [diff] [blame] | 1510 | ResultTy = IntegerType::get(Context, NumBits); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1511 | break; |
Filipe Cabecinhas | fcd044b | 2015-01-30 18:13:50 +0000 | [diff] [blame] | 1512 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1513 | case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or |
Christopher Lamb | 54dd24c | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 1514 | // [pointee type, address space] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1515 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1516 | return error("Invalid record"); |
Christopher Lamb | 54dd24c | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 1517 | unsigned AddressSpace = 0; |
| 1518 | if (Record.size() == 2) |
| 1519 | AddressSpace = Record[1]; |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1520 | ResultTy = getTypeByID(Record[0]); |
Filipe Cabecinhas | d8a1bcd | 2015-04-29 02:27:28 +0000 | [diff] [blame] | 1521 | if (!ResultTy || |
| 1522 | !PointerType::isValidElementType(ResultTy)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1523 | return error("Invalid type"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1524 | ResultTy = PointerType::get(ResultTy, AddressSpace); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1525 | break; |
Christopher Lamb | 54dd24c | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 1526 | } |
Nuno Lopes | 561dae0 | 2012-05-23 15:19:39 +0000 | [diff] [blame] | 1527 | case bitc::TYPE_CODE_FUNCTION_OLD: { |
| 1528 | // FIXME: attrid is dead, remove it in LLVM 4.0 |
| 1529 | // FUNCTION: [vararg, attrid, retty, paramty x N] |
| 1530 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1531 | return error("Invalid record"); |
Nuno Lopes | 561dae0 | 2012-05-23 15:19:39 +0000 | [diff] [blame] | 1532 | SmallVector<Type*, 8> ArgTys; |
| 1533 | for (unsigned i = 3, e = Record.size(); i != e; ++i) { |
| 1534 | if (Type *T = getTypeByID(Record[i])) |
| 1535 | ArgTys.push_back(T); |
| 1536 | else |
| 1537 | break; |
| 1538 | } |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1539 | |
Nuno Lopes | 561dae0 | 2012-05-23 15:19:39 +0000 | [diff] [blame] | 1540 | ResultTy = getTypeByID(Record[2]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1541 | if (!ResultTy || ArgTys.size() < Record.size()-3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1542 | return error("Invalid type"); |
Nuno Lopes | 561dae0 | 2012-05-23 15:19:39 +0000 | [diff] [blame] | 1543 | |
| 1544 | ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); |
| 1545 | break; |
| 1546 | } |
Chad Rosier | 9589872 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 1547 | case bitc::TYPE_CODE_FUNCTION: { |
| 1548 | // FUNCTION: [vararg, retty, paramty x N] |
| 1549 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1550 | return error("Invalid record"); |
Chris Lattner | cc3aaf1 | 2012-01-27 03:15:49 +0000 | [diff] [blame] | 1551 | SmallVector<Type*, 8> ArgTys; |
Chad Rosier | 9589872 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 1552 | for (unsigned i = 2, e = Record.size(); i != e; ++i) { |
Filipe Cabecinhas | 32af542 | 2015-05-19 01:21:06 +0000 | [diff] [blame] | 1553 | if (Type *T = getTypeByID(Record[i])) { |
| 1554 | if (!FunctionType::isValidArgumentType(T)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1555 | return error("Invalid function argument type"); |
Chad Rosier | 9589872 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 1556 | ArgTys.push_back(T); |
Filipe Cabecinhas | 32af542 | 2015-05-19 01:21:06 +0000 | [diff] [blame] | 1557 | } |
Chad Rosier | 9589872 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 1558 | else |
| 1559 | break; |
| 1560 | } |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1561 | |
Chad Rosier | 9589872 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 1562 | ResultTy = getTypeByID(Record[1]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1563 | if (!ResultTy || ArgTys.size() < Record.size()-2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1564 | return error("Invalid type"); |
Chad Rosier | 9589872 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 1565 | |
| 1566 | ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); |
| 1567 | break; |
| 1568 | } |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1569 | case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] |
Chris Lattner | 3c5616e | 2007-05-06 08:21:50 +0000 | [diff] [blame] | 1570 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1571 | return error("Invalid record"); |
Chris Lattner | cc3aaf1 | 2012-01-27 03:15:49 +0000 | [diff] [blame] | 1572 | SmallVector<Type*, 8> EltTys; |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1573 | for (unsigned i = 1, e = Record.size(); i != e; ++i) { |
| 1574 | if (Type *T = getTypeByID(Record[i])) |
| 1575 | EltTys.push_back(T); |
| 1576 | else |
| 1577 | break; |
| 1578 | } |
| 1579 | if (EltTys.size() != Record.size()-1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1580 | return error("Invalid type"); |
Owen Anderson | 03cb69f | 2009-08-05 23:16:16 +0000 | [diff] [blame] | 1581 | ResultTy = StructType::get(Context, EltTys, Record[0]); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1582 | break; |
| 1583 | } |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1584 | case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1585 | if (convertToString(Record, 0, TypeName)) |
| 1586 | return error("Invalid record"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1587 | continue; |
| 1588 | |
| 1589 | case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] |
| 1590 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1591 | return error("Invalid record"); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1592 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1593 | if (NumRecords >= TypeList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1594 | return error("Invalid TYPE table"); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1595 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1596 | // Check to see if this was forward referenced, if so fill in the temp. |
| 1597 | StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); |
| 1598 | if (Res) { |
| 1599 | Res->setName(TypeName); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1600 | TypeList[NumRecords] = nullptr; |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1601 | } else // Otherwise, create a new struct. |
Rafael Espindola | 2fa1e43 | 2014-12-03 07:18:23 +0000 | [diff] [blame] | 1602 | Res = createIdentifiedStructType(Context, TypeName); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1603 | TypeName.clear(); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1604 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1605 | SmallVector<Type*, 8> EltTys; |
| 1606 | for (unsigned i = 1, e = Record.size(); i != e; ++i) { |
| 1607 | if (Type *T = getTypeByID(Record[i])) |
| 1608 | EltTys.push_back(T); |
| 1609 | else |
| 1610 | break; |
| 1611 | } |
| 1612 | if (EltTys.size() != Record.size()-1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1613 | return error("Invalid record"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1614 | Res->setBody(EltTys, Record[0]); |
| 1615 | ResultTy = Res; |
| 1616 | break; |
| 1617 | } |
| 1618 | case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] |
| 1619 | if (Record.size() != 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1620 | return error("Invalid record"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1621 | |
| 1622 | if (NumRecords >= TypeList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1623 | return error("Invalid TYPE table"); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1624 | |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1625 | // Check to see if this was forward referenced, if so fill in the temp. |
| 1626 | StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); |
| 1627 | if (Res) { |
| 1628 | Res->setName(TypeName); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1629 | TypeList[NumRecords] = nullptr; |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1630 | } else // Otherwise, create a new struct with no body. |
Rafael Espindola | 2fa1e43 | 2014-12-03 07:18:23 +0000 | [diff] [blame] | 1631 | Res = createIdentifiedStructType(Context, TypeName); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1632 | TypeName.clear(); |
| 1633 | ResultTy = Res; |
| 1634 | break; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1635 | } |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1636 | case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] |
| 1637 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1638 | return error("Invalid record"); |
Filipe Cabecinhas | 6fe8aab | 2015-04-29 02:36:08 +0000 | [diff] [blame] | 1639 | ResultTy = getTypeByID(Record[1]); |
| 1640 | if (!ResultTy || !ArrayType::isValidElementType(ResultTy)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1641 | return error("Invalid type"); |
Filipe Cabecinhas | 6fe8aab | 2015-04-29 02:36:08 +0000 | [diff] [blame] | 1642 | ResultTy = ArrayType::get(ResultTy, Record[0]); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1643 | break; |
| 1644 | case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] |
| 1645 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1646 | return error("Invalid record"); |
Filipe Cabecinhas | 8e42190 | 2015-06-03 00:05:30 +0000 | [diff] [blame] | 1647 | if (Record[0] == 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1648 | return error("Invalid vector length"); |
Filipe Cabecinhas | 6fe8aab | 2015-04-29 02:36:08 +0000 | [diff] [blame] | 1649 | ResultTy = getTypeByID(Record[1]); |
| 1650 | if (!ResultTy || !StructType::isValidElementType(ResultTy)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1651 | return error("Invalid type"); |
Filipe Cabecinhas | 6fe8aab | 2015-04-29 02:36:08 +0000 | [diff] [blame] | 1652 | ResultTy = VectorType::get(ResultTy, Record[0]); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1653 | break; |
| 1654 | } |
| 1655 | |
| 1656 | if (NumRecords >= TypeList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1657 | return error("Invalid TYPE table"); |
Filipe Cabecinhas | d0858e1 | 2015-01-30 10:57:58 +0000 | [diff] [blame] | 1658 | if (TypeList[NumRecords]) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1659 | return error( |
Filipe Cabecinhas | d0858e1 | 2015-01-30 10:57:58 +0000 | [diff] [blame] | 1660 | "Invalid TYPE table: Only named structs can be forward referenced"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1661 | assert(ResultTy && "Didn't read a type?"); |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1662 | TypeList[NumRecords++] = ResultTy; |
| 1663 | } |
| 1664 | } |
| 1665 | |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 1666 | std::error_code BitcodeReader::parseOperandBundleTags() { |
| 1667 | if (Stream.EnterSubBlock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID)) |
| 1668 | return error("Invalid record"); |
| 1669 | |
| 1670 | if (!BundleTags.empty()) |
| 1671 | return error("Invalid multiple blocks"); |
| 1672 | |
| 1673 | SmallVector<uint64_t, 64> Record; |
| 1674 | |
| 1675 | while (1) { |
| 1676 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 1677 | |
| 1678 | switch (Entry.Kind) { |
| 1679 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 1680 | case BitstreamEntry::Error: |
| 1681 | return error("Malformed block"); |
| 1682 | case BitstreamEntry::EndBlock: |
| 1683 | return std::error_code(); |
| 1684 | case BitstreamEntry::Record: |
| 1685 | // The interesting case. |
| 1686 | break; |
| 1687 | } |
| 1688 | |
| 1689 | // Tags are implicitly mapped to integers by their order. |
| 1690 | |
| 1691 | if (Stream.readRecord(Entry.ID, Record) != bitc::OPERAND_BUNDLE_TAG) |
| 1692 | return error("Invalid record"); |
| 1693 | |
| 1694 | // OPERAND_BUNDLE_TAG: [strchr x N] |
| 1695 | BundleTags.emplace_back(); |
| 1696 | if (convertToString(Record, 0, BundleTags.back())) |
| 1697 | return error("Invalid record"); |
| 1698 | Record.clear(); |
| 1699 | } |
| 1700 | } |
| 1701 | |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1702 | /// Associate a value with its name from the given index in the provided record. |
| 1703 | ErrorOr<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record, |
| 1704 | unsigned NameIndex, Triple &TT) { |
| 1705 | SmallString<128> ValueName; |
| 1706 | if (convertToString(Record, NameIndex, ValueName)) |
| 1707 | return error("Invalid record"); |
| 1708 | unsigned ValueID = Record[0]; |
| 1709 | if (ValueID >= ValueList.size() || !ValueList[ValueID]) |
| 1710 | return error("Invalid record"); |
| 1711 | Value *V = ValueList[ValueID]; |
| 1712 | |
Filipe Cabecinhas | a2b0ac4 | 2015-11-04 14:53:36 +0000 | [diff] [blame] | 1713 | StringRef NameStr(ValueName.data(), ValueName.size()); |
| 1714 | if (NameStr.find_first_of(0) != StringRef::npos) |
| 1715 | return error("Invalid value name"); |
| 1716 | V->setName(NameStr); |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1717 | auto *GO = dyn_cast<GlobalObject>(V); |
| 1718 | if (GO) { |
| 1719 | if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) { |
| 1720 | if (TT.isOSBinFormatMachO()) |
| 1721 | GO->setComdat(nullptr); |
| 1722 | else |
| 1723 | GO->setComdat(TheModule->getOrInsertComdat(V->getName())); |
| 1724 | } |
| 1725 | } |
| 1726 | return V; |
| 1727 | } |
| 1728 | |
| 1729 | /// Parse the value symbol table at either the current parsing location or |
| 1730 | /// at the given bit offset if provided. |
Peter Collingbourne | 128a976 | 2015-10-27 23:01:25 +0000 | [diff] [blame] | 1731 | std::error_code BitcodeReader::parseValueSymbolTable(uint64_t Offset) { |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1732 | uint64_t CurrentBit; |
| 1733 | // Pass in the Offset to distinguish between calling for the module-level |
| 1734 | // VST (where we want to jump to the VST offset) and the function-level |
| 1735 | // VST (where we don't). |
| 1736 | if (Offset > 0) { |
| 1737 | // Save the current parsing location so we can jump back at the end |
| 1738 | // of the VST read. |
| 1739 | CurrentBit = Stream.GetCurrentBitNo(); |
| 1740 | Stream.JumpToBit(Offset * 32); |
| 1741 | #ifndef NDEBUG |
| 1742 | // Do some checking if we are in debug mode. |
| 1743 | BitstreamEntry Entry = Stream.advance(); |
| 1744 | assert(Entry.Kind == BitstreamEntry::SubBlock); |
| 1745 | assert(Entry.ID == bitc::VALUE_SYMTAB_BLOCK_ID); |
| 1746 | #else |
| 1747 | // In NDEBUG mode ignore the output so we don't get an unused variable |
| 1748 | // warning. |
| 1749 | Stream.advance(); |
| 1750 | #endif |
| 1751 | } |
| 1752 | |
| 1753 | // Compute the delta between the bitcode indices in the VST (the word offset |
| 1754 | // to the word-aligned ENTER_SUBBLOCK for the function block, and that |
| 1755 | // expected by the lazy reader. The reader's EnterSubBlock expects to have |
| 1756 | // already read the ENTER_SUBBLOCK code (size getAbbrevIDWidth) and BlockID |
| 1757 | // (size BlockIDWidth). Note that we access the stream's AbbrevID width here |
| 1758 | // just before entering the VST subblock because: 1) the EnterSubBlock |
| 1759 | // changes the AbbrevID width; 2) the VST block is nested within the same |
| 1760 | // outer MODULE_BLOCK as the FUNCTION_BLOCKs and therefore have the same |
| 1761 | // AbbrevID width before calling EnterSubBlock; and 3) when we want to |
| 1762 | // jump to the FUNCTION_BLOCK using this offset later, we don't want |
| 1763 | // to rely on the stream's AbbrevID width being that of the MODULE_BLOCK. |
| 1764 | unsigned FuncBitcodeOffsetDelta = |
| 1765 | Stream.getAbbrevIDWidth() + bitc::BlockIDWidth; |
| 1766 | |
Chris Lattner | 982ec1e | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 1767 | if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1768 | return error("Invalid record"); |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1769 | |
| 1770 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1771 | |
David Majnemer | 3087b22 | 2015-01-20 05:58:07 +0000 | [diff] [blame] | 1772 | Triple TT(TheModule->getTargetTriple()); |
| 1773 | |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1774 | // Read all the records for this value table. |
| 1775 | SmallString<128> ValueName; |
| 1776 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1777 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 1778 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1779 | switch (Entry.Kind) { |
| 1780 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 1781 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1782 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1783 | case BitstreamEntry::EndBlock: |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1784 | if (Offset > 0) |
| 1785 | Stream.JumpToBit(CurrentBit); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1786 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1787 | case BitstreamEntry::Record: |
| 1788 | // The interesting case. |
| 1789 | break; |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1790 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1791 | |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1792 | // Read a record. |
| 1793 | Record.clear(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1794 | switch (Stream.readRecord(Entry.ID, Record)) { |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1795 | default: // Default behavior: unknown type. |
| 1796 | break; |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1797 | case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1798 | ErrorOr<Value *> ValOrErr = recordValue(Record, 1, TT); |
| 1799 | if (std::error_code EC = ValOrErr.getError()) |
| 1800 | return EC; |
| 1801 | ValOrErr.get(); |
| 1802 | break; |
| 1803 | } |
| 1804 | case bitc::VST_CODE_FNENTRY: { |
| 1805 | // VST_FNENTRY: [valueid, offset, namechar x N] |
| 1806 | ErrorOr<Value *> ValOrErr = recordValue(Record, 2, TT); |
| 1807 | if (std::error_code EC = ValOrErr.getError()) |
| 1808 | return EC; |
| 1809 | Value *V = ValOrErr.get(); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1810 | |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1811 | auto *GO = dyn_cast<GlobalObject>(V); |
| 1812 | if (!GO) { |
| 1813 | // If this is an alias, need to get the actual Function object |
| 1814 | // it aliases, in order to set up the DeferredFunctionInfo entry below. |
| 1815 | auto *GA = dyn_cast<GlobalAlias>(V); |
| 1816 | if (GA) |
| 1817 | GO = GA->getBaseObject(); |
| 1818 | assert(GO); |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 1819 | } |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1820 | |
| 1821 | uint64_t FuncWordOffset = Record[1]; |
| 1822 | Function *F = dyn_cast<Function>(GO); |
| 1823 | assert(F); |
| 1824 | uint64_t FuncBitOffset = FuncWordOffset * 32; |
| 1825 | DeferredFunctionInfo[F] = FuncBitOffset + FuncBitcodeOffsetDelta; |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 1826 | // Set the LastFunctionBlockBit to point to the last function block. |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 1827 | // Later when parsing is resumed after function materialization, |
| 1828 | // we can simply skip that last function block. |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 1829 | if (FuncBitOffset > LastFunctionBlockBit) |
| 1830 | LastFunctionBlockBit = FuncBitOffset; |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1831 | break; |
Reid Spencer | dea02bd | 2007-05-04 01:43:33 +0000 | [diff] [blame] | 1832 | } |
Bill Wendling | 35a9c3c | 2011-04-10 23:18:04 +0000 | [diff] [blame] | 1833 | case bitc::VST_CODE_BBENTRY: { |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1834 | if (convertToString(Record, 1, ValueName)) |
| 1835 | return error("Invalid record"); |
Chris Lattner | 6be58c6 | 2007-05-03 22:18:21 +0000 | [diff] [blame] | 1836 | BasicBlock *BB = getBasicBlock(Record[0]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1837 | if (!BB) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1838 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1839 | |
Daniel Dunbar | d786b51 | 2009-07-26 00:34:27 +0000 | [diff] [blame] | 1840 | BB->setName(StringRef(ValueName.data(), ValueName.size())); |
Chris Lattner | 6be58c6 | 2007-05-03 22:18:21 +0000 | [diff] [blame] | 1841 | ValueName.clear(); |
| 1842 | break; |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1843 | } |
Reid Spencer | dea02bd | 2007-05-04 01:43:33 +0000 | [diff] [blame] | 1844 | } |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1845 | } |
| 1846 | } |
| 1847 | |
Teresa Johnson | 1254507 | 2015-11-15 02:00:09 +0000 | [diff] [blame] | 1848 | /// Parse a single METADATA_KIND record, inserting result in MDKindMap. |
| 1849 | std::error_code |
| 1850 | BitcodeReader::parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record) { |
| 1851 | if (Record.size() < 2) |
| 1852 | return error("Invalid record"); |
| 1853 | |
| 1854 | unsigned Kind = Record[0]; |
| 1855 | SmallString<8> Name(Record.begin() + 1, Record.end()); |
| 1856 | |
| 1857 | unsigned NewKind = TheModule->getMDKindID(Name.str()); |
| 1858 | if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) |
| 1859 | return error("Conflicting METADATA_KIND records"); |
| 1860 | return std::error_code(); |
| 1861 | } |
| 1862 | |
Duncan P. N. Exon Smith | c7363f1 | 2015-02-13 01:10:38 +0000 | [diff] [blame] | 1863 | static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; } |
| 1864 | |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 1865 | /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing |
| 1866 | /// module level metadata. |
| 1867 | std::error_code BitcodeReader::parseMetadata(bool ModuleLevel) { |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 1868 | IsMetadataMaterialized = true; |
Devang Patel | 8992323 | 2010-01-11 18:52:33 +0000 | [diff] [blame] | 1869 | unsigned NextMDValueNo = MDValueList.size(); |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 1870 | if (ModuleLevel && SeenModuleValuesRecord) { |
| 1871 | // Now that we are parsing the module level metadata, we want to restart |
| 1872 | // the numbering of the MD values, and replace temp MD created earlier |
| 1873 | // with their real values. If we saw a METADATA_VALUE record then we |
| 1874 | // would have set the MDValueList size to the number specified in that |
| 1875 | // record, to support parsing function-level metadata first, and we need |
| 1876 | // to reset back to 0 to fill the MDValueList in with the parsed module |
| 1877 | // The function-level metadata parsing should have reset the MDValueList |
| 1878 | // size back to the value reported by the METADATA_VALUE record, saved in |
| 1879 | // NumModuleMDs. |
| 1880 | assert(NumModuleMDs == MDValueList.size() && |
| 1881 | "Expected MDValueList to only contain module level values"); |
| 1882 | NextMDValueNo = 0; |
| 1883 | } |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1884 | |
| 1885 | if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1886 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1887 | |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1888 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1889 | |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 1890 | auto getMD = |
| 1891 | [&](unsigned ID) -> Metadata *{ return MDValueList.getValueFwdRef(ID); }; |
| 1892 | auto getMDOrNull = [&](unsigned ID) -> Metadata *{ |
| 1893 | if (ID) |
| 1894 | return getMD(ID - 1); |
| 1895 | return nullptr; |
| 1896 | }; |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 1897 | auto getMDString = [&](unsigned ID) -> MDString *{ |
| 1898 | // This requires that the ID is not really a forward reference. In |
| 1899 | // particular, the MDString must already have been resolved. |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 1900 | return cast_or_null<MDString>(getMDOrNull(ID)); |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 1901 | }; |
| 1902 | |
| 1903 | #define GET_OR_DISTINCT(CLASS, DISTINCT, ARGS) \ |
| 1904 | (DISTINCT ? CLASS::getDistinct ARGS : CLASS::get ARGS) |
| 1905 | |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1906 | // Read all the records. |
| 1907 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1908 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 1909 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1910 | switch (Entry.Kind) { |
| 1911 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 1912 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1913 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1914 | case BitstreamEntry::EndBlock: |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1915 | MDValueList.tryToResolveCycles(); |
Teresa Johnson | 16e2a9e | 2015-11-21 03:51:23 +0000 | [diff] [blame] | 1916 | assert((!(ModuleLevel && SeenModuleValuesRecord) || |
| 1917 | NumModuleMDs == MDValueList.size()) && |
| 1918 | "Inconsistent bitcode: METADATA_VALUES mismatch"); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1919 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1920 | case BitstreamEntry::Record: |
| 1921 | // The interesting case. |
| 1922 | break; |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1923 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1924 | |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1925 | // Read a record. |
| 1926 | Record.clear(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1927 | unsigned Code = Stream.readRecord(Entry.ID, Record); |
Duncan P. N. Exon Smith | 090a19b | 2015-01-08 22:38:29 +0000 | [diff] [blame] | 1928 | bool IsDistinct = false; |
Dan Gohman | bbcd04d | 2010-09-13 18:00:48 +0000 | [diff] [blame] | 1929 | switch (Code) { |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1930 | default: // Default behavior: ignore. |
| 1931 | break; |
Devang Patel | 27c87ff | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 1932 | case bitc::METADATA_NAME: { |
Chris Lattner | 8d14053 | 2013-01-20 02:54:05 +0000 | [diff] [blame] | 1933 | // Read name of the named metadata. |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 1934 | SmallString<8> Name(Record.begin(), Record.end()); |
Devang Patel | 27c87ff | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 1935 | Record.clear(); |
| 1936 | Code = Stream.ReadCode(); |
| 1937 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 1938 | unsigned NextBitCode = Stream.readRecord(Code, Record); |
Filipe Cabecinhas | 14e6867 | 2015-05-30 00:17:20 +0000 | [diff] [blame] | 1939 | if (NextBitCode != bitc::METADATA_NAMED_NODE) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1940 | return error("METADATA_NAME not followed by METADATA_NAMED_NODE"); |
Devang Patel | 27c87ff | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 1941 | |
| 1942 | // Read named metadata elements. |
| 1943 | unsigned Size = Record.size(); |
Dan Gohman | 2637cc1 | 2010-07-21 23:38:33 +0000 | [diff] [blame] | 1944 | NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); |
Devang Patel | 27c87ff | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 1945 | for (unsigned i = 0; i != Size; ++i) { |
Karthik Bhat | 82540e9 | 2014-03-27 12:08:23 +0000 | [diff] [blame] | 1946 | MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i])); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 1947 | if (!MD) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1948 | return error("Invalid record"); |
Dan Gohman | 2637cc1 | 2010-07-21 23:38:33 +0000 | [diff] [blame] | 1949 | NMD->addOperand(MD); |
Devang Patel | 27c87ff | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 1950 | } |
Devang Patel | 27c87ff | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 1951 | break; |
| 1952 | } |
Duncan P. N. Exon Smith | 005f9f4 | 2014-12-11 22:30:48 +0000 | [diff] [blame] | 1953 | case bitc::METADATA_OLD_FN_NODE: { |
Duncan P. N. Exon Smith | 5bd34e5 | 2014-12-12 02:11:31 +0000 | [diff] [blame] | 1954 | // FIXME: Remove in 4.0. |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1955 | // This is a LocalAsMetadata record, the only type of function-local |
| 1956 | // metadata. |
Duncan P. N. Exon Smith | da41af9 | 2014-12-06 01:26:49 +0000 | [diff] [blame] | 1957 | if (Record.size() % 2 == 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1958 | return error("Invalid record"); |
Duncan P. N. Exon Smith | da41af9 | 2014-12-06 01:26:49 +0000 | [diff] [blame] | 1959 | |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1960 | // If this isn't a LocalAsMetadata record, we're dropping it. This used |
| 1961 | // to be legal, but there's no upgrade path. |
Duncan P. N. Exon Smith | da41af9 | 2014-12-06 01:26:49 +0000 | [diff] [blame] | 1962 | auto dropRecord = [&] { |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1963 | MDValueList.assignValue(MDNode::get(Context, None), NextMDValueNo++); |
Duncan P. N. Exon Smith | da41af9 | 2014-12-06 01:26:49 +0000 | [diff] [blame] | 1964 | }; |
| 1965 | if (Record.size() != 2) { |
| 1966 | dropRecord(); |
| 1967 | break; |
| 1968 | } |
| 1969 | |
| 1970 | Type *Ty = getTypeByID(Record[0]); |
| 1971 | if (Ty->isMetadataTy() || Ty->isVoidTy()) { |
| 1972 | dropRecord(); |
| 1973 | break; |
| 1974 | } |
| 1975 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1976 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1977 | LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), |
| 1978 | NextMDValueNo++); |
Duncan P. N. Exon Smith | da41af9 | 2014-12-06 01:26:49 +0000 | [diff] [blame] | 1979 | break; |
| 1980 | } |
Duncan P. N. Exon Smith | 005f9f4 | 2014-12-11 22:30:48 +0000 | [diff] [blame] | 1981 | case bitc::METADATA_OLD_NODE: { |
Duncan P. N. Exon Smith | 5bd34e5 | 2014-12-12 02:11:31 +0000 | [diff] [blame] | 1982 | // FIXME: Remove in 4.0. |
Dan Gohman | 1e0213a | 2010-07-13 19:33:27 +0000 | [diff] [blame] | 1983 | if (Record.size() % 2 == 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1984 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1985 | |
Devang Patel | e059ba6e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 1986 | unsigned Size = Record.size(); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1987 | SmallVector<Metadata *, 8> Elts; |
Devang Patel | e059ba6e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 1988 | for (unsigned i = 0; i != Size; i += 2) { |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1989 | Type *Ty = getTypeByID(Record[i]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 1990 | if (!Ty) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 1991 | return error("Invalid record"); |
Chris Lattner | fdd8790 | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1992 | if (Ty->isMetadataTy()) |
Devang Patel | 05eb617 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 1993 | Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 1994 | else if (!Ty->isVoidTy()) { |
| 1995 | auto *MD = |
| 1996 | ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty)); |
| 1997 | assert(isa<ConstantAsMetadata>(MD) && |
| 1998 | "Expected non-function-local metadata"); |
| 1999 | Elts.push_back(MD); |
| 2000 | } else |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2001 | Elts.push_back(nullptr); |
Devang Patel | e059ba6e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 2002 | } |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2003 | MDValueList.assignValue(MDNode::get(Context, Elts), NextMDValueNo++); |
Devang Patel | e059ba6e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 2004 | break; |
| 2005 | } |
Duncan P. N. Exon Smith | 5c7006e | 2014-12-11 23:02:24 +0000 | [diff] [blame] | 2006 | case bitc::METADATA_VALUE: { |
| 2007 | if (Record.size() != 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2008 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 5c7006e | 2014-12-11 23:02:24 +0000 | [diff] [blame] | 2009 | |
| 2010 | Type *Ty = getTypeByID(Record[0]); |
| 2011 | if (Ty->isMetadataTy() || Ty->isVoidTy()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2012 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 5c7006e | 2014-12-11 23:02:24 +0000 | [diff] [blame] | 2013 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2014 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | 5c7006e | 2014-12-11 23:02:24 +0000 | [diff] [blame] | 2015 | ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), |
| 2016 | NextMDValueNo++); |
| 2017 | break; |
| 2018 | } |
Duncan P. N. Exon Smith | 090a19b | 2015-01-08 22:38:29 +0000 | [diff] [blame] | 2019 | case bitc::METADATA_DISTINCT_NODE: |
| 2020 | IsDistinct = true; |
| 2021 | // fallthrough... |
Duncan P. N. Exon Smith | 5c7006e | 2014-12-11 23:02:24 +0000 | [diff] [blame] | 2022 | case bitc::METADATA_NODE: { |
| 2023 | SmallVector<Metadata *, 8> Elts; |
| 2024 | Elts.reserve(Record.size()); |
| 2025 | for (unsigned ID : Record) |
| 2026 | Elts.push_back(ID ? MDValueList.getValueFwdRef(ID - 1) : nullptr); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2027 | MDValueList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts) |
Duncan P. N. Exon Smith | 090a19b | 2015-01-08 22:38:29 +0000 | [diff] [blame] | 2028 | : MDNode::get(Context, Elts), |
| 2029 | NextMDValueNo++); |
Duncan P. N. Exon Smith | 5c7006e | 2014-12-11 23:02:24 +0000 | [diff] [blame] | 2030 | break; |
| 2031 | } |
Duncan P. N. Exon Smith | 6a48483 | 2015-01-13 21:10:44 +0000 | [diff] [blame] | 2032 | case bitc::METADATA_LOCATION: { |
| 2033 | if (Record.size() != 5) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2034 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 6a48483 | 2015-01-13 21:10:44 +0000 | [diff] [blame] | 2035 | |
Duncan P. N. Exon Smith | 6a48483 | 2015-01-13 21:10:44 +0000 | [diff] [blame] | 2036 | unsigned Line = Record[1]; |
| 2037 | unsigned Column = Record[2]; |
| 2038 | MDNode *Scope = cast<MDNode>(MDValueList.getValueFwdRef(Record[3])); |
| 2039 | Metadata *InlinedAt = |
| 2040 | Record[4] ? MDValueList.getValueFwdRef(Record[4] - 1) : nullptr; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2041 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2042 | GET_OR_DISTINCT(DILocation, Record[0], |
Duncan P. N. Exon Smith | 2648998 | 2015-03-26 22:05:04 +0000 | [diff] [blame] | 2043 | (Context, Line, Column, Scope, InlinedAt)), |
| 2044 | NextMDValueNo++); |
Duncan P. N. Exon Smith | 6a48483 | 2015-01-13 21:10:44 +0000 | [diff] [blame] | 2045 | break; |
| 2046 | } |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 2047 | case bitc::METADATA_GENERIC_DEBUG: { |
| 2048 | if (Record.size() < 4) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2049 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 2050 | |
| 2051 | unsigned Tag = Record[1]; |
| 2052 | unsigned Version = Record[2]; |
| 2053 | |
| 2054 | if (Tag >= 1u << 16 || Version != 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2055 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 2056 | |
| 2057 | auto *Header = getMDString(Record[3]); |
| 2058 | SmallVector<Metadata *, 8> DwarfOps; |
| 2059 | for (unsigned I = 4, E = Record.size(); I != E; ++I) |
| 2060 | DwarfOps.push_back(Record[I] ? MDValueList.getValueFwdRef(Record[I] - 1) |
| 2061 | : nullptr); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2062 | MDValueList.assignValue(GET_OR_DISTINCT(GenericDINode, Record[0], |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 2063 | (Context, Tag, Header, DwarfOps)), |
| 2064 | NextMDValueNo++); |
| 2065 | break; |
| 2066 | } |
Duncan P. N. Exon Smith | c7363f1 | 2015-02-13 01:10:38 +0000 | [diff] [blame] | 2067 | case bitc::METADATA_SUBRANGE: { |
| 2068 | if (Record.size() != 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2069 | return error("Invalid record"); |
Duncan P. N. Exon Smith | c7363f1 | 2015-02-13 01:10:38 +0000 | [diff] [blame] | 2070 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2071 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2072 | GET_OR_DISTINCT(DISubrange, Record[0], |
Duncan P. N. Exon Smith | c7363f1 | 2015-02-13 01:10:38 +0000 | [diff] [blame] | 2073 | (Context, Record[1], unrotateSign(Record[2]))), |
| 2074 | NextMDValueNo++); |
| 2075 | break; |
| 2076 | } |
Duncan P. N. Exon Smith | 8775476 | 2015-02-13 01:14:11 +0000 | [diff] [blame] | 2077 | case bitc::METADATA_ENUMERATOR: { |
| 2078 | if (Record.size() != 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2079 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 8775476 | 2015-02-13 01:14:11 +0000 | [diff] [blame] | 2080 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2081 | MDValueList.assignValue(GET_OR_DISTINCT(DIEnumerator, Record[0], |
Duncan P. N. Exon Smith | 8775476 | 2015-02-13 01:14:11 +0000 | [diff] [blame] | 2082 | (Context, unrotateSign(Record[1]), |
| 2083 | getMDString(Record[2]))), |
| 2084 | NextMDValueNo++); |
| 2085 | break; |
| 2086 | } |
Duncan P. N. Exon Smith | 09e03f3 | 2015-02-13 01:14:58 +0000 | [diff] [blame] | 2087 | case bitc::METADATA_BASIC_TYPE: { |
| 2088 | if (Record.size() != 6) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2089 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 09e03f3 | 2015-02-13 01:14:58 +0000 | [diff] [blame] | 2090 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2091 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2092 | GET_OR_DISTINCT(DIBasicType, Record[0], |
Duncan P. N. Exon Smith | 09e03f3 | 2015-02-13 01:14:58 +0000 | [diff] [blame] | 2093 | (Context, Record[1], getMDString(Record[2]), |
| 2094 | Record[3], Record[4], Record[5])), |
| 2095 | NextMDValueNo++); |
| 2096 | break; |
| 2097 | } |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 2098 | case bitc::METADATA_DERIVED_TYPE: { |
| 2099 | if (Record.size() != 12) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2100 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 2101 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2102 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2103 | GET_OR_DISTINCT(DIDerivedType, Record[0], |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 2104 | (Context, Record[1], getMDString(Record[2]), |
| 2105 | getMDOrNull(Record[3]), Record[4], |
Duncan P. N. Exon Smith | ad6eb127 | 2015-02-20 03:17:58 +0000 | [diff] [blame] | 2106 | getMDOrNull(Record[5]), getMDOrNull(Record[6]), |
| 2107 | Record[7], Record[8], Record[9], Record[10], |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 2108 | getMDOrNull(Record[11]))), |
| 2109 | NextMDValueNo++); |
| 2110 | break; |
| 2111 | } |
| 2112 | case bitc::METADATA_COMPOSITE_TYPE: { |
| 2113 | if (Record.size() != 16) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2114 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 2115 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2116 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2117 | GET_OR_DISTINCT(DICompositeType, Record[0], |
Duncan P. N. Exon Smith | 171d077 | 2015-02-13 01:20:38 +0000 | [diff] [blame] | 2118 | (Context, Record[1], getMDString(Record[2]), |
| 2119 | getMDOrNull(Record[3]), Record[4], |
| 2120 | getMDOrNull(Record[5]), getMDOrNull(Record[6]), |
| 2121 | Record[7], Record[8], Record[9], Record[10], |
| 2122 | getMDOrNull(Record[11]), Record[12], |
| 2123 | getMDOrNull(Record[13]), getMDOrNull(Record[14]), |
| 2124 | getMDString(Record[15]))), |
| 2125 | NextMDValueNo++); |
| 2126 | break; |
| 2127 | } |
Duncan P. N. Exon Smith | 54e2bc6 | 2015-02-13 01:22:59 +0000 | [diff] [blame] | 2128 | case bitc::METADATA_SUBROUTINE_TYPE: { |
| 2129 | if (Record.size() != 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2130 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 54e2bc6 | 2015-02-13 01:22:59 +0000 | [diff] [blame] | 2131 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2132 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2133 | GET_OR_DISTINCT(DISubroutineType, Record[0], |
Duncan P. N. Exon Smith | 54e2bc6 | 2015-02-13 01:22:59 +0000 | [diff] [blame] | 2134 | (Context, Record[1], getMDOrNull(Record[2]))), |
| 2135 | NextMDValueNo++); |
| 2136 | break; |
| 2137 | } |
Adrian Prantl | ab1243f | 2015-06-29 23:03:47 +0000 | [diff] [blame] | 2138 | |
| 2139 | case bitc::METADATA_MODULE: { |
| 2140 | if (Record.size() != 6) |
| 2141 | return error("Invalid record"); |
| 2142 | |
| 2143 | MDValueList.assignValue( |
| 2144 | GET_OR_DISTINCT(DIModule, Record[0], |
| 2145 | (Context, getMDOrNull(Record[1]), |
| 2146 | getMDString(Record[2]), getMDString(Record[3]), |
| 2147 | getMDString(Record[4]), getMDString(Record[5]))), |
| 2148 | NextMDValueNo++); |
| 2149 | break; |
| 2150 | } |
| 2151 | |
Duncan P. N. Exon Smith | f14b9c7 | 2015-02-13 01:19:14 +0000 | [diff] [blame] | 2152 | case bitc::METADATA_FILE: { |
| 2153 | if (Record.size() != 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2154 | return error("Invalid record"); |
Duncan P. N. Exon Smith | f14b9c7 | 2015-02-13 01:19:14 +0000 | [diff] [blame] | 2155 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2156 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2157 | GET_OR_DISTINCT(DIFile, Record[0], (Context, getMDString(Record[1]), |
Duncan P. N. Exon Smith | f14b9c7 | 2015-02-13 01:19:14 +0000 | [diff] [blame] | 2158 | getMDString(Record[2]))), |
| 2159 | NextMDValueNo++); |
| 2160 | break; |
| 2161 | } |
Duncan P. N. Exon Smith | c1f1acc | 2015-02-13 01:25:10 +0000 | [diff] [blame] | 2162 | case bitc::METADATA_COMPILE_UNIT: { |
Amjad Aboud | a9bcf16 | 2015-12-10 12:56:35 +0000 | [diff] [blame] | 2163 | if (Record.size() < 14 || Record.size() > 16) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2164 | return error("Invalid record"); |
Duncan P. N. Exon Smith | c1f1acc | 2015-02-13 01:25:10 +0000 | [diff] [blame] | 2165 | |
Amjad Aboud | a9bcf16 | 2015-12-10 12:56:35 +0000 | [diff] [blame] | 2166 | // Ignore Record[0], which indicates whether this compile unit is |
Duncan P. N. Exon Smith | 55ca964 | 2015-08-03 17:26:41 +0000 | [diff] [blame] | 2167 | // distinct. It's always distinct. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2168 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | 55ca964 | 2015-08-03 17:26:41 +0000 | [diff] [blame] | 2169 | DICompileUnit::getDistinct( |
| 2170 | Context, Record[1], getMDOrNull(Record[2]), |
| 2171 | getMDString(Record[3]), Record[4], getMDString(Record[5]), |
| 2172 | Record[6], getMDString(Record[7]), Record[8], |
| 2173 | getMDOrNull(Record[9]), getMDOrNull(Record[10]), |
| 2174 | getMDOrNull(Record[11]), getMDOrNull(Record[12]), |
Amjad Aboud | a9bcf16 | 2015-12-10 12:56:35 +0000 | [diff] [blame] | 2175 | getMDOrNull(Record[13]), |
| 2176 | Record.size() <= 15 ? 0 : getMDOrNull(Record[15]), |
| 2177 | Record.size() <= 14 ? 0 : Record[14]), |
Duncan P. N. Exon Smith | c1f1acc | 2015-02-13 01:25:10 +0000 | [diff] [blame] | 2178 | NextMDValueNo++); |
| 2179 | break; |
| 2180 | } |
Duncan P. N. Exon Smith | 19fc5ed | 2015-02-13 01:26:47 +0000 | [diff] [blame] | 2181 | case bitc::METADATA_SUBPROGRAM: { |
Peter Collingbourne | d4bff30 | 2015-11-05 22:03:56 +0000 | [diff] [blame] | 2182 | if (Record.size() != 18 && Record.size() != 19) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2183 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 19fc5ed | 2015-02-13 01:26:47 +0000 | [diff] [blame] | 2184 | |
Peter Collingbourne | d4bff30 | 2015-11-05 22:03:56 +0000 | [diff] [blame] | 2185 | bool HasFn = Record.size() == 19; |
| 2186 | DISubprogram *SP = GET_OR_DISTINCT( |
| 2187 | DISubprogram, |
| 2188 | Record[0] || Record[8], // All definitions should be distinct. |
| 2189 | (Context, getMDOrNull(Record[1]), getMDString(Record[2]), |
| 2190 | getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], |
| 2191 | getMDOrNull(Record[6]), Record[7], Record[8], Record[9], |
| 2192 | getMDOrNull(Record[10]), Record[11], Record[12], Record[13], |
| 2193 | Record[14], getMDOrNull(Record[15 + HasFn]), |
| 2194 | getMDOrNull(Record[16 + HasFn]), getMDOrNull(Record[17 + HasFn]))); |
| 2195 | MDValueList.assignValue(SP, NextMDValueNo++); |
| 2196 | |
| 2197 | // Upgrade sp->function mapping to function->sp mapping. |
| 2198 | if (HasFn && Record[15]) { |
| 2199 | if (auto *CMD = dyn_cast<ConstantAsMetadata>(getMDOrNull(Record[15]))) |
| 2200 | if (auto *F = dyn_cast<Function>(CMD->getValue())) { |
| 2201 | if (F->isMaterializable()) |
| 2202 | // Defer until materialized; unmaterialized functions may not have |
| 2203 | // metadata. |
| 2204 | FunctionsWithSPs[F] = SP; |
| 2205 | else if (!F->empty()) |
| 2206 | F->setSubprogram(SP); |
| 2207 | } |
| 2208 | } |
Duncan P. N. Exon Smith | 19fc5ed | 2015-02-13 01:26:47 +0000 | [diff] [blame] | 2209 | break; |
| 2210 | } |
Duncan P. N. Exon Smith | a96d409 | 2015-02-13 01:29:28 +0000 | [diff] [blame] | 2211 | case bitc::METADATA_LEXICAL_BLOCK: { |
| 2212 | if (Record.size() != 5) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2213 | return error("Invalid record"); |
Duncan P. N. Exon Smith | a96d409 | 2015-02-13 01:29:28 +0000 | [diff] [blame] | 2214 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2215 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2216 | GET_OR_DISTINCT(DILexicalBlock, Record[0], |
Duncan P. N. Exon Smith | a96d409 | 2015-02-13 01:29:28 +0000 | [diff] [blame] | 2217 | (Context, getMDOrNull(Record[1]), |
| 2218 | getMDOrNull(Record[2]), Record[3], Record[4])), |
| 2219 | NextMDValueNo++); |
| 2220 | break; |
| 2221 | } |
Duncan P. N. Exon Smith | 06a0702 | 2015-02-13 01:30:42 +0000 | [diff] [blame] | 2222 | case bitc::METADATA_LEXICAL_BLOCK_FILE: { |
| 2223 | if (Record.size() != 4) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2224 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 06a0702 | 2015-02-13 01:30:42 +0000 | [diff] [blame] | 2225 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2226 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2227 | GET_OR_DISTINCT(DILexicalBlockFile, Record[0], |
Duncan P. N. Exon Smith | 06a0702 | 2015-02-13 01:30:42 +0000 | [diff] [blame] | 2228 | (Context, getMDOrNull(Record[1]), |
| 2229 | getMDOrNull(Record[2]), Record[3])), |
| 2230 | NextMDValueNo++); |
| 2231 | break; |
| 2232 | } |
Duncan P. N. Exon Smith | e146000 | 2015-02-13 01:32:09 +0000 | [diff] [blame] | 2233 | case bitc::METADATA_NAMESPACE: { |
| 2234 | if (Record.size() != 5) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2235 | return error("Invalid record"); |
Duncan P. N. Exon Smith | e146000 | 2015-02-13 01:32:09 +0000 | [diff] [blame] | 2236 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2237 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2238 | GET_OR_DISTINCT(DINamespace, Record[0], |
Duncan P. N. Exon Smith | e146000 | 2015-02-13 01:32:09 +0000 | [diff] [blame] | 2239 | (Context, getMDOrNull(Record[1]), |
| 2240 | getMDOrNull(Record[2]), getMDString(Record[3]), |
| 2241 | Record[4])), |
| 2242 | NextMDValueNo++); |
| 2243 | break; |
| 2244 | } |
Amjad Aboud | a9bcf16 | 2015-12-10 12:56:35 +0000 | [diff] [blame] | 2245 | case bitc::METADATA_MACRO: { |
| 2246 | if (Record.size() != 5) |
| 2247 | return error("Invalid record"); |
| 2248 | |
| 2249 | MDValueList.assignValue( |
| 2250 | GET_OR_DISTINCT(DIMacro, Record[0], |
| 2251 | (Context, Record[1], Record[2], |
| 2252 | getMDString(Record[3]), getMDString(Record[4]))), |
| 2253 | NextMDValueNo++); |
| 2254 | break; |
| 2255 | } |
| 2256 | case bitc::METADATA_MACRO_FILE: { |
| 2257 | if (Record.size() != 5) |
| 2258 | return error("Invalid record"); |
| 2259 | |
| 2260 | MDValueList.assignValue( |
| 2261 | GET_OR_DISTINCT(DIMacroFile, Record[0], |
| 2262 | (Context, Record[1], Record[2], |
| 2263 | getMDOrNull(Record[3]), getMDOrNull(Record[4]))), |
| 2264 | NextMDValueNo++); |
| 2265 | break; |
| 2266 | } |
Duncan P. N. Exon Smith | 2847f38 | 2015-02-13 01:34:32 +0000 | [diff] [blame] | 2267 | case bitc::METADATA_TEMPLATE_TYPE: { |
Duncan P. N. Exon Smith | 3d62bba | 2015-02-19 00:37:21 +0000 | [diff] [blame] | 2268 | if (Record.size() != 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2269 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 2847f38 | 2015-02-13 01:34:32 +0000 | [diff] [blame] | 2270 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2271 | MDValueList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter, |
Duncan P. N. Exon Smith | 3d62bba | 2015-02-19 00:37:21 +0000 | [diff] [blame] | 2272 | Record[0], |
| 2273 | (Context, getMDString(Record[1]), |
| 2274 | getMDOrNull(Record[2]))), |
| 2275 | NextMDValueNo++); |
Duncan P. N. Exon Smith | 2847f38 | 2015-02-13 01:34:32 +0000 | [diff] [blame] | 2276 | break; |
| 2277 | } |
| 2278 | case bitc::METADATA_TEMPLATE_VALUE: { |
Duncan P. N. Exon Smith | 3d62bba | 2015-02-19 00:37:21 +0000 | [diff] [blame] | 2279 | if (Record.size() != 5) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2280 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 2847f38 | 2015-02-13 01:34:32 +0000 | [diff] [blame] | 2281 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2282 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2283 | GET_OR_DISTINCT(DITemplateValueParameter, Record[0], |
Duncan P. N. Exon Smith | 3d62bba | 2015-02-19 00:37:21 +0000 | [diff] [blame] | 2284 | (Context, Record[1], getMDString(Record[2]), |
| 2285 | getMDOrNull(Record[3]), getMDOrNull(Record[4]))), |
Duncan P. N. Exon Smith | 2847f38 | 2015-02-13 01:34:32 +0000 | [diff] [blame] | 2286 | NextMDValueNo++); |
| 2287 | break; |
| 2288 | } |
Duncan P. N. Exon Smith | c8f810a | 2015-02-13 01:35:40 +0000 | [diff] [blame] | 2289 | case bitc::METADATA_GLOBAL_VAR: { |
| 2290 | if (Record.size() != 11) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2291 | return error("Invalid record"); |
Duncan P. N. Exon Smith | c8f810a | 2015-02-13 01:35:40 +0000 | [diff] [blame] | 2292 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2293 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2294 | GET_OR_DISTINCT(DIGlobalVariable, Record[0], |
Duncan P. N. Exon Smith | c8f810a | 2015-02-13 01:35:40 +0000 | [diff] [blame] | 2295 | (Context, getMDOrNull(Record[1]), |
| 2296 | getMDString(Record[2]), getMDString(Record[3]), |
| 2297 | getMDOrNull(Record[4]), Record[5], |
| 2298 | getMDOrNull(Record[6]), Record[7], Record[8], |
| 2299 | getMDOrNull(Record[9]), getMDOrNull(Record[10]))), |
| 2300 | NextMDValueNo++); |
| 2301 | break; |
| 2302 | } |
Duncan P. N. Exon Smith | 72fe2d0 | 2015-02-13 01:39:44 +0000 | [diff] [blame] | 2303 | case bitc::METADATA_LOCAL_VAR: { |
Duncan P. N. Exon Smith | 62e0f45 | 2015-04-15 22:29:27 +0000 | [diff] [blame] | 2304 | // 10th field is for the obseleted 'inlinedAt:' field. |
Duncan P. N. Exon Smith | ed013cd | 2015-07-31 18:58:39 +0000 | [diff] [blame] | 2305 | if (Record.size() < 8 || Record.size() > 10) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2306 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 72fe2d0 | 2015-02-13 01:39:44 +0000 | [diff] [blame] | 2307 | |
Duncan P. N. Exon Smith | ed013cd | 2015-07-31 18:58:39 +0000 | [diff] [blame] | 2308 | // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or |
| 2309 | // DW_TAG_arg_variable. |
| 2310 | bool HasTag = Record.size() > 8; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2311 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2312 | GET_OR_DISTINCT(DILocalVariable, Record[0], |
Duncan P. N. Exon Smith | ed013cd | 2015-07-31 18:58:39 +0000 | [diff] [blame] | 2313 | (Context, getMDOrNull(Record[1 + HasTag]), |
| 2314 | getMDString(Record[2 + HasTag]), |
| 2315 | getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag], |
| 2316 | getMDOrNull(Record[5 + HasTag]), Record[6 + HasTag], |
| 2317 | Record[7 + HasTag])), |
Duncan P. N. Exon Smith | 72fe2d0 | 2015-02-13 01:39:44 +0000 | [diff] [blame] | 2318 | NextMDValueNo++); |
| 2319 | break; |
| 2320 | } |
Duncan P. N. Exon Smith | 0c5c012 | 2015-02-13 01:42:09 +0000 | [diff] [blame] | 2321 | case bitc::METADATA_EXPRESSION: { |
| 2322 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2323 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 0c5c012 | 2015-02-13 01:42:09 +0000 | [diff] [blame] | 2324 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2325 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2326 | GET_OR_DISTINCT(DIExpression, Record[0], |
Duncan P. N. Exon Smith | 0c5c012 | 2015-02-13 01:42:09 +0000 | [diff] [blame] | 2327 | (Context, makeArrayRef(Record).slice(1))), |
| 2328 | NextMDValueNo++); |
| 2329 | break; |
| 2330 | } |
Duncan P. N. Exon Smith | d45ce96 | 2015-02-13 01:43:22 +0000 | [diff] [blame] | 2331 | case bitc::METADATA_OBJC_PROPERTY: { |
| 2332 | if (Record.size() != 8) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2333 | return error("Invalid record"); |
Duncan P. N. Exon Smith | d45ce96 | 2015-02-13 01:43:22 +0000 | [diff] [blame] | 2334 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2335 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2336 | GET_OR_DISTINCT(DIObjCProperty, Record[0], |
Duncan P. N. Exon Smith | d45ce96 | 2015-02-13 01:43:22 +0000 | [diff] [blame] | 2337 | (Context, getMDString(Record[1]), |
| 2338 | getMDOrNull(Record[2]), Record[3], |
| 2339 | getMDString(Record[4]), getMDString(Record[5]), |
| 2340 | Record[6], getMDOrNull(Record[7]))), |
| 2341 | NextMDValueNo++); |
| 2342 | break; |
| 2343 | } |
Duncan P. N. Exon Smith | 1c93116 | 2015-02-13 01:46:02 +0000 | [diff] [blame] | 2344 | case bitc::METADATA_IMPORTED_ENTITY: { |
| 2345 | if (Record.size() != 6) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2346 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 1c93116 | 2015-02-13 01:46:02 +0000 | [diff] [blame] | 2347 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2348 | MDValueList.assignValue( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 2349 | GET_OR_DISTINCT(DIImportedEntity, Record[0], |
Duncan P. N. Exon Smith | 1c93116 | 2015-02-13 01:46:02 +0000 | [diff] [blame] | 2350 | (Context, Record[1], getMDOrNull(Record[2]), |
| 2351 | getMDOrNull(Record[3]), Record[4], |
| 2352 | getMDString(Record[5]))), |
| 2353 | NextMDValueNo++); |
| 2354 | break; |
| 2355 | } |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 2356 | case bitc::METADATA_STRING: { |
Eli Bendersky | 5d5e18d | 2014-06-25 15:41:00 +0000 | [diff] [blame] | 2357 | std::string String(Record.begin(), Record.end()); |
| 2358 | llvm::UpgradeMDStringConstant(String); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 2359 | Metadata *MD = MDString::get(Context, String); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2360 | MDValueList.assignValue(MD, NextMDValueNo++); |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 2361 | break; |
| 2362 | } |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2363 | case bitc::METADATA_KIND: { |
Teresa Johnson | 1254507 | 2015-11-15 02:00:09 +0000 | [diff] [blame] | 2364 | // Support older bitcode files that had METADATA_KIND records in a |
| 2365 | // block with METADATA_BLOCK_ID. |
| 2366 | if (std::error_code EC = parseMetadataKindRecord(Record)) |
| 2367 | return EC; |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2368 | break; |
| 2369 | } |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 2370 | } |
| 2371 | } |
Duncan P. N. Exon Smith | 4e4aa70 | 2015-02-03 21:54:14 +0000 | [diff] [blame] | 2372 | #undef GET_OR_DISTINCT |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 2373 | } |
| 2374 | |
Teresa Johnson | 1254507 | 2015-11-15 02:00:09 +0000 | [diff] [blame] | 2375 | /// Parse the metadata kinds out of the METADATA_KIND_BLOCK. |
| 2376 | std::error_code BitcodeReader::parseMetadataKinds() { |
| 2377 | if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID)) |
| 2378 | return error("Invalid record"); |
| 2379 | |
| 2380 | SmallVector<uint64_t, 64> Record; |
| 2381 | |
| 2382 | // Read all the records. |
| 2383 | while (1) { |
| 2384 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 2385 | |
| 2386 | switch (Entry.Kind) { |
| 2387 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 2388 | case BitstreamEntry::Error: |
| 2389 | return error("Malformed block"); |
| 2390 | case BitstreamEntry::EndBlock: |
| 2391 | return std::error_code(); |
| 2392 | case BitstreamEntry::Record: |
| 2393 | // The interesting case. |
| 2394 | break; |
| 2395 | } |
| 2396 | |
| 2397 | // Read a record. |
| 2398 | Record.clear(); |
| 2399 | unsigned Code = Stream.readRecord(Entry.ID, Record); |
| 2400 | switch (Code) { |
| 2401 | default: // Default behavior: ignore. |
| 2402 | break; |
| 2403 | case bitc::METADATA_KIND: { |
| 2404 | if (std::error_code EC = parseMetadataKindRecord(Record)) |
| 2405 | return EC; |
| 2406 | break; |
| 2407 | } |
| 2408 | } |
| 2409 | } |
| 2410 | } |
| 2411 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2412 | /// Decode a signed value stored with the sign bit in the LSB for dense VBR |
| 2413 | /// encoding. |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2414 | uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 2415 | if ((V & 1) == 0) |
| 2416 | return V >> 1; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2417 | if (V != 1) |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 2418 | return -(V >> 1); |
| 2419 | // There is no such thing as -0 with integers. "-0" really means MININT. |
| 2420 | return 1ULL << 63; |
| 2421 | } |
| 2422 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2423 | /// Resolve all of the initializers for global values and aliases that we can. |
| 2424 | std::error_code BitcodeReader::resolveGlobalAndAliasInits() { |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2425 | std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; |
| 2426 | std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; |
Peter Collingbourne | 3fa50f9 | 2013-09-16 01:08:15 +0000 | [diff] [blame] | 2427 | std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist; |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 2428 | std::vector<std::pair<Function*, unsigned> > FunctionPrologueWorklist; |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 2429 | std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFnWorklist; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2430 | |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2431 | GlobalInitWorklist.swap(GlobalInits); |
| 2432 | AliasInitWorklist.swap(AliasInits); |
Peter Collingbourne | 3fa50f9 | 2013-09-16 01:08:15 +0000 | [diff] [blame] | 2433 | FunctionPrefixWorklist.swap(FunctionPrefixes); |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 2434 | FunctionPrologueWorklist.swap(FunctionPrologues); |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 2435 | FunctionPersonalityFnWorklist.swap(FunctionPersonalityFns); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2436 | |
| 2437 | while (!GlobalInitWorklist.empty()) { |
Chris Lattner | 831d420 | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 2438 | unsigned ValID = GlobalInitWorklist.back().second; |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2439 | if (ValID >= ValueList.size()) { |
| 2440 | // Not ready to resolve this yet, it requires something later in the file. |
Chris Lattner | 831d420 | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 2441 | GlobalInits.push_back(GlobalInitWorklist.back()); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2442 | } else { |
Karthik Bhat | 82540e9 | 2014-03-27 12:08:23 +0000 | [diff] [blame] | 2443 | if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2444 | GlobalInitWorklist.back().first->setInitializer(C); |
| 2445 | else |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2446 | return error("Expected a constant"); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2447 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2448 | GlobalInitWorklist.pop_back(); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2449 | } |
| 2450 | |
| 2451 | while (!AliasInitWorklist.empty()) { |
| 2452 | unsigned ValID = AliasInitWorklist.back().second; |
| 2453 | if (ValID >= ValueList.size()) { |
| 2454 | AliasInits.push_back(AliasInitWorklist.back()); |
| 2455 | } else { |
Filipe Cabecinhas | a911af0 | 2015-06-06 20:44:53 +0000 | [diff] [blame] | 2456 | Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]); |
| 2457 | if (!C) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2458 | return error("Expected a constant"); |
Filipe Cabecinhas | a911af0 | 2015-06-06 20:44:53 +0000 | [diff] [blame] | 2459 | GlobalAlias *Alias = AliasInitWorklist.back().first; |
| 2460 | if (C->getType() != Alias->getType()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2461 | return error("Alias and aliasee types don't match"); |
Filipe Cabecinhas | a911af0 | 2015-06-06 20:44:53 +0000 | [diff] [blame] | 2462 | Alias->setAliasee(C); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2463 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2464 | AliasInitWorklist.pop_back(); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2465 | } |
Peter Collingbourne | 3fa50f9 | 2013-09-16 01:08:15 +0000 | [diff] [blame] | 2466 | |
| 2467 | while (!FunctionPrefixWorklist.empty()) { |
| 2468 | unsigned ValID = FunctionPrefixWorklist.back().second; |
| 2469 | if (ValID >= ValueList.size()) { |
| 2470 | FunctionPrefixes.push_back(FunctionPrefixWorklist.back()); |
| 2471 | } else { |
Karthik Bhat | 82540e9 | 2014-03-27 12:08:23 +0000 | [diff] [blame] | 2472 | if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) |
Peter Collingbourne | 3fa50f9 | 2013-09-16 01:08:15 +0000 | [diff] [blame] | 2473 | FunctionPrefixWorklist.back().first->setPrefixData(C); |
| 2474 | else |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2475 | return error("Expected a constant"); |
Peter Collingbourne | 3fa50f9 | 2013-09-16 01:08:15 +0000 | [diff] [blame] | 2476 | } |
| 2477 | FunctionPrefixWorklist.pop_back(); |
| 2478 | } |
| 2479 | |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 2480 | while (!FunctionPrologueWorklist.empty()) { |
| 2481 | unsigned ValID = FunctionPrologueWorklist.back().second; |
| 2482 | if (ValID >= ValueList.size()) { |
| 2483 | FunctionPrologues.push_back(FunctionPrologueWorklist.back()); |
| 2484 | } else { |
| 2485 | if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) |
| 2486 | FunctionPrologueWorklist.back().first->setPrologueData(C); |
| 2487 | else |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2488 | return error("Expected a constant"); |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 2489 | } |
| 2490 | FunctionPrologueWorklist.pop_back(); |
| 2491 | } |
| 2492 | |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 2493 | while (!FunctionPersonalityFnWorklist.empty()) { |
| 2494 | unsigned ValID = FunctionPersonalityFnWorklist.back().second; |
| 2495 | if (ValID >= ValueList.size()) { |
| 2496 | FunctionPersonalityFns.push_back(FunctionPersonalityFnWorklist.back()); |
| 2497 | } else { |
| 2498 | if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) |
| 2499 | FunctionPersonalityFnWorklist.back().first->setPersonalityFn(C); |
| 2500 | else |
| 2501 | return error("Expected a constant"); |
| 2502 | } |
| 2503 | FunctionPersonalityFnWorklist.pop_back(); |
| 2504 | } |
| 2505 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 2506 | return std::error_code(); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 2507 | } |
| 2508 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2509 | static APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2510 | SmallVector<uint64_t, 8> Words(Vals.size()); |
| 2511 | std::transform(Vals.begin(), Vals.end(), Words.begin(), |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2512 | BitcodeReader::decodeSignRotatedValue); |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2513 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2514 | return APInt(TypeBits, Words); |
| 2515 | } |
| 2516 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2517 | std::error_code BitcodeReader::parseConstants() { |
Chris Lattner | 982ec1e | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 2518 | if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2519 | return error("Invalid record"); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2520 | |
| 2521 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2522 | |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2523 | // Read all the records for this value table. |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2524 | Type *CurTy = Type::getInt32Ty(Context); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2525 | unsigned NextCstNo = ValueList.size(); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2526 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2527 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 2528 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2529 | switch (Entry.Kind) { |
| 2530 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 2531 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2532 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2533 | case BitstreamEntry::EndBlock: |
| 2534 | if (NextCstNo != ValueList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2535 | return error("Invalid ronstant reference"); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 2536 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2537 | // Once all the constants have been read, go through and resolve forward |
| 2538 | // references. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2539 | ValueList.resolveConstantForwardRefs(); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 2540 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2541 | case BitstreamEntry::Record: |
| 2542 | // The interesting case. |
Chris Lattner | 7442993 | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 2543 | break; |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2544 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2545 | |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2546 | // Read a record. |
| 2547 | Record.clear(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2548 | Value *V = nullptr; |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2549 | unsigned BitCode = Stream.readRecord(Entry.ID, Record); |
Dan Gohman | 0ebd696 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 2550 | switch (BitCode) { |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2551 | default: // Default behavior: unknown constant |
| 2552 | case bitc::CST_CODE_UNDEF: // UNDEF |
Owen Anderson | b292b8c | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2553 | V = UndefValue::get(CurTy); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2554 | break; |
| 2555 | case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] |
| 2556 | if (Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2557 | return error("Invalid record"); |
Karthik Bhat | 82540e9 | 2014-03-27 12:08:23 +0000 | [diff] [blame] | 2558 | if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2559 | return error("Invalid record"); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2560 | CurTy = TypeList[Record[0]]; |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 2561 | continue; // Skip the ValueList manipulation. |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2562 | case bitc::CST_CODE_NULL: // NULL |
Owen Anderson | 5a1acd9 | 2009-07-31 20:28:14 +0000 | [diff] [blame] | 2563 | V = Constant::getNullValue(CurTy); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2564 | break; |
| 2565 | case bitc::CST_CODE_INTEGER: // INTEGER: [intval] |
Duncan Sands | 19d0b47 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 2566 | if (!CurTy->isIntegerTy() || Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2567 | return error("Invalid record"); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2568 | V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 2569 | break; |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2570 | case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] |
Duncan Sands | 19d0b47 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 2571 | if (!CurTy->isIntegerTy() || Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2572 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2573 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2574 | APInt VInt = |
| 2575 | readWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth()); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2576 | V = ConstantInt::get(Context, VInt); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2577 | |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 2578 | break; |
| 2579 | } |
Dale Johannesen | 245dceb | 2007-09-11 18:32:33 +0000 | [diff] [blame] | 2580 | case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] |
Chris Lattner | 08feb1e | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 2581 | if (Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2582 | return error("Invalid record"); |
Dan Gohman | 518cda4 | 2011-12-17 00:04:22 +0000 | [diff] [blame] | 2583 | if (CurTy->isHalfTy()) |
Tim Northover | 29178a3 | 2013-01-22 09:46:31 +0000 | [diff] [blame] | 2584 | V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, |
| 2585 | APInt(16, (uint16_t)Record[0]))); |
Dan Gohman | 518cda4 | 2011-12-17 00:04:22 +0000 | [diff] [blame] | 2586 | else if (CurTy->isFloatTy()) |
Tim Northover | 29178a3 | 2013-01-22 09:46:31 +0000 | [diff] [blame] | 2587 | V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, |
| 2588 | APInt(32, (uint32_t)Record[0]))); |
Chris Lattner | fdd8790 | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2589 | else if (CurTy->isDoubleTy()) |
Tim Northover | 29178a3 | 2013-01-22 09:46:31 +0000 | [diff] [blame] | 2590 | V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, |
| 2591 | APInt(64, Record[0]))); |
Chris Lattner | fdd8790 | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2592 | else if (CurTy->isX86_FP80Ty()) { |
Dale Johannesen | 93eefa0 | 2009-03-23 21:16:53 +0000 | [diff] [blame] | 2593 | // Bits are not stored the same way as a normal i80 APInt, compensate. |
| 2594 | uint64_t Rearrange[2]; |
| 2595 | Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); |
| 2596 | Rearrange[1] = Record[0] >> 48; |
Tim Northover | 29178a3 | 2013-01-22 09:46:31 +0000 | [diff] [blame] | 2597 | V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, |
| 2598 | APInt(80, Rearrange))); |
Chris Lattner | fdd8790 | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2599 | } else if (CurTy->isFP128Ty()) |
Tim Northover | 29178a3 | 2013-01-22 09:46:31 +0000 | [diff] [blame] | 2600 | V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, |
| 2601 | APInt(128, Record))); |
Chris Lattner | fdd8790 | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2602 | else if (CurTy->isPPC_FP128Ty()) |
Tim Northover | 29178a3 | 2013-01-22 09:46:31 +0000 | [diff] [blame] | 2603 | V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, |
| 2604 | APInt(128, Record))); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2605 | else |
Owen Anderson | b292b8c | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2606 | V = UndefValue::get(CurTy); |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2607 | break; |
Dale Johannesen | 245dceb | 2007-09-11 18:32:33 +0000 | [diff] [blame] | 2608 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2609 | |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2610 | case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] |
| 2611 | if (Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2612 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2613 | |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2614 | unsigned Size = Record.size(); |
Chris Lattner | cc3aaf1 | 2012-01-27 03:15:49 +0000 | [diff] [blame] | 2615 | SmallVector<Constant*, 16> Elts; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2616 | |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2617 | if (StructType *STy = dyn_cast<StructType>(CurTy)) { |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2618 | for (unsigned i = 0; i != Size; ++i) |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2619 | Elts.push_back(ValueList.getConstantFwdRef(Record[i], |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2620 | STy->getElementType(i))); |
Owen Anderson | 45308b5 | 2009-07-27 22:29:26 +0000 | [diff] [blame] | 2621 | V = ConstantStruct::get(STy, Elts); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2622 | } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { |
| 2623 | Type *EltTy = ATy->getElementType(); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2624 | for (unsigned i = 0; i != Size; ++i) |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2625 | Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); |
Owen Anderson | c2c7932 | 2009-07-28 18:32:17 +0000 | [diff] [blame] | 2626 | V = ConstantArray::get(ATy, Elts); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2627 | } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { |
| 2628 | Type *EltTy = VTy->getElementType(); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2629 | for (unsigned i = 0; i != Size; ++i) |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2630 | Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); |
Owen Anderson | 4aa3295 | 2009-07-28 21:19:26 +0000 | [diff] [blame] | 2631 | V = ConstantVector::get(Elts); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2632 | } else { |
Owen Anderson | b292b8c | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2633 | V = UndefValue::get(CurTy); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2634 | } |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2635 | break; |
| 2636 | } |
Chris Lattner | bb8278a | 2012-02-05 02:41:35 +0000 | [diff] [blame] | 2637 | case bitc::CST_CODE_STRING: // STRING: [values] |
Chris Lattner | f25f710 | 2007-05-06 00:53:07 +0000 | [diff] [blame] | 2638 | case bitc::CST_CODE_CSTRING: { // CSTRING: [values] |
| 2639 | if (Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2640 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2641 | |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2642 | SmallString<16> Elts(Record.begin(), Record.end()); |
Chris Lattner | bb8278a | 2012-02-05 02:41:35 +0000 | [diff] [blame] | 2643 | V = ConstantDataArray::getString(Context, Elts, |
| 2644 | BitCode == bitc::CST_CODE_CSTRING); |
Chris Lattner | f25f710 | 2007-05-06 00:53:07 +0000 | [diff] [blame] | 2645 | break; |
| 2646 | } |
Chris Lattner | 372dd1e | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 2647 | case bitc::CST_CODE_DATA: {// DATA: [n x value] |
| 2648 | if (Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2649 | return error("Invalid record"); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2650 | |
Chris Lattner | 372dd1e | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 2651 | Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); |
| 2652 | unsigned Size = Record.size(); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2653 | |
Chris Lattner | 372dd1e | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 2654 | if (EltTy->isIntegerTy(8)) { |
| 2655 | SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end()); |
| 2656 | if (isa<VectorType>(CurTy)) |
| 2657 | V = ConstantDataVector::get(Context, Elts); |
| 2658 | else |
| 2659 | V = ConstantDataArray::get(Context, Elts); |
| 2660 | } else if (EltTy->isIntegerTy(16)) { |
| 2661 | SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end()); |
| 2662 | if (isa<VectorType>(CurTy)) |
| 2663 | V = ConstantDataVector::get(Context, Elts); |
| 2664 | else |
| 2665 | V = ConstantDataArray::get(Context, Elts); |
| 2666 | } else if (EltTy->isIntegerTy(32)) { |
| 2667 | SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end()); |
| 2668 | if (isa<VectorType>(CurTy)) |
| 2669 | V = ConstantDataVector::get(Context, Elts); |
| 2670 | else |
| 2671 | V = ConstantDataArray::get(Context, Elts); |
| 2672 | } else if (EltTy->isIntegerTy(64)) { |
| 2673 | SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end()); |
| 2674 | if (isa<VectorType>(CurTy)) |
| 2675 | V = ConstantDataVector::get(Context, Elts); |
| 2676 | else |
| 2677 | V = ConstantDataArray::get(Context, Elts); |
| 2678 | } else if (EltTy->isFloatTy()) { |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2679 | SmallVector<float, 16> Elts(Size); |
| 2680 | std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat); |
Chris Lattner | 372dd1e | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 2681 | if (isa<VectorType>(CurTy)) |
| 2682 | V = ConstantDataVector::get(Context, Elts); |
| 2683 | else |
| 2684 | V = ConstantDataArray::get(Context, Elts); |
| 2685 | } else if (EltTy->isDoubleTy()) { |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2686 | SmallVector<double, 16> Elts(Size); |
| 2687 | std::transform(Record.begin(), Record.end(), Elts.begin(), |
| 2688 | BitsToDouble); |
Chris Lattner | 372dd1e | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 2689 | if (isa<VectorType>(CurTy)) |
| 2690 | V = ConstantDataVector::get(Context, Elts); |
| 2691 | else |
| 2692 | V = ConstantDataArray::get(Context, Elts); |
| 2693 | } else { |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2694 | return error("Invalid type for value"); |
Chris Lattner | 372dd1e | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 2695 | } |
| 2696 | break; |
| 2697 | } |
| 2698 | |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2699 | case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2700 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2701 | return error("Invalid record"); |
| 2702 | int Opc = getDecodedBinaryOpcode(Record[0], CurTy); |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2703 | if (Opc < 0) { |
Owen Anderson | b292b8c | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2704 | V = UndefValue::get(CurTy); // Unknown binop. |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2705 | } else { |
| 2706 | Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); |
| 2707 | Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2708 | unsigned Flags = 0; |
| 2709 | if (Record.size() >= 4) { |
| 2710 | if (Opc == Instruction::Add || |
| 2711 | Opc == Instruction::Sub || |
Chris Lattner | a676c0f | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 2712 | Opc == Instruction::Mul || |
| 2713 | Opc == Instruction::Shl) { |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2714 | if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) |
| 2715 | Flags |= OverflowingBinaryOperator::NoSignedWrap; |
| 2716 | if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) |
| 2717 | Flags |= OverflowingBinaryOperator::NoUnsignedWrap; |
Chris Lattner | 35315d0 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 2718 | } else if (Opc == Instruction::SDiv || |
Chris Lattner | a676c0f | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 2719 | Opc == Instruction::UDiv || |
| 2720 | Opc == Instruction::LShr || |
| 2721 | Opc == Instruction::AShr) { |
Chris Lattner | 35315d0 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 2722 | if (Record[3] & (1 << bitc::PEO_EXACT)) |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2723 | Flags |= SDivOperator::IsExact; |
| 2724 | } |
| 2725 | } |
| 2726 | V = ConstantExpr::get(Opc, LHS, RHS, Flags); |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2727 | } |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2728 | break; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2729 | } |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2730 | case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2731 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2732 | return error("Invalid record"); |
| 2733 | int Opc = getDecodedCastOpcode(Record[0]); |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2734 | if (Opc < 0) { |
Owen Anderson | b292b8c | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2735 | V = UndefValue::get(CurTy); // Unknown cast. |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2736 | } else { |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2737 | Type *OpTy = getTypeByID(Record[1]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2738 | if (!OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2739 | return error("Invalid record"); |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2740 | Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); |
Matt Arsenault | b03bd4d | 2013-11-15 01:34:59 +0000 | [diff] [blame] | 2741 | V = UpgradeBitCastExpr(Opc, Op, CurTy); |
| 2742 | if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2743 | } |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2744 | break; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2745 | } |
Dan Gohman | 1639c39 | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 2746 | case bitc::CST_CODE_CE_INBOUNDS_GEP: |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2747 | case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] |
David Blaikie | b926357 | 2015-03-13 21:03:36 +0000 | [diff] [blame] | 2748 | unsigned OpNum = 0; |
| 2749 | Type *PointeeType = nullptr; |
| 2750 | if (Record.size() % 2) |
| 2751 | PointeeType = getTypeByID(Record[OpNum++]); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2752 | SmallVector<Constant*, 16> Elts; |
David Blaikie | b926357 | 2015-03-13 21:03:36 +0000 | [diff] [blame] | 2753 | while (OpNum != Record.size()) { |
| 2754 | Type *ElTy = getTypeByID(Record[OpNum++]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2755 | if (!ElTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2756 | return error("Invalid record"); |
David Blaikie | b926357 | 2015-03-13 21:03:36 +0000 | [diff] [blame] | 2757 | Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy)); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2758 | } |
David Blaikie | b926357 | 2015-03-13 21:03:36 +0000 | [diff] [blame] | 2759 | |
David Blaikie | b926357 | 2015-03-13 21:03:36 +0000 | [diff] [blame] | 2760 | if (PointeeType && |
David Blaikie | 4a2e73b | 2015-04-02 18:55:32 +0000 | [diff] [blame] | 2761 | PointeeType != |
| 2762 | cast<SequentialType>(Elts[0]->getType()->getScalarType()) |
| 2763 | ->getElementType()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2764 | return error("Explicit gep operator type does not match pointee type " |
David Blaikie | 12cf5d70 | 2015-03-16 22:03:50 +0000 | [diff] [blame] | 2765 | "of pointer operand"); |
David Blaikie | 4a2e73b | 2015-04-02 18:55:32 +0000 | [diff] [blame] | 2766 | |
| 2767 | ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); |
| 2768 | V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices, |
| 2769 | BitCode == |
| 2770 | bitc::CST_CODE_CE_INBOUNDS_GEP); |
Chris Lattner | 890683d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 2771 | break; |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2772 | } |
Joe Abbey | 1a6e770 | 2013-09-12 22:02:31 +0000 | [diff] [blame] | 2773 | case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2774 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2775 | return error("Invalid record"); |
Joe Abbey | 1a6e770 | 2013-09-12 22:02:31 +0000 | [diff] [blame] | 2776 | |
| 2777 | Type *SelectorTy = Type::getInt1Ty(Context); |
| 2778 | |
Filipe Cabecinhas | 984fefd | 2015-08-31 18:00:30 +0000 | [diff] [blame] | 2779 | // The selector might be an i1 or an <n x i1> |
| 2780 | // Get the type from the ValueList before getting a forward ref. |
Joe Abbey | 1a6e770 | 2013-09-12 22:02:31 +0000 | [diff] [blame] | 2781 | if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) |
Filipe Cabecinhas | 984fefd | 2015-08-31 18:00:30 +0000 | [diff] [blame] | 2782 | if (Value *V = ValueList[Record[0]]) |
| 2783 | if (SelectorTy != V->getType()) |
| 2784 | SelectorTy = VectorType::get(SelectorTy, VTy->getNumElements()); |
Joe Abbey | 1a6e770 | 2013-09-12 22:02:31 +0000 | [diff] [blame] | 2785 | |
| 2786 | V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], |
| 2787 | SelectorTy), |
| 2788 | ValueList.getConstantFwdRef(Record[1],CurTy), |
| 2789 | ValueList.getConstantFwdRef(Record[2],CurTy)); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2790 | break; |
Joe Abbey | 1a6e770 | 2013-09-12 22:02:31 +0000 | [diff] [blame] | 2791 | } |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 2792 | case bitc::CST_CODE_CE_EXTRACTELT |
| 2793 | : { // CE_EXTRACTELT: [opty, opval, opty, opval] |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2794 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2795 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2796 | VectorType *OpTy = |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2797 | dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2798 | if (!OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2799 | return error("Invalid record"); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2800 | Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 2801 | Constant *Op1 = nullptr; |
| 2802 | if (Record.size() == 4) { |
| 2803 | Type *IdxTy = getTypeByID(Record[2]); |
| 2804 | if (!IdxTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2805 | return error("Invalid record"); |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 2806 | Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy); |
| 2807 | } else // TODO: Remove with llvm 4.0 |
| 2808 | Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); |
| 2809 | if (!Op1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2810 | return error("Invalid record"); |
Owen Anderson | 487375e | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2811 | V = ConstantExpr::getExtractElement(Op0, Op1); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2812 | break; |
| 2813 | } |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 2814 | case bitc::CST_CODE_CE_INSERTELT |
| 2815 | : { // CE_INSERTELT: [opval, opval, opty, opval] |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2816 | VectorType *OpTy = dyn_cast<VectorType>(CurTy); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2817 | if (Record.size() < 3 || !OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2818 | return error("Invalid record"); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2819 | Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); |
| 2820 | Constant *Op1 = ValueList.getConstantFwdRef(Record[1], |
| 2821 | OpTy->getElementType()); |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 2822 | Constant *Op2 = nullptr; |
| 2823 | if (Record.size() == 4) { |
| 2824 | Type *IdxTy = getTypeByID(Record[2]); |
| 2825 | if (!IdxTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2826 | return error("Invalid record"); |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 2827 | Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy); |
| 2828 | } else // TODO: Remove with llvm 4.0 |
| 2829 | Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); |
| 2830 | if (!Op2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2831 | return error("Invalid record"); |
Owen Anderson | 487375e | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2832 | V = ConstantExpr::getInsertElement(Op0, Op1, Op2); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2833 | break; |
| 2834 | } |
| 2835 | case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2836 | VectorType *OpTy = dyn_cast<VectorType>(CurTy); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2837 | if (Record.size() < 3 || !OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2838 | return error("Invalid record"); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2839 | Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); |
| 2840 | Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2841 | Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), |
Owen Anderson | e9f9804 | 2009-07-07 20:18:58 +0000 | [diff] [blame] | 2842 | OpTy->getNumElements()); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2843 | Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); |
Owen Anderson | 487375e | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2844 | V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2845 | break; |
| 2846 | } |
Nate Begeman | 94aa38d | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 2847 | case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2848 | VectorType *RTy = dyn_cast<VectorType>(CurTy); |
| 2849 | VectorType *OpTy = |
Duncan Sands | 89d412a | 2010-10-28 15:47:26 +0000 | [diff] [blame] | 2850 | dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2851 | if (Record.size() < 4 || !RTy || !OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2852 | return error("Invalid record"); |
Nate Begeman | 94aa38d | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 2853 | Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); |
| 2854 | Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2855 | Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), |
Owen Anderson | e9f9804 | 2009-07-07 20:18:58 +0000 | [diff] [blame] | 2856 | RTy->getNumElements()); |
Nate Begeman | 94aa38d | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 2857 | Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); |
Owen Anderson | 487375e | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2858 | V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); |
Nate Begeman | 94aa38d | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 2859 | break; |
| 2860 | } |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2861 | case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2862 | if (Record.size() < 4) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2863 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2864 | Type *OpTy = getTypeByID(Record[0]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2865 | if (!OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2866 | return error("Invalid record"); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2867 | Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); |
| 2868 | Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); |
| 2869 | |
Duncan Sands | 9dff9be | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 2870 | if (OpTy->isFPOrFPVectorTy()) |
Owen Anderson | 487375e | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2871 | V = ConstantExpr::getFCmp(Record[3], Op0, Op1); |
Nate Begeman | d219570 | 2008-05-12 19:01:56 +0000 | [diff] [blame] | 2872 | else |
Owen Anderson | 487375e | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2873 | V = ConstantExpr::getICmp(Record[3], Op0, Op1); |
Chris Lattner | 1e16bcf7 | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 2874 | break; |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2875 | } |
Chad Rosier | d8c7610 | 2012-09-05 19:00:49 +0000 | [diff] [blame] | 2876 | // This maintains backward compatibility, pre-asm dialect keywords. |
Chad Rosier | 5895eda | 2012-09-05 06:28:52 +0000 | [diff] [blame] | 2877 | // FIXME: Remove with the 4.0 release. |
Chad Rosier | 18fcdcf | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 2878 | case bitc::CST_CODE_INLINEASM_OLD: { |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2879 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2880 | return error("Invalid record"); |
Chris Lattner | af8fffc | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 2881 | std::string AsmStr, ConstrStr; |
Dale Johannesen | fd04c74 | 2009-10-13 20:46:56 +0000 | [diff] [blame] | 2882 | bool HasSideEffects = Record[0] & 1; |
Dale Johannesen | 1cfb958 | 2009-10-21 23:28:00 +0000 | [diff] [blame] | 2883 | bool IsAlignStack = Record[0] >> 1; |
Chris Lattner | af8fffc | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 2884 | unsigned AsmStrSize = Record[1]; |
| 2885 | if (2+AsmStrSize >= Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2886 | return error("Invalid record"); |
Chris Lattner | af8fffc | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 2887 | unsigned ConstStrSize = Record[2+AsmStrSize]; |
| 2888 | if (3+AsmStrSize+ConstStrSize > Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2889 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2890 | |
Chris Lattner | af8fffc | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 2891 | for (unsigned i = 0; i != AsmStrSize; ++i) |
| 2892 | AsmStr += (char)Record[2+i]; |
| 2893 | for (unsigned i = 0; i != ConstStrSize; ++i) |
| 2894 | ConstrStr += (char)Record[3+AsmStrSize+i]; |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2895 | PointerType *PTy = cast<PointerType>(CurTy); |
Chris Lattner | af8fffc | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 2896 | V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), |
Dale Johannesen | 1cfb958 | 2009-10-21 23:28:00 +0000 | [diff] [blame] | 2897 | AsmStr, ConstrStr, HasSideEffects, IsAlignStack); |
Chris Lattner | af8fffc | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 2898 | break; |
| 2899 | } |
Chad Rosier | d8c7610 | 2012-09-05 19:00:49 +0000 | [diff] [blame] | 2900 | // This version adds support for the asm dialect keywords (e.g., |
| 2901 | // inteldialect). |
Chad Rosier | 18fcdcf | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 2902 | case bitc::CST_CODE_INLINEASM: { |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2903 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2904 | return error("Invalid record"); |
Chad Rosier | 18fcdcf | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 2905 | std::string AsmStr, ConstrStr; |
| 2906 | bool HasSideEffects = Record[0] & 1; |
| 2907 | bool IsAlignStack = (Record[0] >> 1) & 1; |
| 2908 | unsigned AsmDialect = Record[0] >> 2; |
| 2909 | unsigned AsmStrSize = Record[1]; |
| 2910 | if (2+AsmStrSize >= Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2911 | return error("Invalid record"); |
Chad Rosier | 18fcdcf | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 2912 | unsigned ConstStrSize = Record[2+AsmStrSize]; |
| 2913 | if (3+AsmStrSize+ConstStrSize > Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2914 | return error("Invalid record"); |
Chad Rosier | 18fcdcf | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 2915 | |
| 2916 | for (unsigned i = 0; i != AsmStrSize; ++i) |
| 2917 | AsmStr += (char)Record[2+i]; |
| 2918 | for (unsigned i = 0; i != ConstStrSize; ++i) |
| 2919 | ConstrStr += (char)Record[3+AsmStrSize+i]; |
| 2920 | PointerType *PTy = cast<PointerType>(CurTy); |
| 2921 | V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), |
| 2922 | AsmStr, ConstrStr, HasSideEffects, IsAlignStack, |
Chad Rosier | d8c7610 | 2012-09-05 19:00:49 +0000 | [diff] [blame] | 2923 | InlineAsm::AsmDialect(AsmDialect)); |
Chad Rosier | 18fcdcf | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 2924 | break; |
| 2925 | } |
Chris Lattner | 5956dc8 | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2926 | case bitc::CST_CODE_BLOCKADDRESS:{ |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 2927 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2928 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2929 | Type *FnTy = getTypeByID(Record[0]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2930 | if (!FnTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2931 | return error("Invalid record"); |
Chris Lattner | 5956dc8 | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2932 | Function *Fn = |
| 2933 | dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 2934 | if (!Fn) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2935 | return error("Invalid record"); |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2936 | |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 2937 | // Don't let Fn get dematerialized. |
| 2938 | BlockAddressesTaken.insert(Fn); |
| 2939 | |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2940 | // If the function is already parsed we can insert the block address right |
| 2941 | // away. |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 2942 | BasicBlock *BB; |
| 2943 | unsigned BBID = Record[2]; |
| 2944 | if (!BBID) |
| 2945 | // Invalid reference to entry block. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2946 | return error("Invalid ID"); |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2947 | if (!Fn->empty()) { |
| 2948 | Function::iterator BBI = Fn->begin(), BBE = Fn->end(); |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 2949 | for (size_t I = 0, E = BBID; I != E; ++I) { |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2950 | if (BBI == BBE) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2951 | return error("Invalid ID"); |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2952 | ++BBI; |
| 2953 | } |
Duncan P. N. Exon Smith | fb1743a3 | 2015-10-13 16:48:55 +0000 | [diff] [blame] | 2954 | BB = &*BBI; |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2955 | } else { |
| 2956 | // Otherwise insert a placeholder and remember it so it can be inserted |
| 2957 | // when the function is parsed. |
Duncan P. N. Exon Smith | 5a511b5 | 2014-08-05 17:49:48 +0000 | [diff] [blame] | 2958 | auto &FwdBBs = BasicBlockFwdRefs[Fn]; |
| 2959 | if (FwdBBs.empty()) |
| 2960 | BasicBlockFwdRefQueue.push_back(Fn); |
Duncan P. N. Exon Smith | 5a5fd7b | 2014-08-16 01:54:37 +0000 | [diff] [blame] | 2961 | if (FwdBBs.size() < BBID + 1) |
| 2962 | FwdBBs.resize(BBID + 1); |
| 2963 | if (!FwdBBs[BBID]) |
| 2964 | FwdBBs[BBID] = BasicBlock::Create(Context); |
| 2965 | BB = FwdBBs[BBID]; |
Benjamin Kramer | 736a4fc | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 2966 | } |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 2967 | V = BlockAddress::get(Fn, BB); |
Chris Lattner | 5956dc8 | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2968 | break; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2969 | } |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2970 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2971 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 2972 | ValueList.assignValue(V, NextCstNo); |
Chris Lattner | 1663cca | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 2973 | ++NextCstNo; |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 2974 | } |
| 2975 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 2976 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2977 | std::error_code BitcodeReader::parseUseLists() { |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 2978 | if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2979 | return error("Invalid record"); |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 2980 | |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 2981 | // Read all the records. |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 2982 | SmallVector<uint64_t, 64> Record; |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 2983 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2984 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 2985 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2986 | switch (Entry.Kind) { |
| 2987 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 2988 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 2989 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2990 | case BitstreamEntry::EndBlock: |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 2991 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 2992 | case BitstreamEntry::Record: |
| 2993 | // The interesting case. |
| 2994 | break; |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 2995 | } |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2996 | |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 2997 | // Read a use list record. |
| 2998 | Record.clear(); |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 2999 | bool IsBB = false; |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3000 | switch (Stream.readRecord(Entry.ID, Record)) { |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 3001 | default: // Default behavior: unknown type. |
| 3002 | break; |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3003 | case bitc::USELIST_CODE_BB: |
| 3004 | IsBB = true; |
| 3005 | // fallthrough |
| 3006 | case bitc::USELIST_CODE_DEFAULT: { |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 3007 | unsigned RecordLength = Record.size(); |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3008 | if (RecordLength < 3) |
| 3009 | // Records should have at least an ID and two indexes. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3010 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3011 | unsigned ID = Record.back(); |
| 3012 | Record.pop_back(); |
| 3013 | |
| 3014 | Value *V; |
| 3015 | if (IsBB) { |
| 3016 | assert(ID < FunctionBBs.size() && "Basic block not found"); |
| 3017 | V = FunctionBBs[ID]; |
| 3018 | } else |
| 3019 | V = ValueList[ID]; |
| 3020 | unsigned NumUses = 0; |
| 3021 | SmallDenseMap<const Use *, unsigned, 16> Order; |
| 3022 | for (const Use &U : V->uses()) { |
Duncan P. N. Exon Smith | 1318364 | 2014-08-16 01:54:34 +0000 | [diff] [blame] | 3023 | if (++NumUses > Record.size()) |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3024 | break; |
Duncan P. N. Exon Smith | 1318364 | 2014-08-16 01:54:34 +0000 | [diff] [blame] | 3025 | Order[&U] = Record[NumUses - 1]; |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3026 | } |
| 3027 | if (Order.size() != Record.size() || NumUses > Record.size()) |
| 3028 | // Mismatches can happen if the functions are being materialized lazily |
| 3029 | // (out-of-order), or a value has been upgraded. |
| 3030 | break; |
| 3031 | |
| 3032 | V->sortUseList([&](const Use &L, const Use &R) { |
| 3033 | return Order.lookup(&L) < Order.lookup(&R); |
| 3034 | }); |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 3035 | break; |
| 3036 | } |
| 3037 | } |
| 3038 | } |
| 3039 | } |
| 3040 | |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 3041 | /// When we see the block for metadata, remember where it is and then skip it. |
| 3042 | /// This lets us lazily deserialize the metadata. |
| 3043 | std::error_code BitcodeReader::rememberAndSkipMetadata() { |
| 3044 | // Save the current stream state. |
| 3045 | uint64_t CurBit = Stream.GetCurrentBitNo(); |
| 3046 | DeferredMetadataInfo.push_back(CurBit); |
| 3047 | |
| 3048 | // Skip over the block for now. |
| 3049 | if (Stream.SkipBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3050 | return error("Invalid record"); |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 3051 | return std::error_code(); |
| 3052 | } |
| 3053 | |
| 3054 | std::error_code BitcodeReader::materializeMetadata() { |
| 3055 | for (uint64_t BitPos : DeferredMetadataInfo) { |
| 3056 | // Move the bit stream to the saved position. |
| 3057 | Stream.JumpToBit(BitPos); |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 3058 | if (std::error_code EC = parseMetadata(true)) |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 3059 | return EC; |
| 3060 | } |
| 3061 | DeferredMetadataInfo.clear(); |
| 3062 | return std::error_code(); |
| 3063 | } |
| 3064 | |
Rafael Espindola | 468b868 | 2015-04-01 14:44:59 +0000 | [diff] [blame] | 3065 | void BitcodeReader::setStripDebugInfo() { StripDebugInfo = true; } |
Rafael Espindola | 0d68b4c | 2015-03-30 21:36:43 +0000 | [diff] [blame] | 3066 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3067 | /// When we see the block for a function body, remember where it is and then |
| 3068 | /// skip it. This lets us lazily deserialize the functions. |
| 3069 | std::error_code BitcodeReader::rememberAndSkipFunctionBody() { |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3070 | // Get the function we are talking about. |
| 3071 | if (FunctionsWithBodies.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3072 | return error("Insufficient function protos"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3073 | |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3074 | Function *Fn = FunctionsWithBodies.back(); |
| 3075 | FunctionsWithBodies.pop_back(); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3076 | |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3077 | // Save the current stream state. |
| 3078 | uint64_t CurBit = Stream.GetCurrentBitNo(); |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3079 | assert( |
| 3080 | (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) && |
| 3081 | "Mismatch between VST and scanned function offsets"); |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 3082 | DeferredFunctionInfo[Fn] = CurBit; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3083 | |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3084 | // Skip over the function block for now. |
| 3085 | if (Stream.SkipBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3086 | return error("Invalid record"); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 3087 | return std::error_code(); |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3088 | } |
| 3089 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3090 | std::error_code BitcodeReader::globalCleanup() { |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3091 | // Patch the initializers for globals and aliases up. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3092 | resolveGlobalAndAliasInits(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3093 | if (!GlobalInits.empty() || !AliasInits.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3094 | return error("Malformed global initializer set"); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3095 | |
| 3096 | // Look for intrinsic functions which need to be upgraded at some point |
Yaron Keren | ef5e7ad | 2015-06-12 18:13:20 +0000 | [diff] [blame] | 3097 | for (Function &F : *TheModule) { |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3098 | Function *NewFn; |
Yaron Keren | ef5e7ad | 2015-06-12 18:13:20 +0000 | [diff] [blame] | 3099 | if (UpgradeIntrinsicFunction(&F, NewFn)) |
Rafael Espindola | 4e72121 | 2015-07-02 16:22:40 +0000 | [diff] [blame] | 3100 | UpgradedIntrinsics[&F] = NewFn; |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3101 | } |
| 3102 | |
| 3103 | // Look for global variables which need to be renamed. |
Yaron Keren | ef5e7ad | 2015-06-12 18:13:20 +0000 | [diff] [blame] | 3104 | for (GlobalVariable &GV : TheModule->globals()) |
| 3105 | UpgradeGlobalVariable(&GV); |
Reid Kleckner | fceb76f | 2014-05-16 20:39:27 +0000 | [diff] [blame] | 3106 | |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3107 | // Force deallocation of memory for these vectors to favor the client that |
| 3108 | // want lazy deserialization. |
| 3109 | std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); |
| 3110 | std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 3111 | return std::error_code(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3112 | } |
| 3113 | |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3114 | /// Support for lazy parsing of function bodies. This is required if we |
| 3115 | /// either have an old bitcode file without a VST forward declaration record, |
| 3116 | /// or if we have an anonymous function being materialized, since anonymous |
| 3117 | /// functions do not have a name and are therefore not in the VST. |
| 3118 | std::error_code BitcodeReader::rememberAndSkipFunctionBodies() { |
| 3119 | Stream.JumpToBit(NextUnreadBit); |
| 3120 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 3121 | if (Stream.AtEndOfStream()) |
| 3122 | return error("Could not find function in stream"); |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3123 | |
Filipe Cabecinhas | 7aae2f2 | 2015-11-03 13:48:26 +0000 | [diff] [blame] | 3124 | if (!SeenFirstFunctionBody) |
| 3125 | return error("Trying to materialize functions before seeing function blocks"); |
| 3126 | |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3127 | // An old bitcode file with the symbol table at the end would have |
| 3128 | // finished the parse greedily. |
| 3129 | assert(SeenValueSymbolTable); |
| 3130 | |
| 3131 | SmallVector<uint64_t, 64> Record; |
| 3132 | |
| 3133 | while (1) { |
| 3134 | BitstreamEntry Entry = Stream.advance(); |
| 3135 | switch (Entry.Kind) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 3136 | default: |
| 3137 | return error("Expect SubBlock"); |
| 3138 | case BitstreamEntry::SubBlock: |
| 3139 | switch (Entry.ID) { |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3140 | default: |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 3141 | return error("Expect function block"); |
| 3142 | case bitc::FUNCTION_BLOCK_ID: |
| 3143 | if (std::error_code EC = rememberAndSkipFunctionBody()) |
| 3144 | return EC; |
| 3145 | NextUnreadBit = Stream.GetCurrentBitNo(); |
| 3146 | return std::error_code(); |
| 3147 | } |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3148 | } |
| 3149 | } |
| 3150 | } |
| 3151 | |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 3152 | std::error_code BitcodeReader::parseBitcodeVersion() { |
| 3153 | if (Stream.EnterSubBlock(bitc::IDENTIFICATION_BLOCK_ID)) |
| 3154 | return error("Invalid record"); |
| 3155 | |
| 3156 | // Read all the records. |
| 3157 | SmallVector<uint64_t, 64> Record; |
| 3158 | while (1) { |
| 3159 | BitstreamEntry Entry = Stream.advance(); |
| 3160 | |
| 3161 | switch (Entry.Kind) { |
| 3162 | default: |
| 3163 | case BitstreamEntry::Error: |
| 3164 | return error("Malformed block"); |
| 3165 | case BitstreamEntry::EndBlock: |
| 3166 | return std::error_code(); |
| 3167 | case BitstreamEntry::Record: |
| 3168 | // The interesting case. |
| 3169 | break; |
| 3170 | } |
| 3171 | |
| 3172 | // Read a record. |
| 3173 | Record.clear(); |
| 3174 | unsigned BitCode = Stream.readRecord(Entry.ID, Record); |
| 3175 | switch (BitCode) { |
| 3176 | default: // Default behavior: reject |
| 3177 | return error("Invalid value"); |
| 3178 | case bitc::IDENTIFICATION_CODE_STRING: { // IDENTIFICATION: [strchr x |
| 3179 | // N] |
| 3180 | convertToString(Record, 0, ProducerIdentification); |
| 3181 | break; |
| 3182 | } |
| 3183 | case bitc::IDENTIFICATION_CODE_EPOCH: { // EPOCH: [epoch#] |
| 3184 | unsigned epoch = (unsigned)Record[0]; |
| 3185 | if (epoch != bitc::BITCODE_CURRENT_EPOCH) { |
Oleksiy Vyalov | 6c2403f | 2015-10-26 22:37:36 +0000 | [diff] [blame] | 3186 | return error( |
| 3187 | Twine("Incompatible epoch: Bitcode '") + Twine(epoch) + |
| 3188 | "' vs current: '" + Twine(bitc::BITCODE_CURRENT_EPOCH) + "'"); |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 3189 | } |
| 3190 | } |
| 3191 | } |
| 3192 | } |
| 3193 | } |
| 3194 | |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3195 | std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 3196 | bool ShouldLazyLoadMetadata) { |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3197 | if (ResumeBit) |
| 3198 | Stream.JumpToBit(ResumeBit); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3199 | else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3200 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3201 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3202 | SmallVector<uint64_t, 64> Record; |
| 3203 | std::vector<std::string> SectionTable; |
Gordon Henriksen | d930f91 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 3204 | std::vector<std::string> GCTable; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3205 | |
| 3206 | // Read all the records for this module. |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3207 | while (1) { |
| 3208 | BitstreamEntry Entry = Stream.advance(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3209 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3210 | switch (Entry.Kind) { |
| 3211 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3212 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3213 | case BitstreamEntry::EndBlock: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3214 | return globalCleanup(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3215 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3216 | case BitstreamEntry::SubBlock: |
| 3217 | switch (Entry.ID) { |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3218 | default: // Skip unknown content. |
| 3219 | if (Stream.SkipBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3220 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3221 | break; |
Chris Lattner | 6eeea5d | 2007-05-05 18:57:30 +0000 | [diff] [blame] | 3222 | case bitc::BLOCKINFO_BLOCK_ID: |
| 3223 | if (Stream.ReadBlockInfoBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3224 | return error("Malformed block"); |
Chris Lattner | 6eeea5d | 2007-05-05 18:57:30 +0000 | [diff] [blame] | 3225 | break; |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 3226 | case bitc::PARAMATTR_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3227 | if (std::error_code EC = parseAttributeBlock()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3228 | return EC; |
Chris Lattner | fee5a37 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 3229 | break; |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 3230 | case bitc::PARAMATTR_GROUP_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3231 | if (std::error_code EC = parseAttributeGroupBlock()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3232 | return EC; |
Bill Wendling | ba62933 | 2013-02-10 23:24:25 +0000 | [diff] [blame] | 3233 | break; |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 3234 | case bitc::TYPE_BLOCK_ID_NEW: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3235 | if (std::error_code EC = parseTypeTable()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3236 | return EC; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3237 | break; |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 3238 | case bitc::VALUE_SYMTAB_BLOCK_ID: |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 3239 | if (!SeenValueSymbolTable) { |
| 3240 | // Either this is an old form VST without function index and an |
| 3241 | // associated VST forward declaration record (which would have caused |
| 3242 | // the VST to be jumped to and parsed before it was encountered |
| 3243 | // normally in the stream), or there were no function blocks to |
| 3244 | // trigger an earlier parsing of the VST. |
| 3245 | assert(VSTOffset == 0 || FunctionsWithBodies.empty()); |
| 3246 | if (std::error_code EC = parseValueSymbolTable()) |
| 3247 | return EC; |
| 3248 | SeenValueSymbolTable = true; |
| 3249 | } else { |
| 3250 | // We must have had a VST forward declaration record, which caused |
| 3251 | // the parser to jump to and parse the VST earlier. |
| 3252 | assert(VSTOffset > 0); |
| 3253 | if (Stream.SkipBlock()) |
| 3254 | return error("Invalid record"); |
| 3255 | } |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 3256 | break; |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 3257 | case bitc::CONSTANTS_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3258 | if (std::error_code EC = parseConstants()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3259 | return EC; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3260 | if (std::error_code EC = resolveGlobalAndAliasInits()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3261 | return EC; |
Chris Lattner | fbc1d33 | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 3262 | break; |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 3263 | case bitc::METADATA_BLOCK_ID: |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 3264 | if (ShouldLazyLoadMetadata && !IsMetadataMaterialized) { |
| 3265 | if (std::error_code EC = rememberAndSkipMetadata()) |
| 3266 | return EC; |
| 3267 | break; |
| 3268 | } |
| 3269 | assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata"); |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 3270 | if (std::error_code EC = parseMetadata(true)) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3271 | return EC; |
Devang Patel | 7428d8a | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 3272 | break; |
Teresa Johnson | 1254507 | 2015-11-15 02:00:09 +0000 | [diff] [blame] | 3273 | case bitc::METADATA_KIND_BLOCK_ID: |
| 3274 | if (std::error_code EC = parseMetadataKinds()) |
| 3275 | return EC; |
| 3276 | break; |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3277 | case bitc::FUNCTION_BLOCK_ID: |
| 3278 | // If this is the first function body we've seen, reverse the |
| 3279 | // FunctionsWithBodies list. |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3280 | if (!SeenFirstFunctionBody) { |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3281 | std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3282 | if (std::error_code EC = globalCleanup()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3283 | return EC; |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3284 | SeenFirstFunctionBody = true; |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3285 | } |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3286 | |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 3287 | if (VSTOffset > 0) { |
| 3288 | // If we have a VST forward declaration record, make sure we |
| 3289 | // parse the VST now if we haven't already. It is needed to |
| 3290 | // set up the DeferredFunctionInfo vector for lazy reading. |
| 3291 | if (!SeenValueSymbolTable) { |
| 3292 | if (std::error_code EC = |
| 3293 | BitcodeReader::parseValueSymbolTable(VSTOffset)) |
| 3294 | return EC; |
| 3295 | SeenValueSymbolTable = true; |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3296 | // Fall through so that we record the NextUnreadBit below. |
| 3297 | // This is necessary in case we have an anonymous function that |
| 3298 | // is later materialized. Since it will not have a VST entry we |
| 3299 | // need to fall back to the lazy parse to find its offset. |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 3300 | } else { |
| 3301 | // If we have a VST forward declaration record, but have already |
| 3302 | // parsed the VST (just above, when the first function body was |
| 3303 | // encountered here), then we are resuming the parse after |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3304 | // materializing functions. The ResumeBit points to the |
| 3305 | // start of the last function block recorded in the |
| 3306 | // DeferredFunctionInfo map. Skip it. |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 3307 | if (Stream.SkipBlock()) |
| 3308 | return error("Invalid record"); |
| 3309 | continue; |
| 3310 | } |
| 3311 | } |
| 3312 | |
| 3313 | // Support older bitcode files that did not have the function |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3314 | // index in the VST, nor a VST forward declaration record, as |
| 3315 | // well as anonymous functions that do not have VST entries. |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 3316 | // Build the DeferredFunctionInfo vector on the fly. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3317 | if (std::error_code EC = rememberAndSkipFunctionBody()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3318 | return EC; |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3319 | |
Rafael Espindola | 1c863ca | 2015-06-22 18:06:15 +0000 | [diff] [blame] | 3320 | // Suspend parsing when we reach the function bodies. Subsequent |
| 3321 | // materialization calls will resume it when necessary. If the bitcode |
| 3322 | // file is old, the symbol table will be at the end instead and will not |
| 3323 | // have been seen yet. In this case, just finish the parse now. |
| 3324 | if (SeenValueSymbolTable) { |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3325 | NextUnreadBit = Stream.GetCurrentBitNo(); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 3326 | return std::error_code(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3327 | } |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3328 | break; |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 3329 | case bitc::USELIST_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3330 | if (std::error_code EC = parseUseLists()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3331 | return EC; |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 3332 | break; |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 3333 | case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID: |
| 3334 | if (std::error_code EC = parseOperandBundleTags()) |
| 3335 | return EC; |
| 3336 | break; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3337 | } |
| 3338 | continue; |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3339 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3340 | case BitstreamEntry::Record: |
| 3341 | // The interesting case. |
| 3342 | break; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3343 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3344 | |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3345 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3346 | // Read a record. |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3347 | auto BitCode = Stream.readRecord(Entry.ID, Record); |
| 3348 | switch (BitCode) { |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3349 | default: break; // Default behavior, ignore unknown content. |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 3350 | case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3351 | if (Record.size() < 1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3352 | return error("Invalid record"); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 3353 | // Only version #0 and #1 are supported so far. |
| 3354 | unsigned module_version = Record[0]; |
| 3355 | switch (module_version) { |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3356 | default: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3357 | return error("Invalid value"); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 3358 | case 0: |
| 3359 | UseRelativeIDs = false; |
| 3360 | break; |
| 3361 | case 1: |
| 3362 | UseRelativeIDs = true; |
| 3363 | break; |
| 3364 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3365 | break; |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 3366 | } |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 3367 | case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3368 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3369 | if (convertToString(Record, 0, S)) |
| 3370 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3371 | TheModule->setTargetTriple(S); |
| 3372 | break; |
| 3373 | } |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 3374 | case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3375 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3376 | if (convertToString(Record, 0, S)) |
| 3377 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3378 | TheModule->setDataLayout(S); |
| 3379 | break; |
| 3380 | } |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 3381 | case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3382 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3383 | if (convertToString(Record, 0, S)) |
| 3384 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3385 | TheModule->setModuleInlineAsm(S); |
| 3386 | break; |
| 3387 | } |
Bill Wendling | 706d3d6 | 2012-11-28 08:41:48 +0000 | [diff] [blame] | 3388 | case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] |
| 3389 | // FIXME: Remove in 4.0. |
| 3390 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3391 | if (convertToString(Record, 0, S)) |
| 3392 | return error("Invalid record"); |
Bill Wendling | 706d3d6 | 2012-11-28 08:41:48 +0000 | [diff] [blame] | 3393 | // Ignore value. |
| 3394 | break; |
| 3395 | } |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 3396 | case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3397 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3398 | if (convertToString(Record, 0, S)) |
| 3399 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3400 | SectionTable.push_back(S); |
| 3401 | break; |
| 3402 | } |
Gordon Henriksen | d930f91 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 3403 | case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] |
Gordon Henriksen | 71183b6 | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 3404 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3405 | if (convertToString(Record, 0, S)) |
| 3406 | return error("Invalid record"); |
Gordon Henriksen | d930f91 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 3407 | GCTable.push_back(S); |
Gordon Henriksen | 71183b6 | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 3408 | break; |
| 3409 | } |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3410 | case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name] |
| 3411 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3412 | return error("Invalid record"); |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3413 | Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]); |
| 3414 | unsigned ComdatNameSize = Record[1]; |
| 3415 | std::string ComdatName; |
| 3416 | ComdatName.reserve(ComdatNameSize); |
| 3417 | for (unsigned i = 0; i != ComdatNameSize; ++i) |
| 3418 | ComdatName += (char)Record[2 + i]; |
| 3419 | Comdat *C = TheModule->getOrInsertComdat(ComdatName); |
| 3420 | C->setSelectionKind(SK); |
| 3421 | ComdatList.push_back(C); |
| 3422 | break; |
| 3423 | } |
Christopher Lamb | 54dd24c | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 3424 | // GLOBALVAR: [pointer type, isconst, initid, |
Rafael Espindola | 45e6c19 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 3425 | // linkage, alignment, section, visibility, threadlocal, |
Peter Collingbourne | 69ba016 | 2015-02-04 00:42:45 +0000 | [diff] [blame] | 3426 | // unnamed_addr, externally_initialized, dllstorageclass, |
| 3427 | // comdat] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3428 | case bitc::MODULE_CODE_GLOBALVAR: { |
Chris Lattner | 4b00d92 | 2007-04-23 16:04:05 +0000 | [diff] [blame] | 3429 | if (Record.size() < 6) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3430 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 3431 | Type *Ty = getTypeByID(Record[0]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3432 | if (!Ty) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3433 | return error("Invalid record"); |
David Blaikie | 1a848da | 2015-04-27 19:58:56 +0000 | [diff] [blame] | 3434 | bool isConstant = Record[1] & 1; |
| 3435 | bool explicitType = Record[1] & 2; |
| 3436 | unsigned AddressSpace; |
| 3437 | if (explicitType) { |
| 3438 | AddressSpace = Record[1] >> 2; |
| 3439 | } else { |
| 3440 | if (!Ty->isPointerTy()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3441 | return error("Invalid type for value"); |
David Blaikie | 1a848da | 2015-04-27 19:58:56 +0000 | [diff] [blame] | 3442 | AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); |
| 3443 | Ty = cast<PointerType>(Ty)->getElementType(); |
| 3444 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3445 | |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 3446 | uint64_t RawLinkage = Record[3]; |
| 3447 | GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage); |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 3448 | unsigned Alignment; |
| 3449 | if (std::error_code EC = parseAlignmentValue(Record[4], Alignment)) |
| 3450 | return EC; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3451 | std::string Section; |
| 3452 | if (Record[5]) { |
| 3453 | if (Record[5]-1 >= SectionTable.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3454 | return error("Invalid ID"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3455 | Section = SectionTable[Record[5]-1]; |
| 3456 | } |
Chris Lattner | 4b00d92 | 2007-04-23 16:04:05 +0000 | [diff] [blame] | 3457 | GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; |
Duncan P. N. Exon Smith | b80de10 | 2014-05-07 22:57:20 +0000 | [diff] [blame] | 3458 | // Local linkage must have default visibility. |
| 3459 | if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage)) |
| 3460 | // FIXME: Change to an error if non-default in 4.0. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3461 | Visibility = getDecodedVisibility(Record[6]); |
Hans Wennborg | cbe34b4 | 2012-06-23 11:37:03 +0000 | [diff] [blame] | 3462 | |
| 3463 | GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; |
Chris Lattner | 53862f7 | 2007-05-06 19:27:46 +0000 | [diff] [blame] | 3464 | if (Record.size() > 7) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3465 | TLM = getDecodedThreadLocalMode(Record[7]); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3466 | |
Rafael Espindola | 45e6c19 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 3467 | bool UnnamedAddr = false; |
| 3468 | if (Record.size() > 8) |
| 3469 | UnnamedAddr = Record[8]; |
| 3470 | |
Michael Gottesman | 27e7ef3 | 2013-02-05 05:57:38 +0000 | [diff] [blame] | 3471 | bool ExternallyInitialized = false; |
| 3472 | if (Record.size() > 9) |
| 3473 | ExternallyInitialized = Record[9]; |
| 3474 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3475 | GlobalVariable *NewGV = |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 3476 | new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr, |
Michael Gottesman | 27e7ef3 | 2013-02-05 05:57:38 +0000 | [diff] [blame] | 3477 | TLM, AddressSpace, ExternallyInitialized); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3478 | NewGV->setAlignment(Alignment); |
| 3479 | if (!Section.empty()) |
| 3480 | NewGV->setSection(Section); |
| 3481 | NewGV->setVisibility(Visibility); |
Rafael Espindola | 45e6c19 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 3482 | NewGV->setUnnamedAddr(UnnamedAddr); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3483 | |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3484 | if (Record.size() > 10) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3485 | NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10])); |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3486 | else |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3487 | upgradeDLLImportExportLinkage(NewGV, RawLinkage); |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3488 | |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 3489 | ValueList.push_back(NewGV); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3490 | |
Chris Lattner | 47d131b | 2007-04-24 00:18:21 +0000 | [diff] [blame] | 3491 | // Remember which value to use for the global initializer. |
| 3492 | if (unsigned InitID = Record[2]) |
| 3493 | GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3494 | |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 3495 | if (Record.size() > 11) { |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3496 | if (unsigned ComdatID = Record[11]) { |
Filipe Cabecinhas | 0eb8a59 | 2015-05-26 23:00:56 +0000 | [diff] [blame] | 3497 | if (ComdatID > ComdatList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3498 | return error("Invalid global variable comdat ID"); |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3499 | NewGV->setComdat(ComdatList[ComdatID - 1]); |
| 3500 | } |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 3501 | } else if (hasImplicitComdat(RawLinkage)) { |
| 3502 | NewGV->setComdat(reinterpret_cast<Comdat *>(1)); |
| 3503 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3504 | break; |
| 3505 | } |
Chris Lattner | 4c0a6d6 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 3506 | // FUNCTION: [type, callingconv, isproto, linkage, paramattr, |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3507 | // alignment, section, visibility, gc, unnamed_addr, |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 3508 | // prologuedata, dllstorageclass, comdat, prefixdata] |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3509 | case bitc::MODULE_CODE_FUNCTION: { |
Chris Lattner | 4c0a6d6 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 3510 | if (Record.size() < 8) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3511 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 3512 | Type *Ty = getTypeByID(Record[0]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3513 | if (!Ty) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3514 | return error("Invalid record"); |
David Blaikie | 561a157 | 2015-04-17 16:28:26 +0000 | [diff] [blame] | 3515 | if (auto *PTy = dyn_cast<PointerType>(Ty)) |
| 3516 | Ty = PTy->getElementType(); |
| 3517 | auto *FTy = dyn_cast<FunctionType>(Ty); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3518 | if (!FTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3519 | return error("Invalid type for value"); |
Vedant Kumar | ad6d6e7 | 2015-10-27 21:17:06 +0000 | [diff] [blame] | 3520 | auto CC = static_cast<CallingConv::ID>(Record[1]); |
| 3521 | if (CC & ~CallingConv::MaxID) |
| 3522 | return error("Invalid calling convention ID"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3523 | |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 3524 | Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, |
| 3525 | "", TheModule); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3526 | |
Vedant Kumar | ad6d6e7 | 2015-10-27 21:17:06 +0000 | [diff] [blame] | 3527 | Func->setCallingConv(CC); |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3528 | bool isProto = Record[2]; |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 3529 | uint64_t RawLinkage = Record[3]; |
| 3530 | Func->setLinkage(getDecodedLinkage(RawLinkage)); |
Devang Patel | 4c758ea | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 3531 | Func->setAttributes(getAttributes(Record[4])); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3532 | |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 3533 | unsigned Alignment; |
| 3534 | if (std::error_code EC = parseAlignmentValue(Record[5], Alignment)) |
| 3535 | return EC; |
| 3536 | Func->setAlignment(Alignment); |
Chris Lattner | 4c0a6d6 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 3537 | if (Record[6]) { |
| 3538 | if (Record[6]-1 >= SectionTable.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3539 | return error("Invalid ID"); |
Chris Lattner | 4c0a6d6 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 3540 | Func->setSection(SectionTable[Record[6]-1]); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3541 | } |
Duncan P. N. Exon Smith | b80de10 | 2014-05-07 22:57:20 +0000 | [diff] [blame] | 3542 | // Local linkage must have default visibility. |
| 3543 | if (!Func->hasLocalLinkage()) |
| 3544 | // FIXME: Change to an error if non-default in 4.0. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3545 | Func->setVisibility(getDecodedVisibility(Record[7])); |
Gordon Henriksen | 71183b6 | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 3546 | if (Record.size() > 8 && Record[8]) { |
Filipe Cabecinhas | f8a16a9 | 2015-04-30 04:09:41 +0000 | [diff] [blame] | 3547 | if (Record[8]-1 >= GCTable.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3548 | return error("Invalid ID"); |
Gordon Henriksen | d930f91 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 3549 | Func->setGC(GCTable[Record[8]-1].c_str()); |
Gordon Henriksen | 71183b6 | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 3550 | } |
Rafael Espindola | 45e6c19 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 3551 | bool UnnamedAddr = false; |
| 3552 | if (Record.size() > 9) |
| 3553 | UnnamedAddr = Record[9]; |
| 3554 | Func->setUnnamedAddr(UnnamedAddr); |
Peter Collingbourne | 3fa50f9 | 2013-09-16 01:08:15 +0000 | [diff] [blame] | 3555 | if (Record.size() > 10 && Record[10] != 0) |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 3556 | FunctionPrologues.push_back(std::make_pair(Func, Record[10]-1)); |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3557 | |
| 3558 | if (Record.size() > 11) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3559 | Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11])); |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3560 | else |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3561 | upgradeDLLImportExportLinkage(Func, RawLinkage); |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3562 | |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 3563 | if (Record.size() > 12) { |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3564 | if (unsigned ComdatID = Record[12]) { |
Filipe Cabecinhas | 0eb8a59 | 2015-05-26 23:00:56 +0000 | [diff] [blame] | 3565 | if (ComdatID > ComdatList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3566 | return error("Invalid function comdat ID"); |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3567 | Func->setComdat(ComdatList[ComdatID - 1]); |
| 3568 | } |
Rafael Espindola | 12ca34f | 2015-01-19 15:16:06 +0000 | [diff] [blame] | 3569 | } else if (hasImplicitComdat(RawLinkage)) { |
| 3570 | Func->setComdat(reinterpret_cast<Comdat *>(1)); |
| 3571 | } |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 3572 | |
Peter Collingbourne | 51d2de7 | 2014-12-03 02:08:38 +0000 | [diff] [blame] | 3573 | if (Record.size() > 13 && Record[13] != 0) |
| 3574 | FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1)); |
| 3575 | |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 3576 | if (Record.size() > 14 && Record[14] != 0) |
| 3577 | FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1)); |
| 3578 | |
Chris Lattner | ccaa448 | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 3579 | ValueList.push_back(Func); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3580 | |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3581 | // If this is a function with a body, remember the prototype we are |
| 3582 | // creating now, so that we can match up the body with them later. |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3583 | if (!isProto) { |
Rafael Espindola | d4bcefc | 2014-10-24 18:13:04 +0000 | [diff] [blame] | 3584 | Func->setIsMaterializable(true); |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3585 | FunctionsWithBodies.push_back(Func); |
Rafael Espindola | 1c863ca | 2015-06-22 18:06:15 +0000 | [diff] [blame] | 3586 | DeferredFunctionInfo[Func] = 0; |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 3587 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3588 | break; |
| 3589 | } |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3590 | // ALIAS: [alias type, addrspace, aliasee val#, linkage] |
| 3591 | // ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility, dllstorageclass] |
| 3592 | case bitc::MODULE_CODE_ALIAS: |
| 3593 | case bitc::MODULE_CODE_ALIAS_OLD: { |
| 3594 | bool NewRecord = BitCode == bitc::MODULE_CODE_ALIAS; |
Aaron Ballman | 2d0f38c | 2015-09-18 13:31:42 +0000 | [diff] [blame] | 3595 | if (Record.size() < (3 + (unsigned)NewRecord)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3596 | return error("Invalid record"); |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3597 | unsigned OpNum = 0; |
| 3598 | Type *Ty = getTypeByID(Record[OpNum++]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3599 | if (!Ty) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3600 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3601 | |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3602 | unsigned AddrSpace; |
| 3603 | if (!NewRecord) { |
| 3604 | auto *PTy = dyn_cast<PointerType>(Ty); |
| 3605 | if (!PTy) |
| 3606 | return error("Invalid type for value"); |
| 3607 | Ty = PTy->getElementType(); |
| 3608 | AddrSpace = PTy->getAddressSpace(); |
| 3609 | } else { |
| 3610 | AddrSpace = Record[OpNum++]; |
| 3611 | } |
| 3612 | |
| 3613 | auto Val = Record[OpNum++]; |
| 3614 | auto Linkage = Record[OpNum++]; |
| 3615 | auto *NewGA = GlobalAlias::create( |
| 3616 | Ty, AddrSpace, getDecodedLinkage(Linkage), "", TheModule); |
Anton Korobeynikov | 2f22e3f | 2008-03-12 00:49:19 +0000 | [diff] [blame] | 3617 | // Old bitcode files didn't have visibility field. |
Duncan P. N. Exon Smith | b80de10 | 2014-05-07 22:57:20 +0000 | [diff] [blame] | 3618 | // Local linkage must have default visibility. |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3619 | if (OpNum != Record.size()) { |
| 3620 | auto VisInd = OpNum++; |
| 3621 | if (!NewGA->hasLocalLinkage()) |
| 3622 | // FIXME: Change to an error if non-default in 4.0. |
| 3623 | NewGA->setVisibility(getDecodedVisibility(Record[VisInd])); |
| 3624 | } |
| 3625 | if (OpNum != Record.size()) |
| 3626 | NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++])); |
Nico Rieck | 7157bb7 | 2014-01-14 15:22:47 +0000 | [diff] [blame] | 3627 | else |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3628 | upgradeDLLImportExportLinkage(NewGA, Linkage); |
| 3629 | if (OpNum != Record.size()) |
| 3630 | NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++])); |
| 3631 | if (OpNum != Record.size()) |
| 3632 | NewGA->setUnnamedAddr(Record[OpNum++]); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 3633 | ValueList.push_back(NewGA); |
David Blaikie | 6a51dbd | 2015-09-17 22:18:59 +0000 | [diff] [blame] | 3634 | AliasInits.push_back(std::make_pair(NewGA, Val)); |
Chris Lattner | 44c1707 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 3635 | break; |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3636 | } |
Chris Lattner | 831d420 | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 3637 | /// MODULE_CODE_PURGEVALS: [numvals] |
| 3638 | case bitc::MODULE_CODE_PURGEVALS: |
| 3639 | // Trim down the value list to the specified size. |
| 3640 | if (Record.size() < 1 || Record[0] > ValueList.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3641 | return error("Invalid record"); |
Chris Lattner | 831d420 | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 3642 | ValueList.shrinkTo(Record[0]); |
| 3643 | break; |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 3644 | /// MODULE_CODE_VSTOFFSET: [offset] |
| 3645 | case bitc::MODULE_CODE_VSTOFFSET: |
| 3646 | if (Record.size() < 1) |
| 3647 | return error("Invalid record"); |
| 3648 | VSTOffset = Record[0]; |
| 3649 | break; |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 3650 | /// MODULE_CODE_METADATA_VALUES: [numvals] |
| 3651 | case bitc::MODULE_CODE_METADATA_VALUES: |
| 3652 | if (Record.size() < 1) |
| 3653 | return error("Invalid record"); |
| 3654 | assert(!IsMetadataMaterialized); |
| 3655 | // This record contains the number of metadata values in the module-level |
| 3656 | // METADATA_BLOCK. It is used to support lazy parsing of metadata as |
| 3657 | // a postpass, where we will parse function-level metadata first. |
| 3658 | // This is needed because the ids of metadata are assigned implicitly |
| 3659 | // based on their ordering in the bitcode, with the function-level |
| 3660 | // metadata ids starting after the module-level metadata ids. Otherwise, |
| 3661 | // we would have to parse the module-level metadata block to prime the |
| 3662 | // MDValueList when we are lazy loading metadata during function |
| 3663 | // importing. Initialize the MDValueList size here based on the |
| 3664 | // record value, regardless of whether we are doing lazy metadata |
| 3665 | // loading, so that we have consistent handling and assertion |
| 3666 | // checking in parseMetadata for module-level metadata. |
| 3667 | NumModuleMDs = Record[0]; |
| 3668 | SeenModuleValuesRecord = true; |
| 3669 | assert(MDValueList.size() == 0); |
| 3670 | MDValueList.resize(NumModuleMDs); |
| 3671 | break; |
Chris Lattner | 831d420 | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 3672 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3673 | Record.clear(); |
| 3674 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3675 | } |
| 3676 | |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 3677 | /// Helper to read the header common to all bitcode files. |
| 3678 | static bool hasValidBitcodeHeader(BitstreamCursor &Stream) { |
| 3679 | // Sniff for the signature. |
| 3680 | if (Stream.Read(8) != 'B' || |
| 3681 | Stream.Read(8) != 'C' || |
| 3682 | Stream.Read(4) != 0x0 || |
| 3683 | Stream.Read(4) != 0xC || |
| 3684 | Stream.Read(4) != 0xE || |
| 3685 | Stream.Read(4) != 0xD) |
| 3686 | return false; |
| 3687 | return true; |
| 3688 | } |
| 3689 | |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 3690 | std::error_code |
| 3691 | BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer, |
| 3692 | Module *M, bool ShouldLazyLoadMetadata) { |
Rafael Espindola | c6afe0d | 2015-06-16 20:03:39 +0000 | [diff] [blame] | 3693 | TheModule = M; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3694 | |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 3695 | if (std::error_code EC = initStream(std::move(Streamer))) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3696 | return EC; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3697 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3698 | // Sniff for the signature. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 3699 | if (!hasValidBitcodeHeader(Stream)) |
| 3700 | return error("Invalid bitcode signature"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3701 | |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3702 | // We expect a number of well-defined blocks, though we don't necessarily |
| 3703 | // need to understand them all. |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3704 | while (1) { |
Filipe Cabecinhas | 2255427 | 2015-04-14 14:07:15 +0000 | [diff] [blame] | 3705 | if (Stream.AtEndOfStream()) { |
Filipe Cabecinhas | 2255427 | 2015-04-14 14:07:15 +0000 | [diff] [blame] | 3706 | // We didn't really read a proper Module. |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3707 | return error("Malformed IR file"); |
Filipe Cabecinhas | 2255427 | 2015-04-14 14:07:15 +0000 | [diff] [blame] | 3708 | } |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3709 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3710 | BitstreamEntry Entry = |
| 3711 | Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3712 | |
Rafael Espindola | c6afe0d | 2015-06-16 20:03:39 +0000 | [diff] [blame] | 3713 | if (Entry.Kind != BitstreamEntry::SubBlock) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3714 | return error("Malformed block"); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3715 | |
Mehdi Amini | 5d30328 | 2015-10-26 18:37:00 +0000 | [diff] [blame] | 3716 | if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) { |
| 3717 | parseBitcodeVersion(); |
| 3718 | continue; |
| 3719 | } |
| 3720 | |
Rafael Espindola | c6afe0d | 2015-06-16 20:03:39 +0000 | [diff] [blame] | 3721 | if (Entry.ID == bitc::MODULE_BLOCK_ID) |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 3722 | return parseModule(0, ShouldLazyLoadMetadata); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3723 | |
Rafael Espindola | c6afe0d | 2015-06-16 20:03:39 +0000 | [diff] [blame] | 3724 | if (Stream.SkipBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3725 | return error("Invalid record"); |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3726 | } |
Chris Lattner | 1314b99 | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 3727 | } |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 3728 | |
Rafael Espindola | c75c4fa | 2014-07-04 20:02:42 +0000 | [diff] [blame] | 3729 | ErrorOr<std::string> BitcodeReader::parseModuleTriple() { |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3730 | if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3731 | return error("Invalid record"); |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3732 | |
| 3733 | SmallVector<uint64_t, 64> Record; |
| 3734 | |
Rafael Espindola | c75c4fa | 2014-07-04 20:02:42 +0000 | [diff] [blame] | 3735 | std::string Triple; |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3736 | // Read all the records for this module. |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3737 | while (1) { |
| 3738 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3739 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3740 | switch (Entry.Kind) { |
| 3741 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 3742 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3743 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3744 | case BitstreamEntry::EndBlock: |
Rafael Espindola | e610779 | 2014-07-04 20:05:56 +0000 | [diff] [blame] | 3745 | return Triple; |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3746 | case BitstreamEntry::Record: |
| 3747 | // The interesting case. |
| 3748 | break; |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3749 | } |
| 3750 | |
| 3751 | // Read a record. |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3752 | switch (Stream.readRecord(Entry.ID, Record)) { |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3753 | default: break; // Default behavior, ignore unknown content. |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3754 | case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] |
Rafael Espindola | c75c4fa | 2014-07-04 20:02:42 +0000 | [diff] [blame] | 3755 | std::string S; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3756 | if (convertToString(Record, 0, S)) |
| 3757 | return error("Invalid record"); |
Rafael Espindola | c75c4fa | 2014-07-04 20:02:42 +0000 | [diff] [blame] | 3758 | Triple = S; |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3759 | break; |
| 3760 | } |
| 3761 | } |
| 3762 | Record.clear(); |
| 3763 | } |
Rafael Espindola | e610779 | 2014-07-04 20:05:56 +0000 | [diff] [blame] | 3764 | llvm_unreachable("Exit infinite loop"); |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3765 | } |
| 3766 | |
Rafael Espindola | c75c4fa | 2014-07-04 20:02:42 +0000 | [diff] [blame] | 3767 | ErrorOr<std::string> BitcodeReader::parseTriple() { |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 3768 | if (std::error_code EC = initStream(nullptr)) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3769 | return EC; |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3770 | |
| 3771 | // Sniff for the signature. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 3772 | if (!hasValidBitcodeHeader(Stream)) |
| 3773 | return error("Invalid bitcode signature"); |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3774 | |
| 3775 | // We expect a number of well-defined blocks, though we don't necessarily |
| 3776 | // need to understand them all. |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3777 | while (1) { |
| 3778 | BitstreamEntry Entry = Stream.advance(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3779 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3780 | switch (Entry.Kind) { |
| 3781 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3782 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3783 | case BitstreamEntry::EndBlock: |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 3784 | return std::error_code(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3785 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3786 | case BitstreamEntry::SubBlock: |
| 3787 | if (Entry.ID == bitc::MODULE_BLOCK_ID) |
Rafael Espindola | d346cc8 | 2014-07-04 13:52:01 +0000 | [diff] [blame] | 3788 | return parseModuleTriple(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3789 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3790 | // Ignore other sub-blocks. |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3791 | if (Stream.SkipBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3792 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3793 | continue; |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3794 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3795 | case BitstreamEntry::Record: |
| 3796 | Stream.skipRecord(Entry.ID); |
| 3797 | continue; |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3798 | } |
| 3799 | } |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3800 | } |
| 3801 | |
Mehdi Amini | 3383ccc | 2015-11-09 02:46:41 +0000 | [diff] [blame] | 3802 | ErrorOr<std::string> BitcodeReader::parseIdentificationBlock() { |
| 3803 | if (std::error_code EC = initStream(nullptr)) |
| 3804 | return EC; |
| 3805 | |
| 3806 | // Sniff for the signature. |
| 3807 | if (!hasValidBitcodeHeader(Stream)) |
| 3808 | return error("Invalid bitcode signature"); |
| 3809 | |
| 3810 | // We expect a number of well-defined blocks, though we don't necessarily |
| 3811 | // need to understand them all. |
| 3812 | while (1) { |
| 3813 | BitstreamEntry Entry = Stream.advance(); |
| 3814 | switch (Entry.Kind) { |
| 3815 | case BitstreamEntry::Error: |
| 3816 | return error("Malformed block"); |
| 3817 | case BitstreamEntry::EndBlock: |
| 3818 | return std::error_code(); |
| 3819 | |
| 3820 | case BitstreamEntry::SubBlock: |
| 3821 | if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) { |
| 3822 | if (std::error_code EC = parseBitcodeVersion()) |
| 3823 | return EC; |
| 3824 | return ProducerIdentification; |
| 3825 | } |
| 3826 | // Ignore other sub-blocks. |
| 3827 | if (Stream.SkipBlock()) |
| 3828 | return error("Malformed block"); |
| 3829 | continue; |
| 3830 | case BitstreamEntry::Record: |
| 3831 | Stream.skipRecord(Entry.ID); |
| 3832 | continue; |
| 3833 | } |
| 3834 | } |
| 3835 | } |
| 3836 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3837 | /// Parse metadata attachments. |
| 3838 | std::error_code BitcodeReader::parseMetadataAttachment(Function &F) { |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3839 | if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3840 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3841 | |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3842 | SmallVector<uint64_t, 64> Record; |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3843 | while (1) { |
| 3844 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3845 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3846 | switch (Entry.Kind) { |
| 3847 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 3848 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3849 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3850 | case BitstreamEntry::EndBlock: |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 3851 | return std::error_code(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3852 | case BitstreamEntry::Record: |
| 3853 | // The interesting case. |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3854 | break; |
| 3855 | } |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3856 | |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3857 | // Read a metadata attachment record. |
| 3858 | Record.clear(); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3859 | switch (Stream.readRecord(Entry.ID, Record)) { |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3860 | default: // Default behavior: ignore. |
| 3861 | break; |
Chris Lattner | b877855 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 3862 | case bitc::METADATA_ATTACHMENT: { |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3863 | unsigned RecordLength = Record.size(); |
Duncan P. N. Exon Smith | 3d4cd75 | 2015-04-24 22:04:41 +0000 | [diff] [blame] | 3864 | if (Record.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3865 | return error("Invalid record"); |
Duncan P. N. Exon Smith | 3d4cd75 | 2015-04-24 22:04:41 +0000 | [diff] [blame] | 3866 | if (RecordLength % 2 == 0) { |
| 3867 | // A function attachment. |
| 3868 | for (unsigned I = 0; I != RecordLength; I += 2) { |
| 3869 | auto K = MDKindMap.find(Record[I]); |
| 3870 | if (K == MDKindMap.end()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3871 | return error("Invalid ID"); |
Duncan P. N. Exon Smith | 3d4cd75 | 2015-04-24 22:04:41 +0000 | [diff] [blame] | 3872 | Metadata *MD = MDValueList.getValueFwdRef(Record[I + 1]); |
| 3873 | F.setMetadata(K->second, cast<MDNode>(MD)); |
| 3874 | } |
| 3875 | continue; |
| 3876 | } |
| 3877 | |
| 3878 | // An instruction attachment. |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3879 | Instruction *Inst = InstructionList[Record[0]]; |
| 3880 | for (unsigned i = 1; i != RecordLength; i = i+2) { |
Devang Patel | b1a4477 | 2009-09-28 21:14:55 +0000 | [diff] [blame] | 3881 | unsigned Kind = Record[i]; |
Dan Gohman | 43aa8f0 | 2010-07-20 21:42:28 +0000 | [diff] [blame] | 3882 | DenseMap<unsigned, unsigned>::iterator I = |
| 3883 | MDKindMap.find(Kind); |
| 3884 | if (I == MDKindMap.end()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3885 | return error("Invalid ID"); |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 3886 | Metadata *Node = MDValueList.getValueFwdRef(Record[i + 1]); |
| 3887 | if (isa<LocalAsMetadata>(Node)) |
Duncan P. N. Exon Smith | 35303fd | 2014-12-06 02:29:44 +0000 | [diff] [blame] | 3888 | // Drop the attachment. This used to be legal, but there's no |
| 3889 | // upgrade path. |
| 3890 | break; |
Duncan P. N. Exon Smith | 5bf8fef | 2014-12-09 18:38:53 +0000 | [diff] [blame] | 3891 | Inst->setMetadata(I->second, cast<MDNode>(Node)); |
Manman Ren | 209b17c | 2013-09-28 00:22:27 +0000 | [diff] [blame] | 3892 | if (I->second == LLVMContext::MD_tbaa) |
| 3893 | InstsWithTBAATag.push_back(Inst); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3894 | } |
| 3895 | break; |
| 3896 | } |
| 3897 | } |
| 3898 | } |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3899 | } |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 3900 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3901 | static std::error_code typeCheckLoadStoreInst(DiagnosticHandlerFunction DH, |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 3902 | Type *ValType, Type *PtrType) { |
| 3903 | if (!isa<PointerType>(PtrType)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3904 | return error(DH, "Load/Store operand is not a pointer type"); |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 3905 | Type *ElemType = cast<PointerType>(PtrType)->getElementType(); |
| 3906 | |
| 3907 | if (ValType && ValType != ElemType) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3908 | return error(DH, "Explicit load/store type does not match pointee type of " |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 3909 | "pointer operand"); |
| 3910 | if (!PointerType::isLoadableOrStorableType(ElemType)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3911 | return error(DH, "Cannot load/store from pointer"); |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 3912 | return std::error_code(); |
| 3913 | } |
| 3914 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3915 | /// Lazily parse the specified function body block. |
| 3916 | std::error_code BitcodeReader::parseFunctionBody(Function *F) { |
Chris Lattner | 982ec1e | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 3917 | if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3918 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3919 | |
Nick Lewycky | a72e1af | 2010-02-25 08:30:17 +0000 | [diff] [blame] | 3920 | InstructionList.clear(); |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3921 | unsigned ModuleValueListSize = ValueList.size(); |
Dan Gohman | 26d837d | 2010-08-25 20:22:53 +0000 | [diff] [blame] | 3922 | unsigned ModuleMDValueListSize = MDValueList.size(); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3923 | |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3924 | // Add all the function arguments to the value table. |
Duncan P. N. Exon Smith | fb1743a3 | 2015-10-13 16:48:55 +0000 | [diff] [blame] | 3925 | for (Argument &I : F->args()) |
| 3926 | ValueList.push_back(&I); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3927 | |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 3928 | unsigned NextValueNo = ValueList.size(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 3929 | BasicBlock *CurBB = nullptr; |
Chris Lattner | e53603e | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 3930 | unsigned CurBBNo = 0; |
| 3931 | |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 3932 | DebugLoc LastLoc; |
Duncan P. N. Exon Smith | 52d0f16 | 2015-01-09 02:51:45 +0000 | [diff] [blame] | 3933 | auto getLastInstruction = [&]() -> Instruction * { |
| 3934 | if (CurBB && !CurBB->empty()) |
| 3935 | return &CurBB->back(); |
| 3936 | else if (CurBBNo && FunctionBBs[CurBBNo - 1] && |
| 3937 | !FunctionBBs[CurBBNo - 1]->empty()) |
| 3938 | return &FunctionBBs[CurBBNo - 1]->back(); |
| 3939 | return nullptr; |
| 3940 | }; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 3941 | |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 3942 | std::vector<OperandBundleDef> OperandBundles; |
| 3943 | |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3944 | // Read all the records. |
| 3945 | SmallVector<uint64_t, 64> Record; |
| 3946 | while (1) { |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3947 | BitstreamEntry Entry = Stream.advance(); |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3948 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3949 | switch (Entry.Kind) { |
| 3950 | case BitstreamEntry::Error: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3951 | return error("Malformed block"); |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3952 | case BitstreamEntry::EndBlock: |
| 3953 | goto OutOfRecordLoop; |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3954 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3955 | case BitstreamEntry::SubBlock: |
| 3956 | switch (Entry.ID) { |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3957 | default: // Skip unknown content. |
| 3958 | if (Stream.SkipBlock()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3959 | return error("Invalid record"); |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3960 | break; |
| 3961 | case bitc::CONSTANTS_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3962 | if (std::error_code EC = parseConstants()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3963 | return EC; |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 3964 | NextValueNo = ValueList.size(); |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3965 | break; |
| 3966 | case bitc::VALUE_SYMTAB_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3967 | if (std::error_code EC = parseValueSymbolTable()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3968 | return EC; |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3969 | break; |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 3970 | case bitc::METADATA_ATTACHMENT_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3971 | if (std::error_code EC = parseMetadataAttachment(*F)) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3972 | return EC; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3973 | break; |
Victor Hernandez | 108d3ac | 2010-01-13 19:34:08 +0000 | [diff] [blame] | 3974 | case bitc::METADATA_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3975 | if (std::error_code EC = parseMetadata()) |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 3976 | return EC; |
Victor Hernandez | 108d3ac | 2010-01-13 19:34:08 +0000 | [diff] [blame] | 3977 | break; |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3978 | case bitc::USELIST_BLOCK_ID: |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3979 | if (std::error_code EC = parseUseLists()) |
Duncan P. N. Exon Smith | 1f66c85 | 2014-07-28 21:19:41 +0000 | [diff] [blame] | 3980 | return EC; |
| 3981 | break; |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3982 | } |
| 3983 | continue; |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3984 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3985 | case BitstreamEntry::Record: |
| 3986 | // The interesting case. |
| 3987 | break; |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3988 | } |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 3989 | |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 3990 | // Read a record. |
| 3991 | Record.clear(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 3992 | Instruction *I = nullptr; |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 3993 | unsigned BitCode = Stream.readRecord(Entry.ID, Record); |
Dan Gohman | 0ebd696 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 3994 | switch (BitCode) { |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 3995 | default: // Default behavior: reject |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3996 | return error("Invalid value"); |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 3997 | case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks] |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 3998 | if (Record.size() < 1 || Record[0] == 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 3999 | return error("Invalid record"); |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 4000 | // Create all the basic blocks for the function. |
Chris Lattner | 6ce15cb | 2007-05-03 22:09:51 +0000 | [diff] [blame] | 4001 | FunctionBBs.resize(Record[0]); |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 4002 | |
| 4003 | // See if anything took the address of blocks in this function. |
| 4004 | auto BBFRI = BasicBlockFwdRefs.find(F); |
| 4005 | if (BBFRI == BasicBlockFwdRefs.end()) { |
| 4006 | for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) |
| 4007 | FunctionBBs[i] = BasicBlock::Create(Context, "", F); |
| 4008 | } else { |
| 4009 | auto &BBRefs = BBFRI->second; |
Duncan P. N. Exon Smith | 5a5fd7b | 2014-08-16 01:54:37 +0000 | [diff] [blame] | 4010 | // Check for invalid basic block references. |
| 4011 | if (BBRefs.size() > FunctionBBs.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4012 | return error("Invalid ID"); |
Duncan P. N. Exon Smith | 5a5fd7b | 2014-08-16 01:54:37 +0000 | [diff] [blame] | 4013 | assert(!BBRefs.empty() && "Unexpected empty array"); |
| 4014 | assert(!BBRefs.front() && "Invalid reference to entry block"); |
| 4015 | for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E; |
| 4016 | ++I) |
| 4017 | if (I < RE && BBRefs[I]) { |
| 4018 | BBRefs[I]->insertInto(F); |
| 4019 | FunctionBBs[I] = BBRefs[I]; |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 4020 | } else { |
| 4021 | FunctionBBs[I] = BasicBlock::Create(Context, "", F); |
| 4022 | } |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 4023 | |
| 4024 | // Erase from the table. |
| 4025 | BasicBlockFwdRefs.erase(BBFRI); |
| 4026 | } |
| 4027 | |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 4028 | CurBB = FunctionBBs[0]; |
| 4029 | continue; |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 4030 | } |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4031 | |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 4032 | case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN |
| 4033 | // This record indicates that the last instruction is at the same |
| 4034 | // location as the previous instruction with a location. |
Duncan P. N. Exon Smith | 52d0f16 | 2015-01-09 02:51:45 +0000 | [diff] [blame] | 4035 | I = getLastInstruction(); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4036 | |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4037 | if (!I) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4038 | return error("Invalid record"); |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 4039 | I->setDebugLoc(LastLoc); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4040 | I = nullptr; |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 4041 | continue; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4042 | |
Duncan P. N. Exon Smith | 9ed1966 | 2015-01-09 17:53:27 +0000 | [diff] [blame] | 4043 | case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] |
Duncan P. N. Exon Smith | 52d0f16 | 2015-01-09 02:51:45 +0000 | [diff] [blame] | 4044 | I = getLastInstruction(); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4045 | if (!I || Record.size() < 4) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4046 | return error("Invalid record"); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4047 | |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 4048 | unsigned Line = Record[0], Col = Record[1]; |
| 4049 | unsigned ScopeID = Record[2], IAID = Record[3]; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4050 | |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4051 | MDNode *Scope = nullptr, *IA = nullptr; |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 4052 | if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); |
| 4053 | if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); |
| 4054 | LastLoc = DebugLoc::get(Line, Col, Scope, IA); |
| 4055 | I->setDebugLoc(LastLoc); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4056 | I = nullptr; |
Chris Lattner | 07d09ed | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 4057 | continue; |
| 4058 | } |
| 4059 | |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4060 | case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] |
| 4061 | unsigned OpNum = 0; |
| 4062 | Value *LHS, *RHS; |
| 4063 | if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4064 | popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || |
Dan Gohman | 0ebd696 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 4065 | OpNum+1 > Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4066 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4067 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4068 | int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 4069 | if (Opc == -1) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4070 | return error("Invalid record"); |
Gabor Greif | e1f6e4b | 2008-05-16 19:29:10 +0000 | [diff] [blame] | 4071 | I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4072 | InstructionList.push_back(I); |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4073 | if (OpNum < Record.size()) { |
| 4074 | if (Opc == Instruction::Add || |
| 4075 | Opc == Instruction::Sub || |
Chris Lattner | a676c0f | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 4076 | Opc == Instruction::Mul || |
| 4077 | Opc == Instruction::Shl) { |
Dan Gohman | 00f4747 | 2010-01-25 21:55:39 +0000 | [diff] [blame] | 4078 | if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4079 | cast<BinaryOperator>(I)->setHasNoSignedWrap(true); |
Dan Gohman | 00f4747 | 2010-01-25 21:55:39 +0000 | [diff] [blame] | 4080 | if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4081 | cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); |
Chris Lattner | 35315d0 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 4082 | } else if (Opc == Instruction::SDiv || |
Chris Lattner | a676c0f | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 4083 | Opc == Instruction::UDiv || |
| 4084 | Opc == Instruction::LShr || |
| 4085 | Opc == Instruction::AShr) { |
Chris Lattner | 35315d0 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 4086 | if (Record[OpNum] & (1 << bitc::PEO_EXACT)) |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4087 | cast<BinaryOperator>(I)->setIsExact(true); |
Michael Ilseman | 9978d7e | 2012-11-27 00:43:38 +0000 | [diff] [blame] | 4088 | } else if (isa<FPMathOperator>(I)) { |
James Molloy | 88eb535 | 2015-07-10 12:52:00 +0000 | [diff] [blame] | 4089 | FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]); |
Michael Ilseman | 9978d7e | 2012-11-27 00:43:38 +0000 | [diff] [blame] | 4090 | if (FMF.any()) |
| 4091 | I->setFastMathFlags(FMF); |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4092 | } |
Michael Ilseman | 9978d7e | 2012-11-27 00:43:38 +0000 | [diff] [blame] | 4093 | |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4094 | } |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 4095 | break; |
| 4096 | } |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4097 | case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] |
| 4098 | unsigned OpNum = 0; |
| 4099 | Value *Op; |
| 4100 | if (getValueTypePair(Record, OpNum, NextValueNo, Op) || |
| 4101 | OpNum+2 != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4102 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4103 | |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 4104 | Type *ResTy = getTypeByID(Record[OpNum]); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4105 | int Opc = getDecodedCastOpcode(Record[OpNum + 1]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4106 | if (Opc == -1 || !ResTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4107 | return error("Invalid record"); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4108 | Instruction *Temp = nullptr; |
Matt Arsenault | b03bd4d | 2013-11-15 01:34:59 +0000 | [diff] [blame] | 4109 | if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { |
| 4110 | if (Temp) { |
| 4111 | InstructionList.push_back(Temp); |
| 4112 | CurBB->getInstList().push_back(Temp); |
| 4113 | } |
| 4114 | } else { |
Filipe Cabecinhas | b70fd87 | 2015-10-06 12:37:54 +0000 | [diff] [blame] | 4115 | auto CastOp = (Instruction::CastOps)Opc; |
| 4116 | if (!CastInst::castIsValid(CastOp, Op, ResTy)) |
| 4117 | return error("Invalid cast"); |
| 4118 | I = CastInst::Create(CastOp, Op, ResTy); |
Matt Arsenault | b03bd4d | 2013-11-15 01:34:59 +0000 | [diff] [blame] | 4119 | } |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4120 | InstructionList.push_back(I); |
Chris Lattner | e53603e | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 4121 | break; |
| 4122 | } |
David Blaikie | b5b5efd | 2015-02-25 01:08:52 +0000 | [diff] [blame] | 4123 | case bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD: |
| 4124 | case bitc::FUNC_CODE_INST_GEP_OLD: |
| 4125 | case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands] |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4126 | unsigned OpNum = 0; |
David Blaikie | b5b5efd | 2015-02-25 01:08:52 +0000 | [diff] [blame] | 4127 | |
| 4128 | Type *Ty; |
| 4129 | bool InBounds; |
| 4130 | |
| 4131 | if (BitCode == bitc::FUNC_CODE_INST_GEP) { |
| 4132 | InBounds = Record[OpNum++]; |
| 4133 | Ty = getTypeByID(Record[OpNum++]); |
| 4134 | } else { |
| 4135 | InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD; |
| 4136 | Ty = nullptr; |
| 4137 | } |
| 4138 | |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4139 | Value *BasePtr; |
| 4140 | if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4141 | return error("Invalid record"); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4142 | |
David Blaikie | 60310f2 | 2015-05-08 00:42:26 +0000 | [diff] [blame] | 4143 | if (!Ty) |
| 4144 | Ty = cast<SequentialType>(BasePtr->getType()->getScalarType()) |
| 4145 | ->getElementType(); |
| 4146 | else if (Ty != |
| 4147 | cast<SequentialType>(BasePtr->getType()->getScalarType()) |
| 4148 | ->getElementType()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4149 | return error( |
David Blaikie | 675e8cb | 2015-03-16 21:35:48 +0000 | [diff] [blame] | 4150 | "Explicit gep type does not match pointee type of pointer operand"); |
| 4151 | |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4152 | SmallVector<Value*, 16> GEPIdx; |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4153 | while (OpNum != Record.size()) { |
| 4154 | Value *Op; |
| 4155 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4156 | return error("Invalid record"); |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4157 | GEPIdx.push_back(Op); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4158 | } |
| 4159 | |
David Blaikie | 096b1da | 2015-03-14 19:53:33 +0000 | [diff] [blame] | 4160 | I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx); |
David Blaikie | 675e8cb | 2015-03-16 21:35:48 +0000 | [diff] [blame] | 4161 | |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4162 | InstructionList.push_back(I); |
David Blaikie | b5b5efd | 2015-02-25 01:08:52 +0000 | [diff] [blame] | 4163 | if (InBounds) |
Dan Gohman | 1b84908 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 4164 | cast<GetElementPtrInst>(I)->setIsInBounds(true); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4165 | break; |
| 4166 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4167 | |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4168 | case bitc::FUNC_CODE_INST_EXTRACTVAL: { |
| 4169 | // EXTRACTVAL: [opty, opval, n x indices] |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4170 | unsigned OpNum = 0; |
| 4171 | Value *Agg; |
| 4172 | if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4173 | return error("Invalid record"); |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4174 | |
Filipe Cabecinhas | 1c299d0 | 2015-05-16 00:33:12 +0000 | [diff] [blame] | 4175 | unsigned RecSize = Record.size(); |
| 4176 | if (OpNum == RecSize) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4177 | return error("EXTRACTVAL: Invalid instruction with 0 indices"); |
Filipe Cabecinhas | 1c299d0 | 2015-05-16 00:33:12 +0000 | [diff] [blame] | 4178 | |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4179 | SmallVector<unsigned, 4> EXTRACTVALIdx; |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4180 | Type *CurTy = Agg->getType(); |
Filipe Cabecinhas | 1c299d0 | 2015-05-16 00:33:12 +0000 | [diff] [blame] | 4181 | for (; OpNum != RecSize; ++OpNum) { |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4182 | bool IsArray = CurTy->isArrayTy(); |
| 4183 | bool IsStruct = CurTy->isStructTy(); |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4184 | uint64_t Index = Record[OpNum]; |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4185 | |
| 4186 | if (!IsStruct && !IsArray) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4187 | return error("EXTRACTVAL: Invalid type"); |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4188 | if ((unsigned)Index != Index) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4189 | return error("Invalid value"); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4190 | if (IsStruct && Index >= CurTy->subtypes().size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4191 | return error("EXTRACTVAL: Invalid struct index"); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4192 | if (IsArray && Index >= CurTy->getArrayNumElements()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4193 | return error("EXTRACTVAL: Invalid array index"); |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4194 | EXTRACTVALIdx.push_back((unsigned)Index); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4195 | |
| 4196 | if (IsStruct) |
| 4197 | CurTy = CurTy->subtypes()[Index]; |
| 4198 | else |
| 4199 | CurTy = CurTy->subtypes()[0]; |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4200 | } |
| 4201 | |
Jay Foad | 57aa636 | 2011-07-13 10:26:04 +0000 | [diff] [blame] | 4202 | I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4203 | InstructionList.push_back(I); |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4204 | break; |
| 4205 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4206 | |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4207 | case bitc::FUNC_CODE_INST_INSERTVAL: { |
| 4208 | // INSERTVAL: [opty, opval, opty, opval, n x indices] |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4209 | unsigned OpNum = 0; |
| 4210 | Value *Agg; |
| 4211 | if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4212 | return error("Invalid record"); |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4213 | Value *Val; |
| 4214 | if (getValueTypePair(Record, OpNum, NextValueNo, Val)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4215 | return error("Invalid record"); |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4216 | |
Filipe Cabecinhas | 1c299d0 | 2015-05-16 00:33:12 +0000 | [diff] [blame] | 4217 | unsigned RecSize = Record.size(); |
| 4218 | if (OpNum == RecSize) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4219 | return error("INSERTVAL: Invalid instruction with 0 indices"); |
Filipe Cabecinhas | 1c299d0 | 2015-05-16 00:33:12 +0000 | [diff] [blame] | 4220 | |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4221 | SmallVector<unsigned, 4> INSERTVALIdx; |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4222 | Type *CurTy = Agg->getType(); |
Filipe Cabecinhas | 1c299d0 | 2015-05-16 00:33:12 +0000 | [diff] [blame] | 4223 | for (; OpNum != RecSize; ++OpNum) { |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4224 | bool IsArray = CurTy->isArrayTy(); |
| 4225 | bool IsStruct = CurTy->isStructTy(); |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4226 | uint64_t Index = Record[OpNum]; |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4227 | |
| 4228 | if (!IsStruct && !IsArray) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4229 | return error("INSERTVAL: Invalid type"); |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4230 | if ((unsigned)Index != Index) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4231 | return error("Invalid value"); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4232 | if (IsStruct && Index >= CurTy->subtypes().size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4233 | return error("INSERTVAL: Invalid struct index"); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4234 | if (IsArray && Index >= CurTy->getArrayNumElements()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4235 | return error("INSERTVAL: Invalid array index"); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4236 | |
Dan Gohman | 1ecaf45 | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 4237 | INSERTVALIdx.push_back((unsigned)Index); |
Filipe Cabecinhas | ecf8f7f | 2015-02-16 00:03:11 +0000 | [diff] [blame] | 4238 | if (IsStruct) |
| 4239 | CurTy = CurTy->subtypes()[Index]; |
| 4240 | else |
| 4241 | CurTy = CurTy->subtypes()[0]; |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4242 | } |
| 4243 | |
Filipe Cabecinhas | 4708a02 | 2015-05-18 22:27:11 +0000 | [diff] [blame] | 4244 | if (CurTy != Val->getType()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4245 | return error("Inserted value type doesn't match aggregate type"); |
Filipe Cabecinhas | 4708a02 | 2015-05-18 22:27:11 +0000 | [diff] [blame] | 4246 | |
Jay Foad | 57aa636 | 2011-07-13 10:26:04 +0000 | [diff] [blame] | 4247 | I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4248 | InstructionList.push_back(I); |
Dan Gohman | 3049984 | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 4249 | break; |
| 4250 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4251 | |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4252 | case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] |
Dan Gohman | c5d2892 | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 4253 | // obsolete form of select |
| 4254 | // handles select i1 ... in old bitcode |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4255 | unsigned OpNum = 0; |
| 4256 | Value *TrueVal, *FalseVal, *Cond; |
| 4257 | if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4258 | popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || |
| 4259 | popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4260 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4261 | |
Dan Gohman | c5d2892 | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 4262 | I = SelectInst::Create(Cond, TrueVal, FalseVal); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4263 | InstructionList.push_back(I); |
Dan Gohman | c5d2892 | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 4264 | break; |
| 4265 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4266 | |
Dan Gohman | c5d2892 | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 4267 | case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] |
| 4268 | // new form of select |
| 4269 | // handles select i1 or select [N x i1] |
| 4270 | unsigned OpNum = 0; |
| 4271 | Value *TrueVal, *FalseVal, *Cond; |
| 4272 | if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4273 | popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || |
Dan Gohman | c5d2892 | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 4274 | getValueTypePair(Record, OpNum, NextValueNo, Cond)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4275 | return error("Invalid record"); |
Dan Gohman | c579d97 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 4276 | |
| 4277 | // select condition can be either i1 or [N x i1] |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 4278 | if (VectorType* vector_type = |
| 4279 | dyn_cast<VectorType>(Cond->getType())) { |
Dan Gohman | c579d97 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 4280 | // expect <n x i1> |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4281 | if (vector_type->getElementType() != Type::getInt1Ty(Context)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4282 | return error("Invalid type for value"); |
Dan Gohman | c579d97 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 4283 | } else { |
| 4284 | // expect i1 |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4285 | if (Cond->getType() != Type::getInt1Ty(Context)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4286 | return error("Invalid type for value"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4287 | } |
| 4288 | |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 4289 | I = SelectInst::Create(Cond, TrueVal, FalseVal); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4290 | InstructionList.push_back(I); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4291 | break; |
| 4292 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4293 | |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4294 | case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4295 | unsigned OpNum = 0; |
| 4296 | Value *Vec, *Idx; |
| 4297 | if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 4298 | getValueTypePair(Record, OpNum, NextValueNo, Idx)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4299 | return error("Invalid record"); |
Filipe Cabecinhas | ff1e234 | 2015-04-24 11:30:15 +0000 | [diff] [blame] | 4300 | if (!Vec->getType()->isVectorTy()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4301 | return error("Invalid type for value"); |
Eric Christopher | c974225 | 2009-07-25 02:28:41 +0000 | [diff] [blame] | 4302 | I = ExtractElementInst::Create(Vec, Idx); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4303 | InstructionList.push_back(I); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4304 | break; |
| 4305 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4306 | |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4307 | case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4308 | unsigned OpNum = 0; |
| 4309 | Value *Vec, *Elt, *Idx; |
Filipe Cabecinhas | ff1e234 | 2015-04-24 11:30:15 +0000 | [diff] [blame] | 4310 | if (getValueTypePair(Record, OpNum, NextValueNo, Vec)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4311 | return error("Invalid record"); |
Filipe Cabecinhas | ff1e234 | 2015-04-24 11:30:15 +0000 | [diff] [blame] | 4312 | if (!Vec->getType()->isVectorTy()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4313 | return error("Invalid type for value"); |
Filipe Cabecinhas | ff1e234 | 2015-04-24 11:30:15 +0000 | [diff] [blame] | 4314 | if (popValue(Record, OpNum, NextValueNo, |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4315 | cast<VectorType>(Vec->getType())->getElementType(), Elt) || |
Michael J. Spencer | 1f10c5ea | 2014-05-01 22:12:39 +0000 | [diff] [blame] | 4316 | getValueTypePair(Record, OpNum, NextValueNo, Idx)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4317 | return error("Invalid record"); |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 4318 | I = InsertElementInst::Create(Vec, Elt, Idx); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4319 | InstructionList.push_back(I); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4320 | break; |
| 4321 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4322 | |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4323 | case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] |
| 4324 | unsigned OpNum = 0; |
| 4325 | Value *Vec1, *Vec2, *Mask; |
| 4326 | if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4327 | popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4328 | return error("Invalid record"); |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4329 | |
Mon P Wang | 25f0106 | 2008-11-10 04:46:22 +0000 | [diff] [blame] | 4330 | if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4331 | return error("Invalid record"); |
Filipe Cabecinhas | ff1e234 | 2015-04-24 11:30:15 +0000 | [diff] [blame] | 4332 | if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4333 | return error("Invalid type for value"); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4334 | I = new ShuffleVectorInst(Vec1, Vec2, Mask); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4335 | InstructionList.push_back(I); |
Chris Lattner | 1fc27f0 | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 4336 | break; |
| 4337 | } |
Mon P Wang | 25f0106 | 2008-11-10 04:46:22 +0000 | [diff] [blame] | 4338 | |
Nick Lewycky | a21d3da | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 4339 | case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] |
| 4340 | // Old form of ICmp/FCmp returning bool |
| 4341 | // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were |
| 4342 | // both legal on vectors but had different behaviour. |
| 4343 | case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] |
| 4344 | // FCmp/ICmp returning bool or vector of bool |
| 4345 | |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4346 | unsigned OpNum = 0; |
| 4347 | Value *LHS, *RHS; |
| 4348 | if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || |
James Molloy | 88eb535 | 2015-07-10 12:52:00 +0000 | [diff] [blame] | 4349 | popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS)) |
| 4350 | return error("Invalid record"); |
| 4351 | |
| 4352 | unsigned PredVal = Record[OpNum]; |
| 4353 | bool IsFP = LHS->getType()->isFPOrFPVectorTy(); |
| 4354 | FastMathFlags FMF; |
| 4355 | if (IsFP && Record.size() > OpNum+1) |
| 4356 | FMF = getDecodedFastMathFlags(Record[++OpNum]); |
| 4357 | |
| 4358 | if (OpNum+1 != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4359 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4360 | |
Duncan Sands | 9dff9be | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 4361 | if (LHS->getType()->isFPOrFPVectorTy()) |
James Molloy | 88eb535 | 2015-07-10 12:52:00 +0000 | [diff] [blame] | 4362 | I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS); |
Nick Lewycky | a21d3da | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 4363 | else |
James Molloy | 88eb535 | 2015-07-10 12:52:00 +0000 | [diff] [blame] | 4364 | I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS); |
| 4365 | |
| 4366 | if (FMF.any()) |
| 4367 | I->setFastMathFlags(FMF); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4368 | InstructionList.push_back(I); |
Dan Gohman | c579d97 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 4369 | break; |
| 4370 | } |
Nick Lewycky | a21d3da | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 4371 | |
Chris Lattner | e53603e | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 4372 | case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] |
Devang Patel | bbfd874 | 2008-02-26 01:29:32 +0000 | [diff] [blame] | 4373 | { |
| 4374 | unsigned Size = Record.size(); |
| 4375 | if (Size == 0) { |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 4376 | I = ReturnInst::Create(Context); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4377 | InstructionList.push_back(I); |
Devang Patel | bbfd874 | 2008-02-26 01:29:32 +0000 | [diff] [blame] | 4378 | break; |
Dan Gohman | fa1211f | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 4379 | } |
Devang Patel | bbfd874 | 2008-02-26 01:29:32 +0000 | [diff] [blame] | 4380 | |
Dan Gohman | fa1211f | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 4381 | unsigned OpNum = 0; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4382 | Value *Op = nullptr; |
Chris Lattner | f1c8710 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 4383 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4384 | return error("Invalid record"); |
Chris Lattner | f1c8710 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 4385 | if (OpNum != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4386 | return error("Invalid record"); |
Dan Gohman | fa1211f | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 4387 | |
Chris Lattner | f1c8710 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 4388 | I = ReturnInst::Create(Context, Op); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4389 | InstructionList.push_back(I); |
Dan Gohman | fa1211f | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 4390 | break; |
Chris Lattner | e53603e | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 4391 | } |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4392 | case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] |
Chris Lattner | 6ce15cb | 2007-05-03 22:09:51 +0000 | [diff] [blame] | 4393 | if (Record.size() != 1 && Record.size() != 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4394 | return error("Invalid record"); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4395 | BasicBlock *TrueDest = getBasicBlock(Record[0]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4396 | if (!TrueDest) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4397 | return error("Invalid record"); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4398 | |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4399 | if (Record.size() == 1) { |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 4400 | I = BranchInst::Create(TrueDest); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4401 | InstructionList.push_back(I); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4402 | } |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4403 | else { |
| 4404 | BasicBlock *FalseDest = getBasicBlock(Record[1]); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4405 | Value *Cond = getValue(Record, 2, NextValueNo, |
| 4406 | Type::getInt1Ty(Context)); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4407 | if (!FalseDest || !Cond) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4408 | return error("Invalid record"); |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 4409 | I = BranchInst::Create(TrueDest, FalseDest, Cond); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4410 | InstructionList.push_back(I); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4411 | } |
| 4412 | break; |
| 4413 | } |
David Majnemer | b01aa9f | 2015-08-23 19:22:31 +0000 | [diff] [blame] | 4414 | case bitc::FUNC_CODE_INST_CLEANUPRET: { // CLEANUPRET: [val] or [val,bb#] |
Joseph Tremoulet | 8220bcc | 2015-08-23 00:26:33 +0000 | [diff] [blame] | 4415 | if (Record.size() != 1 && Record.size() != 2) |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4416 | return error("Invalid record"); |
| 4417 | unsigned Idx = 0; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4418 | Value *CleanupPad = |
| 4419 | getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); |
Joseph Tremoulet | 8220bcc | 2015-08-23 00:26:33 +0000 | [diff] [blame] | 4420 | if (!CleanupPad) |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4421 | return error("Invalid record"); |
Joseph Tremoulet | 8220bcc | 2015-08-23 00:26:33 +0000 | [diff] [blame] | 4422 | BasicBlock *UnwindDest = nullptr; |
| 4423 | if (Record.size() == 2) { |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4424 | UnwindDest = getBasicBlock(Record[Idx++]); |
| 4425 | if (!UnwindDest) |
| 4426 | return error("Invalid record"); |
| 4427 | } |
| 4428 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4429 | I = CleanupReturnInst::Create(CleanupPad, UnwindDest); |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4430 | InstructionList.push_back(I); |
| 4431 | break; |
| 4432 | } |
Joseph Tremoulet | 8220bcc | 2015-08-23 00:26:33 +0000 | [diff] [blame] | 4433 | case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [val,bb#] |
| 4434 | if (Record.size() != 2) |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4435 | return error("Invalid record"); |
David Majnemer | 0bc0eef | 2015-08-15 02:46:08 +0000 | [diff] [blame] | 4436 | unsigned Idx = 0; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4437 | Value *CatchPad = |
| 4438 | getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); |
Joseph Tremoulet | 8220bcc | 2015-08-23 00:26:33 +0000 | [diff] [blame] | 4439 | if (!CatchPad) |
| 4440 | return error("Invalid record"); |
David Majnemer | 0bc0eef | 2015-08-15 02:46:08 +0000 | [diff] [blame] | 4441 | BasicBlock *BB = getBasicBlock(Record[Idx++]); |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4442 | if (!BB) |
| 4443 | return error("Invalid record"); |
David Majnemer | 0bc0eef | 2015-08-15 02:46:08 +0000 | [diff] [blame] | 4444 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4445 | I = CatchReturnInst::Create(CatchPad, BB); |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4446 | InstructionList.push_back(I); |
| 4447 | break; |
| 4448 | } |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4449 | case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?] |
| 4450 | // We must have, at minimum, the outer scope and the number of arguments. |
| 4451 | if (Record.size() < 2) |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4452 | return error("Invalid record"); |
| 4453 | |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4454 | unsigned Idx = 0; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4455 | |
| 4456 | Value *ParentPad = |
| 4457 | getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); |
| 4458 | |
| 4459 | unsigned NumHandlers = Record[Idx++]; |
| 4460 | |
| 4461 | SmallVector<BasicBlock *, 2> Handlers; |
| 4462 | for (unsigned Op = 0; Op != NumHandlers; ++Op) { |
| 4463 | BasicBlock *BB = getBasicBlock(Record[Idx++]); |
| 4464 | if (!BB) |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4465 | return error("Invalid record"); |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4466 | Handlers.push_back(BB); |
| 4467 | } |
| 4468 | |
| 4469 | BasicBlock *UnwindDest = nullptr; |
| 4470 | if (Idx + 1 == Record.size()) { |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4471 | UnwindDest = getBasicBlock(Record[Idx++]); |
| 4472 | if (!UnwindDest) |
| 4473 | return error("Invalid record"); |
| 4474 | } |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4475 | |
| 4476 | if (Record.size() != Idx) |
| 4477 | return error("Invalid record"); |
| 4478 | |
| 4479 | auto *CatchSwitch = |
| 4480 | CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers); |
| 4481 | for (BasicBlock *Handler : Handlers) |
| 4482 | CatchSwitch->addHandler(Handler); |
| 4483 | I = CatchSwitch; |
| 4484 | InstructionList.push_back(I); |
| 4485 | break; |
| 4486 | } |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4487 | case bitc::FUNC_CODE_INST_CATCHPAD: |
| 4488 | case bitc::FUNC_CODE_INST_CLEANUPPAD: { // [tok,num,(ty,val)*] |
| 4489 | // We must have, at minimum, the outer scope and the number of arguments. |
| 4490 | if (Record.size() < 2) |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4491 | return error("Invalid record"); |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4492 | |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4493 | unsigned Idx = 0; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4494 | |
| 4495 | Value *ParentPad = |
| 4496 | getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); |
| 4497 | |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4498 | unsigned NumArgOperands = Record[Idx++]; |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4499 | |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4500 | SmallVector<Value *, 2> Args; |
| 4501 | for (unsigned Op = 0; Op != NumArgOperands; ++Op) { |
| 4502 | Value *Val; |
| 4503 | if (getValueTypePair(Record, Idx, NextValueNo, Val)) |
| 4504 | return error("Invalid record"); |
| 4505 | Args.push_back(Val); |
| 4506 | } |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4507 | |
David Majnemer | 654e130 | 2015-07-31 17:58:14 +0000 | [diff] [blame] | 4508 | if (Record.size() != Idx) |
| 4509 | return error("Invalid record"); |
| 4510 | |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 4511 | if (BitCode == bitc::FUNC_CODE_INST_CLEANUPPAD) |
| 4512 | I = CleanupPadInst::Create(ParentPad, Args); |
| 4513 | else |
| 4514 | I = CatchPadInst::Create(ParentPad, Args); |
Joseph Tremoulet | 9ce71f7 | 2015-09-03 09:09:43 +0000 | [diff] [blame] | 4515 | InstructionList.push_back(I); |
| 4516 | break; |
| 4517 | } |
Chris Lattner | 3ed871f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 4518 | case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4519 | // Check magic |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4520 | if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { |
Bob Wilson | e407736 | 2013-09-09 19:14:35 +0000 | [diff] [blame] | 4521 | // "New" SwitchInst format with case ranges. The changes to write this |
| 4522 | // format were reverted but we still recognize bitcode that uses it. |
| 4523 | // Hopefully someday we will have support for case ranges and can use |
| 4524 | // this format again. |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4525 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4526 | Type *OpTy = getTypeByID(Record[1]); |
| 4527 | unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth(); |
| 4528 | |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4529 | Value *Cond = getValue(Record, 2, NextValueNo, OpTy); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4530 | BasicBlock *Default = getBasicBlock(Record[3]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4531 | if (!OpTy || !Cond || !Default) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4532 | return error("Invalid record"); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4533 | |
| 4534 | unsigned NumCases = Record[4]; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4535 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4536 | SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); |
| 4537 | InstructionList.push_back(SI); |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4538 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4539 | unsigned CurIdx = 5; |
| 4540 | for (unsigned i = 0; i != NumCases; ++i) { |
Bob Wilson | e407736 | 2013-09-09 19:14:35 +0000 | [diff] [blame] | 4541 | SmallVector<ConstantInt*, 1> CaseVals; |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4542 | unsigned NumItems = Record[CurIdx++]; |
| 4543 | for (unsigned ci = 0; ci != NumItems; ++ci) { |
| 4544 | bool isSingleNumber = Record[CurIdx++]; |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4545 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4546 | APInt Low; |
| 4547 | unsigned ActiveWords = 1; |
| 4548 | if (ValueBitWidth > 64) |
| 4549 | ActiveWords = Record[CurIdx++]; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4550 | Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), |
Benjamin Kramer | 9704ed0 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 4551 | ValueBitWidth); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4552 | CurIdx += ActiveWords; |
Stepan Dyatkovskiy | e3e19cb | 2012-05-28 12:39:09 +0000 | [diff] [blame] | 4553 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4554 | if (!isSingleNumber) { |
| 4555 | ActiveWords = 1; |
| 4556 | if (ValueBitWidth > 64) |
| 4557 | ActiveWords = Record[CurIdx++]; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4558 | APInt High = readWideAPInt( |
| 4559 | makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4560 | CurIdx += ActiveWords; |
Bob Wilson | e407736 | 2013-09-09 19:14:35 +0000 | [diff] [blame] | 4561 | |
| 4562 | // FIXME: It is not clear whether values in the range should be |
| 4563 | // compared as signed or unsigned values. The partially |
| 4564 | // implemented changes that used this format in the past used |
| 4565 | // unsigned comparisons. |
| 4566 | for ( ; Low.ule(High); ++Low) |
| 4567 | CaseVals.push_back(ConstantInt::get(Context, Low)); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4568 | } else |
Bob Wilson | e407736 | 2013-09-09 19:14:35 +0000 | [diff] [blame] | 4569 | CaseVals.push_back(ConstantInt::get(Context, Low)); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4570 | } |
| 4571 | BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); |
Bob Wilson | e407736 | 2013-09-09 19:14:35 +0000 | [diff] [blame] | 4572 | for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(), |
| 4573 | cve = CaseVals.end(); cvi != cve; ++cvi) |
| 4574 | SI->addCase(*cvi, DestBB); |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4575 | } |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4576 | I = SI; |
| 4577 | break; |
| 4578 | } |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4579 | |
Stepan Dyatkovskiy | 0beab5e | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 4580 | // Old SwitchInst format without case ranges. |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4581 | |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4582 | if (Record.size() < 3 || (Record.size() & 1) == 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4583 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 4584 | Type *OpTy = getTypeByID(Record[0]); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4585 | Value *Cond = getValue(Record, 1, NextValueNo, OpTy); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4586 | BasicBlock *Default = getBasicBlock(Record[2]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4587 | if (!OpTy || !Cond || !Default) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4588 | return error("Invalid record"); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4589 | unsigned NumCases = (Record.size()-3)/2; |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 4590 | SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4591 | InstructionList.push_back(SI); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4592 | for (unsigned i = 0, e = NumCases; i != e; ++i) { |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4593 | ConstantInt *CaseVal = |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4594 | dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); |
| 4595 | BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4596 | if (!CaseVal || !DestBB) { |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4597 | delete SI; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4598 | return error("Invalid record"); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4599 | } |
| 4600 | SI->addCase(CaseVal, DestBB); |
| 4601 | } |
| 4602 | I = SI; |
| 4603 | break; |
| 4604 | } |
Chris Lattner | d04cb6d | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 4605 | case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] |
Chris Lattner | 3ed871f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 4606 | if (Record.size() < 2) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4607 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 4608 | Type *OpTy = getTypeByID(Record[0]); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4609 | Value *Address = getValue(Record, 1, NextValueNo, OpTy); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4610 | if (!OpTy || !Address) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4611 | return error("Invalid record"); |
Chris Lattner | 3ed871f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 4612 | unsigned NumDests = Record.size()-2; |
Chris Lattner | d04cb6d | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 4613 | IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); |
Chris Lattner | 3ed871f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 4614 | InstructionList.push_back(IBI); |
| 4615 | for (unsigned i = 0, e = NumDests; i != e; ++i) { |
| 4616 | if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { |
| 4617 | IBI->addDestination(DestBB); |
| 4618 | } else { |
| 4619 | delete IBI; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4620 | return error("Invalid record"); |
Chris Lattner | 3ed871f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 4621 | } |
| 4622 | } |
| 4623 | I = IBI; |
| 4624 | break; |
| 4625 | } |
Michael Ilseman | 26ee2b8 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 4626 | |
Duncan Sands | ad0ea2d | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 4627 | case bitc::FUNC_CODE_INST_INVOKE: { |
| 4628 | // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 4629 | if (Record.size() < 4) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4630 | return error("Invalid record"); |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4631 | unsigned OpNum = 0; |
| 4632 | AttributeSet PAL = getAttributes(Record[OpNum++]); |
| 4633 | unsigned CCInfo = Record[OpNum++]; |
| 4634 | BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]); |
| 4635 | BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4636 | |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4637 | FunctionType *FTy = nullptr; |
| 4638 | if (CCInfo >> 13 & 1 && |
| 4639 | !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++])))) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4640 | return error("Explicit invoke type is not a function type"); |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4641 | |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4642 | Value *Callee; |
| 4643 | if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4644 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4645 | |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 4646 | PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4647 | if (!CalleeTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4648 | return error("Callee is not a pointer"); |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4649 | if (!FTy) { |
| 4650 | FTy = dyn_cast<FunctionType>(CalleeTy->getElementType()); |
| 4651 | if (!FTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4652 | return error("Callee is not of pointer to function type"); |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4653 | } else if (CalleeTy->getElementType() != FTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4654 | return error("Explicit invoke type does not match pointee type of " |
David Blaikie | 5ea1f7b | 2015-04-24 18:06:06 +0000 | [diff] [blame] | 4655 | "callee operand"); |
| 4656 | if (Record.size() < FTy->getNumParams() + OpNum) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4657 | return error("Insufficient operands to call"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4658 | |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4659 | SmallVector<Value*, 16> Ops; |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4660 | for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4661 | Ops.push_back(getValue(Record, OpNum, NextValueNo, |
| 4662 | FTy->getParamType(i))); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4663 | if (!Ops.back()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4664 | return error("Invalid record"); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4665 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4666 | |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4667 | if (!FTy->isVarArg()) { |
| 4668 | if (Record.size() != OpNum) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4669 | return error("Invalid record"); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4670 | } else { |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4671 | // Read type/value pairs for varargs params. |
| 4672 | while (OpNum != Record.size()) { |
| 4673 | Value *Op; |
| 4674 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4675 | return error("Invalid record"); |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4676 | Ops.push_back(Op); |
| 4677 | } |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4678 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4679 | |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 4680 | I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops, OperandBundles); |
| 4681 | OperandBundles.clear(); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4682 | InstructionList.push_back(I); |
Vedant Kumar | ad6d6e7 | 2015-10-27 21:17:06 +0000 | [diff] [blame] | 4683 | cast<InvokeInst>(I)->setCallingConv( |
| 4684 | static_cast<CallingConv::ID>(CallingConv::MaxID & CCInfo)); |
Devang Patel | 4c758ea | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 4685 | cast<InvokeInst>(I)->setAttributes(PAL); |
Chris Lattner | 5285b5e | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 4686 | break; |
| 4687 | } |
Bill Wendling | f891bf8 | 2011-07-31 06:30:59 +0000 | [diff] [blame] | 4688 | case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] |
| 4689 | unsigned Idx = 0; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 4690 | Value *Val = nullptr; |
Bill Wendling | f891bf8 | 2011-07-31 06:30:59 +0000 | [diff] [blame] | 4691 | if (getValueTypePair(Record, Idx, NextValueNo, Val)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4692 | return error("Invalid record"); |
Bill Wendling | f891bf8 | 2011-07-31 06:30:59 +0000 | [diff] [blame] | 4693 | I = ResumeInst::Create(Val); |
Bill Wendling | b9a8999 | 2011-09-01 00:50:20 +0000 | [diff] [blame] | 4694 | InstructionList.push_back(I); |
Bill Wendling | f891bf8 | 2011-07-31 06:30:59 +0000 | [diff] [blame] | 4695 | break; |
| 4696 | } |
Chris Lattner | e53603e | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 4697 | case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE |
Owen Anderson | 55f1c09 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 4698 | I = new UnreachableInst(Context); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4699 | InstructionList.push_back(I); |
Chris Lattner | e53603e | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 4700 | break; |
Chris Lattner | e9759c2 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 4701 | case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 4702 | if (Record.size() < 1 || ((Record.size()-1)&1)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4703 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 4704 | Type *Ty = getTypeByID(Record[0]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 4705 | if (!Ty) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4706 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4707 | |
Jay Foad | 5213134 | 2011-03-30 11:28:46 +0000 | [diff] [blame] | 4708 | PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4709 | InstructionList.push_back(PN); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4710 | |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 4711 | for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4712 | Value *V; |
| 4713 | // With the new function encoding, it is possible that operands have |
| 4714 | // negative IDs (for forward references). Use a signed VBR |
| 4715 | // representation to keep the encoding small. |
| 4716 | if (UseRelativeIDs) |
| 4717 | V = getValueSigned(Record, 1+i, NextValueNo, Ty); |
| 4718 | else |
| 4719 | V = getValue(Record, 1+i, NextValueNo, Ty); |
Chris Lattner | e14cb88 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 4720 | BasicBlock *BB = getBasicBlock(Record[2+i]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 4721 | if (!V || !BB) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4722 | return error("Invalid record"); |
Chris Lattner | c332bba | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 4723 | PN->addIncoming(V, BB); |
| 4724 | } |
| 4725 | I = PN; |
| 4726 | break; |
| 4727 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 4728 | |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 4729 | case bitc::FUNC_CODE_INST_LANDINGPAD: |
| 4730 | case bitc::FUNC_CODE_INST_LANDINGPAD_OLD: { |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4731 | // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] |
| 4732 | unsigned Idx = 0; |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 4733 | if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD) { |
| 4734 | if (Record.size() < 3) |
| 4735 | return error("Invalid record"); |
| 4736 | } else { |
| 4737 | assert(BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD); |
| 4738 | if (Record.size() < 4) |
| 4739 | return error("Invalid record"); |
| 4740 | } |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4741 | Type *Ty = getTypeByID(Record[Idx++]); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 4742 | if (!Ty) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4743 | return error("Invalid record"); |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 4744 | if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) { |
| 4745 | Value *PersFn = nullptr; |
| 4746 | if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) |
| 4747 | return error("Invalid record"); |
| 4748 | |
| 4749 | if (!F->hasPersonalityFn()) |
| 4750 | F->setPersonalityFn(cast<Constant>(PersFn)); |
| 4751 | else if (F->getPersonalityFn() != cast<Constant>(PersFn)) |
| 4752 | return error("Personality function mismatch"); |
| 4753 | } |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4754 | |
| 4755 | bool IsCleanup = !!Record[Idx++]; |
| 4756 | unsigned NumClauses = Record[Idx++]; |
David Majnemer | 7fddecc | 2015-06-17 20:52:32 +0000 | [diff] [blame] | 4757 | LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses); |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4758 | LP->setCleanup(IsCleanup); |
| 4759 | for (unsigned J = 0; J != NumClauses; ++J) { |
| 4760 | LandingPadInst::ClauseType CT = |
| 4761 | LandingPadInst::ClauseType(Record[Idx++]); (void)CT; |
| 4762 | Value *Val; |
| 4763 | |
| 4764 | if (getValueTypePair(Record, Idx, NextValueNo, Val)) { |
| 4765 | delete LP; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4766 | return error("Invalid record"); |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4767 | } |
| 4768 | |
| 4769 | assert((CT != LandingPadInst::Catch || |
| 4770 | !isa<ArrayType>(Val->getType())) && |
| 4771 | "Catch clause has a invalid type!"); |
| 4772 | assert((CT != LandingPadInst::Filter || |
| 4773 | isa<ArrayType>(Val->getType())) && |
| 4774 | "Filter clause has invalid type!"); |
Rafael Espindola | 4dc5dfc | 2014-06-04 18:51:31 +0000 | [diff] [blame] | 4775 | LP->addClause(cast<Constant>(Val)); |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4776 | } |
| 4777 | |
| 4778 | I = LP; |
Bill Wendling | b9a8999 | 2011-09-01 00:50:20 +0000 | [diff] [blame] | 4779 | InstructionList.push_back(I); |
Bill Wendling | fae1475 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 4780 | break; |
| 4781 | } |
| 4782 | |
Chris Lattner | f1c8710 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 4783 | case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] |
| 4784 | if (Record.size() != 4) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4785 | return error("Invalid record"); |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4786 | uint64_t AlignRecord = Record[3]; |
| 4787 | const uint64_t InAllocaMask = uint64_t(1) << 5; |
David Blaikie | bdb4910 | 2015-04-28 16:51:01 +0000 | [diff] [blame] | 4788 | const uint64_t ExplicitTypeMask = uint64_t(1) << 6; |
Bob Wilson | 043ee65 | 2015-07-28 04:05:45 +0000 | [diff] [blame] | 4789 | // Reserve bit 7 for SwiftError flag. |
| 4790 | // const uint64_t SwiftErrorMask = uint64_t(1) << 7; |
David Blaikie | bdb4910 | 2015-04-28 16:51:01 +0000 | [diff] [blame] | 4791 | const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask; |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4792 | bool InAlloca = AlignRecord & InAllocaMask; |
David Blaikie | bdb4910 | 2015-04-28 16:51:01 +0000 | [diff] [blame] | 4793 | Type *Ty = getTypeByID(Record[0]); |
| 4794 | if ((AlignRecord & ExplicitTypeMask) == 0) { |
| 4795 | auto *PTy = dyn_cast_or_null<PointerType>(Ty); |
| 4796 | if (!PTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4797 | return error("Old-style alloca with a non-pointer type"); |
David Blaikie | bdb4910 | 2015-04-28 16:51:01 +0000 | [diff] [blame] | 4798 | Ty = PTy->getElementType(); |
| 4799 | } |
| 4800 | Type *OpTy = getTypeByID(Record[1]); |
| 4801 | Value *Size = getFnValueByID(Record[2], OpTy); |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4802 | unsigned Align; |
| 4803 | if (std::error_code EC = |
David Blaikie | bdb4910 | 2015-04-28 16:51:01 +0000 | [diff] [blame] | 4804 | parseAlignmentValue(AlignRecord & ~FlagMask, Align)) { |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4805 | return EC; |
| 4806 | } |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 4807 | if (!Ty || !Size) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4808 | return error("Invalid record"); |
David Blaikie | bdb4910 | 2015-04-28 16:51:01 +0000 | [diff] [blame] | 4809 | AllocaInst *AI = new AllocaInst(Ty, Size, Align); |
Reid Kleckner | 56b56ea | 2014-07-16 01:34:27 +0000 | [diff] [blame] | 4810 | AI->setUsedWithInAlloca(InAlloca); |
| 4811 | I = AI; |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4812 | InstructionList.push_back(I); |
Chris Lattner | c332bba | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 4813 | break; |
| 4814 | } |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 4815 | case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 4816 | unsigned OpNum = 0; |
| 4817 | Value *Op; |
| 4818 | if (getValueTypePair(Record, OpNum, NextValueNo, Op) || |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4819 | (OpNum + 2 != Record.size() && OpNum + 3 != Record.size())) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4820 | return error("Invalid record"); |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4821 | |
| 4822 | Type *Ty = nullptr; |
| 4823 | if (OpNum + 3 == Record.size()) |
| 4824 | Ty = getTypeByID(Record[OpNum++]); |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4825 | if (std::error_code EC = |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4826 | typeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType())) |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4827 | return EC; |
David Blaikie | b7a02987 | 2015-04-17 19:56:21 +0000 | [diff] [blame] | 4828 | if (!Ty) |
| 4829 | Ty = cast<PointerType>(Op->getType())->getElementType(); |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4830 | |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4831 | unsigned Align; |
| 4832 | if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align)) |
| 4833 | return EC; |
David Blaikie | b7a02987 | 2015-04-17 19:56:21 +0000 | [diff] [blame] | 4834 | I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align); |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4835 | |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4836 | InstructionList.push_back(I); |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 4837 | break; |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 4838 | } |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4839 | case bitc::FUNC_CODE_INST_LOADATOMIC: { |
| 4840 | // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] |
| 4841 | unsigned OpNum = 0; |
| 4842 | Value *Op; |
| 4843 | if (getValueTypePair(Record, OpNum, NextValueNo, Op) || |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4844 | (OpNum + 4 != Record.size() && OpNum + 5 != Record.size())) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4845 | return error("Invalid record"); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4846 | |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4847 | Type *Ty = nullptr; |
| 4848 | if (OpNum + 5 == Record.size()) |
| 4849 | Ty = getTypeByID(Record[OpNum++]); |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4850 | if (std::error_code EC = |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4851 | typeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType())) |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4852 | return EC; |
| 4853 | if (!Ty) |
| 4854 | Ty = cast<PointerType>(Op->getType())->getElementType(); |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4855 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4856 | AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4857 | if (Ordering == NotAtomic || Ordering == Release || |
| 4858 | Ordering == AcquireRelease) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4859 | return error("Invalid record"); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4860 | if (Ordering != NotAtomic && Record[OpNum] == 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4861 | return error("Invalid record"); |
| 4862 | SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 3]); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4863 | |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4864 | unsigned Align; |
| 4865 | if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align)) |
| 4866 | return EC; |
| 4867 | I = new LoadInst(Op, "", Record[OpNum+1], Align, Ordering, SynchScope); |
David Blaikie | 8503565 | 2015-02-25 01:07:20 +0000 | [diff] [blame] | 4868 | |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4869 | InstructionList.push_back(I); |
| 4870 | break; |
| 4871 | } |
David Blaikie | 612ddbf | 2015-04-22 04:14:42 +0000 | [diff] [blame] | 4872 | case bitc::FUNC_CODE_INST_STORE: |
| 4873 | case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol] |
Christopher Lamb | 54dd24c | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 4874 | unsigned OpNum = 0; |
| 4875 | Value *Val, *Ptr; |
| 4876 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
David Blaikie | 612ddbf | 2015-04-22 04:14:42 +0000 | [diff] [blame] | 4877 | (BitCode == bitc::FUNC_CODE_INST_STORE |
| 4878 | ? getValueTypePair(Record, OpNum, NextValueNo, Val) |
| 4879 | : popValue(Record, OpNum, NextValueNo, |
| 4880 | cast<PointerType>(Ptr->getType())->getElementType(), |
| 4881 | Val)) || |
| 4882 | OpNum + 2 != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4883 | return error("Invalid record"); |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4884 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4885 | if (std::error_code EC = typeCheckLoadStoreInst( |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4886 | DiagnosticHandler, Val->getType(), Ptr->getType())) |
| 4887 | return EC; |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4888 | unsigned Align; |
| 4889 | if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align)) |
| 4890 | return EC; |
| 4891 | I = new StoreInst(Val, Ptr, Record[OpNum+1], Align); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 4892 | InstructionList.push_back(I); |
Christopher Lamb | 54dd24c | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 4893 | break; |
| 4894 | } |
David Blaikie | 50a0615 | 2015-04-22 04:14:46 +0000 | [diff] [blame] | 4895 | case bitc::FUNC_CODE_INST_STOREATOMIC: |
| 4896 | case bitc::FUNC_CODE_INST_STOREATOMIC_OLD: { |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4897 | // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] |
| 4898 | unsigned OpNum = 0; |
| 4899 | Value *Val, *Ptr; |
| 4900 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
David Blaikie | 50a0615 | 2015-04-22 04:14:46 +0000 | [diff] [blame] | 4901 | (BitCode == bitc::FUNC_CODE_INST_STOREATOMIC |
| 4902 | ? getValueTypePair(Record, OpNum, NextValueNo, Val) |
| 4903 | : popValue(Record, OpNum, NextValueNo, |
| 4904 | cast<PointerType>(Ptr->getType())->getElementType(), |
| 4905 | Val)) || |
| 4906 | OpNum + 4 != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4907 | return error("Invalid record"); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4908 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4909 | if (std::error_code EC = typeCheckLoadStoreInst( |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4910 | DiagnosticHandler, Val->getType(), Ptr->getType())) |
| 4911 | return EC; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4912 | AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]); |
Eli Friedman | 222b5a4 | 2011-09-19 19:41:28 +0000 | [diff] [blame] | 4913 | if (Ordering == NotAtomic || Ordering == Acquire || |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4914 | Ordering == AcquireRelease) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4915 | return error("Invalid record"); |
| 4916 | SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 3]); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4917 | if (Ordering != NotAtomic && Record[OpNum] == 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4918 | return error("Invalid record"); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4919 | |
JF Bastien | 30bf96b | 2015-02-22 19:32:03 +0000 | [diff] [blame] | 4920 | unsigned Align; |
| 4921 | if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align)) |
| 4922 | return EC; |
| 4923 | I = new StoreInst(Val, Ptr, Record[OpNum+1], Align, Ordering, SynchScope); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4924 | InstructionList.push_back(I); |
| 4925 | break; |
| 4926 | } |
David Blaikie | 2a661cd | 2015-04-28 04:30:29 +0000 | [diff] [blame] | 4927 | case bitc::FUNC_CODE_INST_CMPXCHG_OLD: |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4928 | case bitc::FUNC_CODE_INST_CMPXCHG: { |
Tim Northover | e94a518 | 2014-03-11 10:48:52 +0000 | [diff] [blame] | 4929 | // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, synchscope, |
Tim Northover | 420a216 | 2014-06-13 14:24:07 +0000 | [diff] [blame] | 4930 | // failureordering?, isweak?] |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4931 | unsigned OpNum = 0; |
| 4932 | Value *Ptr, *Cmp, *New; |
| 4933 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
David Blaikie | 2a661cd | 2015-04-28 04:30:29 +0000 | [diff] [blame] | 4934 | (BitCode == bitc::FUNC_CODE_INST_CMPXCHG |
| 4935 | ? getValueTypePair(Record, OpNum, NextValueNo, Cmp) |
| 4936 | : popValue(Record, OpNum, NextValueNo, |
| 4937 | cast<PointerType>(Ptr->getType())->getElementType(), |
| 4938 | Cmp)) || |
| 4939 | popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) || |
| 4940 | Record.size() < OpNum + 3 || Record.size() > OpNum + 5) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4941 | return error("Invalid record"); |
| 4942 | AtomicOrdering SuccessOrdering = getDecodedOrdering(Record[OpNum + 1]); |
Tim Northover | e94a518 | 2014-03-11 10:48:52 +0000 | [diff] [blame] | 4943 | if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4944 | return error("Invalid record"); |
| 4945 | SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 2]); |
Tim Northover | e94a518 | 2014-03-11 10:48:52 +0000 | [diff] [blame] | 4946 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4947 | if (std::error_code EC = typeCheckLoadStoreInst( |
Filipe Cabecinhas | 11bb849 | 2015-05-18 21:48:55 +0000 | [diff] [blame] | 4948 | DiagnosticHandler, Cmp->getType(), Ptr->getType())) |
| 4949 | return EC; |
Tim Northover | e94a518 | 2014-03-11 10:48:52 +0000 | [diff] [blame] | 4950 | AtomicOrdering FailureOrdering; |
| 4951 | if (Record.size() < 7) |
| 4952 | FailureOrdering = |
| 4953 | AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering); |
| 4954 | else |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4955 | FailureOrdering = getDecodedOrdering(Record[OpNum + 3]); |
Tim Northover | e94a518 | 2014-03-11 10:48:52 +0000 | [diff] [blame] | 4956 | |
| 4957 | I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering, |
| 4958 | SynchScope); |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4959 | cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); |
Tim Northover | 420a216 | 2014-06-13 14:24:07 +0000 | [diff] [blame] | 4960 | |
| 4961 | if (Record.size() < 8) { |
| 4962 | // Before weak cmpxchgs existed, the instruction simply returned the |
| 4963 | // value loaded from memory, so bitcode files from that era will be |
| 4964 | // expecting the first component of a modern cmpxchg. |
| 4965 | CurBB->getInstList().push_back(I); |
| 4966 | I = ExtractValueInst::Create(I, 0); |
| 4967 | } else { |
| 4968 | cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]); |
| 4969 | } |
| 4970 | |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4971 | InstructionList.push_back(I); |
| 4972 | break; |
| 4973 | } |
| 4974 | case bitc::FUNC_CODE_INST_ATOMICRMW: { |
| 4975 | // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] |
| 4976 | unsigned OpNum = 0; |
| 4977 | Value *Ptr, *Val; |
| 4978 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 4979 | popValue(Record, OpNum, NextValueNo, |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4980 | cast<PointerType>(Ptr->getType())->getElementType(), Val) || |
| 4981 | OpNum+4 != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4982 | return error("Invalid record"); |
| 4983 | AtomicRMWInst::BinOp Operation = getDecodedRMWOperation(Record[OpNum]); |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4984 | if (Operation < AtomicRMWInst::FIRST_BINOP || |
| 4985 | Operation > AtomicRMWInst::LAST_BINOP) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4986 | return error("Invalid record"); |
| 4987 | AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]); |
Eli Friedman | 59b6688 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 4988 | if (Ordering == NotAtomic || Ordering == Unordered) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4989 | return error("Invalid record"); |
| 4990 | SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 3]); |
Eli Friedman | c9a551e | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 4991 | I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); |
| 4992 | cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); |
| 4993 | InstructionList.push_back(I); |
| 4994 | break; |
| 4995 | } |
Eli Friedman | fee02c6 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 4996 | case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] |
| 4997 | if (2 != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 4998 | return error("Invalid record"); |
| 4999 | AtomicOrdering Ordering = getDecodedOrdering(Record[0]); |
Eli Friedman | fee02c6 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 5000 | if (Ordering == NotAtomic || Ordering == Unordered || |
| 5001 | Ordering == Monotonic) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5002 | return error("Invalid record"); |
| 5003 | SynchronizationScope SynchScope = getDecodedSynchScope(Record[1]); |
Eli Friedman | fee02c6 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 5004 | I = new FenceInst(Context, Ordering, SynchScope); |
| 5005 | InstructionList.push_back(I); |
| 5006 | break; |
| 5007 | } |
Chris Lattner | c4407080 | 2011-06-17 18:17:37 +0000 | [diff] [blame] | 5008 | case bitc::FUNC_CODE_INST_CALL: { |
Sanjay Patel | fa54ace | 2015-12-14 21:59:03 +0000 | [diff] [blame^] | 5009 | // CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...] |
Duncan Sands | ad0ea2d | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 5010 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5011 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5012 | |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 5013 | unsigned OpNum = 0; |
| 5014 | AttributeSet PAL = getAttributes(Record[OpNum++]); |
| 5015 | unsigned CCInfo = Record[OpNum++]; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5016 | |
Sanjay Patel | fa54ace | 2015-12-14 21:59:03 +0000 | [diff] [blame^] | 5017 | FastMathFlags FMF; |
| 5018 | if ((CCInfo >> bitc::CALL_FMF) & 1) { |
| 5019 | FMF = getDecodedFastMathFlags(Record[OpNum++]); |
| 5020 | if (!FMF.any()) |
| 5021 | return error("Fast math flags indicator set for call with no FMF"); |
| 5022 | } |
| 5023 | |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 5024 | FunctionType *FTy = nullptr; |
Akira Hatanaka | 97cb397 | 2015-11-07 02:48:49 +0000 | [diff] [blame] | 5025 | if (CCInfo >> bitc::CALL_EXPLICIT_TYPE & 1 && |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 5026 | !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++])))) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5027 | return error("Explicit call type is not a function type"); |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 5028 | |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 5029 | Value *Callee; |
| 5030 | if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5031 | return error("Invalid record"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5032 | |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 5033 | PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 5034 | if (!OpTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5035 | return error("Callee is not a pointer type"); |
David Blaikie | 348de69 | 2015-04-23 21:36:23 +0000 | [diff] [blame] | 5036 | if (!FTy) { |
| 5037 | FTy = dyn_cast<FunctionType>(OpTy->getElementType()); |
| 5038 | if (!FTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5039 | return error("Callee is not of pointer to function type"); |
David Blaikie | 348de69 | 2015-04-23 21:36:23 +0000 | [diff] [blame] | 5040 | } else if (OpTy->getElementType() != FTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5041 | return error("Explicit call type does not match pointee type of " |
David Blaikie | dbe6e0f | 2015-04-17 06:40:14 +0000 | [diff] [blame] | 5042 | "callee operand"); |
| 5043 | if (Record.size() < FTy->getNumParams() + OpNum) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5044 | return error("Insufficient operands to call"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5045 | |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5046 | SmallVector<Value*, 16> Args; |
| 5047 | // Read the fixed params. |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 5048 | for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { |
Chris Lattner | b1ed91f | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 5049 | if (FTy->getParamType(i)->isLabelTy()) |
Dale Johannesen | 4646aa3 | 2007-11-05 21:20:28 +0000 | [diff] [blame] | 5050 | Args.push_back(getBasicBlock(Record[OpNum])); |
Dan Gohman | bbcd04d | 2010-09-13 18:00:48 +0000 | [diff] [blame] | 5051 | else |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 5052 | Args.push_back(getValue(Record, OpNum, NextValueNo, |
| 5053 | FTy->getParamType(i))); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 5054 | if (!Args.back()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5055 | return error("Invalid record"); |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5056 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5057 | |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5058 | // Read type/value pairs for varargs params. |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5059 | if (!FTy->isVarArg()) { |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 5060 | if (OpNum != Record.size()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5061 | return error("Invalid record"); |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5062 | } else { |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 5063 | while (OpNum != Record.size()) { |
| 5064 | Value *Op; |
| 5065 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5066 | return error("Invalid record"); |
Chris Lattner | df1233d | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 5067 | Args.push_back(Op); |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5068 | } |
| 5069 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5070 | |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 5071 | I = CallInst::Create(FTy, Callee, Args, OperandBundles); |
| 5072 | OperandBundles.clear(); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 5073 | InstructionList.push_back(I); |
Sandeep Patel | 68c5f47 | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 5074 | cast<CallInst>(I)->setCallingConv( |
Akira Hatanaka | 97cb397 | 2015-11-07 02:48:49 +0000 | [diff] [blame] | 5075 | static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV)); |
Reid Kleckner | 5772b77 | 2014-04-24 20:14:34 +0000 | [diff] [blame] | 5076 | CallInst::TailCallKind TCK = CallInst::TCK_None; |
Akira Hatanaka | 97cb397 | 2015-11-07 02:48:49 +0000 | [diff] [blame] | 5077 | if (CCInfo & 1 << bitc::CALL_TAIL) |
Reid Kleckner | 5772b77 | 2014-04-24 20:14:34 +0000 | [diff] [blame] | 5078 | TCK = CallInst::TCK_Tail; |
Akira Hatanaka | 97cb397 | 2015-11-07 02:48:49 +0000 | [diff] [blame] | 5079 | if (CCInfo & (1 << bitc::CALL_MUSTTAIL)) |
Reid Kleckner | 5772b77 | 2014-04-24 20:14:34 +0000 | [diff] [blame] | 5080 | TCK = CallInst::TCK_MustTail; |
Akira Hatanaka | 97cb397 | 2015-11-07 02:48:49 +0000 | [diff] [blame] | 5081 | if (CCInfo & (1 << bitc::CALL_NOTAIL)) |
Akira Hatanaka | 5cfcce12 | 2015-11-06 23:55:38 +0000 | [diff] [blame] | 5082 | TCK = CallInst::TCK_NoTail; |
Reid Kleckner | 5772b77 | 2014-04-24 20:14:34 +0000 | [diff] [blame] | 5083 | cast<CallInst>(I)->setTailCallKind(TCK); |
Devang Patel | 4c758ea | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 5084 | cast<CallInst>(I)->setAttributes(PAL); |
Sanjay Patel | fa54ace | 2015-12-14 21:59:03 +0000 | [diff] [blame^] | 5085 | if (FMF.any()) { |
| 5086 | if (!isa<FPMathOperator>(I)) |
| 5087 | return error("Fast-math-flags specified for call without " |
| 5088 | "floating-point scalar or vector return type"); |
| 5089 | I->setFastMathFlags(FMF); |
| 5090 | } |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5091 | break; |
| 5092 | } |
| 5093 | case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] |
| 5094 | if (Record.size() < 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5095 | return error("Invalid record"); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 5096 | Type *OpTy = getTypeByID(Record[0]); |
Jan Wen Voung | afaced0 | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 5097 | Value *Op = getValue(Record, 1, NextValueNo, OpTy); |
Chris Lattner | 229907c | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 5098 | Type *ResTy = getTypeByID(Record[2]); |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5099 | if (!OpTy || !Op || !ResTy) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5100 | return error("Invalid record"); |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5101 | I = new VAArgInst(Op, ResTy); |
Devang Patel | af206b8 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 5102 | InstructionList.push_back(I); |
Chris Lattner | 9f600c5 | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 5103 | break; |
| 5104 | } |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 5105 | |
| 5106 | case bitc::FUNC_CODE_OPERAND_BUNDLE: { |
| 5107 | // A call or an invoke can be optionally prefixed with some variable |
| 5108 | // number of operand bundle blocks. These blocks are read into |
| 5109 | // OperandBundles and consumed at the next call or invoke instruction. |
| 5110 | |
| 5111 | if (Record.size() < 1 || Record[0] >= BundleTags.size()) |
| 5112 | return error("Invalid record"); |
| 5113 | |
Sanjoy Das | f79d344 | 2015-11-18 08:30:07 +0000 | [diff] [blame] | 5114 | std::vector<Value *> Inputs; |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 5115 | |
| 5116 | unsigned OpNum = 1; |
| 5117 | while (OpNum != Record.size()) { |
| 5118 | Value *Op; |
| 5119 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
| 5120 | return error("Invalid record"); |
| 5121 | Inputs.push_back(Op); |
| 5122 | } |
| 5123 | |
Sanjoy Das | f79d344 | 2015-11-18 08:30:07 +0000 | [diff] [blame] | 5124 | OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs)); |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 5125 | continue; |
| 5126 | } |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5127 | } |
| 5128 | |
| 5129 | // Add instruction to end of current BB. If there is no current BB, reject |
| 5130 | // this file. |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 5131 | if (!CurBB) { |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5132 | delete I; |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5133 | return error("Invalid instruction with no BB"); |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5134 | } |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 5135 | if (!OperandBundles.empty()) { |
| 5136 | delete I; |
| 5137 | return error("Operand bundles found with no consumer"); |
| 5138 | } |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5139 | CurBB->getInstList().push_back(I); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5140 | |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5141 | // If this was a terminator instruction, move to the next block. |
| 5142 | if (isa<TerminatorInst>(I)) { |
| 5143 | ++CurBBNo; |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 5144 | CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr; |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5145 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5146 | |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5147 | // Non-void values get registered in the value table for future use. |
Benjamin Kramer | ccce8ba | 2010-01-05 13:12:22 +0000 | [diff] [blame] | 5148 | if (I && !I->getType()->isVoidTy()) |
David Majnemer | 8a1c45d | 2015-12-12 05:38:55 +0000 | [diff] [blame] | 5149 | ValueList.assignValue(I, NextValueNo++); |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 5150 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5151 | |
Chris Lattner | 27d3875 | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 5152 | OutOfRecordLoop: |
Joe Abbey | 97b7a17 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 5153 | |
Sanjoy Das | b513a9f | 2015-09-24 23:34:52 +0000 | [diff] [blame] | 5154 | if (!OperandBundles.empty()) |
| 5155 | return error("Operand bundles found with no consumer"); |
| 5156 | |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5157 | // Check the function list for unresolved values. |
| 5158 | if (Argument *A = dyn_cast<Argument>(ValueList.back())) { |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 5159 | if (!A->getParent()) { |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5160 | // We found at least one unresolved value. Nuke them all to avoid leaks. |
| 5161 | for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 5162 | if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) { |
Owen Anderson | b292b8c | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 5163 | A->replaceAllUsesWith(UndefValue::get(A->getType())); |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5164 | delete A; |
| 5165 | } |
| 5166 | } |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5167 | return error("Never resolved value found in function"); |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5168 | } |
Chris Lattner | 8393055 | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 5169 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5170 | |
Dan Gohman | 9b9ff46 | 2010-08-25 20:23:38 +0000 | [diff] [blame] | 5171 | // FIXME: Check for unresolved forward-declared metadata references |
| 5172 | // and clean up leaks. |
| 5173 | |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 5174 | // Trim the value list down to the size it was before we parsed this function. |
| 5175 | ValueList.shrinkTo(ModuleValueListSize); |
Dan Gohman | 26d837d | 2010-08-25 20:22:53 +0000 | [diff] [blame] | 5176 | MDValueList.shrinkTo(ModuleMDValueListSize); |
Chris Lattner | 85b7b40 | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 5177 | std::vector<BasicBlock*>().swap(FunctionBBs); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5178 | return std::error_code(); |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 5179 | } |
| 5180 | |
Rafael Espindola | 7d71203 | 2013-11-05 17:16:08 +0000 | [diff] [blame] | 5181 | /// Find the function body in the bitcode stream |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5182 | std::error_code BitcodeReader::findFunctionInStream( |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5183 | Function *F, |
| 5184 | DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) { |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5185 | while (DeferredFunctionInfoIterator->second == 0) { |
Teresa Johnson | ff642b9 | 2015-09-17 20:12:00 +0000 | [diff] [blame] | 5186 | // This is the fallback handling for the old format bitcode that |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 5187 | // didn't contain the function index in the VST, or when we have |
| 5188 | // an anonymous function which would not have a VST entry. |
| 5189 | // Assert that we have one of those two cases. |
| 5190 | assert(VSTOffset == 0 || !F->hasName()); |
| 5191 | // Parse the next body in the stream and set its position in the |
| 5192 | // DeferredFunctionInfo map. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5193 | if (std::error_code EC = rememberAndSkipFunctionBodies()) |
| 5194 | return EC; |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5195 | } |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5196 | return std::error_code(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5197 | } |
| 5198 | |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5199 | //===----------------------------------------------------------------------===// |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5200 | // GVMaterializer implementation |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5201 | //===----------------------------------------------------------------------===// |
| 5202 | |
Rafael Espindola | c3f9b5a | 2014-06-23 21:53:12 +0000 | [diff] [blame] | 5203 | void BitcodeReader::releaseBuffer() { Buffer.release(); } |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5204 | |
Rafael Espindola | 5a52e6d | 2014-10-24 22:50:48 +0000 | [diff] [blame] | 5205 | std::error_code BitcodeReader::materialize(GlobalValue *GV) { |
Teresa Johnson | d4d3dfd | 2015-11-20 14:51:27 +0000 | [diff] [blame] | 5206 | // In older bitcode we must materialize the metadata before parsing |
| 5207 | // any functions, in order to set up the MDValueList properly. |
| 5208 | if (!SeenModuleValuesRecord) { |
| 5209 | if (std::error_code EC = materializeMetadata()) |
| 5210 | return EC; |
| 5211 | } |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 5212 | |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5213 | Function *F = dyn_cast<Function>(GV); |
| 5214 | // If it's not a function or is already material, ignore the request. |
Rafael Espindola | 2b11ad4 | 2013-11-05 19:36:34 +0000 | [diff] [blame] | 5215 | if (!F || !F->isMaterializable()) |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5216 | return std::error_code(); |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5217 | |
| 5218 | DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5219 | assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5220 | // If its position is recorded as 0, its body is somewhere in the stream |
| 5221 | // but we haven't seen it yet. |
Rafael Espindola | 1c863ca | 2015-06-22 18:06:15 +0000 | [diff] [blame] | 5222 | if (DFII->second == 0) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5223 | if (std::error_code EC = findFunctionInStream(F, DFII)) |
Rafael Espindola | 2b11ad4 | 2013-11-05 19:36:34 +0000 | [diff] [blame] | 5224 | return EC; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5225 | |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5226 | // Move the bit stream to the saved position of the deferred function body. |
| 5227 | Stream.JumpToBit(DFII->second); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5228 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5229 | if (std::error_code EC = parseFunctionBody(F)) |
Rafael Espindola | 2b11ad4 | 2013-11-05 19:36:34 +0000 | [diff] [blame] | 5230 | return EC; |
Rafael Espindola | d4bcefc | 2014-10-24 18:13:04 +0000 | [diff] [blame] | 5231 | F->setIsMaterializable(false); |
Chandler Carruth | 7132e00 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 5232 | |
Rafael Espindola | 0d68b4c | 2015-03-30 21:36:43 +0000 | [diff] [blame] | 5233 | if (StripDebugInfo) |
| 5234 | stripDebugInfo(*F); |
| 5235 | |
Chandler Carruth | 7132e00 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 5236 | // Upgrade any old intrinsic calls in the function. |
Rafael Espindola | 86e3340 | 2015-07-02 15:55:09 +0000 | [diff] [blame] | 5237 | for (auto &I : UpgradedIntrinsics) { |
Filipe Cabecinhas | 0011c58 | 2015-07-03 20:12:01 +0000 | [diff] [blame] | 5238 | for (auto UI = I.first->user_begin(), UE = I.first->user_end(); UI != UE;) { |
| 5239 | User *U = *UI; |
| 5240 | ++UI; |
| 5241 | if (CallInst *CI = dyn_cast<CallInst>(U)) |
| 5242 | UpgradeIntrinsicCall(CI, I.second); |
Chandler Carruth | 7132e00 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 5243 | } |
| 5244 | } |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5245 | |
Peter Collingbourne | d4bff30 | 2015-11-05 22:03:56 +0000 | [diff] [blame] | 5246 | // Finish fn->subprogram upgrade for materialized functions. |
| 5247 | if (DISubprogram *SP = FunctionsWithSPs.lookup(F)) |
| 5248 | F->setSubprogram(SP); |
| 5249 | |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5250 | // Bring in any functions that this function forward-referenced via |
| 5251 | // blockaddresses. |
| 5252 | return materializeForwardReferencedFunctions(); |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5253 | } |
| 5254 | |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5255 | bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { |
| 5256 | const Function *F = dyn_cast<Function>(GV); |
| 5257 | if (!F || F->isDeclaration()) |
| 5258 | return false; |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5259 | |
| 5260 | // Dematerializing F would leave dangling references that wouldn't be |
| 5261 | // reconnected on re-materialization. |
| 5262 | if (BlockAddressesTaken.count(F)) |
| 5263 | return false; |
| 5264 | |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5265 | return DeferredFunctionInfo.count(const_cast<Function*>(F)); |
| 5266 | } |
| 5267 | |
Eric Christopher | 97cb565 | 2015-05-15 18:20:14 +0000 | [diff] [blame] | 5268 | void BitcodeReader::dematerialize(GlobalValue *GV) { |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5269 | Function *F = dyn_cast<Function>(GV); |
| 5270 | // If this function isn't dematerializable, this is a noop. |
| 5271 | if (!F || !isDematerializable(F)) |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5272 | return; |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5273 | |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5274 | assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5275 | |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5276 | // Just forget the function body, we can remat it later. |
Petar Jovanovic | 7480e4d | 2014-09-23 12:54:19 +0000 | [diff] [blame] | 5277 | F->dropAllReferences(); |
Rafael Espindola | d4bcefc | 2014-10-24 18:13:04 +0000 | [diff] [blame] | 5278 | F->setIsMaterializable(true); |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5279 | } |
| 5280 | |
Eric Christopher | 97cb565 | 2015-05-15 18:20:14 +0000 | [diff] [blame] | 5281 | std::error_code BitcodeReader::materializeModule(Module *M) { |
Jeffrey Yasskin | 091217b | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 5282 | assert(M == TheModule && |
| 5283 | "Can only Materialize the Module this BitcodeReader is attached to."); |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5284 | |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 5285 | if (std::error_code EC = materializeMetadata()) |
| 5286 | return EC; |
| 5287 | |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5288 | // Promise to materialize all forward references. |
| 5289 | WillMaterializeAllForwardRefs = true; |
| 5290 | |
Chris Lattner | 06310bf | 2009-06-16 05:15:21 +0000 | [diff] [blame] | 5291 | // Iterate over the module, deserializing any functions that are still on |
| 5292 | // disk. |
Duncan P. N. Exon Smith | fb1743a3 | 2015-10-13 16:48:55 +0000 | [diff] [blame] | 5293 | for (Function &F : *TheModule) { |
| 5294 | if (std::error_code EC = materialize(&F)) |
Rafael Espindola | 246c4fb | 2014-11-01 16:46:18 +0000 | [diff] [blame] | 5295 | return EC; |
Rafael Espindola | 2b11ad4 | 2013-11-05 19:36:34 +0000 | [diff] [blame] | 5296 | } |
Teresa Johnson | 1493ad9 | 2015-10-10 14:18:36 +0000 | [diff] [blame] | 5297 | // At this point, if there are any function bodies, parse the rest of |
| 5298 | // the bits in the module past the last function block we have recorded |
| 5299 | // through either lazy scanning or the VST. |
| 5300 | if (LastFunctionBlockBit || NextUnreadBit) |
| 5301 | parseModule(LastFunctionBlockBit > NextUnreadBit ? LastFunctionBlockBit |
| 5302 | : NextUnreadBit); |
Derek Schuff | 92ef975 | 2012-02-29 00:07:09 +0000 | [diff] [blame] | 5303 | |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5304 | // Check that all block address forward references got resolved (as we |
| 5305 | // promised above). |
Duncan P. N. Exon Smith | 00f20ac | 2014-08-01 21:51:52 +0000 | [diff] [blame] | 5306 | if (!BasicBlockFwdRefs.empty()) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5307 | return error("Never resolved function from blockaddress"); |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5308 | |
Daniel Dunbar | 7d6781b | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 5309 | // Upgrade any intrinsic calls that slipped through (should not happen!) and |
| 5310 | // delete the old functions to clean up. We can't do this unless the entire |
| 5311 | // module is materialized because there could always be another function body |
Chandler Carruth | 7132e00 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 5312 | // with calls to the old function. |
Rafael Espindola | 86e3340 | 2015-07-02 15:55:09 +0000 | [diff] [blame] | 5313 | for (auto &I : UpgradedIntrinsics) { |
Filipe Cabecinhas | 0011c58 | 2015-07-03 20:12:01 +0000 | [diff] [blame] | 5314 | for (auto *U : I.first->users()) { |
| 5315 | if (CallInst *CI = dyn_cast<CallInst>(U)) |
| 5316 | UpgradeIntrinsicCall(CI, I.second); |
Chandler Carruth | 7132e00 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 5317 | } |
Filipe Cabecinhas | 0011c58 | 2015-07-03 20:12:01 +0000 | [diff] [blame] | 5318 | if (!I.first->use_empty()) |
| 5319 | I.first->replaceAllUsesWith(I.second); |
| 5320 | I.first->eraseFromParent(); |
Chandler Carruth | 7132e00 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 5321 | } |
Rafael Espindola | 4e72121 | 2015-07-02 16:22:40 +0000 | [diff] [blame] | 5322 | UpgradedIntrinsics.clear(); |
Devang Patel | 80ae349 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 5323 | |
Manman Ren | 209b17c | 2013-09-28 00:22:27 +0000 | [diff] [blame] | 5324 | for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++) |
| 5325 | UpgradeInstWithTBAATag(InstsWithTBAATag[I]); |
| 5326 | |
Manman Ren | 8b4306c | 2013-12-02 21:29:56 +0000 | [diff] [blame] | 5327 | UpgradeDebugInfo(*M); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5328 | return std::error_code(); |
Chris Lattner | 9eeada9 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 5329 | } |
| 5330 | |
Rafael Espindola | 2fa1e43 | 2014-12-03 07:18:23 +0000 | [diff] [blame] | 5331 | std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const { |
| 5332 | return IdentifiedStructTypes; |
| 5333 | } |
| 5334 | |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 5335 | std::error_code |
| 5336 | BitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) { |
Rafael Espindola | 4223a1f | 2015-06-15 20:08:17 +0000 | [diff] [blame] | 5337 | if (Streamer) |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 5338 | return initLazyStream(std::move(Streamer)); |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5339 | return initStreamFromBuffer(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5340 | } |
| 5341 | |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5342 | std::error_code BitcodeReader::initStreamFromBuffer() { |
Roman Divacky | 4717a8d | 2012-09-06 15:42:13 +0000 | [diff] [blame] | 5343 | const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5344 | const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); |
| 5345 | |
Rafael Espindola | 2743525 | 2014-07-29 21:01:24 +0000 | [diff] [blame] | 5346 | if (Buffer->getBufferSize() & 3) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5347 | return error("Invalid bitcode signature"); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5348 | |
| 5349 | // If we have a wrapper header, parse it and ignore the non-bc file contents. |
| 5350 | // The magic number is 0x0B17C0DE stored in little endian. |
| 5351 | if (isBitcodeWrapper(BufPtr, BufEnd)) |
| 5352 | if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5353 | return error("Invalid bitcode wrapper header"); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5354 | |
| 5355 | StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); |
Rafael Espindola | de1e5b8 | 2014-11-12 14:48:38 +0000 | [diff] [blame] | 5356 | Stream.init(&*StreamFile); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5357 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5358 | return std::error_code(); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5359 | } |
| 5360 | |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 5361 | std::error_code |
| 5362 | BitcodeReader::initLazyStream(std::unique_ptr<DataStreamer> Streamer) { |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5363 | // Check and strip off the bitcode wrapper; BitstreamReader expects never to |
| 5364 | // see it. |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 5365 | auto OwnedBytes = |
| 5366 | llvm::make_unique<StreamingMemoryObject>(std::move(Streamer)); |
Rafael Espindola | 7d727b5 | 2014-12-18 05:08:43 +0000 | [diff] [blame] | 5367 | StreamingMemoryObject &Bytes = *OwnedBytes; |
Yaron Keren | 06d6930 | 2014-12-18 10:03:35 +0000 | [diff] [blame] | 5368 | StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes)); |
Rafael Espindola | de1e5b8 | 2014-11-12 14:48:38 +0000 | [diff] [blame] | 5369 | Stream.init(&*StreamFile); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5370 | |
| 5371 | unsigned char buf[16]; |
Rafael Espindola | 7d727b5 | 2014-12-18 05:08:43 +0000 | [diff] [blame] | 5372 | if (Bytes.readBytes(buf, 16, 0) != 16) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5373 | return error("Invalid bitcode signature"); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5374 | |
| 5375 | if (!isBitcode(buf, buf + 16)) |
Rafael Espindola | cbdcb50 | 2015-06-15 20:55:37 +0000 | [diff] [blame] | 5376 | return error("Invalid bitcode signature"); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5377 | |
| 5378 | if (isBitcodeWrapper(buf, buf + 4)) { |
| 5379 | const unsigned char *bitcodeStart = buf; |
| 5380 | const unsigned char *bitcodeEnd = buf + 16; |
| 5381 | SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); |
Rafael Espindola | 7d727b5 | 2014-12-18 05:08:43 +0000 | [diff] [blame] | 5382 | Bytes.dropLeadingBytes(bitcodeStart - buf); |
| 5383 | Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5384 | } |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 5385 | return std::error_code(); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5386 | } |
| 5387 | |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5388 | std::error_code FunctionIndexBitcodeReader::error(BitcodeError E, |
| 5389 | const Twine &Message) { |
| 5390 | return ::error(DiagnosticHandler, make_error_code(E), Message); |
| 5391 | } |
| 5392 | |
| 5393 | std::error_code FunctionIndexBitcodeReader::error(const Twine &Message) { |
| 5394 | return ::error(DiagnosticHandler, |
| 5395 | make_error_code(BitcodeError::CorruptedBitcode), Message); |
| 5396 | } |
| 5397 | |
| 5398 | std::error_code FunctionIndexBitcodeReader::error(BitcodeError E) { |
| 5399 | return ::error(DiagnosticHandler, make_error_code(E)); |
| 5400 | } |
| 5401 | |
| 5402 | FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5403 | MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, |
| 5404 | bool IsLazy, bool CheckFuncSummaryPresenceOnly) |
| 5405 | : DiagnosticHandler(DiagnosticHandler), Buffer(Buffer), IsLazy(IsLazy), |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5406 | CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} |
| 5407 | |
| 5408 | FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5409 | DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, |
| 5410 | bool CheckFuncSummaryPresenceOnly) |
| 5411 | : DiagnosticHandler(DiagnosticHandler), Buffer(nullptr), IsLazy(IsLazy), |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5412 | CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} |
| 5413 | |
| 5414 | void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; } |
| 5415 | |
| 5416 | void FunctionIndexBitcodeReader::releaseBuffer() { Buffer.release(); } |
| 5417 | |
| 5418 | // Specialized value symbol table parser used when reading function index |
| 5419 | // blocks where we don't actually create global values. |
| 5420 | // At the end of this routine the function index is populated with a map |
| 5421 | // from function name to FunctionInfo. The function info contains |
| 5422 | // the function block's bitcode offset as well as the offset into the |
| 5423 | // function summary section. |
| 5424 | std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable() { |
| 5425 | if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) |
| 5426 | return error("Invalid record"); |
| 5427 | |
| 5428 | SmallVector<uint64_t, 64> Record; |
| 5429 | |
| 5430 | // Read all the records for this value table. |
| 5431 | SmallString<128> ValueName; |
| 5432 | while (1) { |
| 5433 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 5434 | |
| 5435 | switch (Entry.Kind) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5436 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 5437 | case BitstreamEntry::Error: |
| 5438 | return error("Malformed block"); |
| 5439 | case BitstreamEntry::EndBlock: |
| 5440 | return std::error_code(); |
| 5441 | case BitstreamEntry::Record: |
| 5442 | // The interesting case. |
| 5443 | break; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5444 | } |
| 5445 | |
| 5446 | // Read a record. |
| 5447 | Record.clear(); |
| 5448 | switch (Stream.readRecord(Entry.ID, Record)) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5449 | default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records). |
| 5450 | break; |
| 5451 | case bitc::VST_CODE_FNENTRY: { |
| 5452 | // VST_FNENTRY: [valueid, offset, namechar x N] |
| 5453 | if (convertToString(Record, 2, ValueName)) |
| 5454 | return error("Invalid record"); |
| 5455 | unsigned ValueID = Record[0]; |
| 5456 | uint64_t FuncOffset = Record[1]; |
| 5457 | std::unique_ptr<FunctionInfo> FuncInfo = |
| 5458 | llvm::make_unique<FunctionInfo>(FuncOffset); |
| 5459 | if (foundFuncSummary() && !IsLazy) { |
| 5460 | DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI = |
| 5461 | SummaryMap.find(ValueID); |
| 5462 | assert(SMI != SummaryMap.end() && "Summary info not found"); |
| 5463 | FuncInfo->setFunctionSummary(std::move(SMI->second)); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5464 | } |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5465 | TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo)); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5466 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5467 | ValueName.clear(); |
| 5468 | break; |
| 5469 | } |
| 5470 | case bitc::VST_CODE_COMBINED_FNENTRY: { |
| 5471 | // VST_FNENTRY: [offset, namechar x N] |
| 5472 | if (convertToString(Record, 1, ValueName)) |
| 5473 | return error("Invalid record"); |
| 5474 | uint64_t FuncSummaryOffset = Record[0]; |
| 5475 | std::unique_ptr<FunctionInfo> FuncInfo = |
| 5476 | llvm::make_unique<FunctionInfo>(FuncSummaryOffset); |
| 5477 | if (foundFuncSummary() && !IsLazy) { |
| 5478 | DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI = |
| 5479 | SummaryMap.find(FuncSummaryOffset); |
| 5480 | assert(SMI != SummaryMap.end() && "Summary info not found"); |
| 5481 | FuncInfo->setFunctionSummary(std::move(SMI->second)); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5482 | } |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5483 | TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo)); |
| 5484 | |
| 5485 | ValueName.clear(); |
| 5486 | break; |
| 5487 | } |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5488 | } |
| 5489 | } |
| 5490 | } |
| 5491 | |
| 5492 | // Parse just the blocks needed for function index building out of the module. |
| 5493 | // At the end of this routine the function Index is populated with a map |
| 5494 | // from function name to FunctionInfo. The function info contains |
| 5495 | // either the parsed function summary information (when parsing summaries |
| 5496 | // eagerly), or just to the function summary record's offset |
| 5497 | // if parsing lazily (IsLazy). |
| 5498 | std::error_code FunctionIndexBitcodeReader::parseModule() { |
| 5499 | if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) |
| 5500 | return error("Invalid record"); |
| 5501 | |
| 5502 | // Read the function index for this module. |
| 5503 | while (1) { |
| 5504 | BitstreamEntry Entry = Stream.advance(); |
| 5505 | |
| 5506 | switch (Entry.Kind) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5507 | case BitstreamEntry::Error: |
| 5508 | return error("Malformed block"); |
| 5509 | case BitstreamEntry::EndBlock: |
| 5510 | return std::error_code(); |
| 5511 | |
| 5512 | case BitstreamEntry::SubBlock: |
| 5513 | if (CheckFuncSummaryPresenceOnly) { |
Teresa Johnson | 6290dbc | 2015-11-21 21:55:48 +0000 | [diff] [blame] | 5514 | if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5515 | SeenFuncSummary = true; |
Teresa Johnson | 6290dbc | 2015-11-21 21:55:48 +0000 | [diff] [blame] | 5516 | // No need to parse the rest since we found the summary. |
| 5517 | return std::error_code(); |
| 5518 | } |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5519 | if (Stream.SkipBlock()) |
| 5520 | return error("Invalid record"); |
Teresa Johnson | 6290dbc | 2015-11-21 21:55:48 +0000 | [diff] [blame] | 5521 | continue; |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5522 | } |
| 5523 | switch (Entry.ID) { |
| 5524 | default: // Skip unknown content. |
| 5525 | if (Stream.SkipBlock()) |
| 5526 | return error("Invalid record"); |
| 5527 | break; |
| 5528 | case bitc::BLOCKINFO_BLOCK_ID: |
| 5529 | // Need to parse these to get abbrev ids (e.g. for VST) |
| 5530 | if (Stream.ReadBlockInfoBlock()) |
| 5531 | return error("Malformed block"); |
| 5532 | break; |
| 5533 | case bitc::VALUE_SYMTAB_BLOCK_ID: |
| 5534 | if (std::error_code EC = parseValueSymbolTable()) |
| 5535 | return EC; |
| 5536 | break; |
| 5537 | case bitc::FUNCTION_SUMMARY_BLOCK_ID: |
| 5538 | SeenFuncSummary = true; |
| 5539 | if (IsLazy) { |
| 5540 | // Lazy parsing of summary info, skip it. |
| 5541 | if (Stream.SkipBlock()) |
| 5542 | return error("Invalid record"); |
| 5543 | } else if (std::error_code EC = parseEntireSummary()) |
| 5544 | return EC; |
| 5545 | break; |
| 5546 | case bitc::MODULE_STRTAB_BLOCK_ID: |
| 5547 | if (std::error_code EC = parseModuleStringTable()) |
| 5548 | return EC; |
| 5549 | break; |
| 5550 | } |
| 5551 | continue; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5552 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5553 | case BitstreamEntry::Record: |
| 5554 | Stream.skipRecord(Entry.ID); |
| 5555 | continue; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5556 | } |
| 5557 | } |
| 5558 | } |
| 5559 | |
| 5560 | // Eagerly parse the entire function summary block (i.e. for all functions |
| 5561 | // in the index). This populates the FunctionSummary objects in |
| 5562 | // the index. |
| 5563 | std::error_code FunctionIndexBitcodeReader::parseEntireSummary() { |
| 5564 | if (Stream.EnterSubBlock(bitc::FUNCTION_SUMMARY_BLOCK_ID)) |
| 5565 | return error("Invalid record"); |
| 5566 | |
| 5567 | SmallVector<uint64_t, 64> Record; |
| 5568 | |
| 5569 | while (1) { |
| 5570 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 5571 | |
| 5572 | switch (Entry.Kind) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5573 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 5574 | case BitstreamEntry::Error: |
| 5575 | return error("Malformed block"); |
| 5576 | case BitstreamEntry::EndBlock: |
| 5577 | return std::error_code(); |
| 5578 | case BitstreamEntry::Record: |
| 5579 | // The interesting case. |
| 5580 | break; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5581 | } |
| 5582 | |
| 5583 | // Read a record. The record format depends on whether this |
| 5584 | // is a per-module index or a combined index file. In the per-module |
| 5585 | // case the records contain the associated value's ID for correlation |
| 5586 | // with VST entries. In the combined index the correlation is done |
| 5587 | // via the bitcode offset of the summary records (which were saved |
| 5588 | // in the combined index VST entries). The records also contain |
| 5589 | // information used for ThinLTO renaming and importing. |
| 5590 | Record.clear(); |
| 5591 | uint64_t CurRecordBit = Stream.GetCurrentBitNo(); |
| 5592 | switch (Stream.readRecord(Entry.ID, Record)) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5593 | default: // Default behavior: ignore. |
| 5594 | break; |
| 5595 | // FS_PERMODULE_ENTRY: [valueid, islocal, instcount] |
| 5596 | case bitc::FS_CODE_PERMODULE_ENTRY: { |
| 5597 | unsigned ValueID = Record[0]; |
| 5598 | bool IsLocal = Record[1]; |
| 5599 | unsigned InstCount = Record[2]; |
| 5600 | std::unique_ptr<FunctionSummary> FS = |
| 5601 | llvm::make_unique<FunctionSummary>(InstCount); |
| 5602 | FS->setLocalFunction(IsLocal); |
| 5603 | // The module path string ref set in the summary must be owned by the |
| 5604 | // index's module string table. Since we don't have a module path |
| 5605 | // string table section in the per-module index, we create a single |
| 5606 | // module path string table entry with an empty (0) ID to take |
| 5607 | // ownership. |
| 5608 | FS->setModulePath( |
| 5609 | TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)); |
| 5610 | SummaryMap[ValueID] = std::move(FS); |
| 5611 | } |
| 5612 | // FS_COMBINED_ENTRY: [modid, instcount] |
| 5613 | case bitc::FS_CODE_COMBINED_ENTRY: { |
| 5614 | uint64_t ModuleId = Record[0]; |
| 5615 | unsigned InstCount = Record[1]; |
| 5616 | std::unique_ptr<FunctionSummary> FS = |
| 5617 | llvm::make_unique<FunctionSummary>(InstCount); |
| 5618 | FS->setModulePath(ModuleIdMap[ModuleId]); |
| 5619 | SummaryMap[CurRecordBit] = std::move(FS); |
| 5620 | } |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5621 | } |
| 5622 | } |
| 5623 | llvm_unreachable("Exit infinite loop"); |
| 5624 | } |
| 5625 | |
| 5626 | // Parse the module string table block into the Index. |
| 5627 | // This populates the ModulePathStringTable map in the index. |
| 5628 | std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() { |
| 5629 | if (Stream.EnterSubBlock(bitc::MODULE_STRTAB_BLOCK_ID)) |
| 5630 | return error("Invalid record"); |
| 5631 | |
| 5632 | SmallVector<uint64_t, 64> Record; |
| 5633 | |
| 5634 | SmallString<128> ModulePath; |
| 5635 | while (1) { |
| 5636 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 5637 | |
| 5638 | switch (Entry.Kind) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5639 | case BitstreamEntry::SubBlock: // Handled for us already. |
| 5640 | case BitstreamEntry::Error: |
| 5641 | return error("Malformed block"); |
| 5642 | case BitstreamEntry::EndBlock: |
| 5643 | return std::error_code(); |
| 5644 | case BitstreamEntry::Record: |
| 5645 | // The interesting case. |
| 5646 | break; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5647 | } |
| 5648 | |
| 5649 | Record.clear(); |
| 5650 | switch (Stream.readRecord(Entry.ID, Record)) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5651 | default: // Default behavior: ignore. |
| 5652 | break; |
| 5653 | case bitc::MST_CODE_ENTRY: { |
| 5654 | // MST_ENTRY: [modid, namechar x N] |
| 5655 | if (convertToString(Record, 1, ModulePath)) |
| 5656 | return error("Invalid record"); |
| 5657 | uint64_t ModuleId = Record[0]; |
| 5658 | StringRef ModulePathInMap = TheIndex->addModulePath(ModulePath, ModuleId); |
| 5659 | ModuleIdMap[ModuleId] = ModulePathInMap; |
| 5660 | ModulePath.clear(); |
| 5661 | break; |
| 5662 | } |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5663 | } |
| 5664 | } |
| 5665 | llvm_unreachable("Exit infinite loop"); |
| 5666 | } |
| 5667 | |
| 5668 | // Parse the function info index from the bitcode streamer into the given index. |
| 5669 | std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto( |
| 5670 | std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I) { |
| 5671 | TheIndex = I; |
| 5672 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5673 | if (std::error_code EC = initStream(std::move(Streamer))) |
| 5674 | return EC; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5675 | |
| 5676 | // Sniff for the signature. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5677 | if (!hasValidBitcodeHeader(Stream)) |
| 5678 | return error("Invalid bitcode signature"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5679 | |
| 5680 | // We expect a number of well-defined blocks, though we don't necessarily |
| 5681 | // need to understand them all. |
| 5682 | while (1) { |
| 5683 | if (Stream.AtEndOfStream()) { |
| 5684 | // We didn't really read a proper Module block. |
| 5685 | return error("Malformed block"); |
| 5686 | } |
| 5687 | |
| 5688 | BitstreamEntry Entry = |
| 5689 | Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); |
| 5690 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5691 | if (Entry.Kind != BitstreamEntry::SubBlock) |
| 5692 | return error("Malformed block"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5693 | |
| 5694 | // If we see a MODULE_BLOCK, parse it to find the blocks needed for |
| 5695 | // building the function summary index. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5696 | if (Entry.ID == bitc::MODULE_BLOCK_ID) |
| 5697 | return parseModule(); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5698 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5699 | if (Stream.SkipBlock()) |
| 5700 | return error("Invalid record"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5701 | } |
| 5702 | } |
| 5703 | |
| 5704 | // Parse the function information at the given offset in the buffer into |
| 5705 | // the index. Used to support lazy parsing of function summaries from the |
| 5706 | // combined index during importing. |
| 5707 | // TODO: This function is not yet complete as it won't have a consumer |
| 5708 | // until ThinLTO function importing is added. |
| 5709 | std::error_code FunctionIndexBitcodeReader::parseFunctionSummary( |
| 5710 | std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I, |
| 5711 | size_t FunctionSummaryOffset) { |
| 5712 | TheIndex = I; |
| 5713 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5714 | if (std::error_code EC = initStream(std::move(Streamer))) |
| 5715 | return EC; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5716 | |
| 5717 | // Sniff for the signature. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5718 | if (!hasValidBitcodeHeader(Stream)) |
| 5719 | return error("Invalid bitcode signature"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5720 | |
| 5721 | Stream.JumpToBit(FunctionSummaryOffset); |
| 5722 | |
| 5723 | BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); |
| 5724 | |
| 5725 | switch (Entry.Kind) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5726 | default: |
| 5727 | return error("Malformed block"); |
| 5728 | case BitstreamEntry::Record: |
| 5729 | // The expected case. |
| 5730 | break; |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5731 | } |
| 5732 | |
| 5733 | // TODO: Read a record. This interface will be completed when ThinLTO |
| 5734 | // importing is added so that it can be tested. |
| 5735 | SmallVector<uint64_t, 64> Record; |
| 5736 | switch (Stream.readRecord(Entry.ID, Record)) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5737 | case bitc::FS_CODE_COMBINED_ENTRY: |
| 5738 | default: |
| 5739 | return error("Invalid record"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5740 | } |
| 5741 | |
| 5742 | return std::error_code(); |
| 5743 | } |
| 5744 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5745 | std::error_code |
| 5746 | FunctionIndexBitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) { |
| 5747 | if (Streamer) |
| 5748 | return initLazyStream(std::move(Streamer)); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5749 | return initStreamFromBuffer(); |
| 5750 | } |
| 5751 | |
| 5752 | std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() { |
| 5753 | const unsigned char *BufPtr = (const unsigned char *)Buffer->getBufferStart(); |
| 5754 | const unsigned char *BufEnd = BufPtr + Buffer->getBufferSize(); |
| 5755 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5756 | if (Buffer->getBufferSize() & 3) |
| 5757 | return error("Invalid bitcode signature"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5758 | |
| 5759 | // If we have a wrapper header, parse it and ignore the non-bc file contents. |
| 5760 | // The magic number is 0x0B17C0DE stored in little endian. |
| 5761 | if (isBitcodeWrapper(BufPtr, BufEnd)) |
| 5762 | if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) |
| 5763 | return error("Invalid bitcode wrapper header"); |
| 5764 | |
| 5765 | StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); |
| 5766 | Stream.init(&*StreamFile); |
| 5767 | |
| 5768 | return std::error_code(); |
| 5769 | } |
| 5770 | |
| 5771 | std::error_code FunctionIndexBitcodeReader::initLazyStream( |
| 5772 | std::unique_ptr<DataStreamer> Streamer) { |
| 5773 | // Check and strip off the bitcode wrapper; BitstreamReader expects never to |
| 5774 | // see it. |
| 5775 | auto OwnedBytes = |
| 5776 | llvm::make_unique<StreamingMemoryObject>(std::move(Streamer)); |
| 5777 | StreamingMemoryObject &Bytes = *OwnedBytes; |
| 5778 | StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes)); |
| 5779 | Stream.init(&*StreamFile); |
| 5780 | |
| 5781 | unsigned char buf[16]; |
| 5782 | if (Bytes.readBytes(buf, 16, 0) != 16) |
| 5783 | return error("Invalid bitcode signature"); |
| 5784 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5785 | if (!isBitcode(buf, buf + 16)) |
| 5786 | return error("Invalid bitcode signature"); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5787 | |
| 5788 | if (isBitcodeWrapper(buf, buf + 4)) { |
| 5789 | const unsigned char *bitcodeStart = buf; |
| 5790 | const unsigned char *bitcodeEnd = buf + 16; |
| 5791 | SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); |
| 5792 | Bytes.dropLeadingBytes(bitcodeStart - buf); |
| 5793 | Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart); |
| 5794 | } |
| 5795 | return std::error_code(); |
| 5796 | } |
| 5797 | |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5798 | namespace { |
Rafael Espindola | 25188c9 | 2014-06-12 01:45:43 +0000 | [diff] [blame] | 5799 | class BitcodeErrorCategoryType : public std::error_category { |
Rafael Espindola | f5d07fa | 2014-06-10 21:26:47 +0000 | [diff] [blame] | 5800 | const char *name() const LLVM_NOEXCEPT override { |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5801 | return "llvm.bitcode"; |
| 5802 | } |
Craig Topper | 7315602 | 2014-03-02 09:09:27 +0000 | [diff] [blame] | 5803 | std::string message(int IE) const override { |
Rafael Espindola | c3f2e73 | 2014-07-29 20:22:46 +0000 | [diff] [blame] | 5804 | BitcodeError E = static_cast<BitcodeError>(IE); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5805 | switch (E) { |
Rafael Espindola | c3f2e73 | 2014-07-29 20:22:46 +0000 | [diff] [blame] | 5806 | case BitcodeError::InvalidBitcodeSignature: |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5807 | return "Invalid bitcode signature"; |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 5808 | case BitcodeError::CorruptedBitcode: |
| 5809 | return "Corrupted bitcode"; |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5810 | } |
Benjamin Kramer | 77db163 | 2013-11-05 13:45:09 +0000 | [diff] [blame] | 5811 | llvm_unreachable("Unknown error type!"); |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5812 | } |
| 5813 | }; |
Alexander Kornienko | f00654e | 2015-06-23 09:49:53 +0000 | [diff] [blame] | 5814 | } |
Rafael Espindola | 48da4f4 | 2013-11-04 16:16:24 +0000 | [diff] [blame] | 5815 | |
Chris Bieneman | 770163e | 2014-09-19 20:29:02 +0000 | [diff] [blame] | 5816 | static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory; |
| 5817 | |
Rafael Espindola | c3f2e73 | 2014-07-29 20:22:46 +0000 | [diff] [blame] | 5818 | const std::error_category &llvm::BitcodeErrorCategory() { |
Chris Bieneman | 770163e | 2014-09-19 20:29:02 +0000 | [diff] [blame] | 5819 | return *ErrorCategory; |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5820 | } |
Chris Lattner | 51ffe7c | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 5821 | |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 5822 | //===----------------------------------------------------------------------===// |
| 5823 | // External interface |
| 5824 | //===----------------------------------------------------------------------===// |
| 5825 | |
Rafael Espindola | 456baad | 2015-06-17 01:15:47 +0000 | [diff] [blame] | 5826 | static ErrorOr<std::unique_ptr<Module>> |
| 5827 | getBitcodeModuleImpl(std::unique_ptr<DataStreamer> Streamer, StringRef Name, |
| 5828 | BitcodeReader *R, LLVMContext &Context, |
| 5829 | bool MaterializeAll, bool ShouldLazyLoadMetadata) { |
| 5830 | std::unique_ptr<Module> M = make_unique<Module>(Name, Context); |
| 5831 | M->setMaterializer(R); |
| 5832 | |
| 5833 | auto cleanupOnError = [&](std::error_code EC) { |
| 5834 | R->releaseBuffer(); // Never take ownership on error. |
| 5835 | return EC; |
| 5836 | }; |
| 5837 | |
| 5838 | // Delay parsing Metadata if ShouldLazyLoadMetadata is true. |
| 5839 | if (std::error_code EC = R->parseBitcodeInto(std::move(Streamer), M.get(), |
| 5840 | ShouldLazyLoadMetadata)) |
| 5841 | return cleanupOnError(EC); |
| 5842 | |
| 5843 | if (MaterializeAll) { |
| 5844 | // Read in the entire module, and destroy the BitcodeReader. |
| 5845 | if (std::error_code EC = M->materializeAllPermanently()) |
| 5846 | return cleanupOnError(EC); |
| 5847 | } else { |
| 5848 | // Resolve forward references from blockaddresses. |
| 5849 | if (std::error_code EC = R->materializeForwardReferencedFunctions()) |
| 5850 | return cleanupOnError(EC); |
| 5851 | } |
| 5852 | return std::move(M); |
| 5853 | } |
| 5854 | |
Duncan P. N. Exon Smith | 6e1009b | 2014-08-01 22:27:19 +0000 | [diff] [blame] | 5855 | /// \brief Get a lazy one-at-time loading module from bitcode. |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 5856 | /// |
Duncan P. N. Exon Smith | 6e1009b | 2014-08-01 22:27:19 +0000 | [diff] [blame] | 5857 | /// This isn't always used in a lazy context. In particular, it's also used by |
| 5858 | /// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull |
| 5859 | /// in forward-referenced functions from block address references. |
| 5860 | /// |
Rafael Espindola | 728074b | 2015-06-17 00:40:56 +0000 | [diff] [blame] | 5861 | /// \param[in] MaterializeAll Set to \c true if we should materialize |
| 5862 | /// everything. |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame] | 5863 | static ErrorOr<std::unique_ptr<Module>> |
Rafael Espindola | 6881215 | 2014-09-03 17:31:46 +0000 | [diff] [blame] | 5864 | getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer, |
Rafael Espindola | 728074b | 2015-06-17 00:40:56 +0000 | [diff] [blame] | 5865 | LLVMContext &Context, bool MaterializeAll, |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 5866 | DiagnosticHandlerFunction DiagnosticHandler, |
| 5867 | bool ShouldLazyLoadMetadata = false) { |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 5868 | BitcodeReader *R = |
| 5869 | new BitcodeReader(Buffer.get(), Context, DiagnosticHandler); |
Duncan P. N. Exon Smith | 908d809 | 2014-08-01 21:11:34 +0000 | [diff] [blame] | 5870 | |
Rafael Espindola | 456baad | 2015-06-17 01:15:47 +0000 | [diff] [blame] | 5871 | ErrorOr<std::unique_ptr<Module>> Ret = |
| 5872 | getBitcodeModuleImpl(nullptr, Buffer->getBufferIdentifier(), R, Context, |
| 5873 | MaterializeAll, ShouldLazyLoadMetadata); |
| 5874 | if (!Ret) |
| 5875 | return Ret; |
Rafael Espindola | b799346 | 2012-01-02 07:49:53 +0000 | [diff] [blame] | 5876 | |
Rafael Espindola | e2c1d77 | 2014-08-26 22:00:09 +0000 | [diff] [blame] | 5877 | Buffer.release(); // The BitcodeReader owns it now. |
Rafael Espindola | 456baad | 2015-06-17 01:15:47 +0000 | [diff] [blame] | 5878 | return Ret; |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 5879 | } |
| 5880 | |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame] | 5881 | ErrorOr<std::unique_ptr<Module>> llvm::getLazyBitcodeModule( |
| 5882 | std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context, |
| 5883 | DiagnosticHandlerFunction DiagnosticHandler, bool ShouldLazyLoadMetadata) { |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 5884 | return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false, |
Manman Ren | 4a9b0eb | 2015-03-13 19:24:30 +0000 | [diff] [blame] | 5885 | DiagnosticHandler, ShouldLazyLoadMetadata); |
Duncan P. N. Exon Smith | 6e1009b | 2014-08-01 22:27:19 +0000 | [diff] [blame] | 5886 | } |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5887 | |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 5888 | ErrorOr<std::unique_ptr<Module>> llvm::getStreamedBitcodeModule( |
| 5889 | StringRef Name, std::unique_ptr<DataStreamer> Streamer, |
| 5890 | LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler) { |
Rafael Espindola | 7d727b5 | 2014-12-18 05:08:43 +0000 | [diff] [blame] | 5891 | std::unique_ptr<Module> M = make_unique<Module>(Name, Context); |
Rafael Espindola | 1aabf98 | 2015-06-16 23:29:49 +0000 | [diff] [blame] | 5892 | BitcodeReader *R = new BitcodeReader(Context, DiagnosticHandler); |
Rafael Espindola | 456baad | 2015-06-17 01:15:47 +0000 | [diff] [blame] | 5893 | |
| 5894 | return getBitcodeModuleImpl(std::move(Streamer), Name, R, Context, false, |
| 5895 | false); |
Derek Schuff | 8b2dcad | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 5896 | } |
| 5897 | |
Rafael Espindola | dcd1dca | 2015-06-16 22:27:55 +0000 | [diff] [blame] | 5898 | ErrorOr<std::unique_ptr<Module>> |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 5899 | llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, |
| 5900 | DiagnosticHandlerFunction DiagnosticHandler) { |
Rafael Espindola | d96d553 | 2014-08-26 21:49:01 +0000 | [diff] [blame] | 5901 | std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); |
Rafael Espindola | 728074b | 2015-06-17 00:40:56 +0000 | [diff] [blame] | 5902 | return getLazyBitcodeModuleImpl(std::move(Buf), Context, true, |
| 5903 | DiagnosticHandler); |
Chad Rosier | ca2567b | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 5904 | // TODO: Restore the use-lists to the in-memory state when the bitcode was |
| 5905 | // written. We must defer until the Module has been fully materialized. |
Chris Lattner | 6694f60 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 5906 | } |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 5907 | |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 5908 | std::string |
| 5909 | llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context, |
| 5910 | DiagnosticHandlerFunction DiagnosticHandler) { |
Rafael Espindola | d96d553 | 2014-08-26 21:49:01 +0000 | [diff] [blame] | 5911 | std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); |
Rafael Espindola | d0b23be | 2015-01-10 00:07:30 +0000 | [diff] [blame] | 5912 | auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context, |
| 5913 | DiagnosticHandler); |
Rafael Espindola | c75c4fa | 2014-07-04 20:02:42 +0000 | [diff] [blame] | 5914 | ErrorOr<std::string> Triple = R->parseTriple(); |
Rafael Espindola | d346cc8 | 2014-07-04 13:52:01 +0000 | [diff] [blame] | 5915 | if (Triple.getError()) |
| 5916 | return ""; |
| 5917 | return Triple.get(); |
Bill Wendling | 0198ce0 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 5918 | } |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5919 | |
Mehdi Amini | 3383ccc | 2015-11-09 02:46:41 +0000 | [diff] [blame] | 5920 | std::string |
| 5921 | llvm::getBitcodeProducerString(MemoryBufferRef Buffer, LLVMContext &Context, |
| 5922 | DiagnosticHandlerFunction DiagnosticHandler) { |
| 5923 | std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); |
| 5924 | BitcodeReader R(Buf.release(), Context, DiagnosticHandler); |
| 5925 | ErrorOr<std::string> ProducerString = R.parseIdentificationBlock(); |
| 5926 | if (ProducerString.getError()) |
| 5927 | return ""; |
| 5928 | return ProducerString.get(); |
| 5929 | } |
| 5930 | |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5931 | // Parse the specified bitcode buffer, returning the function info index. |
| 5932 | // If IsLazy is false, parse the entire function summary into |
| 5933 | // the index. Otherwise skip the function summary section, and only create |
| 5934 | // an index object with a map from function name to function summary offset. |
| 5935 | // The index is used to perform lazy function summary reading later. |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5936 | ErrorOr<std::unique_ptr<FunctionInfoIndex>> |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5937 | llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5938 | DiagnosticHandlerFunction DiagnosticHandler, |
Mehdi Amini | 9abe108 | 2015-12-03 02:37:23 +0000 | [diff] [blame] | 5939 | bool IsLazy) { |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5940 | std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5941 | FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, IsLazy); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5942 | |
Mehdi Amini | 9abe108 | 2015-12-03 02:37:23 +0000 | [diff] [blame] | 5943 | auto Index = llvm::make_unique<FunctionInfoIndex>(); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5944 | |
| 5945 | auto cleanupOnError = [&](std::error_code EC) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5946 | R.releaseBuffer(); // Never take ownership on error. |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5947 | return EC; |
| 5948 | }; |
| 5949 | |
| 5950 | if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get())) |
| 5951 | return cleanupOnError(EC); |
| 5952 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5953 | Buf.release(); // The FunctionIndexBitcodeReader owns it now. |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5954 | return std::move(Index); |
| 5955 | } |
| 5956 | |
| 5957 | // Check if the given bitcode buffer contains a function summary block. |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5958 | bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5959 | DiagnosticHandlerFunction DiagnosticHandler) { |
| 5960 | std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5961 | FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, false, true); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5962 | |
| 5963 | auto cleanupOnError = [&](std::error_code EC) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5964 | R.releaseBuffer(); // Never take ownership on error. |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5965 | return false; |
| 5966 | }; |
| 5967 | |
| 5968 | if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr)) |
| 5969 | return cleanupOnError(EC); |
| 5970 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5971 | Buf.release(); // The FunctionIndexBitcodeReader owns it now. |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5972 | return R.foundFuncSummary(); |
| 5973 | } |
| 5974 | |
| 5975 | // This method supports lazy reading of function summary data from the combined |
| 5976 | // index during ThinLTO function importing. When reading the combined index |
| 5977 | // file, getFunctionInfoIndex is first invoked with IsLazy=true. |
| 5978 | // Then this method is called for each function considered for importing, |
| 5979 | // to parse the summary information for the given function name into |
| 5980 | // the index. |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5981 | std::error_code llvm::readFunctionSummary( |
| 5982 | MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler, |
| 5983 | StringRef FunctionName, std::unique_ptr<FunctionInfoIndex> Index) { |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5984 | std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); |
Mehdi Amini | 354f520 | 2015-11-19 05:52:29 +0000 | [diff] [blame] | 5985 | FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler); |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5986 | |
| 5987 | auto cleanupOnError = [&](std::error_code EC) { |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 5988 | R.releaseBuffer(); // Never take ownership on error. |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 5989 | return EC; |
| 5990 | }; |
| 5991 | |
| 5992 | // Lookup the given function name in the FunctionMap, which may |
| 5993 | // contain a list of function infos in the case of a COMDAT. Walk through |
| 5994 | // and parse each function summary info at the function summary offset |
| 5995 | // recorded when parsing the value symbol table. |
| 5996 | for (const auto &FI : Index->getFunctionInfoList(FunctionName)) { |
| 5997 | size_t FunctionSummaryOffset = FI->bitcodeIndex(); |
| 5998 | if (std::error_code EC = |
| 5999 | R.parseFunctionSummary(nullptr, Index.get(), FunctionSummaryOffset)) |
| 6000 | return cleanupOnError(EC); |
| 6001 | } |
| 6002 | |
Teresa Johnson | f72278f | 2015-11-02 18:02:11 +0000 | [diff] [blame] | 6003 | Buf.release(); // The FunctionIndexBitcodeReader owns it now. |
Teresa Johnson | 403a787 | 2015-10-04 14:33:43 +0000 | [diff] [blame] | 6004 | return std::error_code(); |
| 6005 | } |