LLVM  3.7.0
BitcodeReader.cpp
Go to the documentation of this file.
1 //===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/ADT/Triple.h"
17 #include "llvm/IR/AutoUpgrade.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DebugInfo.h"
21 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/GVMaterializer.h"
24 #include "llvm/IR/InlineAsm.h"
25 #include "llvm/IR/IntrinsicInst.h"
26 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/OperandTraits.h"
29 #include "llvm/IR/Operator.h"
30 #include "llvm/IR/ValueHandle.h"
36 #include <deque>
37 using namespace llvm;
38 
39 namespace {
40 enum {
41  SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
42 };
43 
44 class BitcodeReaderValueList {
45  std::vector<WeakVH> ValuePtrs;
46 
47  /// As we resolve forward-referenced constants, we add information about them
48  /// to this vector. This allows us to resolve them in bulk instead of
49  /// resolving each reference at a time. See the code in
50  /// ResolveConstantForwardRefs for more information about this.
51  ///
52  /// The key of this vector is the placeholder constant, the value is the slot
53  /// number that holds the resolved value.
54  typedef std::vector<std::pair<Constant*, unsigned> > ResolveConstantsTy;
55  ResolveConstantsTy ResolveConstants;
56  LLVMContext &Context;
57 public:
58  BitcodeReaderValueList(LLVMContext &C) : Context(C) {}
59  ~BitcodeReaderValueList() {
60  assert(ResolveConstants.empty() && "Constants not resolved?");
61  }
62 
63  // vector compatibility methods
64  unsigned size() const { return ValuePtrs.size(); }
65  void resize(unsigned N) { ValuePtrs.resize(N); }
66  void push_back(Value *V) { ValuePtrs.emplace_back(V); }
67 
68  void clear() {
69  assert(ResolveConstants.empty() && "Constants not resolved?");
70  ValuePtrs.clear();
71  }
72 
73  Value *operator[](unsigned i) const {
74  assert(i < ValuePtrs.size());
75  return ValuePtrs[i];
76  }
77 
78  Value *back() const { return ValuePtrs.back(); }
79  void pop_back() { ValuePtrs.pop_back(); }
80  bool empty() const { return ValuePtrs.empty(); }
81  void shrinkTo(unsigned N) {
82  assert(N <= size() && "Invalid shrinkTo request!");
83  ValuePtrs.resize(N);
84  }
85 
86  Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
87  Value *getValueFwdRef(unsigned Idx, Type *Ty);
88 
89  void assignValue(Value *V, unsigned Idx);
90 
91  /// Once all constants are read, this method bulk resolves any forward
92  /// references.
93  void resolveConstantForwardRefs();
94 };
95 
96 class BitcodeReaderMDValueList {
97  unsigned NumFwdRefs;
98  bool AnyFwdRefs;
99  unsigned MinFwdRef;
100  unsigned MaxFwdRef;
101  std::vector<TrackingMDRef> MDValuePtrs;
102 
103  LLVMContext &Context;
104 public:
105  BitcodeReaderMDValueList(LLVMContext &C)
106  : NumFwdRefs(0), AnyFwdRefs(false), Context(C) {}
107 
108  // vector compatibility methods
109  unsigned size() const { return MDValuePtrs.size(); }
110  void resize(unsigned N) { MDValuePtrs.resize(N); }
111  void push_back(Metadata *MD) { MDValuePtrs.emplace_back(MD); }
112  void clear() { MDValuePtrs.clear(); }
113  Metadata *back() const { return MDValuePtrs.back(); }
114  void pop_back() { MDValuePtrs.pop_back(); }
115  bool empty() const { return MDValuePtrs.empty(); }
116 
117  Metadata *operator[](unsigned i) const {
118  assert(i < MDValuePtrs.size());
119  return MDValuePtrs[i];
120  }
121 
122  void shrinkTo(unsigned N) {
123  assert(N <= size() && "Invalid shrinkTo request!");
124  MDValuePtrs.resize(N);
125  }
126 
127  Metadata *getValueFwdRef(unsigned Idx);
128  void assignValue(Metadata *MD, unsigned Idx);
129  void tryToResolveCycles();
130 };
131 
132 class BitcodeReader : public GVMaterializer {
133  LLVMContext &Context;
134  DiagnosticHandlerFunction DiagnosticHandler;
135  Module *TheModule = nullptr;
136  std::unique_ptr<MemoryBuffer> Buffer;
137  std::unique_ptr<BitstreamReader> StreamFile;
138  BitstreamCursor Stream;
139  uint64_t NextUnreadBit = 0;
140  bool SeenValueSymbolTable = false;
141 
142  std::vector<Type*> TypeList;
143  BitcodeReaderValueList ValueList;
144  BitcodeReaderMDValueList MDValueList;
145  std::vector<Comdat *> ComdatList;
146  SmallVector<Instruction *, 64> InstructionList;
147 
148  std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
149  std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
150  std::vector<std::pair<Function*, unsigned> > FunctionPrefixes;
151  std::vector<std::pair<Function*, unsigned> > FunctionPrologues;
152  std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFns;
153 
154  SmallVector<Instruction*, 64> InstsWithTBAATag;
155 
156  /// The set of attributes by index. Index zero in the file is for null, and
157  /// is thus not represented here. As such all indices are off by one.
158  std::vector<AttributeSet> MAttributes;
159 
160  /// \brief The set of attribute groups.
161  std::map<unsigned, AttributeSet> MAttributeGroups;
162 
163  /// While parsing a function body, this is a list of the basic blocks for the
164  /// function.
165  std::vector<BasicBlock*> FunctionBBs;
166 
167  // When reading the module header, this list is populated with functions that
168  // have bodies later in the file.
169  std::vector<Function*> FunctionsWithBodies;
170 
171  // When intrinsic functions are encountered which require upgrading they are
172  // stored here with their replacement function.
173  typedef DenseMap<Function*, Function*> UpgradedIntrinsicMap;
174  UpgradedIntrinsicMap UpgradedIntrinsics;
175 
176  // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
178 
179  // Several operations happen after the module header has been read, but
180  // before function bodies are processed. This keeps track of whether
181  // we've done this yet.
182  bool SeenFirstFunctionBody = false;
183 
184  /// When function bodies are initially scanned, this map contains info about
185  /// where to find deferred function body in the stream.
186  DenseMap<Function*, uint64_t> DeferredFunctionInfo;
187 
188  /// When Metadata block is initially scanned when parsing the module, we may
189  /// choose to defer parsing of the metadata. This vector contains info about
190  /// which Metadata blocks are deferred.
191  std::vector<uint64_t> DeferredMetadataInfo;
192 
193  /// These are basic blocks forward-referenced by block addresses. They are
194  /// inserted lazily into functions when they're loaded. The basic block ID is
195  /// its index into the vector.
197  std::deque<Function *> BasicBlockFwdRefQueue;
198 
199  /// Indicates that we are using a new encoding for instruction operands where
200  /// most operands in the current FUNCTION_BLOCK are encoded relative to the
201  /// instruction number, for a more compact encoding. Some instruction
202  /// operands are not relative to the instruction ID: basic block numbers, and
203  /// types. Once the old style function blocks have been phased out, we would
204  /// not need this flag.
205  bool UseRelativeIDs = false;
206 
207  /// True if all functions will be materialized, negating the need to process
208  /// (e.g.) blockaddress forward references.
209  bool WillMaterializeAllForwardRefs = false;
210 
211  /// Functions that have block addresses taken. This is usually empty.
212  SmallPtrSet<const Function *, 4> BlockAddressesTaken;
213 
214  /// True if any Metadata block has been materialized.
215  bool IsMetadataMaterialized = false;
216 
217  bool StripDebugInfo = false;
218 
219 public:
220  std::error_code error(BitcodeError E, const Twine &Message);
221  std::error_code error(BitcodeError E);
222  std::error_code error(const Twine &Message);
223 
224  BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context,
225  DiagnosticHandlerFunction DiagnosticHandler);
226  BitcodeReader(LLVMContext &Context,
227  DiagnosticHandlerFunction DiagnosticHandler);
228  ~BitcodeReader() override { freeState(); }
229 
230  std::error_code materializeForwardReferencedFunctions();
231 
232  void freeState();
233 
234  void releaseBuffer();
235 
236  bool isDematerializable(const GlobalValue *GV) const override;
237  std::error_code materialize(GlobalValue *GV) override;
238  std::error_code materializeModule(Module *M) override;
239  std::vector<StructType *> getIdentifiedStructTypes() const override;
240  void dematerialize(GlobalValue *GV) override;
241 
242  /// \brief Main interface to parsing a bitcode buffer.
243  /// \returns true if an error occurred.
244  std::error_code parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
245  Module *M,
246  bool ShouldLazyLoadMetadata = false);
247 
248  /// \brief Cheap mechanism to just extract module triple
249  /// \returns true if an error occurred.
250  ErrorOr<std::string> parseTriple();
251 
252  static uint64_t decodeSignRotatedValue(uint64_t V);
253 
254  /// Materialize any deferred Metadata block.
255  std::error_code materializeMetadata() override;
256 
257  void setStripDebugInfo() override;
258 
259 private:
260  std::vector<StructType *> IdentifiedStructTypes;
261  StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
262  StructType *createIdentifiedStructType(LLVMContext &Context);
263 
264  Type *getTypeByID(unsigned ID);
265  Value *getFnValueByID(unsigned ID, Type *Ty) {
266  if (Ty && Ty->isMetadataTy())
267  return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
268  return ValueList.getValueFwdRef(ID, Ty);
269  }
270  Metadata *getFnMetadataByID(unsigned ID) {
271  return MDValueList.getValueFwdRef(ID);
272  }
273  BasicBlock *getBasicBlock(unsigned ID) const {
274  if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
275  return FunctionBBs[ID];
276  }
277  AttributeSet getAttributes(unsigned i) const {
278  if (i-1 < MAttributes.size())
279  return MAttributes[i-1];
280  return AttributeSet();
281  }
282 
283  /// Read a value/type pair out of the specified record from slot 'Slot'.
284  /// Increment Slot past the number of slots used in the record. Return true on
285  /// failure.
286  bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
287  unsigned InstNum, Value *&ResVal) {
288  if (Slot == Record.size()) return true;
289  unsigned ValNo = (unsigned)Record[Slot++];
290  // Adjust the ValNo, if it was encoded relative to the InstNum.
291  if (UseRelativeIDs)
292  ValNo = InstNum - ValNo;
293  if (ValNo < InstNum) {
294  // If this is not a forward reference, just return the value we already
295  // have.
296  ResVal = getFnValueByID(ValNo, nullptr);
297  return ResVal == nullptr;
298  }
299  if (Slot == Record.size())
300  return true;
301 
302  unsigned TypeNo = (unsigned)Record[Slot++];
303  ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
304  return ResVal == nullptr;
305  }
306 
307  /// Read a value out of the specified record from slot 'Slot'. Increment Slot
308  /// past the number of slots used by the value in the record. Return true if
309  /// there is an error.
310  bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
311  unsigned InstNum, Type *Ty, Value *&ResVal) {
312  if (getValue(Record, Slot, InstNum, Ty, ResVal))
313  return true;
314  // All values currently take a single record slot.
315  ++Slot;
316  return false;
317  }
318 
319  /// Like popValue, but does not increment the Slot number.
320  bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
321  unsigned InstNum, Type *Ty, Value *&ResVal) {
322  ResVal = getValue(Record, Slot, InstNum, Ty);
323  return ResVal == nullptr;
324  }
325 
326  /// Version of getValue that returns ResVal directly, or 0 if there is an
327  /// error.
328  Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
329  unsigned InstNum, Type *Ty) {
330  if (Slot == Record.size()) return nullptr;
331  unsigned ValNo = (unsigned)Record[Slot];
332  // Adjust the ValNo, if it was encoded relative to the InstNum.
333  if (UseRelativeIDs)
334  ValNo = InstNum - ValNo;
335  return getFnValueByID(ValNo, Ty);
336  }
337 
338  /// Like getValue, but decodes signed VBRs.
339  Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
340  unsigned InstNum, Type *Ty) {
341  if (Slot == Record.size()) return nullptr;
342  unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
343  // Adjust the ValNo, if it was encoded relative to the InstNum.
344  if (UseRelativeIDs)
345  ValNo = InstNum - ValNo;
346  return getFnValueByID(ValNo, Ty);
347  }
348 
349  /// Converts alignment exponent (i.e. power of two (or zero)) to the
350  /// corresponding alignment to use. If alignment is too large, returns
351  /// a corresponding error code.
352  std::error_code parseAlignmentValue(uint64_t Exponent, unsigned &Alignment);
353  std::error_code parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
354  std::error_code parseModule(bool Resume, bool ShouldLazyLoadMetadata = false);
355  std::error_code parseAttributeBlock();
356  std::error_code parseAttributeGroupBlock();
357  std::error_code parseTypeTable();
358  std::error_code parseTypeTableBody();
359 
360  std::error_code parseValueSymbolTable();
361  std::error_code parseConstants();
362  std::error_code rememberAndSkipFunctionBody();
363  /// Save the positions of the Metadata blocks and skip parsing the blocks.
364  std::error_code rememberAndSkipMetadata();
365  std::error_code parseFunctionBody(Function *F);
366  std::error_code globalCleanup();
367  std::error_code resolveGlobalAndAliasInits();
368  std::error_code parseMetadata();
369  std::error_code parseMetadataAttachment(Function &F);
370  ErrorOr<std::string> parseModuleTriple();
371  std::error_code parseUseLists();
372  std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
373  std::error_code initStreamFromBuffer();
374  std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
375  std::error_code findFunctionInStream(
376  Function *F,
377  DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
378 };
379 } // namespace
380 
382  DiagnosticSeverity Severity,
383  const Twine &Msg)
384  : DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}
385 
386 void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
387 
388 static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler,
389  std::error_code EC, const Twine &Message) {
390  BitcodeDiagnosticInfo DI(EC, DS_Error, Message);
391  DiagnosticHandler(DI);
392  return EC;
393 }
394 
395 static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler,
396  std::error_code EC) {
397  return error(DiagnosticHandler, EC, EC.message());
398 }
399 
400 static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler,
401  const Twine &Message) {
402  return error(DiagnosticHandler,
404 }
405 
406 std::error_code BitcodeReader::error(BitcodeError E, const Twine &Message) {
407  return ::error(DiagnosticHandler, make_error_code(E), Message);
408 }
409 
410 std::error_code BitcodeReader::error(const Twine &Message) {
411  return ::error(DiagnosticHandler,
413 }
414 
415 std::error_code BitcodeReader::error(BitcodeError E) {
416  return ::error(DiagnosticHandler, make_error_code(E));
417 }
418 
420  LLVMContext &C) {
421  if (F)
422  return F;
423  return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); };
424 }
425 
426 BitcodeReader::BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context,
427  DiagnosticHandlerFunction DiagnosticHandler)
428  : Context(Context),
429  DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
430  Buffer(Buffer), ValueList(Context), MDValueList(Context) {}
431 
432 BitcodeReader::BitcodeReader(LLVMContext &Context,
433  DiagnosticHandlerFunction DiagnosticHandler)
434  : Context(Context),
435  DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
436  Buffer(nullptr), ValueList(Context), MDValueList(Context) {}
437 
438 std::error_code BitcodeReader::materializeForwardReferencedFunctions() {
439  if (WillMaterializeAllForwardRefs)
440  return std::error_code();
441 
442  // Prevent recursion.
443  WillMaterializeAllForwardRefs = true;
444 
445  while (!BasicBlockFwdRefQueue.empty()) {
446  Function *F = BasicBlockFwdRefQueue.front();
447  BasicBlockFwdRefQueue.pop_front();
448  assert(F && "Expected valid function");
449  if (!BasicBlockFwdRefs.count(F))
450  // Already materialized.
451  continue;
452 
453  // Check for a function that isn't materializable to prevent an infinite
454  // loop. When parsing a blockaddress stored in a global variable, there
455  // isn't a trivial way to check if a function will have a body without a
456  // linear search through FunctionsWithBodies, so just check it here.
457  if (!F->isMaterializable())
458  return error("Never resolved function from blockaddress");
459 
460  // Try to materialize F.
461  if (std::error_code EC = materialize(F))
462  return EC;
463  }
464  assert(BasicBlockFwdRefs.empty() && "Function missing from queue");
465 
466  // Reset state.
467  WillMaterializeAllForwardRefs = false;
468  return std::error_code();
469 }
470 
471 void BitcodeReader::freeState() {
472  Buffer = nullptr;
473  std::vector<Type*>().swap(TypeList);
474  ValueList.clear();
475  MDValueList.clear();
476  std::vector<Comdat *>().swap(ComdatList);
477 
478  std::vector<AttributeSet>().swap(MAttributes);
479  std::vector<BasicBlock*>().swap(FunctionBBs);
480  std::vector<Function*>().swap(FunctionsWithBodies);
481  DeferredFunctionInfo.clear();
482  DeferredMetadataInfo.clear();
483  MDKindMap.clear();
484 
485  assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references");
486  BasicBlockFwdRefQueue.clear();
487 }
488 
489 //===----------------------------------------------------------------------===//
490 // Helper functions to implement forward reference resolution, etc.
491 //===----------------------------------------------------------------------===//
492 
493 /// Convert a string from a record into an std::string, return true on failure.
494 template <typename StrTy>
495 static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx,
496  StrTy &Result) {
497  if (Idx > Record.size())
498  return true;
499 
500  for (unsigned i = Idx, e = Record.size(); i != e; ++i)
501  Result += (char)Record[i];
502  return false;
503 }
504 
505 static bool hasImplicitComdat(size_t Val) {
506  switch (Val) {
507  default:
508  return false;
509  case 1: // Old WeakAnyLinkage
510  case 4: // Old LinkOnceAnyLinkage
511  case 10: // Old WeakODRLinkage
512  case 11: // Old LinkOnceODRLinkage
513  return true;
514  }
515 }
516 
518  switch (Val) {
519  default: // Map unknown/new linkages to external
520  case 0:
521  return GlobalValue::ExternalLinkage;
522  case 2:
523  return GlobalValue::AppendingLinkage;
524  case 3:
525  return GlobalValue::InternalLinkage;
526  case 5:
527  return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage
528  case 6:
529  return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage
530  case 7:
531  return GlobalValue::ExternalWeakLinkage;
532  case 8:
533  return GlobalValue::CommonLinkage;
534  case 9:
535  return GlobalValue::PrivateLinkage;
536  case 12:
537  return GlobalValue::AvailableExternallyLinkage;
538  case 13:
539  return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage
540  case 14:
541  return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage
542  case 15:
543  return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage
544  case 1: // Old value with implicit comdat.
545  case 16:
546  return GlobalValue::WeakAnyLinkage;
547  case 10: // Old value with implicit comdat.
548  case 17:
549  return GlobalValue::WeakODRLinkage;
550  case 4: // Old value with implicit comdat.
551  case 18:
552  return GlobalValue::LinkOnceAnyLinkage;
553  case 11: // Old value with implicit comdat.
554  case 19:
555  return GlobalValue::LinkOnceODRLinkage;
556  }
557 }
558 
560  switch (Val) {
561  default: // Map unknown visibilities to default.
562  case 0: return GlobalValue::DefaultVisibility;
563  case 1: return GlobalValue::HiddenVisibility;
564  case 2: return GlobalValue::ProtectedVisibility;
565  }
566 }
567 
570  switch (Val) {
571  default: // Map unknown values to default.
572  case 0: return GlobalValue::DefaultStorageClass;
573  case 1: return GlobalValue::DLLImportStorageClass;
574  case 2: return GlobalValue::DLLExportStorageClass;
575  }
576 }
577 
578 static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) {
579  switch (Val) {
580  case 0: return GlobalVariable::NotThreadLocal;
581  default: // Map unknown non-zero value to general dynamic.
582  case 1: return GlobalVariable::GeneralDynamicTLSModel;
583  case 2: return GlobalVariable::LocalDynamicTLSModel;
584  case 3: return GlobalVariable::InitialExecTLSModel;
585  case 4: return GlobalVariable::LocalExecTLSModel;
586  }
587 }
588 
589 static int getDecodedCastOpcode(unsigned Val) {
590  switch (Val) {
591  default: return -1;
592  case bitc::CAST_TRUNC : return Instruction::Trunc;
593  case bitc::CAST_ZEXT : return Instruction::ZExt;
594  case bitc::CAST_SEXT : return Instruction::SExt;
595  case bitc::CAST_FPTOUI : return Instruction::FPToUI;
596  case bitc::CAST_FPTOSI : return Instruction::FPToSI;
597  case bitc::CAST_UITOFP : return Instruction::UIToFP;
598  case bitc::CAST_SITOFP : return Instruction::SIToFP;
599  case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
600  case bitc::CAST_FPEXT : return Instruction::FPExt;
601  case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
602  case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
603  case bitc::CAST_BITCAST : return Instruction::BitCast;
604  case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast;
605  }
606 }
607 
608 static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) {
609  bool IsFP = Ty->isFPOrFPVectorTy();
610  // BinOps are only valid for int/fp or vector of int/fp types
611  if (!IsFP && !Ty->isIntOrIntVectorTy())
612  return -1;
613 
614  switch (Val) {
615  default:
616  return -1;
617  case bitc::BINOP_ADD:
618  return IsFP ? Instruction::FAdd : Instruction::Add;
619  case bitc::BINOP_SUB:
620  return IsFP ? Instruction::FSub : Instruction::Sub;
621  case bitc::BINOP_MUL:
622  return IsFP ? Instruction::FMul : Instruction::Mul;
623  case bitc::BINOP_UDIV:
624  return IsFP ? -1 : Instruction::UDiv;
625  case bitc::BINOP_SDIV:
626  return IsFP ? Instruction::FDiv : Instruction::SDiv;
627  case bitc::BINOP_UREM:
628  return IsFP ? -1 : Instruction::URem;
629  case bitc::BINOP_SREM:
630  return IsFP ? Instruction::FRem : Instruction::SRem;
631  case bitc::BINOP_SHL:
632  return IsFP ? -1 : Instruction::Shl;
633  case bitc::BINOP_LSHR:
634  return IsFP ? -1 : Instruction::LShr;
635  case bitc::BINOP_ASHR:
636  return IsFP ? -1 : Instruction::AShr;
637  case bitc::BINOP_AND:
638  return IsFP ? -1 : Instruction::And;
639  case bitc::BINOP_OR:
640  return IsFP ? -1 : Instruction::Or;
641  case bitc::BINOP_XOR:
642  return IsFP ? -1 : Instruction::Xor;
643  }
644 }
645 
647  switch (Val) {
648  default: return AtomicRMWInst::BAD_BINOP;
649  case bitc::RMW_XCHG: return AtomicRMWInst::Xchg;
650  case bitc::RMW_ADD: return AtomicRMWInst::Add;
651  case bitc::RMW_SUB: return AtomicRMWInst::Sub;
652  case bitc::RMW_AND: return AtomicRMWInst::And;
653  case bitc::RMW_NAND: return AtomicRMWInst::Nand;
654  case bitc::RMW_OR: return AtomicRMWInst::Or;
655  case bitc::RMW_XOR: return AtomicRMWInst::Xor;
656  case bitc::RMW_MAX: return AtomicRMWInst::Max;
657  case bitc::RMW_MIN: return AtomicRMWInst::Min;
658  case bitc::RMW_UMAX: return AtomicRMWInst::UMax;
659  case bitc::RMW_UMIN: return AtomicRMWInst::UMin;
660  }
661 }
662 
663 static AtomicOrdering getDecodedOrdering(unsigned Val) {
664  switch (Val) {
665  case bitc::ORDERING_NOTATOMIC: return NotAtomic;
666  case bitc::ORDERING_UNORDERED: return Unordered;
667  case bitc::ORDERING_MONOTONIC: return Monotonic;
668  case bitc::ORDERING_ACQUIRE: return Acquire;
669  case bitc::ORDERING_RELEASE: return Release;
671  default: // Map unknown orderings to sequentially-consistent.
673  }
674 }
675 
677  switch (Val) {
679  default: // Map unknown scopes to cross-thread.
681  }
682 }
683 
685  switch (Val) {
686  default: // Map unknown selection kinds to any.
688  return Comdat::Any;
690  return Comdat::ExactMatch;
692  return Comdat::Largest;
694  return Comdat::NoDuplicates;
696  return Comdat::SameSize;
697  }
698 }
699 
701  FastMathFlags FMF;
702  if (0 != (Val & FastMathFlags::UnsafeAlgebra))
703  FMF.setUnsafeAlgebra();
704  if (0 != (Val & FastMathFlags::NoNaNs))
705  FMF.setNoNaNs();
706  if (0 != (Val & FastMathFlags::NoInfs))
707  FMF.setNoInfs();
708  if (0 != (Val & FastMathFlags::NoSignedZeros))
709  FMF.setNoSignedZeros();
710  if (0 != (Val & FastMathFlags::AllowReciprocal))
711  FMF.setAllowReciprocal();
712  return FMF;
713 }
714 
715 static void upgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) {
716  switch (Val) {
717  case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break;
718  case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break;
719  }
720 }
721 
722 namespace llvm {
723 namespace {
724 /// \brief A class for maintaining the slot number definition
725 /// as a placeholder for the actual definition for forward constants defs.
726 class ConstantPlaceHolder : public ConstantExpr {
727  void operator=(const ConstantPlaceHolder &) = delete;
728 
729 public:
730  // allocate space for exactly one operand
731  void *operator new(size_t s) { return User::operator new(s, 1); }
732  explicit ConstantPlaceHolder(Type *Ty, LLVMContext &Context)
733  : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
734  Op<0>() = UndefValue::get(Type::getInt32Ty(Context));
735  }
736 
737  /// \brief Methods to support type inquiry through isa, cast, and dyn_cast.
738  static bool classof(const Value *V) {
739  return isa<ConstantExpr>(V) &&
740  cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1;
741  }
742 
743  /// Provide fast operand accessors
745 };
746 }
747 
748 // FIXME: can we inherit this from ConstantExpr?
749 template <>
750 struct OperandTraits<ConstantPlaceHolder> :
751  public FixedNumOperandTraits<ConstantPlaceHolder, 1> {
752 };
753 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value)
754 }
755 
756 void BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) {
757  if (Idx == size()) {
758  push_back(V);
759  return;
760  }
761 
762  if (Idx >= size())
763  resize(Idx+1);
764 
765  WeakVH &OldV = ValuePtrs[Idx];
766  if (!OldV) {
767  OldV = V;
768  return;
769  }
770 
771  // Handle constants and non-constants (e.g. instrs) differently for
772  // efficiency.
773  if (Constant *PHC = dyn_cast<Constant>(&*OldV)) {
774  ResolveConstants.push_back(std::make_pair(PHC, Idx));
775  OldV = V;
776  } else {
777  // If there was a forward reference to this value, replace it.
778  Value *PrevVal = OldV;
779  OldV->replaceAllUsesWith(V);
780  delete PrevVal;
781  }
782 }
783 
784 
785 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
786  Type *Ty) {
787  if (Idx >= size())
788  resize(Idx + 1);
789 
790  if (Value *V = ValuePtrs[Idx]) {
791  if (Ty != V->getType())
792  report_fatal_error("Type mismatch in constant table!");
793  return cast<Constant>(V);
794  }
795 
796  // Create and return a placeholder, which will later be RAUW'd.
797  Constant *C = new ConstantPlaceHolder(Ty, Context);
798  ValuePtrs[Idx] = C;
799  return C;
800 }
801 
802 Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) {
803  // Bail out for a clearly invalid value. This would make us call resize(0)
804  if (Idx == UINT_MAX)
805  return nullptr;
806 
807  if (Idx >= size())
808  resize(Idx + 1);
809 
810  if (Value *V = ValuePtrs[Idx]) {
811  // If the types don't match, it's invalid.
812  if (Ty && Ty != V->getType())
813  return nullptr;
814  return V;
815  }
816 
817  // No type specified, must be invalid reference.
818  if (!Ty) return nullptr;
819 
820  // Create and return a placeholder, which will later be RAUW'd.
821  Value *V = new Argument(Ty);
822  ValuePtrs[Idx] = V;
823  return V;
824 }
825 
826 /// Once all constants are read, this method bulk resolves any forward
827 /// references. The idea behind this is that we sometimes get constants (such
828 /// as large arrays) which reference *many* forward ref constants. Replacing
829 /// each of these causes a lot of thrashing when building/reuniquing the
830 /// constant. Instead of doing this, we look at all the uses and rewrite all
831 /// the place holders at once for any constant that uses a placeholder.
832 void BitcodeReaderValueList::resolveConstantForwardRefs() {
833  // Sort the values by-pointer so that they are efficient to look up with a
834  // binary search.
835  std::sort(ResolveConstants.begin(), ResolveConstants.end());
836 
838 
839  while (!ResolveConstants.empty()) {
840  Value *RealVal = operator[](ResolveConstants.back().second);
841  Constant *Placeholder = ResolveConstants.back().first;
842  ResolveConstants.pop_back();
843 
844  // Loop over all users of the placeholder, updating them to reference the
845  // new value. If they reference more than one placeholder, update them all
846  // at once.
847  while (!Placeholder->use_empty()) {
848  auto UI = Placeholder->user_begin();
849  User *U = *UI;
850 
851  // If the using object isn't uniqued, just update the operands. This
852  // handles instructions and initializers for global variables.
853  if (!isa<Constant>(U) || isa<GlobalValue>(U)) {
854  UI.getUse().set(RealVal);
855  continue;
856  }
857 
858  // Otherwise, we have a constant that uses the placeholder. Replace that
859  // constant with a new constant that has *all* placeholder uses updated.
860  Constant *UserC = cast<Constant>(U);
861  for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end();
862  I != E; ++I) {
863  Value *NewOp;
864  if (!isa<ConstantPlaceHolder>(*I)) {
865  // Not a placeholder reference.
866  NewOp = *I;
867  } else if (*I == Placeholder) {
868  // Common case is that it just references this one placeholder.
869  NewOp = RealVal;
870  } else {
871  // Otherwise, look up the placeholder in ResolveConstants.
872  ResolveConstantsTy::iterator It =
873  std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(),
874  std::pair<Constant*, unsigned>(cast<Constant>(*I),
875  0));
876  assert(It != ResolveConstants.end() && It->first == *I);
877  NewOp = operator[](It->second);
878  }
879 
880  NewOps.push_back(cast<Constant>(NewOp));
881  }
882 
883  // Make the new constant.
884  Constant *NewC;
885  if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) {
886  NewC = ConstantArray::get(UserCA->getType(), NewOps);
887  } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
888  NewC = ConstantStruct::get(UserCS->getType(), NewOps);
889  } else if (isa<ConstantVector>(UserC)) {
890  NewC = ConstantVector::get(NewOps);
891  } else {
892  assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
893  NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps);
894  }
895 
896  UserC->replaceAllUsesWith(NewC);
897  UserC->destroyConstant();
898  NewOps.clear();
899  }
900 
901  // Update all ValueHandles, they should be the only users at this point.
902  Placeholder->replaceAllUsesWith(RealVal);
903  delete Placeholder;
904  }
905 }
906 
907 void BitcodeReaderMDValueList::assignValue(Metadata *MD, unsigned Idx) {
908  if (Idx == size()) {
909  push_back(MD);
910  return;
911  }
912 
913  if (Idx >= size())
914  resize(Idx+1);
915 
916  TrackingMDRef &OldMD = MDValuePtrs[Idx];
917  if (!OldMD) {
918  OldMD.reset(MD);
919  return;
920  }
921 
922  // If there was a forward reference to this value, replace it.
923  TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
924  PrevMD->replaceAllUsesWith(MD);
925  --NumFwdRefs;
926 }
927 
928 Metadata *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) {
929  if (Idx >= size())
930  resize(Idx + 1);
931 
932  if (Metadata *MD = MDValuePtrs[Idx])
933  return MD;
934 
935  // Track forward refs to be resolved later.
936  if (AnyFwdRefs) {
937  MinFwdRef = std::min(MinFwdRef, Idx);
938  MaxFwdRef = std::max(MaxFwdRef, Idx);
939  } else {
940  AnyFwdRefs = true;
941  MinFwdRef = MaxFwdRef = Idx;
942  }
943  ++NumFwdRefs;
944 
945  // Create and return a placeholder, which will later be RAUW'd.
946  Metadata *MD = MDNode::getTemporary(Context, None).release();
947  MDValuePtrs[Idx].reset(MD);
948  return MD;
949 }
950 
951 void BitcodeReaderMDValueList::tryToResolveCycles() {
952  if (!AnyFwdRefs)
953  // Nothing to do.
954  return;
955 
956  if (NumFwdRefs)
957  // Still forward references... can't resolve cycles.
958  return;
959 
960  // Resolve any cycles.
961  for (unsigned I = MinFwdRef, E = MaxFwdRef + 1; I != E; ++I) {
962  auto &MD = MDValuePtrs[I];
963  auto *N = dyn_cast_or_null<MDNode>(MD);
964  if (!N)
965  continue;
966 
967  assert(!N->isTemporary() && "Unexpected forward reference");
968  N->resolveCycles();
969  }
970 
971  // Make sure we return early again until there's another forward ref.
972  AnyFwdRefs = false;
973 }
974 
975 Type *BitcodeReader::getTypeByID(unsigned ID) {
976  // The type table size is always specified correctly.
977  if (ID >= TypeList.size())
978  return nullptr;
979 
980  if (Type *Ty = TypeList[ID])
981  return Ty;
982 
983  // If we have a forward reference, the only possible case is when it is to a
984  // named struct. Just create a placeholder for now.
985  return TypeList[ID] = createIdentifiedStructType(Context);
986 }
987 
988 StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context,
989  StringRef Name) {
990  auto *Ret = StructType::create(Context, Name);
991  IdentifiedStructTypes.push_back(Ret);
992  return Ret;
993 }
994 
995 StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) {
996  auto *Ret = StructType::create(Context);
997  IdentifiedStructTypes.push_back(Ret);
998  return Ret;
999 }
1000 
1001 
1002 //===----------------------------------------------------------------------===//
1003 // Functions for parsing blocks from the bitcode file
1004 //===----------------------------------------------------------------------===//
1005 
1006 
1007 /// \brief This fills an AttrBuilder object with the LLVM attributes that have
1008 /// been decoded from the given integer. This function must stay in sync with
1009 /// 'encodeLLVMAttributesForBitcode'.
1011  uint64_t EncodedAttrs) {
1012  // FIXME: Remove in 4.0.
1013 
1014  // The alignment is stored as a 16-bit raw value from bits 31--16. We shift
1015  // the bits above 31 down by 11 bits.
1016  unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
1017  assert((!Alignment || isPowerOf2_32(Alignment)) &&
1018  "Alignment must be a power of two.");
1019 
1020  if (Alignment)
1021  B.addAlignmentAttr(Alignment);
1022  B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
1023  (EncodedAttrs & 0xffff));
1024 }
1025 
1026 std::error_code BitcodeReader::parseAttributeBlock() {
1027  if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
1028  return error("Invalid record");
1029 
1030  if (!MAttributes.empty())
1031  return error("Invalid multiple blocks");
1032 
1034 
1036 
1037  // Read all the records.
1038  while (1) {
1039  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1040 
1041  switch (Entry.Kind) {
1042  case BitstreamEntry::SubBlock: // Handled for us already.
1043  case BitstreamEntry::Error:
1044  return error("Malformed block");
1045  case BitstreamEntry::EndBlock:
1046  return std::error_code();
1047  case BitstreamEntry::Record:
1048  // The interesting case.
1049  break;
1050  }
1051 
1052  // Read a record.
1053  Record.clear();
1054  switch (Stream.readRecord(Entry.ID, Record)) {
1055  default: // Default behavior: ignore.
1056  break;
1057  case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...]
1058  // FIXME: Remove in 4.0.
1059  if (Record.size() & 1)
1060  return error("Invalid record");
1061 
1062  for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
1063  AttrBuilder B;
1064  decodeLLVMAttributesForBitcode(B, Record[i+1]);
1065  Attrs.push_back(AttributeSet::get(Context, Record[i], B));
1066  }
1067 
1068  MAttributes.push_back(AttributeSet::get(Context, Attrs));
1069  Attrs.clear();
1070  break;
1071  }
1072  case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...]
1073  for (unsigned i = 0, e = Record.size(); i != e; ++i)
1074  Attrs.push_back(MAttributeGroups[Record[i]]);
1075 
1076  MAttributes.push_back(AttributeSet::get(Context, Attrs));
1077  Attrs.clear();
1078  break;
1079  }
1080  }
1081  }
1082 }
1083 
1084 // Returns Attribute::None on unrecognized codes.
1086  switch (Code) {
1087  default:
1088  return Attribute::None;
1090  return Attribute::Alignment;
1092  return Attribute::AlwaysInline;
1094  return Attribute::ArgMemOnly;
1096  return Attribute::Builtin;
1098  return Attribute::ByVal;
1100  return Attribute::InAlloca;
1101  case bitc::ATTR_KIND_COLD:
1102  return Attribute::Cold;
1104  return Attribute::Convergent;
1106  return Attribute::InlineHint;
1108  return Attribute::InReg;
1110  return Attribute::JumpTable;
1112  return Attribute::MinSize;
1113  case bitc::ATTR_KIND_NAKED:
1114  return Attribute::Naked;
1115  case bitc::ATTR_KIND_NEST:
1116  return Attribute::Nest;
1118  return Attribute::NoAlias;
1120  return Attribute::NoBuiltin;
1122  return Attribute::NoCapture;
1124  return Attribute::NoDuplicate;
1126  return Attribute::NoImplicitFloat;
1128  return Attribute::NoInline;
1130  return Attribute::NonLazyBind;
1132  return Attribute::NonNull;
1134  return Attribute::Dereferenceable;
1136  return Attribute::DereferenceableOrNull;
1138  return Attribute::NoRedZone;
1140  return Attribute::NoReturn;
1142  return Attribute::NoUnwind;
1144  return Attribute::OptimizeForSize;
1146  return Attribute::OptimizeNone;
1148  return Attribute::ReadNone;
1150  return Attribute::ReadOnly;
1152  return Attribute::Returned;
1154  return Attribute::ReturnsTwice;
1155  case bitc::ATTR_KIND_S_EXT:
1156  return Attribute::SExt;
1158  return Attribute::StackAlignment;
1160  return Attribute::StackProtect;
1162  return Attribute::StackProtectReq;
1164  return Attribute::StackProtectStrong;
1166  return Attribute::SafeStack;
1168  return Attribute::StructRet;
1170  return Attribute::SanitizeAddress;
1172  return Attribute::SanitizeThread;
1174  return Attribute::SanitizeMemory;
1176  return Attribute::UWTable;
1177  case bitc::ATTR_KIND_Z_EXT:
1178  return Attribute::ZExt;
1179  }
1180 }
1181 
1182 std::error_code BitcodeReader::parseAlignmentValue(uint64_t Exponent,
1183  unsigned &Alignment) {
1184  // Note: Alignment in bitcode files is incremented by 1, so that zero
1185  // can be used for default alignment.
1186  if (Exponent > Value::MaxAlignmentExponent + 1)
1187  return error("Invalid alignment value");
1188  Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1;
1189  return std::error_code();
1190 }
1191 
1192 std::error_code BitcodeReader::parseAttrKind(uint64_t Code,
1194  *Kind = getAttrFromCode(Code);
1195  if (*Kind == Attribute::None)
1196  return error(BitcodeError::CorruptedBitcode,
1197  "Unknown attribute kind (" + Twine(Code) + ")");
1198  return std::error_code();
1199 }
1200 
1201 std::error_code BitcodeReader::parseAttributeGroupBlock() {
1202  if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))
1203  return error("Invalid record");
1204 
1205  if (!MAttributeGroups.empty())
1206  return error("Invalid multiple blocks");
1207 
1209 
1210  // Read all the records.
1211  while (1) {
1212  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1213 
1214  switch (Entry.Kind) {
1215  case BitstreamEntry::SubBlock: // Handled for us already.
1216  case BitstreamEntry::Error:
1217  return error("Malformed block");
1218  case BitstreamEntry::EndBlock:
1219  return std::error_code();
1220  case BitstreamEntry::Record:
1221  // The interesting case.
1222  break;
1223  }
1224 
1225  // Read a record.
1226  Record.clear();
1227  switch (Stream.readRecord(Entry.ID, Record)) {
1228  default: // Default behavior: ignore.
1229  break;
1230  case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
1231  if (Record.size() < 3)
1232  return error("Invalid record");
1233 
1234  uint64_t GrpID = Record[0];
1235  uint64_t Idx = Record[1]; // Index of the object this attribute refers to.
1236 
1237  AttrBuilder B;
1238  for (unsigned i = 2, e = Record.size(); i != e; ++i) {
1239  if (Record[i] == 0) { // Enum attribute
1241  if (std::error_code EC = parseAttrKind(Record[++i], &Kind))
1242  return EC;
1243 
1244  B.addAttribute(Kind);
1245  } else if (Record[i] == 1) { // Integer attribute
1247  if (std::error_code EC = parseAttrKind(Record[++i], &Kind))
1248  return EC;
1249  if (Kind == Attribute::Alignment)
1250  B.addAlignmentAttr(Record[++i]);
1251  else if (Kind == Attribute::StackAlignment)
1252  B.addStackAlignmentAttr(Record[++i]);
1253  else if (Kind == Attribute::Dereferenceable)
1254  B.addDereferenceableAttr(Record[++i]);
1255  else if (Kind == Attribute::DereferenceableOrNull)
1256  B.addDereferenceableOrNullAttr(Record[++i]);
1257  } else { // String attribute
1258  assert((Record[i] == 3 || Record[i] == 4) &&
1259  "Invalid attribute group entry");
1260  bool HasValue = (Record[i++] == 4);
1261  SmallString<64> KindStr;
1262  SmallString<64> ValStr;
1263 
1264  while (Record[i] != 0 && i != e)
1265  KindStr += Record[i++];
1266  assert(Record[i] == 0 && "Kind string not null terminated");
1267 
1268  if (HasValue) {
1269  // Has a value associated with it.
1270  ++i; // Skip the '0' that terminates the "kind" string.
1271  while (Record[i] != 0 && i != e)
1272  ValStr += Record[i++];
1273  assert(Record[i] == 0 && "Value string not null terminated");
1274  }
1275 
1276  B.addAttribute(KindStr.str(), ValStr.str());
1277  }
1278  }
1279 
1280  MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B);
1281  break;
1282  }
1283  }
1284  }
1285 }
1286 
1287 std::error_code BitcodeReader::parseTypeTable() {
1288  if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
1289  return error("Invalid record");
1290 
1291  return parseTypeTableBody();
1292 }
1293 
1294 std::error_code BitcodeReader::parseTypeTableBody() {
1295  if (!TypeList.empty())
1296  return error("Invalid multiple blocks");
1297 
1299  unsigned NumRecords = 0;
1300 
1301  SmallString<64> TypeName;
1302 
1303  // Read all the records for this type table.
1304  while (1) {
1305  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1306 
1307  switch (Entry.Kind) {
1308  case BitstreamEntry::SubBlock: // Handled for us already.
1309  case BitstreamEntry::Error:
1310  return error("Malformed block");
1311  case BitstreamEntry::EndBlock:
1312  if (NumRecords != TypeList.size())
1313  return error("Malformed block");
1314  return std::error_code();
1315  case BitstreamEntry::Record:
1316  // The interesting case.
1317  break;
1318  }
1319 
1320  // Read a record.
1321  Record.clear();
1322  Type *ResultTy = nullptr;
1323  switch (Stream.readRecord(Entry.ID, Record)) {
1324  default:
1325  return error("Invalid value");
1326  case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
1327  // TYPE_CODE_NUMENTRY contains a count of the number of types in the
1328  // type list. This allows us to reserve space.
1329  if (Record.size() < 1)
1330  return error("Invalid record");
1331  TypeList.resize(Record[0]);
1332  continue;
1333  case bitc::TYPE_CODE_VOID: // VOID
1334  ResultTy = Type::getVoidTy(Context);
1335  break;
1336  case bitc::TYPE_CODE_HALF: // HALF
1337  ResultTy = Type::getHalfTy(Context);
1338  break;
1339  case bitc::TYPE_CODE_FLOAT: // FLOAT
1340  ResultTy = Type::getFloatTy(Context);
1341  break;
1342  case bitc::TYPE_CODE_DOUBLE: // DOUBLE
1343  ResultTy = Type::getDoubleTy(Context);
1344  break;
1345  case bitc::TYPE_CODE_X86_FP80: // X86_FP80
1346  ResultTy = Type::getX86_FP80Ty(Context);
1347  break;
1348  case bitc::TYPE_CODE_FP128: // FP128
1349  ResultTy = Type::getFP128Ty(Context);
1350  break;
1351  case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
1352  ResultTy = Type::getPPC_FP128Ty(Context);
1353  break;
1354  case bitc::TYPE_CODE_LABEL: // LABEL
1355  ResultTy = Type::getLabelTy(Context);
1356  break;
1357  case bitc::TYPE_CODE_METADATA: // METADATA
1358  ResultTy = Type::getMetadataTy(Context);
1359  break;
1360  case bitc::TYPE_CODE_X86_MMX: // X86_MMX
1361  ResultTy = Type::getX86_MMXTy(Context);
1362  break;
1363  case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
1364  if (Record.size() < 1)
1365  return error("Invalid record");
1366 
1367  uint64_t NumBits = Record[0];
1368  if (NumBits < IntegerType::MIN_INT_BITS ||
1369  NumBits > IntegerType::MAX_INT_BITS)
1370  return error("Bitwidth for integer type out of range");
1371  ResultTy = IntegerType::get(Context, NumBits);
1372  break;
1373  }
1374  case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
1375  // [pointee type, address space]
1376  if (Record.size() < 1)
1377  return error("Invalid record");
1378  unsigned AddressSpace = 0;
1379  if (Record.size() == 2)
1380  AddressSpace = Record[1];
1381  ResultTy = getTypeByID(Record[0]);
1382  if (!ResultTy ||
1383  !PointerType::isValidElementType(ResultTy))
1384  return error("Invalid type");
1385  ResultTy = PointerType::get(ResultTy, AddressSpace);
1386  break;
1387  }
1389  // FIXME: attrid is dead, remove it in LLVM 4.0
1390  // FUNCTION: [vararg, attrid, retty, paramty x N]
1391  if (Record.size() < 3)
1392  return error("Invalid record");
1393  SmallVector<Type*, 8> ArgTys;
1394  for (unsigned i = 3, e = Record.size(); i != e; ++i) {
1395  if (Type *T = getTypeByID(Record[i]))
1396  ArgTys.push_back(T);
1397  else
1398  break;
1399  }
1400 
1401  ResultTy = getTypeByID(Record[2]);
1402  if (!ResultTy || ArgTys.size() < Record.size()-3)
1403  return error("Invalid type");
1404 
1405  ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
1406  break;
1407  }
1408  case bitc::TYPE_CODE_FUNCTION: {
1409  // FUNCTION: [vararg, retty, paramty x N]
1410  if (Record.size() < 2)
1411  return error("Invalid record");
1412  SmallVector<Type*, 8> ArgTys;
1413  for (unsigned i = 2, e = Record.size(); i != e; ++i) {
1414  if (Type *T = getTypeByID(Record[i])) {
1415  if (!FunctionType::isValidArgumentType(T))
1416  return error("Invalid function argument type");
1417  ArgTys.push_back(T);
1418  }
1419  else
1420  break;
1421  }
1422 
1423  ResultTy = getTypeByID(Record[1]);
1424  if (!ResultTy || ArgTys.size() < Record.size()-2)
1425  return error("Invalid type");
1426 
1427  ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
1428  break;
1429  }
1430  case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N]
1431  if (Record.size() < 1)
1432  return error("Invalid record");
1433  SmallVector<Type*, 8> EltTys;
1434  for (unsigned i = 1, e = Record.size(); i != e; ++i) {
1435  if (Type *T = getTypeByID(Record[i]))
1436  EltTys.push_back(T);
1437  else
1438  break;
1439  }
1440  if (EltTys.size() != Record.size()-1)
1441  return error("Invalid type");
1442  ResultTy = StructType::get(Context, EltTys, Record[0]);
1443  break;
1444  }
1445  case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N]
1446  if (convertToString(Record, 0, TypeName))
1447  return error("Invalid record");
1448  continue;
1449 
1450  case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
1451  if (Record.size() < 1)
1452  return error("Invalid record");
1453 
1454  if (NumRecords >= TypeList.size())
1455  return error("Invalid TYPE table");
1456 
1457  // Check to see if this was forward referenced, if so fill in the temp.
1458  StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
1459  if (Res) {
1460  Res->setName(TypeName);
1461  TypeList[NumRecords] = nullptr;
1462  } else // Otherwise, create a new struct.
1463  Res = createIdentifiedStructType(Context, TypeName);
1464  TypeName.clear();
1465 
1466  SmallVector<Type*, 8> EltTys;
1467  for (unsigned i = 1, e = Record.size(); i != e; ++i) {
1468  if (Type *T = getTypeByID(Record[i]))
1469  EltTys.push_back(T);
1470  else
1471  break;
1472  }
1473  if (EltTys.size() != Record.size()-1)
1474  return error("Invalid record");
1475  Res->setBody(EltTys, Record[0]);
1476  ResultTy = Res;
1477  break;
1478  }
1479  case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
1480  if (Record.size() != 1)
1481  return error("Invalid record");
1482 
1483  if (NumRecords >= TypeList.size())
1484  return error("Invalid TYPE table");
1485 
1486  // Check to see if this was forward referenced, if so fill in the temp.
1487  StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
1488  if (Res) {
1489  Res->setName(TypeName);
1490  TypeList[NumRecords] = nullptr;
1491  } else // Otherwise, create a new struct with no body.
1492  Res = createIdentifiedStructType(Context, TypeName);
1493  TypeName.clear();
1494  ResultTy = Res;
1495  break;
1496  }
1497  case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
1498  if (Record.size() < 2)
1499  return error("Invalid record");
1500  ResultTy = getTypeByID(Record[1]);
1501  if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
1502  return error("Invalid type");
1503  ResultTy = ArrayType::get(ResultTy, Record[0]);
1504  break;
1505  case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
1506  if (Record.size() < 2)
1507  return error("Invalid record");
1508  if (Record[0] == 0)
1509  return error("Invalid vector length");
1510  ResultTy = getTypeByID(Record[1]);
1511  if (!ResultTy || !StructType::isValidElementType(ResultTy))
1512  return error("Invalid type");
1513  ResultTy = VectorType::get(ResultTy, Record[0]);
1514  break;
1515  }
1516 
1517  if (NumRecords >= TypeList.size())
1518  return error("Invalid TYPE table");
1519  if (TypeList[NumRecords])
1520  return error(
1521  "Invalid TYPE table: Only named structs can be forward referenced");
1522  assert(ResultTy && "Didn't read a type?");
1523  TypeList[NumRecords++] = ResultTy;
1524  }
1525 }
1526 
1527 std::error_code BitcodeReader::parseValueSymbolTable() {
1528  if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
1529  return error("Invalid record");
1530 
1532 
1533  Triple TT(TheModule->getTargetTriple());
1534 
1535  // Read all the records for this value table.
1537  while (1) {
1538  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1539 
1540  switch (Entry.Kind) {
1541  case BitstreamEntry::SubBlock: // Handled for us already.
1542  case BitstreamEntry::Error:
1543  return error("Malformed block");
1544  case BitstreamEntry::EndBlock:
1545  return std::error_code();
1546  case BitstreamEntry::Record:
1547  // The interesting case.
1548  break;
1549  }
1550 
1551  // Read a record.
1552  Record.clear();
1553  switch (Stream.readRecord(Entry.ID, Record)) {
1554  default: // Default behavior: unknown type.
1555  break;
1556  case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
1557  if (convertToString(Record, 1, ValueName))
1558  return error("Invalid record");
1559  unsigned ValueID = Record[0];
1560  if (ValueID >= ValueList.size() || !ValueList[ValueID])
1561  return error("Invalid record");
1562  Value *V = ValueList[ValueID];
1563 
1564  V->setName(StringRef(ValueName.data(), ValueName.size()));
1565  if (auto *GO = dyn_cast<GlobalObject>(V)) {
1566  if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
1567  if (TT.isOSBinFormatMachO())
1568  GO->setComdat(nullptr);
1569  else
1570  GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
1571  }
1572  }
1573  ValueName.clear();
1574  break;
1575  }
1576  case bitc::VST_CODE_BBENTRY: {
1577  if (convertToString(Record, 1, ValueName))
1578  return error("Invalid record");
1579  BasicBlock *BB = getBasicBlock(Record[0]);
1580  if (!BB)
1581  return error("Invalid record");
1582 
1583  BB->setName(StringRef(ValueName.data(), ValueName.size()));
1584  ValueName.clear();
1585  break;
1586  }
1587  }
1588  }
1589 }
1590 
1591 static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
1592 
1593 std::error_code BitcodeReader::parseMetadata() {
1594  IsMetadataMaterialized = true;
1595  unsigned NextMDValueNo = MDValueList.size();
1596 
1597  if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
1598  return error("Invalid record");
1599 
1601 
1602  auto getMD =
1603  [&](unsigned ID) -> Metadata *{ return MDValueList.getValueFwdRef(ID); };
1604  auto getMDOrNull = [&](unsigned ID) -> Metadata *{
1605  if (ID)
1606  return getMD(ID - 1);
1607  return nullptr;
1608  };
1609  auto getMDString = [&](unsigned ID) -> MDString *{
1610  // This requires that the ID is not really a forward reference. In
1611  // particular, the MDString must already have been resolved.
1612  return cast_or_null<MDString>(getMDOrNull(ID));
1613  };
1614 
1615 #define GET_OR_DISTINCT(CLASS, DISTINCT, ARGS) \
1616  (DISTINCT ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1617 
1618  // Read all the records.
1619  while (1) {
1620  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1621 
1622  switch (Entry.Kind) {
1623  case BitstreamEntry::SubBlock: // Handled for us already.
1624  case BitstreamEntry::Error:
1625  return error("Malformed block");
1626  case BitstreamEntry::EndBlock:
1627  MDValueList.tryToResolveCycles();
1628  return std::error_code();
1629  case BitstreamEntry::Record:
1630  // The interesting case.
1631  break;
1632  }
1633 
1634  // Read a record.
1635  Record.clear();
1636  unsigned Code = Stream.readRecord(Entry.ID, Record);
1637  bool IsDistinct = false;
1638  switch (Code) {
1639  default: // Default behavior: ignore.
1640  break;
1641  case bitc::METADATA_NAME: {
1642  // Read name of the named metadata.
1643  SmallString<8> Name(Record.begin(), Record.end());
1644  Record.clear();
1645  Code = Stream.ReadCode();
1646 
1647  unsigned NextBitCode = Stream.readRecord(Code, Record);
1648  if (NextBitCode != bitc::METADATA_NAMED_NODE)
1649  return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
1650 
1651  // Read named metadata elements.
1652  unsigned Size = Record.size();
1653  NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name);
1654  for (unsigned i = 0; i != Size; ++i) {
1655  MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i]));
1656  if (!MD)
1657  return error("Invalid record");
1658  NMD->addOperand(MD);
1659  }
1660  break;
1661  }
1663  // FIXME: Remove in 4.0.
1664  // This is a LocalAsMetadata record, the only type of function-local
1665  // metadata.
1666  if (Record.size() % 2 == 1)
1667  return error("Invalid record");
1668 
1669  // If this isn't a LocalAsMetadata record, we're dropping it. This used
1670  // to be legal, but there's no upgrade path.
1671  auto dropRecord = [&] {
1672  MDValueList.assignValue(MDNode::get(Context, None), NextMDValueNo++);
1673  };
1674  if (Record.size() != 2) {
1675  dropRecord();
1676  break;
1677  }
1678 
1679  Type *Ty = getTypeByID(Record[0]);
1680  if (Ty->isMetadataTy() || Ty->isVoidTy()) {
1681  dropRecord();
1682  break;
1683  }
1684 
1685  MDValueList.assignValue(
1686  LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1687  NextMDValueNo++);
1688  break;
1689  }
1690  case bitc::METADATA_OLD_NODE: {
1691  // FIXME: Remove in 4.0.
1692  if (Record.size() % 2 == 1)
1693  return error("Invalid record");
1694 
1695  unsigned Size = Record.size();
1697  for (unsigned i = 0; i != Size; i += 2) {
1698  Type *Ty = getTypeByID(Record[i]);
1699  if (!Ty)
1700  return error("Invalid record");
1701  if (Ty->isMetadataTy())
1702  Elts.push_back(MDValueList.getValueFwdRef(Record[i+1]));
1703  else if (!Ty->isVoidTy()) {
1704  auto *MD =
1705  ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
1706  assert(isa<ConstantAsMetadata>(MD) &&
1707  "Expected non-function-local metadata");
1708  Elts.push_back(MD);
1709  } else
1710  Elts.push_back(nullptr);
1711  }
1712  MDValueList.assignValue(MDNode::get(Context, Elts), NextMDValueNo++);
1713  break;
1714  }
1715  case bitc::METADATA_VALUE: {
1716  if (Record.size() != 2)
1717  return error("Invalid record");
1718 
1719  Type *Ty = getTypeByID(Record[0]);
1720  if (Ty->isMetadataTy() || Ty->isVoidTy())
1721  return error("Invalid record");
1722 
1723  MDValueList.assignValue(
1724  ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1725  NextMDValueNo++);
1726  break;
1727  }
1729  IsDistinct = true;
1730  // fallthrough...
1731  case bitc::METADATA_NODE: {
1733  Elts.reserve(Record.size());
1734  for (unsigned ID : Record)
1735  Elts.push_back(ID ? MDValueList.getValueFwdRef(ID - 1) : nullptr);
1736  MDValueList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1737  : MDNode::get(Context, Elts),
1738  NextMDValueNo++);
1739  break;
1740  }
1741  case bitc::METADATA_LOCATION: {
1742  if (Record.size() != 5)
1743  return error("Invalid record");
1744 
1745  unsigned Line = Record[1];
1746  unsigned Column = Record[2];
1747  MDNode *Scope = cast<MDNode>(MDValueList.getValueFwdRef(Record[3]));
1748  Metadata *InlinedAt =
1749  Record[4] ? MDValueList.getValueFwdRef(Record[4] - 1) : nullptr;
1750  MDValueList.assignValue(
1751  GET_OR_DISTINCT(DILocation, Record[0],
1752  (Context, Line, Column, Scope, InlinedAt)),
1753  NextMDValueNo++);
1754  break;
1755  }
1757  if (Record.size() < 4)
1758  return error("Invalid record");
1759 
1760  unsigned Tag = Record[1];
1761  unsigned Version = Record[2];
1762 
1763  if (Tag >= 1u << 16 || Version != 0)
1764  return error("Invalid record");
1765 
1766  auto *Header = getMDString(Record[3]);
1767  SmallVector<Metadata *, 8> DwarfOps;
1768  for (unsigned I = 4, E = Record.size(); I != E; ++I)
1769  DwarfOps.push_back(Record[I] ? MDValueList.getValueFwdRef(Record[I] - 1)
1770  : nullptr);
1771  MDValueList.assignValue(GET_OR_DISTINCT(GenericDINode, Record[0],
1772  (Context, Tag, Header, DwarfOps)),
1773  NextMDValueNo++);
1774  break;
1775  }
1776  case bitc::METADATA_SUBRANGE: {
1777  if (Record.size() != 3)
1778  return error("Invalid record");
1779 
1780  MDValueList.assignValue(
1781  GET_OR_DISTINCT(DISubrange, Record[0],
1782  (Context, Record[1], unrotateSign(Record[2]))),
1783  NextMDValueNo++);
1784  break;
1785  }
1787  if (Record.size() != 3)
1788  return error("Invalid record");
1789 
1790  MDValueList.assignValue(GET_OR_DISTINCT(DIEnumerator, Record[0],
1791  (Context, unrotateSign(Record[1]),
1792  getMDString(Record[2]))),
1793  NextMDValueNo++);
1794  break;
1795  }
1797  if (Record.size() != 6)
1798  return error("Invalid record");
1799 
1800  MDValueList.assignValue(
1801  GET_OR_DISTINCT(DIBasicType, Record[0],
1802  (Context, Record[1], getMDString(Record[2]),
1803  Record[3], Record[4], Record[5])),
1804  NextMDValueNo++);
1805  break;
1806  }
1808  if (Record.size() != 12)
1809  return error("Invalid record");
1810 
1811  MDValueList.assignValue(
1812  GET_OR_DISTINCT(DIDerivedType, Record[0],
1813  (Context, Record[1], getMDString(Record[2]),
1814  getMDOrNull(Record[3]), Record[4],
1815  getMDOrNull(Record[5]), getMDOrNull(Record[6]),
1816  Record[7], Record[8], Record[9], Record[10],
1817  getMDOrNull(Record[11]))),
1818  NextMDValueNo++);
1819  break;
1820  }
1822  if (Record.size() != 16)
1823  return error("Invalid record");
1824 
1825  MDValueList.assignValue(
1826  GET_OR_DISTINCT(DICompositeType, Record[0],
1827  (Context, Record[1], getMDString(Record[2]),
1828  getMDOrNull(Record[3]), Record[4],
1829  getMDOrNull(Record[5]), getMDOrNull(Record[6]),
1830  Record[7], Record[8], Record[9], Record[10],
1831  getMDOrNull(Record[11]), Record[12],
1832  getMDOrNull(Record[13]), getMDOrNull(Record[14]),
1833  getMDString(Record[15]))),
1834  NextMDValueNo++);
1835  break;
1836  }
1838  if (Record.size() != 3)
1839  return error("Invalid record");
1840 
1841  MDValueList.assignValue(
1842  GET_OR_DISTINCT(DISubroutineType, Record[0],
1843  (Context, Record[1], getMDOrNull(Record[2]))),
1844  NextMDValueNo++);
1845  break;
1846  }
1847 
1848  case bitc::METADATA_MODULE: {
1849  if (Record.size() != 6)
1850  return error("Invalid record");
1851 
1852  MDValueList.assignValue(
1853  GET_OR_DISTINCT(DIModule, Record[0],
1854  (Context, getMDOrNull(Record[1]),
1855  getMDString(Record[2]), getMDString(Record[3]),
1856  getMDString(Record[4]), getMDString(Record[5]))),
1857  NextMDValueNo++);
1858  break;
1859  }
1860 
1861  case bitc::METADATA_FILE: {
1862  if (Record.size() != 3)
1863  return error("Invalid record");
1864 
1865  MDValueList.assignValue(
1866  GET_OR_DISTINCT(DIFile, Record[0], (Context, getMDString(Record[1]),
1867  getMDString(Record[2]))),
1868  NextMDValueNo++);
1869  break;
1870  }
1872  if (Record.size() < 14 || Record.size() > 15)
1873  return error("Invalid record");
1874 
1875  MDValueList.assignValue(
1877  DICompileUnit, Record[0],
1878  (Context, Record[1], getMDOrNull(Record[2]),
1879  getMDString(Record[3]), Record[4], getMDString(Record[5]),
1880  Record[6], getMDString(Record[7]), Record[8],
1881  getMDOrNull(Record[9]), getMDOrNull(Record[10]),
1882  getMDOrNull(Record[11]), getMDOrNull(Record[12]),
1883  getMDOrNull(Record[13]), Record.size() == 14 ? 0 : Record[14])),
1884  NextMDValueNo++);
1885  break;
1886  }
1888  if (Record.size() != 19)
1889  return error("Invalid record");
1890 
1891  MDValueList.assignValue(
1893  DISubprogram, Record[0],
1894  (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1895  getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1896  getMDOrNull(Record[6]), Record[7], Record[8], Record[9],
1897  getMDOrNull(Record[10]), Record[11], Record[12], Record[13],
1898  Record[14], getMDOrNull(Record[15]), getMDOrNull(Record[16]),
1899  getMDOrNull(Record[17]), getMDOrNull(Record[18]))),
1900  NextMDValueNo++);
1901  break;
1902  }
1904  if (Record.size() != 5)
1905  return error("Invalid record");
1906 
1907  MDValueList.assignValue(
1908  GET_OR_DISTINCT(DILexicalBlock, Record[0],
1909  (Context, getMDOrNull(Record[1]),
1910  getMDOrNull(Record[2]), Record[3], Record[4])),
1911  NextMDValueNo++);
1912  break;
1913  }
1915  if (Record.size() != 4)
1916  return error("Invalid record");
1917 
1918  MDValueList.assignValue(
1920  (Context, getMDOrNull(Record[1]),
1921  getMDOrNull(Record[2]), Record[3])),
1922  NextMDValueNo++);
1923  break;
1924  }
1925  case bitc::METADATA_NAMESPACE: {
1926  if (Record.size() != 5)
1927  return error("Invalid record");
1928 
1929  MDValueList.assignValue(
1930  GET_OR_DISTINCT(DINamespace, Record[0],
1931  (Context, getMDOrNull(Record[1]),
1932  getMDOrNull(Record[2]), getMDString(Record[3]),
1933  Record[4])),
1934  NextMDValueNo++);
1935  break;
1936  }
1938  if (Record.size() != 3)
1939  return error("Invalid record");
1940 
1941  MDValueList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
1942  Record[0],
1943  (Context, getMDString(Record[1]),
1944  getMDOrNull(Record[2]))),
1945  NextMDValueNo++);
1946  break;
1947  }
1949  if (Record.size() != 5)
1950  return error("Invalid record");
1951 
1952  MDValueList.assignValue(
1954  (Context, Record[1], getMDString(Record[2]),
1955  getMDOrNull(Record[3]), getMDOrNull(Record[4]))),
1956  NextMDValueNo++);
1957  break;
1958  }
1960  if (Record.size() != 11)
1961  return error("Invalid record");
1962 
1963  MDValueList.assignValue(
1964  GET_OR_DISTINCT(DIGlobalVariable, Record[0],
1965  (Context, getMDOrNull(Record[1]),
1966  getMDString(Record[2]), getMDString(Record[3]),
1967  getMDOrNull(Record[4]), Record[5],
1968  getMDOrNull(Record[6]), Record[7], Record[8],
1969  getMDOrNull(Record[9]), getMDOrNull(Record[10]))),
1970  NextMDValueNo++);
1971  break;
1972  }
1973  case bitc::METADATA_LOCAL_VAR: {
1974  // 10th field is for the obseleted 'inlinedAt:' field.
1975  if (Record.size() != 9 && Record.size() != 10)
1976  return error("Invalid record");
1977 
1978  MDValueList.assignValue(
1979  GET_OR_DISTINCT(DILocalVariable, Record[0],
1980  (Context, Record[1], getMDOrNull(Record[2]),
1981  getMDString(Record[3]), getMDOrNull(Record[4]),
1982  Record[5], getMDOrNull(Record[6]), Record[7],
1983  Record[8])),
1984  NextMDValueNo++);
1985  break;
1986  }
1988  if (Record.size() < 1)
1989  return error("Invalid record");
1990 
1991  MDValueList.assignValue(
1992  GET_OR_DISTINCT(DIExpression, Record[0],
1993  (Context, makeArrayRef(Record).slice(1))),
1994  NextMDValueNo++);
1995  break;
1996  }
1998  if (Record.size() != 8)
1999  return error("Invalid record");
2000 
2001  MDValueList.assignValue(
2002  GET_OR_DISTINCT(DIObjCProperty, Record[0],
2003  (Context, getMDString(Record[1]),
2004  getMDOrNull(Record[2]), Record[3],
2005  getMDString(Record[4]), getMDString(Record[5]),
2006  Record[6], getMDOrNull(Record[7]))),
2007  NextMDValueNo++);
2008  break;
2009  }
2011  if (Record.size() != 6)
2012  return error("Invalid record");
2013 
2014  MDValueList.assignValue(
2015  GET_OR_DISTINCT(DIImportedEntity, Record[0],
2016  (Context, Record[1], getMDOrNull(Record[2]),
2017  getMDOrNull(Record[3]), Record[4],
2018  getMDString(Record[5]))),
2019  NextMDValueNo++);
2020  break;
2021  }
2022  case bitc::METADATA_STRING: {
2023  std::string String(Record.begin(), Record.end());
2025  Metadata *MD = MDString::get(Context, String);
2026  MDValueList.assignValue(MD, NextMDValueNo++);
2027  break;
2028  }
2029  case bitc::METADATA_KIND: {
2030  if (Record.size() < 2)
2031  return error("Invalid record");
2032 
2033  unsigned Kind = Record[0];
2034  SmallString<8> Name(Record.begin()+1, Record.end());
2035 
2036  unsigned NewKind = TheModule->getMDKindID(Name.str());
2037  if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
2038  return error("Conflicting METADATA_KIND records");
2039  break;
2040  }
2041  }
2042  }
2043 #undef GET_OR_DISTINCT
2044 }
2045 
2046 /// Decode a signed value stored with the sign bit in the LSB for dense VBR
2047 /// encoding.
2048 uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {
2049  if ((V & 1) == 0)
2050  return V >> 1;
2051  if (V != 1)
2052  return -(V >> 1);
2053  // There is no such thing as -0 with integers. "-0" really means MININT.
2054  return 1ULL << 63;
2055 }
2056 
2057 /// Resolve all of the initializers for global values and aliases that we can.
2058 std::error_code BitcodeReader::resolveGlobalAndAliasInits() {
2059  std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
2060  std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
2061  std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist;
2062  std::vector<std::pair<Function*, unsigned> > FunctionPrologueWorklist;
2063  std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFnWorklist;
2064 
2065  GlobalInitWorklist.swap(GlobalInits);
2066  AliasInitWorklist.swap(AliasInits);
2067  FunctionPrefixWorklist.swap(FunctionPrefixes);
2068  FunctionPrologueWorklist.swap(FunctionPrologues);
2069  FunctionPersonalityFnWorklist.swap(FunctionPersonalityFns);
2070 
2071  while (!GlobalInitWorklist.empty()) {
2072  unsigned ValID = GlobalInitWorklist.back().second;
2073  if (ValID >= ValueList.size()) {
2074  // Not ready to resolve this yet, it requires something later in the file.
2075  GlobalInits.push_back(GlobalInitWorklist.back());
2076  } else {
2077  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2078  GlobalInitWorklist.back().first->setInitializer(C);
2079  else
2080  return error("Expected a constant");
2081  }
2082  GlobalInitWorklist.pop_back();
2083  }
2084 
2085  while (!AliasInitWorklist.empty()) {
2086  unsigned ValID = AliasInitWorklist.back().second;
2087  if (ValID >= ValueList.size()) {
2088  AliasInits.push_back(AliasInitWorklist.back());
2089  } else {
2090  Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]);
2091  if (!C)
2092  return error("Expected a constant");
2093  GlobalAlias *Alias = AliasInitWorklist.back().first;
2094  if (C->getType() != Alias->getType())
2095  return error("Alias and aliasee types don't match");
2096  Alias->setAliasee(C);
2097  }
2098  AliasInitWorklist.pop_back();
2099  }
2100 
2101  while (!FunctionPrefixWorklist.empty()) {
2102  unsigned ValID = FunctionPrefixWorklist.back().second;
2103  if (ValID >= ValueList.size()) {
2104  FunctionPrefixes.push_back(FunctionPrefixWorklist.back());
2105  } else {
2106  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2107  FunctionPrefixWorklist.back().first->setPrefixData(C);
2108  else
2109  return error("Expected a constant");
2110  }
2111  FunctionPrefixWorklist.pop_back();
2112  }
2113 
2114  while (!FunctionPrologueWorklist.empty()) {
2115  unsigned ValID = FunctionPrologueWorklist.back().second;
2116  if (ValID >= ValueList.size()) {
2117  FunctionPrologues.push_back(FunctionPrologueWorklist.back());
2118  } else {
2119  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2120  FunctionPrologueWorklist.back().first->setPrologueData(C);
2121  else
2122  return error("Expected a constant");
2123  }
2124  FunctionPrologueWorklist.pop_back();
2125  }
2126 
2127  while (!FunctionPersonalityFnWorklist.empty()) {
2128  unsigned ValID = FunctionPersonalityFnWorklist.back().second;
2129  if (ValID >= ValueList.size()) {
2130  FunctionPersonalityFns.push_back(FunctionPersonalityFnWorklist.back());
2131  } else {
2132  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2133  FunctionPersonalityFnWorklist.back().first->setPersonalityFn(C);
2134  else
2135  return error("Expected a constant");
2136  }
2137  FunctionPersonalityFnWorklist.pop_back();
2138  }
2139 
2140  return std::error_code();
2141 }
2142 
2143 static APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
2144  SmallVector<uint64_t, 8> Words(Vals.size());
2145  std::transform(Vals.begin(), Vals.end(), Words.begin(),
2146  BitcodeReader::decodeSignRotatedValue);
2147 
2148  return APInt(TypeBits, Words);
2149 }
2150 
2151 std::error_code BitcodeReader::parseConstants() {
2152  if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
2153  return error("Invalid record");
2154 
2156 
2157  // Read all the records for this value table.
2158  Type *CurTy = Type::getInt32Ty(Context);
2159  unsigned NextCstNo = ValueList.size();
2160  while (1) {
2161  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
2162 
2163  switch (Entry.Kind) {
2164  case BitstreamEntry::SubBlock: // Handled for us already.
2165  case BitstreamEntry::Error:
2166  return error("Malformed block");
2167  case BitstreamEntry::EndBlock:
2168  if (NextCstNo != ValueList.size())
2169  return error("Invalid ronstant reference");
2170 
2171  // Once all the constants have been read, go through and resolve forward
2172  // references.
2173  ValueList.resolveConstantForwardRefs();
2174  return std::error_code();
2175  case BitstreamEntry::Record:
2176  // The interesting case.
2177  break;
2178  }
2179 
2180  // Read a record.
2181  Record.clear();
2182  Value *V = nullptr;
2183  unsigned BitCode = Stream.readRecord(Entry.ID, Record);
2184  switch (BitCode) {
2185  default: // Default behavior: unknown constant
2186  case bitc::CST_CODE_UNDEF: // UNDEF
2187  V = UndefValue::get(CurTy);
2188  break;
2189  case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
2190  if (Record.empty())
2191  return error("Invalid record");
2192  if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
2193  return error("Invalid record");
2194  CurTy = TypeList[Record[0]];
2195  continue; // Skip the ValueList manipulation.
2196  case bitc::CST_CODE_NULL: // NULL
2197  V = Constant::getNullValue(CurTy);
2198  break;
2199  case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
2200  if (!CurTy->isIntegerTy() || Record.empty())
2201  return error("Invalid record");
2202  V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
2203  break;
2204  case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
2205  if (!CurTy->isIntegerTy() || Record.empty())
2206  return error("Invalid record");
2207 
2208  APInt VInt =
2209  readWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth());
2210  V = ConstantInt::get(Context, VInt);
2211 
2212  break;
2213  }
2214  case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
2215  if (Record.empty())
2216  return error("Invalid record");
2217  if (CurTy->isHalfTy())
2218  V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf,
2219  APInt(16, (uint16_t)Record[0])));
2220  else if (CurTy->isFloatTy())
2221  V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle,
2222  APInt(32, (uint32_t)Record[0])));
2223  else if (CurTy->isDoubleTy())
2224  V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble,
2225  APInt(64, Record[0])));
2226  else if (CurTy->isX86_FP80Ty()) {
2227  // Bits are not stored the same way as a normal i80 APInt, compensate.
2228  uint64_t Rearrange[2];
2229  Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
2230  Rearrange[1] = Record[0] >> 48;
2231  V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended,
2232  APInt(80, Rearrange)));
2233  } else if (CurTy->isFP128Ty())
2234  V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad,
2235  APInt(128, Record)));
2236  else if (CurTy->isPPC_FP128Ty())
2237  V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble,
2238  APInt(128, Record)));
2239  else
2240  V = UndefValue::get(CurTy);
2241  break;
2242  }
2243 
2244  case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
2245  if (Record.empty())
2246  return error("Invalid record");
2247 
2248  unsigned Size = Record.size();
2250 
2251  if (StructType *STy = dyn_cast<StructType>(CurTy)) {
2252  for (unsigned i = 0; i != Size; ++i)
2253  Elts.push_back(ValueList.getConstantFwdRef(Record[i],
2254  STy->getElementType(i)));
2255  V = ConstantStruct::get(STy, Elts);
2256  } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
2257  Type *EltTy = ATy->getElementType();
2258  for (unsigned i = 0; i != Size; ++i)
2259  Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
2260  V = ConstantArray::get(ATy, Elts);
2261  } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
2262  Type *EltTy = VTy->getElementType();
2263  for (unsigned i = 0; i != Size; ++i)
2264  Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
2265  V = ConstantVector::get(Elts);
2266  } else {
2267  V = UndefValue::get(CurTy);
2268  }
2269  break;
2270  }
2271  case bitc::CST_CODE_STRING: // STRING: [values]
2272  case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
2273  if (Record.empty())
2274  return error("Invalid record");
2275 
2276  SmallString<16> Elts(Record.begin(), Record.end());
2277  V = ConstantDataArray::getString(Context, Elts,
2278  BitCode == bitc::CST_CODE_CSTRING);
2279  break;
2280  }
2281  case bitc::CST_CODE_DATA: {// DATA: [n x value]
2282  if (Record.empty())
2283  return error("Invalid record");
2284 
2285  Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
2286  unsigned Size = Record.size();
2287 
2288  if (EltTy->isIntegerTy(8)) {
2289  SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
2290  if (isa<VectorType>(CurTy))
2291  V = ConstantDataVector::get(Context, Elts);
2292  else
2293  V = ConstantDataArray::get(Context, Elts);
2294  } else if (EltTy->isIntegerTy(16)) {
2295  SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
2296  if (isa<VectorType>(CurTy))
2297  V = ConstantDataVector::get(Context, Elts);
2298  else
2299  V = ConstantDataArray::get(Context, Elts);
2300  } else if (EltTy->isIntegerTy(32)) {
2301  SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
2302  if (isa<VectorType>(CurTy))
2303  V = ConstantDataVector::get(Context, Elts);
2304  else
2305  V = ConstantDataArray::get(Context, Elts);
2306  } else if (EltTy->isIntegerTy(64)) {
2307  SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
2308  if (isa<VectorType>(CurTy))
2309  V = ConstantDataVector::get(Context, Elts);
2310  else
2311  V = ConstantDataArray::get(Context, Elts);
2312  } else if (EltTy->isFloatTy()) {
2313  SmallVector<float, 16> Elts(Size);
2314  std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat);
2315  if (isa<VectorType>(CurTy))
2316  V = ConstantDataVector::get(Context, Elts);
2317  else
2318  V = ConstantDataArray::get(Context, Elts);
2319  } else if (EltTy->isDoubleTy()) {
2320  SmallVector<double, 16> Elts(Size);
2321  std::transform(Record.begin(), Record.end(), Elts.begin(),
2322  BitsToDouble);
2323  if (isa<VectorType>(CurTy))
2324  V = ConstantDataVector::get(Context, Elts);
2325  else
2326  V = ConstantDataArray::get(Context, Elts);
2327  } else {
2328  return error("Invalid type for value");
2329  }
2330  break;
2331  }
2332 
2333  case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
2334  if (Record.size() < 3)
2335  return error("Invalid record");
2336  int Opc = getDecodedBinaryOpcode(Record[0], CurTy);
2337  if (Opc < 0) {
2338  V = UndefValue::get(CurTy); // Unknown binop.
2339  } else {
2340  Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
2341  Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
2342  unsigned Flags = 0;
2343  if (Record.size() >= 4) {
2344  if (Opc == Instruction::Add ||
2345  Opc == Instruction::Sub ||
2346  Opc == Instruction::Mul ||
2347  Opc == Instruction::Shl) {
2348  if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP))
2349  Flags |= OverflowingBinaryOperator::NoSignedWrap;
2350  if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
2351  Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
2352  } else if (Opc == Instruction::SDiv ||
2353  Opc == Instruction::UDiv ||
2354  Opc == Instruction::LShr ||
2355  Opc == Instruction::AShr) {
2356  if (Record[3] & (1 << bitc::PEO_EXACT))
2357  Flags |= SDivOperator::IsExact;
2358  }
2359  }
2360  V = ConstantExpr::get(Opc, LHS, RHS, Flags);
2361  }
2362  break;
2363  }
2364  case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
2365  if (Record.size() < 3)
2366  return error("Invalid record");
2367  int Opc = getDecodedCastOpcode(Record[0]);
2368  if (Opc < 0) {
2369  V = UndefValue::get(CurTy); // Unknown cast.
2370  } else {
2371  Type *OpTy = getTypeByID(Record[1]);
2372  if (!OpTy)
2373  return error("Invalid record");
2374  Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
2375  V = UpgradeBitCastExpr(Opc, Op, CurTy);
2376  if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy);
2377  }
2378  break;
2379  }
2381  case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands]
2382  unsigned OpNum = 0;
2383  Type *PointeeType = nullptr;
2384  if (Record.size() % 2)
2385  PointeeType = getTypeByID(Record[OpNum++]);
2387  while (OpNum != Record.size()) {
2388  Type *ElTy = getTypeByID(Record[OpNum++]);
2389  if (!ElTy)
2390  return error("Invalid record");
2391  Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy));
2392  }
2393 
2394  if (PointeeType &&
2395  PointeeType !=
2396  cast<SequentialType>(Elts[0]->getType()->getScalarType())
2397  ->getElementType())
2398  return error("Explicit gep operator type does not match pointee type "
2399  "of pointer operand");
2400 
2401  ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
2402  V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices,
2403  BitCode ==
2405  break;
2406  }
2407  case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#]
2408  if (Record.size() < 3)
2409  return error("Invalid record");
2410 
2411  Type *SelectorTy = Type::getInt1Ty(Context);
2412 
2413  // If CurTy is a vector of length n, then Record[0] must be a <n x i1>
2414  // vector. Otherwise, it must be a single bit.
2415  if (VectorType *VTy = dyn_cast<VectorType>(CurTy))
2416  SelectorTy = VectorType::get(Type::getInt1Ty(Context),
2417  VTy->getNumElements());
2418 
2419  V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
2420  SelectorTy),
2421  ValueList.getConstantFwdRef(Record[1],CurTy),
2422  ValueList.getConstantFwdRef(Record[2],CurTy));
2423  break;
2424  }
2426  : { // CE_EXTRACTELT: [opty, opval, opty, opval]
2427  if (Record.size() < 3)
2428  return error("Invalid record");
2429  VectorType *OpTy =
2430  dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
2431  if (!OpTy)
2432  return error("Invalid record");
2433  Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
2434  Constant *Op1 = nullptr;
2435  if (Record.size() == 4) {
2436  Type *IdxTy = getTypeByID(Record[2]);
2437  if (!IdxTy)
2438  return error("Invalid record");
2439  Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy);
2440  } else // TODO: Remove with llvm 4.0
2441  Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
2442  if (!Op1)
2443  return error("Invalid record");
2444  V = ConstantExpr::getExtractElement(Op0, Op1);
2445  break;
2446  }
2448  : { // CE_INSERTELT: [opval, opval, opty, opval]
2449  VectorType *OpTy = dyn_cast<VectorType>(CurTy);
2450  if (Record.size() < 3 || !OpTy)
2451  return error("Invalid record");
2452  Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
2453  Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
2454  OpTy->getElementType());
2455  Constant *Op2 = nullptr;
2456  if (Record.size() == 4) {
2457  Type *IdxTy = getTypeByID(Record[2]);
2458  if (!IdxTy)
2459  return error("Invalid record");
2460  Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy);
2461  } else // TODO: Remove with llvm 4.0
2462  Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
2463  if (!Op2)
2464  return error("Invalid record");
2465  V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
2466  break;
2467  }
2468  case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
2469  VectorType *OpTy = dyn_cast<VectorType>(CurTy);
2470  if (Record.size() < 3 || !OpTy)
2471  return error("Invalid record");
2472  Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
2473  Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
2474  Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2475  OpTy->getNumElements());
2476  Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
2477  V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
2478  break;
2479  }
2480  case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
2481  VectorType *RTy = dyn_cast<VectorType>(CurTy);
2482  VectorType *OpTy =
2483  dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
2484  if (Record.size() < 4 || !RTy || !OpTy)
2485  return error("Invalid record");
2486  Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
2487  Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
2488  Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2489  RTy->getNumElements());
2490  Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
2491  V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
2492  break;
2493  }
2494  case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
2495  if (Record.size() < 4)
2496  return error("Invalid record");
2497  Type *OpTy = getTypeByID(Record[0]);
2498  if (!OpTy)
2499  return error("Invalid record");
2500  Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
2501  Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
2502 
2503  if (OpTy->isFPOrFPVectorTy())
2504  V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
2505  else
2506  V = ConstantExpr::getICmp(Record[3], Op0, Op1);
2507  break;
2508  }
2509  // This maintains backward compatibility, pre-asm dialect keywords.
2510  // FIXME: Remove with the 4.0 release.
2512  if (Record.size() < 2)
2513  return error("Invalid record");
2514  std::string AsmStr, ConstrStr;
2515  bool HasSideEffects = Record[0] & 1;
2516  bool IsAlignStack = Record[0] >> 1;
2517  unsigned AsmStrSize = Record[1];
2518  if (2+AsmStrSize >= Record.size())
2519  return error("Invalid record");
2520  unsigned ConstStrSize = Record[2+AsmStrSize];
2521  if (3+AsmStrSize+ConstStrSize > Record.size())
2522  return error("Invalid record");
2523 
2524  for (unsigned i = 0; i != AsmStrSize; ++i)
2525  AsmStr += (char)Record[2+i];
2526  for (unsigned i = 0; i != ConstStrSize; ++i)
2527  ConstrStr += (char)Record[3+AsmStrSize+i];
2528  PointerType *PTy = cast<PointerType>(CurTy);
2529  V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
2530  AsmStr, ConstrStr, HasSideEffects, IsAlignStack);
2531  break;
2532  }
2533  // This version adds support for the asm dialect keywords (e.g.,
2534  // inteldialect).
2535  case bitc::CST_CODE_INLINEASM: {
2536  if (Record.size() < 2)
2537  return error("Invalid record");
2538  std::string AsmStr, ConstrStr;
2539  bool HasSideEffects = Record[0] & 1;
2540  bool IsAlignStack = (Record[0] >> 1) & 1;
2541  unsigned AsmDialect = Record[0] >> 2;
2542  unsigned AsmStrSize = Record[1];
2543  if (2+AsmStrSize >= Record.size())
2544  return error("Invalid record");
2545  unsigned ConstStrSize = Record[2+AsmStrSize];
2546  if (3+AsmStrSize+ConstStrSize > Record.size())
2547  return error("Invalid record");
2548 
2549  for (unsigned i = 0; i != AsmStrSize; ++i)
2550  AsmStr += (char)Record[2+i];
2551  for (unsigned i = 0; i != ConstStrSize; ++i)
2552  ConstrStr += (char)Record[3+AsmStrSize+i];
2553  PointerType *PTy = cast<PointerType>(CurTy);
2554  V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
2555  AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
2556  InlineAsm::AsmDialect(AsmDialect));
2557  break;
2558  }
2560  if (Record.size() < 3)
2561  return error("Invalid record");
2562  Type *FnTy = getTypeByID(Record[0]);
2563  if (!FnTy)
2564  return error("Invalid record");
2565  Function *Fn =
2566  dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
2567  if (!Fn)
2568  return error("Invalid record");
2569 
2570  // Don't let Fn get dematerialized.
2571  BlockAddressesTaken.insert(Fn);
2572 
2573  // If the function is already parsed we can insert the block address right
2574  // away.
2575  BasicBlock *BB;
2576  unsigned BBID = Record[2];
2577  if (!BBID)
2578  // Invalid reference to entry block.
2579  return error("Invalid ID");
2580  if (!Fn->empty()) {
2581  Function::iterator BBI = Fn->begin(), BBE = Fn->end();
2582  for (size_t I = 0, E = BBID; I != E; ++I) {
2583  if (BBI == BBE)
2584  return error("Invalid ID");
2585  ++BBI;
2586  }
2587  BB = BBI;
2588  } else {
2589  // Otherwise insert a placeholder and remember it so it can be inserted
2590  // when the function is parsed.
2591  auto &FwdBBs = BasicBlockFwdRefs[Fn];
2592  if (FwdBBs.empty())
2593  BasicBlockFwdRefQueue.push_back(Fn);
2594  if (FwdBBs.size() < BBID + 1)
2595  FwdBBs.resize(BBID + 1);
2596  if (!FwdBBs[BBID])
2597  FwdBBs[BBID] = BasicBlock::Create(Context);
2598  BB = FwdBBs[BBID];
2599  }
2600  V = BlockAddress::get(Fn, BB);
2601  break;
2602  }
2603  }
2604 
2605  ValueList.assignValue(V, NextCstNo);
2606  ++NextCstNo;
2607  }
2608 }
2609 
2610 std::error_code BitcodeReader::parseUseLists() {
2611  if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
2612  return error("Invalid record");
2613 
2614  // Read all the records.
2616  while (1) {
2617  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
2618 
2619  switch (Entry.Kind) {
2620  case BitstreamEntry::SubBlock: // Handled for us already.
2621  case BitstreamEntry::Error:
2622  return error("Malformed block");
2623  case BitstreamEntry::EndBlock:
2624  return std::error_code();
2625  case BitstreamEntry::Record:
2626  // The interesting case.
2627  break;
2628  }
2629 
2630  // Read a use list record.
2631  Record.clear();
2632  bool IsBB = false;
2633  switch (Stream.readRecord(Entry.ID, Record)) {
2634  default: // Default behavior: unknown type.
2635  break;
2636  case bitc::USELIST_CODE_BB:
2637  IsBB = true;
2638  // fallthrough
2640  unsigned RecordLength = Record.size();
2641  if (RecordLength < 3)
2642  // Records should have at least an ID and two indexes.
2643  return error("Invalid record");
2644  unsigned ID = Record.back();
2645  Record.pop_back();
2646 
2647  Value *V;
2648  if (IsBB) {
2649  assert(ID < FunctionBBs.size() && "Basic block not found");
2650  V = FunctionBBs[ID];
2651  } else
2652  V = ValueList[ID];
2653  unsigned NumUses = 0;
2655  for (const Use &U : V->uses()) {
2656  if (++NumUses > Record.size())
2657  break;
2658  Order[&U] = Record[NumUses - 1];
2659  }
2660  if (Order.size() != Record.size() || NumUses > Record.size())
2661  // Mismatches can happen if the functions are being materialized lazily
2662  // (out-of-order), or a value has been upgraded.
2663  break;
2664 
2665  V->sortUseList([&](const Use &L, const Use &R) {
2666  return Order.lookup(&L) < Order.lookup(&R);
2667  });
2668  break;
2669  }
2670  }
2671  }
2672 }
2673 
2674 /// When we see the block for metadata, remember where it is and then skip it.
2675 /// This lets us lazily deserialize the metadata.
2676 std::error_code BitcodeReader::rememberAndSkipMetadata() {
2677  // Save the current stream state.
2678  uint64_t CurBit = Stream.GetCurrentBitNo();
2679  DeferredMetadataInfo.push_back(CurBit);
2680 
2681  // Skip over the block for now.
2682  if (Stream.SkipBlock())
2683  return error("Invalid record");
2684  return std::error_code();
2685 }
2686 
2687 std::error_code BitcodeReader::materializeMetadata() {
2688  for (uint64_t BitPos : DeferredMetadataInfo) {
2689  // Move the bit stream to the saved position.
2690  Stream.JumpToBit(BitPos);
2691  if (std::error_code EC = parseMetadata())
2692  return EC;
2693  }
2694  DeferredMetadataInfo.clear();
2695  return std::error_code();
2696 }
2697 
2698 void BitcodeReader::setStripDebugInfo() { StripDebugInfo = true; }
2699 
2700 /// When we see the block for a function body, remember where it is and then
2701 /// skip it. This lets us lazily deserialize the functions.
2702 std::error_code BitcodeReader::rememberAndSkipFunctionBody() {
2703  // Get the function we are talking about.
2704  if (FunctionsWithBodies.empty())
2705  return error("Insufficient function protos");
2706 
2707  Function *Fn = FunctionsWithBodies.back();
2708  FunctionsWithBodies.pop_back();
2709 
2710  // Save the current stream state.
2711  uint64_t CurBit = Stream.GetCurrentBitNo();
2712  DeferredFunctionInfo[Fn] = CurBit;
2713 
2714  // Skip over the function block for now.
2715  if (Stream.SkipBlock())
2716  return error("Invalid record");
2717  return std::error_code();
2718 }
2719 
2720 std::error_code BitcodeReader::globalCleanup() {
2721  // Patch the initializers for globals and aliases up.
2722  resolveGlobalAndAliasInits();
2723  if (!GlobalInits.empty() || !AliasInits.empty())
2724  return error("Malformed global initializer set");
2725 
2726  // Look for intrinsic functions which need to be upgraded at some point
2727  for (Function &F : *TheModule) {
2728  Function *NewFn;
2729  if (UpgradeIntrinsicFunction(&F, NewFn))
2730  UpgradedIntrinsics[&F] = NewFn;
2731  }
2732 
2733  // Look for global variables which need to be renamed.
2734  for (GlobalVariable &GV : TheModule->globals())
2735  UpgradeGlobalVariable(&GV);
2736 
2737  // Force deallocation of memory for these vectors to favor the client that
2738  // want lazy deserialization.
2739  std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
2740  std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
2741  return std::error_code();
2742 }
2743 
2744 std::error_code BitcodeReader::parseModule(bool Resume,
2745  bool ShouldLazyLoadMetadata) {
2746  if (Resume)
2747  Stream.JumpToBit(NextUnreadBit);
2748  else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
2749  return error("Invalid record");
2750 
2752  std::vector<std::string> SectionTable;
2753  std::vector<std::string> GCTable;
2754 
2755  // Read all the records for this module.
2756  while (1) {
2757  BitstreamEntry Entry = Stream.advance();
2758 
2759  switch (Entry.Kind) {
2760  case BitstreamEntry::Error:
2761  return error("Malformed block");
2762  case BitstreamEntry::EndBlock:
2763  return globalCleanup();
2764 
2765  case BitstreamEntry::SubBlock:
2766  switch (Entry.ID) {
2767  default: // Skip unknown content.
2768  if (Stream.SkipBlock())
2769  return error("Invalid record");
2770  break;
2772  if (Stream.ReadBlockInfoBlock())
2773  return error("Malformed block");
2774  break;
2776  if (std::error_code EC = parseAttributeBlock())
2777  return EC;
2778  break;
2780  if (std::error_code EC = parseAttributeGroupBlock())
2781  return EC;
2782  break;
2784  if (std::error_code EC = parseTypeTable())
2785  return EC;
2786  break;
2788  if (std::error_code EC = parseValueSymbolTable())
2789  return EC;
2790  SeenValueSymbolTable = true;
2791  break;
2793  if (std::error_code EC = parseConstants())
2794  return EC;
2795  if (std::error_code EC = resolveGlobalAndAliasInits())
2796  return EC;
2797  break;
2799  if (ShouldLazyLoadMetadata && !IsMetadataMaterialized) {
2800  if (std::error_code EC = rememberAndSkipMetadata())
2801  return EC;
2802  break;
2803  }
2804  assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata");
2805  if (std::error_code EC = parseMetadata())
2806  return EC;
2807  break;
2809  // If this is the first function body we've seen, reverse the
2810  // FunctionsWithBodies list.
2811  if (!SeenFirstFunctionBody) {
2812  std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
2813  if (std::error_code EC = globalCleanup())
2814  return EC;
2815  SeenFirstFunctionBody = true;
2816  }
2817 
2818  if (std::error_code EC = rememberAndSkipFunctionBody())
2819  return EC;
2820  // Suspend parsing when we reach the function bodies. Subsequent
2821  // materialization calls will resume it when necessary. If the bitcode
2822  // file is old, the symbol table will be at the end instead and will not
2823  // have been seen yet. In this case, just finish the parse now.
2824  if (SeenValueSymbolTable) {
2825  NextUnreadBit = Stream.GetCurrentBitNo();
2826  return std::error_code();
2827  }
2828  break;
2830  if (std::error_code EC = parseUseLists())
2831  return EC;
2832  break;
2833  }
2834  continue;
2835 
2836  case BitstreamEntry::Record:
2837  // The interesting case.
2838  break;
2839  }
2840 
2841 
2842  // Read a record.
2843  switch (Stream.readRecord(Entry.ID, Record)) {
2844  default: break; // Default behavior, ignore unknown content.
2845  case bitc::MODULE_CODE_VERSION: { // VERSION: [version#]
2846  if (Record.size() < 1)
2847  return error("Invalid record");
2848  // Only version #0 and #1 are supported so far.
2849  unsigned module_version = Record[0];
2850  switch (module_version) {
2851  default:
2852  return error("Invalid value");
2853  case 0:
2854  UseRelativeIDs = false;
2855  break;
2856  case 1:
2857  UseRelativeIDs = true;
2858  break;
2859  }
2860  break;
2861  }
2862  case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
2863  std::string S;
2864  if (convertToString(Record, 0, S))
2865  return error("Invalid record");
2866  TheModule->setTargetTriple(S);
2867  break;
2868  }
2869  case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
2870  std::string S;
2871  if (convertToString(Record, 0, S))
2872  return error("Invalid record");
2873  TheModule->setDataLayout(S);
2874  break;
2875  }
2876  case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
2877  std::string S;
2878  if (convertToString(Record, 0, S))
2879  return error("Invalid record");
2880  TheModule->setModuleInlineAsm(S);
2881  break;
2882  }
2883  case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
2884  // FIXME: Remove in 4.0.
2885  std::string S;
2886  if (convertToString(Record, 0, S))
2887  return error("Invalid record");
2888  // Ignore value.
2889  break;
2890  }
2891  case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
2892  std::string S;
2893  if (convertToString(Record, 0, S))
2894  return error("Invalid record");
2895  SectionTable.push_back(S);
2896  break;
2897  }
2898  case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N]
2899  std::string S;
2900  if (convertToString(Record, 0, S))
2901  return error("Invalid record");
2902  GCTable.push_back(S);
2903  break;
2904  }
2905  case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name]
2906  if (Record.size() < 2)
2907  return error("Invalid record");
2909  unsigned ComdatNameSize = Record[1];
2910  std::string ComdatName;
2911  ComdatName.reserve(ComdatNameSize);
2912  for (unsigned i = 0; i != ComdatNameSize; ++i)
2913  ComdatName += (char)Record[2 + i];
2914  Comdat *C = TheModule->getOrInsertComdat(ComdatName);
2915  C->setSelectionKind(SK);
2916  ComdatList.push_back(C);
2917  break;
2918  }
2919  // GLOBALVAR: [pointer type, isconst, initid,
2920  // linkage, alignment, section, visibility, threadlocal,
2921  // unnamed_addr, externally_initialized, dllstorageclass,
2922  // comdat]
2924  if (Record.size() < 6)
2925  return error("Invalid record");
2926  Type *Ty = getTypeByID(Record[0]);
2927  if (!Ty)
2928  return error("Invalid record");
2929  bool isConstant = Record[1] & 1;
2930  bool explicitType = Record[1] & 2;
2931  unsigned AddressSpace;
2932  if (explicitType) {
2933  AddressSpace = Record[1] >> 2;
2934  } else {
2935  if (!Ty->isPointerTy())
2936  return error("Invalid type for value");
2937  AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
2938  Ty = cast<PointerType>(Ty)->getElementType();
2939  }
2940 
2941  uint64_t RawLinkage = Record[3];
2942  GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
2943  unsigned Alignment;
2944  if (std::error_code EC = parseAlignmentValue(Record[4], Alignment))
2945  return EC;
2946  std::string Section;
2947  if (Record[5]) {
2948  if (Record[5]-1 >= SectionTable.size())
2949  return error("Invalid ID");
2950  Section = SectionTable[Record[5]-1];
2951  }
2952  GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
2953  // Local linkage must have default visibility.
2954  if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
2955  // FIXME: Change to an error if non-default in 4.0.
2956  Visibility = getDecodedVisibility(Record[6]);
2957 
2958  GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal;
2959  if (Record.size() > 7)
2960  TLM = getDecodedThreadLocalMode(Record[7]);
2961 
2962  bool UnnamedAddr = false;
2963  if (Record.size() > 8)
2964  UnnamedAddr = Record[8];
2965 
2966  bool ExternallyInitialized = false;
2967  if (Record.size() > 9)
2968  ExternallyInitialized = Record[9];
2969 
2970  GlobalVariable *NewGV =
2971  new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr,
2972  TLM, AddressSpace, ExternallyInitialized);
2973  NewGV->setAlignment(Alignment);
2974  if (!Section.empty())
2975  NewGV->setSection(Section);
2976  NewGV->setVisibility(Visibility);
2977  NewGV->setUnnamedAddr(UnnamedAddr);
2978 
2979  if (Record.size() > 10)
2980  NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10]));
2981  else
2982  upgradeDLLImportExportLinkage(NewGV, RawLinkage);
2983 
2984  ValueList.push_back(NewGV);
2985 
2986  // Remember which value to use for the global initializer.
2987  if (unsigned InitID = Record[2])
2988  GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
2989 
2990  if (Record.size() > 11) {
2991  if (unsigned ComdatID = Record[11]) {
2992  if (ComdatID > ComdatList.size())
2993  return error("Invalid global variable comdat ID");
2994  NewGV->setComdat(ComdatList[ComdatID - 1]);
2995  }
2996  } else if (hasImplicitComdat(RawLinkage)) {
2997  NewGV->setComdat(reinterpret_cast<Comdat *>(1));
2998  }
2999  break;
3000  }
3001  // FUNCTION: [type, callingconv, isproto, linkage, paramattr,
3002  // alignment, section, visibility, gc, unnamed_addr,
3003  // prologuedata, dllstorageclass, comdat, prefixdata]
3005  if (Record.size() < 8)
3006  return error("Invalid record");
3007  Type *Ty = getTypeByID(Record[0]);
3008  if (!Ty)
3009  return error("Invalid record");
3010  if (auto *PTy = dyn_cast<PointerType>(Ty))
3011  Ty = PTy->getElementType();
3012  auto *FTy = dyn_cast<FunctionType>(Ty);
3013  if (!FTy)
3014  return error("Invalid type for value");
3015 
3016  Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
3017  "", TheModule);
3018 
3019  Func->setCallingConv(static_cast<CallingConv::ID>(Record[1]));
3020  bool isProto = Record[2];
3021  uint64_t RawLinkage = Record[3];
3022  Func->setLinkage(getDecodedLinkage(RawLinkage));
3023  Func->setAttributes(getAttributes(Record[4]));
3024 
3025  unsigned Alignment;
3026  if (std::error_code EC = parseAlignmentValue(Record[5], Alignment))
3027  return EC;
3028  Func->setAlignment(Alignment);
3029  if (Record[6]) {
3030  if (Record[6]-1 >= SectionTable.size())
3031  return error("Invalid ID");
3032  Func->setSection(SectionTable[Record[6]-1]);
3033  }
3034  // Local linkage must have default visibility.
3035  if (!Func->hasLocalLinkage())
3036  // FIXME: Change to an error if non-default in 4.0.
3037  Func->setVisibility(getDecodedVisibility(Record[7]));
3038  if (Record.size() > 8 && Record[8]) {
3039  if (Record[8]-1 >= GCTable.size())
3040  return error("Invalid ID");
3041  Func->setGC(GCTable[Record[8]-1].c_str());
3042  }
3043  bool UnnamedAddr = false;
3044  if (Record.size() > 9)
3045  UnnamedAddr = Record[9];
3046  Func->setUnnamedAddr(UnnamedAddr);
3047  if (Record.size() > 10 && Record[10] != 0)
3048  FunctionPrologues.push_back(std::make_pair(Func, Record[10]-1));
3049 
3050  if (Record.size() > 11)
3051  Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
3052  else
3053  upgradeDLLImportExportLinkage(Func, RawLinkage);
3054 
3055  if (Record.size() > 12) {
3056  if (unsigned ComdatID = Record[12]) {
3057  if (ComdatID > ComdatList.size())
3058  return error("Invalid function comdat ID");
3059  Func->setComdat(ComdatList[ComdatID - 1]);
3060  }
3061  } else if (hasImplicitComdat(RawLinkage)) {
3062  Func->setComdat(reinterpret_cast<Comdat *>(1));
3063  }
3064 
3065  if (Record.size() > 13 && Record[13] != 0)
3066  FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1));
3067 
3068  if (Record.size() > 14 && Record[14] != 0)
3069  FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));
3070 
3071  ValueList.push_back(Func);
3072 
3073  // If this is a function with a body, remember the prototype we are
3074  // creating now, so that we can match up the body with them later.
3075  if (!isProto) {
3076  Func->setIsMaterializable(true);
3077  FunctionsWithBodies.push_back(Func);
3078  DeferredFunctionInfo[Func] = 0;
3079  }
3080  break;
3081  }
3082  // ALIAS: [alias type, aliasee val#, linkage]
3083  // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass]
3084  case bitc::MODULE_CODE_ALIAS: {
3085  if (Record.size() < 3)
3086  return error("Invalid record");
3087  Type *Ty = getTypeByID(Record[0]);
3088  if (!Ty)
3089  return error("Invalid record");
3090  auto *PTy = dyn_cast<PointerType>(Ty);
3091  if (!PTy)
3092  return error("Invalid type for value");
3093 
3094  auto *NewGA =
3095  GlobalAlias::create(PTy, getDecodedLinkage(Record[2]), "", TheModule);
3096  // Old bitcode files didn't have visibility field.
3097  // Local linkage must have default visibility.
3098  if (Record.size() > 3 && !NewGA->hasLocalLinkage())
3099  // FIXME: Change to an error if non-default in 4.0.
3100  NewGA->setVisibility(getDecodedVisibility(Record[3]));
3101  if (Record.size() > 4)
3102  NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[4]));
3103  else
3104  upgradeDLLImportExportLinkage(NewGA, Record[2]);
3105  if (Record.size() > 5)
3106  NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[5]));
3107  if (Record.size() > 6)
3108  NewGA->setUnnamedAddr(Record[6]);
3109  ValueList.push_back(NewGA);
3110  AliasInits.push_back(std::make_pair(NewGA, Record[1]));
3111  break;
3112  }
3113  /// MODULE_CODE_PURGEVALS: [numvals]
3115  // Trim down the value list to the specified size.
3116  if (Record.size() < 1 || Record[0] > ValueList.size())
3117  return error("Invalid record");
3118  ValueList.shrinkTo(Record[0]);
3119  break;
3120  }
3121  Record.clear();
3122  }
3123 }
3124 
3125 std::error_code
3126 BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
3127  Module *M, bool ShouldLazyLoadMetadata) {
3128  TheModule = M;
3129 
3130  if (std::error_code EC = initStream(std::move(Streamer)))
3131  return EC;
3132 
3133  // Sniff for the signature.
3134  if (Stream.Read(8) != 'B' ||
3135  Stream.Read(8) != 'C' ||
3136  Stream.Read(4) != 0x0 ||
3137  Stream.Read(4) != 0xC ||
3138  Stream.Read(4) != 0xE ||
3139  Stream.Read(4) != 0xD)
3140  return error("Invalid bitcode signature");
3141 
3142  // We expect a number of well-defined blocks, though we don't necessarily
3143  // need to understand them all.
3144  while (1) {
3145  if (Stream.AtEndOfStream()) {
3146  // We didn't really read a proper Module.
3147  return error("Malformed IR file");
3148  }
3149 
3150  BitstreamEntry Entry =
3151  Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
3152 
3153  if (Entry.Kind != BitstreamEntry::SubBlock)
3154  return error("Malformed block");
3155 
3156  if (Entry.ID == bitc::MODULE_BLOCK_ID)
3157  return parseModule(false, ShouldLazyLoadMetadata);
3158 
3159  if (Stream.SkipBlock())
3160  return error("Invalid record");
3161  }
3162 }
3163 
3164 ErrorOr<std::string> BitcodeReader::parseModuleTriple() {
3165  if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
3166  return error("Invalid record");
3167 
3169 
3170  std::string Triple;
3171  // Read all the records for this module.
3172  while (1) {
3173  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
3174 
3175  switch (Entry.Kind) {
3176  case BitstreamEntry::SubBlock: // Handled for us already.
3177  case BitstreamEntry::Error:
3178  return error("Malformed block");
3179  case BitstreamEntry::EndBlock:
3180  return Triple;
3181  case BitstreamEntry::Record:
3182  // The interesting case.
3183  break;
3184  }
3185 
3186  // Read a record.
3187  switch (Stream.readRecord(Entry.ID, Record)) {
3188  default: break; // Default behavior, ignore unknown content.
3189  case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
3190  std::string S;
3191  if (convertToString(Record, 0, S))
3192  return error("Invalid record");
3193  Triple = S;
3194  break;
3195  }
3196  }
3197  Record.clear();
3198  }
3199  llvm_unreachable("Exit infinite loop");
3200 }
3201 
3202 ErrorOr<std::string> BitcodeReader::parseTriple() {
3203  if (std::error_code EC = initStream(nullptr))
3204  return EC;
3205 
3206  // Sniff for the signature.
3207  if (Stream.Read(8) != 'B' ||
3208  Stream.Read(8) != 'C' ||
3209  Stream.Read(4) != 0x0 ||
3210  Stream.Read(4) != 0xC ||
3211  Stream.Read(4) != 0xE ||
3212  Stream.Read(4) != 0xD)
3213  return error("Invalid bitcode signature");
3214 
3215  // We expect a number of well-defined blocks, though we don't necessarily
3216  // need to understand them all.
3217  while (1) {
3218  BitstreamEntry Entry = Stream.advance();
3219 
3220  switch (Entry.Kind) {
3221  case BitstreamEntry::Error:
3222  return error("Malformed block");
3223  case BitstreamEntry::EndBlock:
3224  return std::error_code();
3225 
3226  case BitstreamEntry::SubBlock:
3227  if (Entry.ID == bitc::MODULE_BLOCK_ID)
3228  return parseModuleTriple();
3229 
3230  // Ignore other sub-blocks.
3231  if (Stream.SkipBlock())
3232  return error("Malformed block");
3233  continue;
3234 
3235  case BitstreamEntry::Record:
3236  Stream.skipRecord(Entry.ID);
3237  continue;
3238  }
3239  }
3240 }
3241 
3242 /// Parse metadata attachments.
3243 std::error_code BitcodeReader::parseMetadataAttachment(Function &F) {
3244  if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
3245  return error("Invalid record");
3246 
3248  while (1) {
3249  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
3250 
3251  switch (Entry.Kind) {
3252  case BitstreamEntry::SubBlock: // Handled for us already.
3253  case BitstreamEntry::Error:
3254  return error("Malformed block");
3255  case BitstreamEntry::EndBlock:
3256  return std::error_code();
3257  case BitstreamEntry::Record:
3258  // The interesting case.
3259  break;
3260  }
3261 
3262  // Read a metadata attachment record.
3263  Record.clear();
3264  switch (Stream.readRecord(Entry.ID, Record)) {
3265  default: // Default behavior: ignore.
3266  break;
3268  unsigned RecordLength = Record.size();
3269  if (Record.empty())
3270  return error("Invalid record");
3271  if (RecordLength % 2 == 0) {
3272  // A function attachment.
3273  for (unsigned I = 0; I != RecordLength; I += 2) {
3274  auto K = MDKindMap.find(Record[I]);
3275  if (K == MDKindMap.end())
3276  return error("Invalid ID");
3277  Metadata *MD = MDValueList.getValueFwdRef(Record[I + 1]);
3278  F.setMetadata(K->second, cast<MDNode>(MD));
3279  }
3280  continue;
3281  }
3282 
3283  // An instruction attachment.
3284  Instruction *Inst = InstructionList[Record[0]];
3285  for (unsigned i = 1; i != RecordLength; i = i+2) {
3286  unsigned Kind = Record[i];
3288  MDKindMap.find(Kind);
3289  if (I == MDKindMap.end())
3290  return error("Invalid ID");
3291  Metadata *Node = MDValueList.getValueFwdRef(Record[i + 1]);
3292  if (isa<LocalAsMetadata>(Node))
3293  // Drop the attachment. This used to be legal, but there's no
3294  // upgrade path.
3295  break;
3296  Inst->setMetadata(I->second, cast<MDNode>(Node));
3297  if (I->second == LLVMContext::MD_tbaa)
3298  InstsWithTBAATag.push_back(Inst);
3299  }
3300  break;
3301  }
3302  }
3303  }
3304 }
3305 
3307  Type *ValType, Type *PtrType) {
3308  if (!isa<PointerType>(PtrType))
3309  return error(DH, "Load/Store operand is not a pointer type");
3310  Type *ElemType = cast<PointerType>(PtrType)->getElementType();
3311 
3312  if (ValType && ValType != ElemType)
3313  return error(DH, "Explicit load/store type does not match pointee type of "
3314  "pointer operand");
3315  if (!PointerType::isLoadableOrStorableType(ElemType))
3316  return error(DH, "Cannot load/store from pointer");
3317  return std::error_code();
3318 }
3319 
3320 /// Lazily parse the specified function body block.
3321 std::error_code BitcodeReader::parseFunctionBody(Function *F) {
3322  if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
3323  return error("Invalid record");
3324 
3325  InstructionList.clear();
3326  unsigned ModuleValueListSize = ValueList.size();
3327  unsigned ModuleMDValueListSize = MDValueList.size();
3328 
3329  // Add all the function arguments to the value table.
3330  for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
3331  ValueList.push_back(I);
3332 
3333  unsigned NextValueNo = ValueList.size();
3334  BasicBlock *CurBB = nullptr;
3335  unsigned CurBBNo = 0;
3336 
3337  DebugLoc LastLoc;
3338  auto getLastInstruction = [&]() -> Instruction * {
3339  if (CurBB && !CurBB->empty())
3340  return &CurBB->back();
3341  else if (CurBBNo && FunctionBBs[CurBBNo - 1] &&
3342  !FunctionBBs[CurBBNo - 1]->empty())
3343  return &FunctionBBs[CurBBNo - 1]->back();
3344  return nullptr;
3345  };
3346 
3347  // Read all the records.
3349  while (1) {
3350  BitstreamEntry Entry = Stream.advance();
3351 
3352  switch (Entry.Kind) {
3353  case BitstreamEntry::Error:
3354  return error("Malformed block");
3355  case BitstreamEntry::EndBlock:
3356  goto OutOfRecordLoop;
3357 
3358  case BitstreamEntry::SubBlock:
3359  switch (Entry.ID) {
3360  default: // Skip unknown content.
3361  if (Stream.SkipBlock())
3362  return error("Invalid record");
3363  break;
3365  if (std::error_code EC = parseConstants())
3366  return EC;
3367  NextValueNo = ValueList.size();
3368  break;
3370  if (std::error_code EC = parseValueSymbolTable())
3371  return EC;
3372  break;
3374  if (std::error_code EC = parseMetadataAttachment(*F))
3375  return EC;
3376  break;
3378  if (std::error_code EC = parseMetadata())
3379  return EC;
3380  break;
3382  if (std::error_code EC = parseUseLists())
3383  return EC;
3384  break;
3385  }
3386  continue;
3387 
3388  case BitstreamEntry::Record:
3389  // The interesting case.
3390  break;
3391  }
3392 
3393  // Read a record.
3394  Record.clear();
3395  Instruction *I = nullptr;
3396  unsigned BitCode = Stream.readRecord(Entry.ID, Record);
3397  switch (BitCode) {
3398  default: // Default behavior: reject
3399  return error("Invalid value");
3400  case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
3401  if (Record.size() < 1 || Record[0] == 0)
3402  return error("Invalid record");
3403  // Create all the basic blocks for the function.
3404  FunctionBBs.resize(Record[0]);
3405 
3406  // See if anything took the address of blocks in this function.
3407  auto BBFRI = BasicBlockFwdRefs.find(F);
3408  if (BBFRI == BasicBlockFwdRefs.end()) {
3409  for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
3410  FunctionBBs[i] = BasicBlock::Create(Context, "", F);
3411  } else {
3412  auto &BBRefs = BBFRI->second;
3413  // Check for invalid basic block references.
3414  if (BBRefs.size() > FunctionBBs.size())
3415  return error("Invalid ID");
3416  assert(!BBRefs.empty() && "Unexpected empty array");
3417  assert(!BBRefs.front() && "Invalid reference to entry block");
3418  for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
3419  ++I)
3420  if (I < RE && BBRefs[I]) {
3421  BBRefs[I]->insertInto(F);
3422  FunctionBBs[I] = BBRefs[I];
3423  } else {
3424  FunctionBBs[I] = BasicBlock::Create(Context, "", F);
3425  }
3426 
3427  // Erase from the table.
3428  BasicBlockFwdRefs.erase(BBFRI);
3429  }
3430 
3431  CurBB = FunctionBBs[0];
3432  continue;
3433  }
3434 
3435  case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN
3436  // This record indicates that the last instruction is at the same
3437  // location as the previous instruction with a location.
3438  I = getLastInstruction();
3439 
3440  if (!I)
3441  return error("Invalid record");
3442  I->setDebugLoc(LastLoc);
3443  I = nullptr;
3444  continue;
3445 
3446  case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
3447  I = getLastInstruction();
3448  if (!I || Record.size() < 4)
3449  return error("Invalid record");
3450 
3451  unsigned Line = Record[0], Col = Record[1];
3452  unsigned ScopeID = Record[2], IAID = Record[3];
3453 
3454  MDNode *Scope = nullptr, *IA = nullptr;
3455  if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1));
3456  if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1));
3457  LastLoc = DebugLoc::get(Line, Col, Scope, IA);
3458  I->setDebugLoc(LastLoc);
3459  I = nullptr;
3460  continue;
3461  }
3462 
3463  case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
3464  unsigned OpNum = 0;
3465  Value *LHS, *RHS;
3466  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
3467  popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
3468  OpNum+1 > Record.size())
3469  return error("Invalid record");
3470 
3471  int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
3472  if (Opc == -1)
3473  return error("Invalid record");
3474  I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3475  InstructionList.push_back(I);
3476  if (OpNum < Record.size()) {
3477  if (Opc == Instruction::Add ||
3478  Opc == Instruction::Sub ||
3479  Opc == Instruction::Mul ||
3480  Opc == Instruction::Shl) {
3481  if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
3482  cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
3483  if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
3484  cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
3485  } else if (Opc == Instruction::SDiv ||
3486  Opc == Instruction::UDiv ||
3487  Opc == Instruction::LShr ||
3488  Opc == Instruction::AShr) {
3489  if (Record[OpNum] & (1 << bitc::PEO_EXACT))
3490  cast<BinaryOperator>(I)->setIsExact(true);
3491  } else if (isa<FPMathOperator>(I)) {
3492  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
3493  if (FMF.any())
3494  I->setFastMathFlags(FMF);
3495  }
3496 
3497  }
3498  break;
3499  }
3500  case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
3501  unsigned OpNum = 0;
3502  Value *Op;
3503  if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
3504  OpNum+2 != Record.size())
3505  return error("Invalid record");
3506 
3507  Type *ResTy = getTypeByID(Record[OpNum]);
3508  int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
3509  if (Opc == -1 || !ResTy)
3510  return error("Invalid record");
3511  Instruction *Temp = nullptr;
3512  if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
3513  if (Temp) {
3514  InstructionList.push_back(Temp);
3515  CurBB->getInstList().push_back(Temp);
3516  }
3517  } else {
3518  I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy);
3519  }
3520  InstructionList.push_back(I);
3521  break;
3522  }
3525  case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands]
3526  unsigned OpNum = 0;
3527 
3528  Type *Ty;
3529  bool InBounds;
3530 
3531  if (BitCode == bitc::FUNC_CODE_INST_GEP) {
3532  InBounds = Record[OpNum++];
3533  Ty = getTypeByID(Record[OpNum++]);
3534  } else {
3535  InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD;
3536  Ty = nullptr;
3537  }
3538 
3539  Value *BasePtr;
3540  if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
3541  return error("Invalid record");
3542 
3543  if (!Ty)
3544  Ty = cast<SequentialType>(BasePtr->getType()->getScalarType())
3545  ->getElementType();
3546  else if (Ty !=
3547  cast<SequentialType>(BasePtr->getType()->getScalarType())
3548  ->getElementType())
3549  return error(
3550  "Explicit gep type does not match pointee type of pointer operand");
3551 
3552  SmallVector<Value*, 16> GEPIdx;
3553  while (OpNum != Record.size()) {
3554  Value *Op;
3555  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
3556  return error("Invalid record");
3557  GEPIdx.push_back(Op);
3558  }
3559 
3560  I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);
3561 
3562  InstructionList.push_back(I);
3563  if (InBounds)
3564  cast<GetElementPtrInst>(I)->setIsInBounds(true);
3565  break;
3566  }
3567 
3569  // EXTRACTVAL: [opty, opval, n x indices]
3570  unsigned OpNum = 0;
3571  Value *Agg;
3572  if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
3573  return error("Invalid record");
3574 
3575  unsigned RecSize = Record.size();
3576  if (OpNum == RecSize)
3577  return error("EXTRACTVAL: Invalid instruction with 0 indices");
3578 
3579  SmallVector<unsigned, 4> EXTRACTVALIdx;
3580  Type *CurTy = Agg->getType();
3581  for (; OpNum != RecSize; ++OpNum) {
3582  bool IsArray = CurTy->isArrayTy();
3583  bool IsStruct = CurTy->isStructTy();
3584  uint64_t Index = Record[OpNum];
3585 
3586  if (!IsStruct && !IsArray)
3587  return error("EXTRACTVAL: Invalid type");
3588  if ((unsigned)Index != Index)
3589  return error("Invalid value");
3590  if (IsStruct && Index >= CurTy->subtypes().size())
3591  return error("EXTRACTVAL: Invalid struct index");
3592  if (IsArray && Index >= CurTy->getArrayNumElements())
3593  return error("EXTRACTVAL: Invalid array index");
3594  EXTRACTVALIdx.push_back((unsigned)Index);
3595 
3596  if (IsStruct)
3597  CurTy = CurTy->subtypes()[Index];
3598  else
3599  CurTy = CurTy->subtypes()[0];
3600  }
3601 
3602  I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
3603  InstructionList.push_back(I);
3604  break;
3605  }
3606 
3608  // INSERTVAL: [opty, opval, opty, opval, n x indices]
3609  unsigned OpNum = 0;
3610  Value *Agg;
3611  if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
3612  return error("Invalid record");
3613  Value *Val;
3614  if (getValueTypePair(Record, OpNum, NextValueNo, Val))
3615  return error("Invalid record");
3616 
3617  unsigned RecSize = Record.size();
3618  if (OpNum == RecSize)
3619  return error("INSERTVAL: Invalid instruction with 0 indices");
3620 
3621  SmallVector<unsigned, 4> INSERTVALIdx;
3622  Type *CurTy = Agg->getType();
3623  for (; OpNum != RecSize; ++OpNum) {
3624  bool IsArray = CurTy->isArrayTy();
3625  bool IsStruct = CurTy->isStructTy();
3626  uint64_t Index = Record[OpNum];
3627 
3628  if (!IsStruct && !IsArray)
3629  return error("INSERTVAL: Invalid type");
3630  if ((unsigned)Index != Index)
3631  return error("Invalid value");
3632  if (IsStruct && Index >= CurTy->subtypes().size())
3633  return error("INSERTVAL: Invalid struct index");
3634  if (IsArray && Index >= CurTy->getArrayNumElements())
3635  return error("INSERTVAL: Invalid array index");
3636 
3637  INSERTVALIdx.push_back((unsigned)Index);
3638  if (IsStruct)
3639  CurTy = CurTy->subtypes()[Index];
3640  else
3641  CurTy = CurTy->subtypes()[0];
3642  }
3643 
3644  if (CurTy != Val->getType())
3645  return error("Inserted value type doesn't match aggregate type");
3646 
3647  I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);
3648  InstructionList.push_back(I);
3649  break;
3650  }
3651 
3652  case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
3653  // obsolete form of select
3654  // handles select i1 ... in old bitcode
3655  unsigned OpNum = 0;
3656  Value *TrueVal, *FalseVal, *Cond;
3657  if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
3658  popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
3659  popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
3660  return error("Invalid record");
3661 
3662  I = SelectInst::Create(Cond, TrueVal, FalseVal);
3663  InstructionList.push_back(I);
3664  break;
3665  }
3666 
3667  case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
3668  // new form of select
3669  // handles select i1 or select [N x i1]
3670  unsigned OpNum = 0;
3671  Value *TrueVal, *FalseVal, *Cond;
3672  if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
3673  popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
3674  getValueTypePair(Record, OpNum, NextValueNo, Cond))
3675  return error("Invalid record");
3676 
3677  // select condition can be either i1 or [N x i1]
3678  if (VectorType* vector_type =
3679  dyn_cast<VectorType>(Cond->getType())) {
3680  // expect <n x i1>
3681  if (vector_type->getElementType() != Type::getInt1Ty(Context))
3682  return error("Invalid type for value");
3683  } else {
3684  // expect i1
3685  if (Cond->getType() != Type::getInt1Ty(Context))
3686  return error("Invalid type for value");
3687  }
3688 
3689  I = SelectInst::Create(Cond, TrueVal, FalseVal);
3690  InstructionList.push_back(I);
3691  break;
3692  }
3693 
3694  case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
3695  unsigned OpNum = 0;
3696  Value *Vec, *Idx;
3697  if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
3698  getValueTypePair(Record, OpNum, NextValueNo, Idx))
3699  return error("Invalid record");
3700  if (!Vec->getType()->isVectorTy())
3701  return error("Invalid type for value");
3702  I = ExtractElementInst::Create(Vec, Idx);
3703  InstructionList.push_back(I);
3704  break;
3705  }
3706 
3707  case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
3708  unsigned OpNum = 0;
3709  Value *Vec, *Elt, *Idx;
3710  if (getValueTypePair(Record, OpNum, NextValueNo, Vec))
3711  return error("Invalid record");
3712  if (!Vec->getType()->isVectorTy())
3713  return error("Invalid type for value");
3714  if (popValue(Record, OpNum, NextValueNo,
3715  cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
3716  getValueTypePair(Record, OpNum, NextValueNo, Idx))
3717  return error("Invalid record");
3718  I = InsertElementInst::Create(Vec, Elt, Idx);
3719  InstructionList.push_back(I);
3720  break;
3721  }
3722 
3723  case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
3724  unsigned OpNum = 0;
3725  Value *Vec1, *Vec2, *Mask;
3726  if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
3727  popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
3728  return error("Invalid record");
3729 
3730  if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
3731  return error("Invalid record");
3732  if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())
3733  return error("Invalid type for value");
3734  I = new ShuffleVectorInst(Vec1, Vec2, Mask);
3735  InstructionList.push_back(I);
3736  break;
3737  }
3738 
3739  case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred]
3740  // Old form of ICmp/FCmp returning bool
3741  // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
3742  // both legal on vectors but had different behaviour.
3743  case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
3744  // FCmp/ICmp returning bool or vector of bool
3745 
3746  unsigned OpNum = 0;
3747  Value *LHS, *RHS;
3748  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
3749  popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
3750  return error("Invalid record");
3751 
3752  unsigned PredVal = Record[OpNum];
3753  bool IsFP = LHS->getType()->isFPOrFPVectorTy();
3754  FastMathFlags FMF;
3755  if (IsFP && Record.size() > OpNum+1)
3756  FMF = getDecodedFastMathFlags(Record[++OpNum]);
3757 
3758  if (OpNum+1 != Record.size())
3759  return error("Invalid record");
3760 
3761  if (LHS->getType()->isFPOrFPVectorTy())
3762  I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS);
3763  else
3764  I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS);
3765 
3766  if (FMF.any())
3767  I->setFastMathFlags(FMF);
3768  InstructionList.push_back(I);
3769  break;
3770  }
3771 
3772  case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
3773  {
3774  unsigned Size = Record.size();
3775  if (Size == 0) {
3776  I = ReturnInst::Create(Context);
3777  InstructionList.push_back(I);
3778  break;
3779  }
3780 
3781  unsigned OpNum = 0;
3782  Value *Op = nullptr;
3783  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
3784  return error("Invalid record");
3785  if (OpNum != Record.size())
3786  return error("Invalid record");
3787 
3788  I = ReturnInst::Create(Context, Op);
3789  InstructionList.push_back(I);
3790  break;
3791  }
3792  case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
3793  if (Record.size() != 1 && Record.size() != 3)
3794  return error("Invalid record");
3795  BasicBlock *TrueDest = getBasicBlock(Record[0]);
3796  if (!TrueDest)
3797  return error("Invalid record");
3798 
3799  if (Record.size() == 1) {
3800  I = BranchInst::Create(TrueDest);
3801  InstructionList.push_back(I);
3802  }
3803  else {
3804  BasicBlock *FalseDest = getBasicBlock(Record[1]);
3805  Value *Cond = getValue(Record, 2, NextValueNo,
3806  Type::getInt1Ty(Context));
3807  if (!FalseDest || !Cond)
3808  return error("Invalid record");
3809  I = BranchInst::Create(TrueDest, FalseDest, Cond);
3810  InstructionList.push_back(I);
3811  }
3812  break;
3813  }
3814  case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
3815  // Check magic
3816  if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
3817  // "New" SwitchInst format with case ranges. The changes to write this
3818  // format were reverted but we still recognize bitcode that uses it.
3819  // Hopefully someday we will have support for case ranges and can use
3820  // this format again.
3821 
3822  Type *OpTy = getTypeByID(Record[1]);
3823  unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
3824 
3825  Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
3826  BasicBlock *Default = getBasicBlock(Record[3]);
3827  if (!OpTy || !Cond || !Default)
3828  return error("Invalid record");
3829 
3830  unsigned NumCases = Record[4];
3831 
3832  SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
3833  InstructionList.push_back(SI);
3834 
3835  unsigned CurIdx = 5;
3836  for (unsigned i = 0; i != NumCases; ++i) {
3838  unsigned NumItems = Record[CurIdx++];
3839  for (unsigned ci = 0; ci != NumItems; ++ci) {
3840  bool isSingleNumber = Record[CurIdx++];
3841 
3842  APInt Low;
3843  unsigned ActiveWords = 1;
3844  if (ValueBitWidth > 64)
3845  ActiveWords = Record[CurIdx++];
3846  Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
3847  ValueBitWidth);
3848  CurIdx += ActiveWords;
3849 
3850  if (!isSingleNumber) {
3851  ActiveWords = 1;
3852  if (ValueBitWidth > 64)
3853  ActiveWords = Record[CurIdx++];
3854  APInt High = readWideAPInt(
3855  makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth);
3856  CurIdx += ActiveWords;
3857 
3858  // FIXME: It is not clear whether values in the range should be
3859  // compared as signed or unsigned values. The partially
3860  // implemented changes that used this format in the past used
3861  // unsigned comparisons.
3862  for ( ; Low.ule(High); ++Low)
3863  CaseVals.push_back(ConstantInt::get(Context, Low));
3864  } else
3865  CaseVals.push_back(ConstantInt::get(Context, Low));
3866  }
3867  BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
3868  for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
3869  cve = CaseVals.end(); cvi != cve; ++cvi)
3870  SI->addCase(*cvi, DestBB);
3871  }
3872  I = SI;
3873  break;
3874  }
3875 
3876  // Old SwitchInst format without case ranges.
3877 
3878  if (Record.size() < 3 || (Record.size() & 1) == 0)
3879  return error("Invalid record");
3880  Type *OpTy = getTypeByID(Record[0]);
3881  Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
3882  BasicBlock *Default = getBasicBlock(Record[2]);
3883  if (!OpTy || !Cond || !Default)
3884  return error("Invalid record");
3885  unsigned NumCases = (Record.size()-3)/2;
3886  SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
3887  InstructionList.push_back(SI);
3888  for (unsigned i = 0, e = NumCases; i != e; ++i) {
3889  ConstantInt *CaseVal =
3890  dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
3891  BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
3892  if (!CaseVal || !DestBB) {
3893  delete SI;
3894  return error("Invalid record");
3895  }
3896  SI->addCase(CaseVal, DestBB);
3897  }
3898  I = SI;
3899  break;
3900  }
3901  case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
3902  if (Record.size() < 2)
3903  return error("Invalid record");
3904  Type *OpTy = getTypeByID(Record[0]);
3905  Value *Address = getValue(Record, 1, NextValueNo, OpTy);
3906  if (!OpTy || !Address)
3907  return error("Invalid record");
3908  unsigned NumDests = Record.size()-2;
3909  IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
3910  InstructionList.push_back(IBI);
3911  for (unsigned i = 0, e = NumDests; i != e; ++i) {
3912  if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
3913  IBI->addDestination(DestBB);
3914  } else {
3915  delete IBI;
3916  return error("Invalid record");
3917  }
3918  }
3919  I = IBI;
3920  break;
3921  }
3922 
3924  // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
3925  if (Record.size() < 4)
3926  return error("Invalid record");
3927  unsigned OpNum = 0;
3928  AttributeSet PAL = getAttributes(Record[OpNum++]);
3929  unsigned CCInfo = Record[OpNum++];
3930  BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
3931  BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
3932 
3933  FunctionType *FTy = nullptr;
3934  if (CCInfo >> 13 & 1 &&
3935  !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
3936  return error("Explicit invoke type is not a function type");
3937 
3938  Value *Callee;
3939  if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
3940  return error("Invalid record");
3941 
3942  PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
3943  if (!CalleeTy)
3944  return error("Callee is not a pointer");
3945  if (!FTy) {
3946  FTy = dyn_cast<FunctionType>(CalleeTy->getElementType());
3947  if (!FTy)
3948  return error("Callee is not of pointer to function type");
3949  } else if (CalleeTy->getElementType() != FTy)
3950  return error("Explicit invoke type does not match pointee type of "
3951  "callee operand");
3952  if (Record.size() < FTy->getNumParams() + OpNum)
3953  return error("Insufficient operands to call");
3954 
3956  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
3957  Ops.push_back(getValue(Record, OpNum, NextValueNo,
3958  FTy->getParamType(i)));
3959  if (!Ops.back())
3960  return error("Invalid record");
3961  }
3962 
3963  if (!FTy->isVarArg()) {
3964  if (Record.size() != OpNum)
3965  return error("Invalid record");
3966  } else {
3967  // Read type/value pairs for varargs params.
3968  while (OpNum != Record.size()) {
3969  Value *Op;
3970  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
3971  return error("Invalid record");
3972  Ops.push_back(Op);
3973  }
3974  }
3975 
3976  I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops);
3977  InstructionList.push_back(I);
3978  cast<InvokeInst>(I)
3979  ->setCallingConv(static_cast<CallingConv::ID>(~(1U << 13) & CCInfo));
3980  cast<InvokeInst>(I)->setAttributes(PAL);
3981  break;
3982  }
3983  case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
3984  unsigned Idx = 0;
3985  Value *Val = nullptr;
3986  if (getValueTypePair(Record, Idx, NextValueNo, Val))
3987  return error("Invalid record");
3988  I = ResumeInst::Create(Val);
3989  InstructionList.push_back(I);
3990  break;
3991  }
3992  case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
3993  I = new UnreachableInst(Context);
3994  InstructionList.push_back(I);
3995  break;
3996  case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
3997  if (Record.size() < 1 || ((Record.size()-1)&1))
3998  return error("Invalid record");
3999  Type *Ty = getTypeByID(Record[0]);
4000  if (!Ty)
4001  return error("Invalid record");
4002 
4003  PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
4004  InstructionList.push_back(PN);
4005 
4006  for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
4007  Value *V;
4008  // With the new function encoding, it is possible that operands have
4009  // negative IDs (for forward references). Use a signed VBR
4010  // representation to keep the encoding small.
4011  if (UseRelativeIDs)
4012  V = getValueSigned(Record, 1+i, NextValueNo, Ty);
4013  else
4014  V = getValue(Record, 1+i, NextValueNo, Ty);
4015  BasicBlock *BB = getBasicBlock(Record[2+i]);
4016  if (!V || !BB)
4017  return error("Invalid record");
4018  PN->addIncoming(V, BB);
4019  }
4020  I = PN;
4021  break;
4022  }
4023 
4026  // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
4027  unsigned Idx = 0;
4028  if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD) {
4029  if (Record.size() < 3)
4030  return error("Invalid record");
4031  } else {
4032  assert(BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD);
4033  if (Record.size() < 4)
4034  return error("Invalid record");
4035  }
4036  Type *Ty = getTypeByID(Record[Idx++]);
4037  if (!Ty)
4038  return error("Invalid record");
4039  if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {
4040  Value *PersFn = nullptr;
4041  if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
4042  return error("Invalid record");
4043 
4044  if (!F->hasPersonalityFn())
4045  F->setPersonalityFn(cast<Constant>(PersFn));
4046  else if (F->getPersonalityFn() != cast<Constant>(PersFn))
4047  return error("Personality function mismatch");
4048  }
4049 
4050  bool IsCleanup = !!Record[Idx++];
4051  unsigned NumClauses = Record[Idx++];
4052  LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses);
4053  LP->setCleanup(IsCleanup);
4054  for (unsigned J = 0; J != NumClauses; ++J) {
4056  LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
4057  Value *Val;
4058 
4059  if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
4060  delete LP;
4061  return error("Invalid record");
4062  }
4063 
4064  assert((CT != LandingPadInst::Catch ||
4065  !isa<ArrayType>(Val->getType())) &&
4066  "Catch clause has a invalid type!");
4067  assert((CT != LandingPadInst::Filter ||
4068  isa<ArrayType>(Val->getType())) &&
4069  "Filter clause has invalid type!");
4070  LP->addClause(cast<Constant>(Val));
4071  }
4072 
4073  I = LP;
4074  InstructionList.push_back(I);
4075  break;
4076  }
4077 
4078  case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
4079  if (Record.size() != 4)
4080  return error("Invalid record");
4081  uint64_t AlignRecord = Record[3];
4082  const uint64_t InAllocaMask = uint64_t(1) << 5;
4083  const uint64_t ExplicitTypeMask = uint64_t(1) << 6;
4084  const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask;
4085  bool InAlloca = AlignRecord & InAllocaMask;
4086  Type *Ty = getTypeByID(Record[0]);
4087  if ((AlignRecord & ExplicitTypeMask) == 0) {
4088  auto *PTy = dyn_cast_or_null<PointerType>(Ty);
4089  if (!PTy)
4090  return error("Old-style alloca with a non-pointer type");
4091  Ty = PTy->getElementType();
4092  }
4093  Type *OpTy = getTypeByID(Record[1]);
4094  Value *Size = getFnValueByID(Record[2], OpTy);
4095  unsigned Align;
4096  if (std::error_code EC =
4097  parseAlignmentValue(AlignRecord & ~FlagMask, Align)) {
4098  return EC;
4099  }
4100  if (!Ty || !Size)
4101  return error("Invalid record");
4102  AllocaInst *AI = new AllocaInst(Ty, Size, Align);
4103  AI->setUsedWithInAlloca(InAlloca);
4104  I = AI;
4105  InstructionList.push_back(I);
4106  break;
4107  }
4108  case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
4109  unsigned OpNum = 0;
4110  Value *Op;
4111  if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
4112  (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
4113  return error("Invalid record");
4114 
4115  Type *Ty = nullptr;
4116  if (OpNum + 3 == Record.size())
4117  Ty = getTypeByID(Record[OpNum++]);
4118  if (std::error_code EC =
4119  typeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType()))
4120  return EC;
4121  if (!Ty)
4122  Ty = cast<PointerType>(Op->getType())->getElementType();
4123 
4124  unsigned Align;
4125  if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
4126  return EC;
4127  I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
4128 
4129  InstructionList.push_back(I);
4130  break;
4131  }
4133  // LOADATOMIC: [opty, op, align, vol, ordering, synchscope]
4134  unsigned OpNum = 0;
4135  Value *Op;
4136  if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
4137  (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
4138  return error("Invalid record");
4139 
4140  Type *Ty = nullptr;
4141  if (OpNum + 5 == Record.size())
4142  Ty = getTypeByID(Record[OpNum++]);
4143  if (std::error_code EC =
4144  typeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType()))
4145  return EC;
4146  if (!Ty)
4147  Ty = cast<PointerType>(Op->getType())->getElementType();
4148 
4149  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4150  if (Ordering == NotAtomic || Ordering == Release ||
4151  Ordering == AcquireRelease)
4152  return error("Invalid record");
4153  if (Ordering != NotAtomic && Record[OpNum] == 0)
4154  return error("Invalid record");
4155  SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 3]);
4156 
4157  unsigned Align;
4158  if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
4159  return EC;
4160  I = new LoadInst(Op, "", Record[OpNum+1], Align, Ordering, SynchScope);
4161 
4162  InstructionList.push_back(I);
4163  break;
4164  }
4166  case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol]
4167  unsigned OpNum = 0;
4168  Value *Val, *Ptr;
4169  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
4170  (BitCode == bitc::FUNC_CODE_INST_STORE
4171  ? getValueTypePair(Record, OpNum, NextValueNo, Val)
4172  : popValue(Record, OpNum, NextValueNo,
4173  cast<PointerType>(Ptr->getType())->getElementType(),
4174  Val)) ||
4175  OpNum + 2 != Record.size())
4176  return error("Invalid record");
4177 
4178  if (std::error_code EC = typeCheckLoadStoreInst(
4179  DiagnosticHandler, Val->getType(), Ptr->getType()))
4180  return EC;
4181  unsigned Align;
4182  if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
4183  return EC;
4184  I = new StoreInst(Val, Ptr, Record[OpNum+1], Align);
4185  InstructionList.push_back(I);
4186  break;
4187  }
4190  // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope]
4191  unsigned OpNum = 0;
4192  Value *Val, *Ptr;
4193  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
4195  ? getValueTypePair(Record, OpNum, NextValueNo, Val)
4196  : popValue(Record, OpNum, NextValueNo,
4197  cast<PointerType>(Ptr->getType())->getElementType(),
4198  Val)) ||
4199  OpNum + 4 != Record.size())
4200  return error("Invalid record");
4201 
4202  if (std::error_code EC = typeCheckLoadStoreInst(
4203  DiagnosticHandler, Val->getType(), Ptr->getType()))
4204  return EC;
4205  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4206  if (Ordering == NotAtomic || Ordering == Acquire ||
4207  Ordering == AcquireRelease)
4208  return error("Invalid record");
4209  SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 3]);
4210  if (Ordering != NotAtomic && Record[OpNum] == 0)
4211  return error("Invalid record");
4212 
4213  unsigned Align;
4214  if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align))
4215  return EC;
4216  I = new StoreInst(Val, Ptr, Record[OpNum+1], Align, Ordering, SynchScope);
4217  InstructionList.push_back(I);
4218  break;
4219  }
4222  // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, synchscope,
4223  // failureordering?, isweak?]
4224  unsigned OpNum = 0;
4225  Value *Ptr, *Cmp, *New;
4226  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
4227  (BitCode == bitc::FUNC_CODE_INST_CMPXCHG
4228  ? getValueTypePair(Record, OpNum, NextValueNo, Cmp)
4229  : popValue(Record, OpNum, NextValueNo,
4230  cast<PointerType>(Ptr->getType())->getElementType(),
4231  Cmp)) ||
4232  popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
4233  Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
4234  return error("Invalid record");
4235  AtomicOrdering SuccessOrdering = getDecodedOrdering(Record[OpNum + 1]);
4236  if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered)
4237  return error("Invalid record");
4238  SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 2]);
4239 
4240  if (std::error_code EC = typeCheckLoadStoreInst(
4241  DiagnosticHandler, Cmp->getType(), Ptr->getType()))
4242  return EC;
4243  AtomicOrdering FailureOrdering;
4244  if (Record.size() < 7)
4245  FailureOrdering =
4246  AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering);
4247  else
4248  FailureOrdering = getDecodedOrdering(Record[OpNum + 3]);
4249 
4250  I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering,
4251  SynchScope);
4252  cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
4253 
4254  if (Record.size() < 8) {
4255  // Before weak cmpxchgs existed, the instruction simply returned the
4256  // value loaded from memory, so bitcode files from that era will be
4257  // expecting the first component of a modern cmpxchg.
4258  CurBB->getInstList().push_back(I);
4259  I = ExtractValueInst::Create(I, 0);
4260  } else {
4261  cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
4262  }
4263 
4264  InstructionList.push_back(I);
4265  break;
4266  }
4268  // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope]
4269  unsigned OpNum = 0;
4270  Value *Ptr, *Val;
4271  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
4272  popValue(Record, OpNum, NextValueNo,
4273  cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
4274  OpNum+4 != Record.size())
4275  return error("Invalid record");
4276  AtomicRMWInst::BinOp Operation = getDecodedRMWOperation(Record[OpNum]);
4277  if (Operation < AtomicRMWInst::FIRST_BINOP ||
4278  Operation > AtomicRMWInst::LAST_BINOP)
4279  return error("Invalid record");
4280  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4281  if (Ordering == NotAtomic || Ordering == Unordered)
4282  return error("Invalid record");
4283  SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 3]);
4284  I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope);
4285  cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
4286  InstructionList.push_back(I);
4287  break;
4288  }
4289  case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope]
4290  if (2 != Record.size())
4291  return error("Invalid record");
4292  AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
4293  if (Ordering == NotAtomic || Ordering == Unordered ||
4294  Ordering == Monotonic)
4295  return error("Invalid record");
4296  SynchronizationScope SynchScope = getDecodedSynchScope(Record[1]);
4297  I = new FenceInst(Context, Ordering, SynchScope);
4298  InstructionList.push_back(I);
4299  break;
4300  }
4302  // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...]
4303  if (Record.size() < 3)
4304  return error("Invalid record");
4305 
4306  unsigned OpNum = 0;
4307  AttributeSet PAL = getAttributes(Record[OpNum++]);
4308  unsigned CCInfo = Record[OpNum++];
4309 
4310  FunctionType *FTy = nullptr;
4311  if (CCInfo >> 15 & 1 &&
4312  !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
4313  return error("Explicit call type is not a function type");
4314 
4315  Value *Callee;
4316  if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
4317  return error("Invalid record");
4318 
4319  PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
4320  if (!OpTy)
4321  return error("Callee is not a pointer type");
4322  if (!FTy) {
4323  FTy = dyn_cast<FunctionType>(OpTy->getElementType());
4324  if (!FTy)
4325  return error("Callee is not of pointer to function type");
4326  } else if (OpTy->getElementType() != FTy)
4327  return error("Explicit call type does not match pointee type of "
4328  "callee operand");
4329  if (Record.size() < FTy->getNumParams() + OpNum)
4330  return error("Insufficient operands to call");
4331 
4333  // Read the fixed params.
4334  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
4335  if (FTy->getParamType(i)->isLabelTy())
4336  Args.push_back(getBasicBlock(Record[OpNum]));
4337  else
4338  Args.push_back(getValue(Record, OpNum, NextValueNo,
4339  FTy->getParamType(i)));
4340  if (!Args.back())
4341  return error("Invalid record");
4342  }
4343 
4344  // Read type/value pairs for varargs params.
4345  if (!FTy->isVarArg()) {
4346  if (OpNum != Record.size())
4347  return error("Invalid record");
4348  } else {
4349  while (OpNum != Record.size()) {
4350  Value *Op;
4351  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
4352  return error("Invalid record");
4353  Args.push_back(Op);
4354  }
4355  }
4356 
4357  I = CallInst::Create(FTy, Callee, Args);
4358  InstructionList.push_back(I);
4359  cast<CallInst>(I)->setCallingConv(
4360  static_cast<CallingConv::ID>((~(1U << 14) & CCInfo) >> 1));
4361  CallInst::TailCallKind TCK = CallInst::TCK_None;
4362  if (CCInfo & 1)
4363  TCK = CallInst::TCK_Tail;
4364  if (CCInfo & (1 << 14))
4365  TCK = CallInst::TCK_MustTail;
4366  cast<CallInst>(I)->setTailCallKind(TCK);
4367  cast<CallInst>(I)->setAttributes(PAL);
4368  break;
4369  }
4370  case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
4371  if (Record.size() < 3)
4372  return error("Invalid record");
4373  Type *OpTy = getTypeByID(Record[0]);
4374  Value *Op = getValue(Record, 1, NextValueNo, OpTy);
4375  Type *ResTy = getTypeByID(Record[2]);
4376  if (!OpTy || !Op || !ResTy)
4377  return error("Invalid record");
4378  I = new VAArgInst(Op, ResTy);
4379  InstructionList.push_back(I);
4380  break;
4381  }
4382  }
4383 
4384  // Add instruction to end of current BB. If there is no current BB, reject
4385  // this file.
4386  if (!CurBB) {
4387  delete I;
4388  return error("Invalid instruction with no BB");
4389  }
4390  CurBB->getInstList().push_back(I);
4391 
4392  // If this was a terminator instruction, move to the next block.
4393  if (isa<TerminatorInst>(I)) {
4394  ++CurBBNo;
4395  CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
4396  }
4397 
4398  // Non-void values get registered in the value table for future use.
4399  if (I && !I->getType()->isVoidTy())
4400  ValueList.assignValue(I, NextValueNo++);
4401  }
4402 
4403 OutOfRecordLoop:
4404 
4405  // Check the function list for unresolved values.
4406  if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
4407  if (!A->getParent()) {
4408  // We found at least one unresolved value. Nuke them all to avoid leaks.
4409  for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
4410  if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {
4411  A->replaceAllUsesWith(UndefValue::get(A->getType()));
4412  delete A;
4413  }
4414  }
4415  return error("Never resolved value found in function");
4416  }
4417  }
4418 
4419  // FIXME: Check for unresolved forward-declared metadata references
4420  // and clean up leaks.
4421 
4422  // Trim the value list down to the size it was before we parsed this function.
4423  ValueList.shrinkTo(ModuleValueListSize);
4424  MDValueList.shrinkTo(ModuleMDValueListSize);
4425  std::vector<BasicBlock*>().swap(FunctionBBs);
4426  return std::error_code();
4427 }
4428 
4429 /// Find the function body in the bitcode stream
4430 std::error_code BitcodeReader::findFunctionInStream(
4431  Function *F,
4432  DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
4433  while (DeferredFunctionInfoIterator->second == 0) {
4434  if (Stream.AtEndOfStream())
4435  return error("Could not find function in stream");
4436  // ParseModule will parse the next body in the stream and set its
4437  // position in the DeferredFunctionInfo map.
4438  if (std::error_code EC = parseModule(true))
4439  return EC;
4440  }
4441  return std::error_code();
4442 }
4443 
4444 //===----------------------------------------------------------------------===//
4445 // GVMaterializer implementation
4446 //===----------------------------------------------------------------------===//
4447 
4448 void BitcodeReader::releaseBuffer() { Buffer.release(); }
4449 
4450 std::error_code BitcodeReader::materialize(GlobalValue *GV) {
4451  if (std::error_code EC = materializeMetadata())
4452  return EC;
4453 
4454  Function *F = dyn_cast<Function>(GV);
4455  // If it's not a function or is already material, ignore the request.
4456  if (!F || !F->isMaterializable())
4457  return std::error_code();
4458 
4459  DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
4460  assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
4461  // If its position is recorded as 0, its body is somewhere in the stream
4462  // but we haven't seen it yet.
4463  if (DFII->second == 0)
4464  if (std::error_code EC = findFunctionInStream(F, DFII))
4465  return EC;
4466 
4467  // Move the bit stream to the saved position of the deferred function body.
4468  Stream.JumpToBit(DFII->second);
4469 
4470  if (std::error_code EC = parseFunctionBody(F))
4471  return EC;
4472  F->setIsMaterializable(false);
4473 
4474  if (StripDebugInfo)
4475  stripDebugInfo(*F);
4476 
4477  // Upgrade any old intrinsic calls in the function.
4478  for (auto &I : UpgradedIntrinsics) {
4479  for (auto UI = I.first->user_begin(), UE = I.first->user_end(); UI != UE;) {
4480  User *U = *UI;
4481  ++UI;
4482  if (CallInst *CI = dyn_cast<CallInst>(U))
4483  UpgradeIntrinsicCall(CI, I.second);
4484  }
4485  }
4486 
4487  // Bring in any functions that this function forward-referenced via
4488  // blockaddresses.
4489  return materializeForwardReferencedFunctions();
4490 }
4491 
4492 bool BitcodeReader::isDematerializable(const GlobalValue *GV) const {
4493  const Function *F = dyn_cast<Function>(GV);
4494  if (!F || F->isDeclaration())
4495  return false;
4496 
4497  // Dematerializing F would leave dangling references that wouldn't be
4498  // reconnected on re-materialization.
4499  if (BlockAddressesTaken.count(F))
4500  return false;
4501 
4502  return DeferredFunctionInfo.count(const_cast<Function*>(F));
4503 }
4504 
4505 void BitcodeReader::dematerialize(GlobalValue *GV) {
4506  Function *F = dyn_cast<Function>(GV);
4507  // If this function isn't dematerializable, this is a noop.
4508  if (!F || !isDematerializable(F))
4509  return;
4510 
4511  assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
4512 
4513  // Just forget the function body, we can remat it later.
4514  F->dropAllReferences();
4515  F->setIsMaterializable(true);
4516 }
4517 
4518 std::error_code BitcodeReader::materializeModule(Module *M) {
4519  assert(M == TheModule &&
4520  "Can only Materialize the Module this BitcodeReader is attached to.");
4521 
4522  if (std::error_code EC = materializeMetadata())
4523  return EC;
4524 
4525  // Promise to materialize all forward references.
4526  WillMaterializeAllForwardRefs = true;
4527 
4528  // Iterate over the module, deserializing any functions that are still on
4529  // disk.
4530  for (Module::iterator F = TheModule->begin(), E = TheModule->end();
4531  F != E; ++F) {
4532  if (std::error_code EC = materialize(F))
4533  return EC;
4534  }
4535  // At this point, if there are any function bodies, the current bit is
4536  // pointing to the END_BLOCK record after them. Now make sure the rest
4537  // of the bits in the module have been read.
4538  if (NextUnreadBit)
4539  parseModule(true);
4540 
4541  // Check that all block address forward references got resolved (as we
4542  // promised above).
4543  if (!BasicBlockFwdRefs.empty())
4544  return error("Never resolved function from blockaddress");
4545 
4546  // Upgrade any intrinsic calls that slipped through (should not happen!) and
4547  // delete the old functions to clean up. We can't do this unless the entire
4548  // module is materialized because there could always be another function body
4549  // with calls to the old function.
4550  for (auto &I : UpgradedIntrinsics) {
4551  for (auto *U : I.first->users()) {
4552  if (CallInst *CI = dyn_cast<CallInst>(U))
4553  UpgradeIntrinsicCall(CI, I.second);
4554  }
4555  if (!I.first->use_empty())
4556  I.first->replaceAllUsesWith(I.second);
4557  I.first->eraseFromParent();
4558  }
4559  UpgradedIntrinsics.clear();
4560 
4561  for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++)
4562  UpgradeInstWithTBAATag(InstsWithTBAATag[I]);
4563 
4564  UpgradeDebugInfo(*M);
4565  return std::error_code();
4566 }
4567 
4568 std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const {
4569  return IdentifiedStructTypes;
4570 }
4571 
4572 std::error_code
4573 BitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) {
4574  if (Streamer)
4575  return initLazyStream(std::move(Streamer));
4576  return initStreamFromBuffer();
4577 }
4578 
4579 std::error_code BitcodeReader::initStreamFromBuffer() {
4580  const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart();
4581  const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
4582 
4583  if (Buffer->getBufferSize() & 3)
4584  return error("Invalid bitcode signature");
4585 
4586  // If we have a wrapper header, parse it and ignore the non-bc file contents.
4587  // The magic number is 0x0B17C0DE stored in little endian.
4588  if (isBitcodeWrapper(BufPtr, BufEnd))
4589  if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
4590  return error("Invalid bitcode wrapper header");
4591 
4592  StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
4593  Stream.init(&*StreamFile);
4594 
4595  return std::error_code();
4596 }
4597 
4598 std::error_code
4599 BitcodeReader::initLazyStream(std::unique_ptr<DataStreamer> Streamer) {
4600  // Check and strip off the bitcode wrapper; BitstreamReader expects never to
4601  // see it.
4602  auto OwnedBytes =
4603  llvm::make_unique<StreamingMemoryObject>(std::move(Streamer));
4604  StreamingMemoryObject &Bytes = *OwnedBytes;
4605  StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
4606  Stream.init(&*StreamFile);
4607 
4608  unsigned char buf[16];
4609  if (Bytes.readBytes(buf, 16, 0) != 16)
4610  return error("Invalid bitcode signature");
4611 
4612  if (!isBitcode(buf, buf + 16))
4613  return error("Invalid bitcode signature");
4614 
4615  if (isBitcodeWrapper(buf, buf + 4)) {
4616  const unsigned char *bitcodeStart = buf;
4617  const unsigned char *bitcodeEnd = buf + 16;
4618  SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
4619  Bytes.dropLeadingBytes(bitcodeStart - buf);
4620  Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
4621  }
4622  return std::error_code();
4623 }
4624 
4625 namespace {
4626 class BitcodeErrorCategoryType : public std::error_category {
4627  const char *name() const LLVM_NOEXCEPT override {
4628  return "llvm.bitcode";
4629  }
4630  std::string message(int IE) const override {
4631  BitcodeError E = static_cast<BitcodeError>(IE);
4632  switch (E) {
4633  case BitcodeError::InvalidBitcodeSignature:
4634  return "Invalid bitcode signature";
4635  case BitcodeError::CorruptedBitcode:
4636  return "Corrupted bitcode";
4637  }
4638  llvm_unreachable("Unknown error type!");
4639  }
4640 };
4641 }
4642 
4644 
4646  return *ErrorCategory;
4647 }
4648 
4649 //===----------------------------------------------------------------------===//
4650 // External interface
4651 //===----------------------------------------------------------------------===//
4652 
4654 getBitcodeModuleImpl(std::unique_ptr<DataStreamer> Streamer, StringRef Name,
4655  BitcodeReader *R, LLVMContext &Context,
4656  bool MaterializeAll, bool ShouldLazyLoadMetadata) {
4657  std::unique_ptr<Module> M = make_unique<Module>(Name, Context);
4658  M->setMaterializer(R);
4659 
4660  auto cleanupOnError = [&](std::error_code EC) {
4661  R->releaseBuffer(); // Never take ownership on error.
4662  return EC;
4663  };
4664 
4665  // Delay parsing Metadata if ShouldLazyLoadMetadata is true.
4666  if (std::error_code EC = R->parseBitcodeInto(std::move(Streamer), M.get(),
4667  ShouldLazyLoadMetadata))
4668  return cleanupOnError(EC);
4669 
4670  if (MaterializeAll) {
4671  // Read in the entire module, and destroy the BitcodeReader.
4672  if (std::error_code EC = M->materializeAllPermanently())
4673  return cleanupOnError(EC);
4674  } else {
4675  // Resolve forward references from blockaddresses.
4676  if (std::error_code EC = R->materializeForwardReferencedFunctions())
4677  return cleanupOnError(EC);
4678  }
4679  return std::move(M);
4680 }
4681 
4682 /// \brief Get a lazy one-at-time loading module from bitcode.
4683 ///
4684 /// This isn't always used in a lazy context. In particular, it's also used by
4685 /// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull
4686 /// in forward-referenced functions from block address references.
4687 ///
4688 /// \param[in] MaterializeAll Set to \c true if we should materialize
4689 /// everything.
4691 getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
4692  LLVMContext &Context, bool MaterializeAll,
4693  DiagnosticHandlerFunction DiagnosticHandler,
4694  bool ShouldLazyLoadMetadata = false) {
4695  BitcodeReader *R =
4696  new BitcodeReader(Buffer.get(), Context, DiagnosticHandler);
4697 
4699  getBitcodeModuleImpl(nullptr, Buffer->getBufferIdentifier(), R, Context,
4700  MaterializeAll, ShouldLazyLoadMetadata);
4701  if (!Ret)
4702  return Ret;
4703 
4704  Buffer.release(); // The BitcodeReader owns it now.
4705  return Ret;
4706 }
4707 
4709  std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
4710  DiagnosticHandlerFunction DiagnosticHandler, bool ShouldLazyLoadMetadata) {
4711  return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false,
4712  DiagnosticHandler, ShouldLazyLoadMetadata);
4713 }
4714 
4716  StringRef Name, std::unique_ptr<DataStreamer> Streamer,
4717  LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler) {
4718  std::unique_ptr<Module> M = make_unique<Module>(Name, Context);
4719  BitcodeReader *R = new BitcodeReader(Context, DiagnosticHandler);
4720 
4721  return getBitcodeModuleImpl(std::move(Streamer), Name, R, Context, false,
4722  false);
4723 }
4724 
4727  DiagnosticHandlerFunction DiagnosticHandler) {
4728  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
4729  return getLazyBitcodeModuleImpl(std::move(Buf), Context, true,
4730  DiagnosticHandler);
4731  // TODO: Restore the use-lists to the in-memory state when the bitcode was
4732  // written. We must defer until the Module has been fully materialized.
4733 }
4734 
4735 std::string
4737  DiagnosticHandlerFunction DiagnosticHandler) {
4738  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
4739  auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context,
4740  DiagnosticHandler);
4741  ErrorOr<std::string> Triple = R->parseTriple();
4742  if (Triple.getError())
4743  return "";
4744  return Triple.get();
4745 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:145
static AtomicOrdering getDecodedOrdering(unsigned Val)
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
const NoneType None
Definition: None.h:23
void setPersonalityFn(Constant *C)
Definition: Function.cpp:1001
void sortUseList(Compare Cmp)
Sort the use-list.
Definition: Value.h:522
static APInt readWideAPInt(ArrayRef< uint64_t > Vals, unsigned TypeBits)
Represents either an error or a value T.
Definition: ErrorOr.h:82
iterator_range< use_iterator > uses()
Definition: Value.h:283
void addIncoming(Value *V, BasicBlock *BB)
addIncoming - Add an incoming value to the end of the PHI list
BLOCKINFO_BLOCK is used to define metadata about blocks, for example, standard abbrevs that should be...
Definition: BitCodes.h:62
LLVM Argument representation.
Definition: Argument.h:35
void setNoSignedZeros()
Definition: Operator.h:198
const Instruction & back() const
Definition: BasicBlock.h:245
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:159
This class is used to read from an LLVM bitcode stream, maintaining information that is global to dec...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
unsigned getNumParams() const
getNumParams - Return the number of fixed parameters this function type requires. ...
Definition: DerivedTypes.h:136
void setNoNaNs()
Flag setters.
Definition: Operator.h:196
FenceInst - an instruction for ordering other memory operations.
Definition: Instructions.h:445
iterator end()
Definition: Function.h:459
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
Tracking metadata reference.
Definition: TrackingMDRef.h:29
static int getDecodedBinaryOpcode(unsigned Val, Type *Ty)
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
void addCase(ConstantInt *OnVal, BasicBlock *Dest)
addCase - Add an entry to the switch instruction...
iterator end() const
Definition: ArrayRef.h:123
void setMaterializer(GVMaterializer *GVM)
Sets the GVMaterializer to GVM.
Definition: Module.cpp:377
void addOperand(MDNode *M)
Definition: Metadata.cpp:971
CallInst - This class represents a function call, abstracting a target machine's calling convention...
void UpgradeMDStringConstant(std::string &String)
Upgrade a metadata string constant in place.
BitcodeError
Definition: ReaderWriter.h:149
float BitsToFloat(uint32_t Bits)
BitsToFloat - This function takes a 32-bit integer and returns the bit equivalent float...
Definition: MathExtras.h:515
ShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors.
bool isDoubleTy() const
isDoubleTy - Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:146
bool isBitcodeWrapper(const unsigned char *BufPtr, const unsigned char *BufEnd)
isBitcodeWrapper - Return true if the given bytes are the magic bytes for an LLVM IR bitcode wrapper...
Definition: ReaderWriter.h:75
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:188
AttrBuilder & addDereferenceableAttr(uint64_t Bytes)
This turns the number of dereferenceable bytes into the form used internally in Attribute.
arg_iterator arg_end()
Definition: Function.h:480
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:740
The two locations do not alias at all.
Definition: AliasAnalysis.h:78
static StringRef getString(const MDString *S)
F(f)
bool stripDebugInfo(Function &F)
Definition: DebugInfo.cpp:314
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:590
static Attribute::AttrKind getAttrFromCode(uint64_t Code)
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
Definition: Instructions.h:674
static std::error_code typeCheckLoadStoreInst(DiagnosticHandlerFunction DH, Type *ValType, Type *PtrType)
void reserve(size_type N)
Definition: SmallVector.h:401
void UpgradeIntrinsicCall(CallInst *CI, Function *NewFn)
This is the complement to the above, replacing a specific call to an intrinsic function with a call t...
void setAlignment(unsigned Align)
Definition: Globals.cpp:77
static bool convertToString(ArrayRef< uint64_t > Record, unsigned Idx, StrTy &Result)
Convert a string from a record into an std::string, return true on failure.
ErrorOr< std::unique_ptr< Module > > getStreamedBitcodeModule(StringRef Name, std::unique_ptr< DataStreamer > Streamer, LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler=nullptr)
Read the header of the specified stream and prepare for lazy deserialization and streaming of functio...
op_iterator op_begin()
Definition: User.h:183
AttrBuilder & addRawValue(uint64_t Val)
Add the raw value to the internal representation.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
bool isMaterializable() const
Definition: Function.cpp:215
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
A tuple of MDNodes.
Definition: Metadata.h:1127
void push_back(NodeTy *val)
Definition: ilist.h:554
AttrBuilder & addDereferenceableOrNullAttr(uint64_t Bytes)
This turns the number of dereferenceable_or_null bytes into the form used internally in Attribute...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
enum llvm::BitstreamEntry::@28 Kind
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:308
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
static ErrorOr< std::unique_ptr< Module > > getBitcodeModuleImpl(std::unique_ptr< DataStreamer > Streamer, StringRef Name, BitcodeReader *R, LLVMContext &Context, bool MaterializeAll, bool ShouldLazyLoadMetadata)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
Array subrange.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
std::error_code make_error_code(BitcodeError E)
Definition: ReaderWriter.h:150
void setMetadata(unsigned KindID, MDNode *MD)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1191
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
SynchronizationScope
Definition: Instructions.h:49
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
Interface for custom diagnostic printing.
#define LLVM_NOEXCEPT
Definition: Compiler.h:70
#define false
Definition: ConvertUTF.c:65
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:173
AtomicOrdering
Definition: Instructions.h:38
static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val)
Subprogram description.
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
ConstantExpr - a constant value that is initialized with an expression using other constant values...
Definition: Constants.h:852
void setCleanup(bool V)
setCleanup - Indicate that this landingpad instruction is a cleanup.
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:125
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
const BasicBlock & back() const
Definition: Function.h:466
BinOp
This enumeration lists the possible modifications atomicrmw can make.
Definition: Instructions.h:686
bool isHalfTy() const
isHalfTy - Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:140
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:141
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:54
bool empty() const
Definition: BasicBlock.h:242
Enumeration value.
This instruction compares its operands according to the predicate given to the constructor.
void setComdat(Comdat *C)
Definition: GlobalObject.h:63
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:327
bool UpgradeIntrinsicFunction(Function *F, Function *&NewFn)
This is a more granular function that simply checks an intrinsic function for upgrading, and returns true if it requires upgrading.
Interface to data which is actually streamed from a DataStreamer.
static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, std::error_code EC, const Twine &Message)
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
bool isArrayTy() const
isArrayTy - True if this is an instance of ArrayType.
Definition: Type.h:213
unsigned getNumElements() const
Return the number of elements in the Vector type.
Definition: DerivedTypes.h:432
Debug location.
iterator begin()
Definition: Function.h:457
bool isPPC_FP128Ty() const
isPPC_FP128Ty - Return true if this is powerpc long double.
Definition: Type.h:155
Type * getElementType() const
Definition: DerivedTypes.h:323
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
static GlobalValue::DLLStorageClassTypes getDecodedDLLStorageClass(unsigned Val)
const std::error_category & BitcodeErrorCategory()
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
BitcodeDiagnosticInfo(std::error_code EC, DiagnosticSeverity Severity, const Twine &Msg)
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:75
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:175
bool isIntOrIntVectorTy() const
isIntOrIntVectorTy - Return true if this is an integer type or a vector of integer types...
Definition: Type.h:201
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:131
This is the base abstract class for diagnostic reporting in the backend.
LandingPadInst - The landingpad instruction holds all of the information necessary to generate correc...
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
UnreachableInst - This function has undefined behavior.
This is an important base class in LLVM.
Definition: Constant.h:41
static bool hasImplicitComdat(size_t Val)
This represents a position within a bitcode file.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
ErrorOr< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler=nullptr)
Read the specified bitcode file, returning the module.
void setUsedWithInAlloca(bool V)
Specify whether this alloca is used to represent the arguments to a call.
Definition: Instructions.h:149
IndirectBrInst - Indirect Branch Instruction.
bool isFloatTy() const
isFloatTy - Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:143
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
Metadata * get() const
Definition: TrackingMDRef.h:58
bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1900
bool hasPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.h:132
void setUnsafeAlgebra()
Definition: Operator.h:200
static ManagedStatic< _object_error_category > error_category
op_iterator op_end()
Definition: User.h:185
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
This instruction compares its operands according to the predicate given to the constructor.
iterator begin() const
Definition: ArrayRef.h:122
void addClause(Constant *ClauseVal)
Add a catch or filter clause to the landing pad.
DLLStorageClassTypes
Storage classes of global values for PE targets.
Definition: GlobalValue.h:61
static ErrorOr< std::unique_ptr< Module > > getLazyBitcodeModuleImpl(std::unique_ptr< MemoryBuffer > &&Buffer, LLVMContext &Context, bool MaterializeAll, DiagnosticHandlerFunction DiagnosticHandler, bool ShouldLazyLoadMetadata=false)
Get a lazy one-at-time loading module from bitcode.
arg_iterator arg_begin()
Definition: Function.h:472
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)
Macro for generating in-class operand accessor declarations.
bool isFP128Ty() const
isFP128Ty - Return true if this is 'fp128'.
Definition: Type.h:152
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
bool isFPOrFPVectorTy() const
isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP.
Definition: Type.h:183
static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val)
void setBody(ArrayRef< Type * > Elements, bool isPacked=false)
setBody - Specify a body for an opaque identified type.
Definition: Type.cpp:424
void setMetadata(unsigned KindID, MDNode *Node)
setMetadata - Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1083
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
An imported module (C++ using directive or similar).
static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val)
#define GET_OR_DISTINCT(CLASS, DISTINCT, ARGS)
Instruction * UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy, Instruction *&Temp)
This is an auto-upgrade for bitcast between pointers with different address spaces: the instruction i...
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
void setSelectionKind(SelectionKind Val)
Definition: Comdat.h:43
void setAllowReciprocal()
Definition: Operator.h:199
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
bool UpgradeGlobalVariable(GlobalVariable *GV)
This checks for global variables which should be upgraded.
bool isBitcode(const unsigned char *BufPtr, const unsigned char *BufEnd)
isBitcode - Return true if the given bytes are the magic bytes for LLVM IR bitcode, either with or without a wrapper.
Definition: ReaderWriter.h:103
AddressSpace
Definition: NVPTXBaseInfo.h:22
void print(DiagnosticPrinter &DP) const override
Print using the given DP a user-friendly message.
void setUnnamedAddr(bool Val)
Definition: GlobalValue.h:131
std::function< void(const DiagnosticInfo &)> DiagnosticHandlerFunction
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:320
static SynchronizationScope getDecodedSynchScope(unsigned Val)
bool any() const
Whether any flag is set.
Definition: Operator.h:183
std::string getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler=nullptr)
Read the header of the specified bitcode buffer and extract just the triple information.
static cl::opt< AlignMode > Align(cl::desc("Load/store alignment support"), cl::Hidden, cl::init(NoStrictAlign), cl::values(clEnumValN(StrictAlign,"aarch64-strict-align","Disallow all unaligned memory accesses"), clEnumValN(NoStrictAlign,"aarch64-no-strict-align","Allow unaligned memory accesses"), clEnumValEnd))
DWARF expression.
double BitsToDouble(uint64_t Bits)
BitsToDouble - This function takes a 64-bit integer and returns the bit equivalent double...
Definition: MathExtras.h:504
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:284
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:37
static int64_t unrotateSign(uint64_t U)
static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val)
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
Class for arbitrary precision integers.
Definition: APInt.h:73
ConstantArray - Constant Array Declarations.
Definition: Constants.h:356
static int getDecodedCastOpcode(unsigned Val)
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:39
A (clang) module that has been imported by the compile unit.
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
iterator_range< user_iterator > users()
Definition: Value.h:300
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
void setGC(const char *Str)
Definition: Function.cpp:390
bool empty() const
Definition: Function.h:463
Generic tagged DWARF-like metadata node.
void setIsMaterializable(bool V)
Definition: Function.cpp:219
const Type * getScalarType() const LLVM_READONLY
getScalarType - If this is a vector type, return the element type, otherwise return 'this'...
Definition: Type.cpp:51
static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F, LLVMContext &C)
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1890
bool isStructTy() const
isStructTy - True if this is an instance of StructType.
Definition: Type.h:209
Type array for a subprogram.
void setName(StringRef Name)
setName - Change the name of this type to the specified name, or to a name with a suffix if there is ...
Definition: Type.cpp:439
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val)
bool isX86_FP80Ty() const
isX86_FP80Ty - Return true if this is x86 long double.
Definition: Type.h:149
ValID - Represents a reference of a definition of some sort with no type.
Definition: LLParser.h:47
bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr, const unsigned char *&BufEnd, bool VerifyBufferSize)
SkipBitcodeWrapperHeader - Some systems wrap bc files with a special header for padding or other reas...
Definition: ReaderWriter.h:125
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
Constant * getPersonalityFn() const
Definition: Function.h:133
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
Compile-time customization of User operands.
Definition: User.h:34
void size_t size
void destroyConstant()
Called if some element of this constant is no longer valid.
Definition: Constants.cpp:279
uint64_t getArrayNumElements() const
Definition: Type.cpp:208
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
AttributeSet getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
void setAttributes(AttributeSet attrs)
Set the attribute list for this Function.
Definition: Function.h:184
static void upgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val)
bool hasLocalLinkage() const
Definition: GlobalValue.h:280
void addDestination(BasicBlock *Dest)
addDestination - Add a destination.
bool isVarArg() const
Definition: DerivedTypes.h:120
SwitchInst - Multiway switch.
static void decodeLLVMAttributesForBitcode(AttrBuilder &B, uint64_t EncodedAttrs)
This fills an AttrBuilder object with the LLVM attributes that have been decoded from the given integ...
user_iterator user_begin()
Definition: Value.h:294
const ARM::ArchExtKind Kind
StringMapEntry< Value * > ValueName
Definition: Value.h:49
aarch64 promote const
bool isLabelTy() const
isLabelTy - Return true if this is 'label'.
Definition: Type.h:186
LLVM Value Representation.
Definition: Value.h:69
static const char * name
ErrorOr< std::unique_ptr< Module > > getLazyBitcodeModule(std::unique_ptr< MemoryBuffer > &&Buffer, LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler=nullptr, bool ShouldLazyLoadMetadata=false)
Read the header of the specified bitcode buffer and prepare for lazy deserialization of function bodi...
AttrBuilder & addStackAlignmentAttr(unsigned Align)
This turns an int stack alignment (which must be a power of 2) into the form used internally in Attri...
void UpgradeInstWithTBAATag(Instruction *I)
If the TBAA tag for the given instruction uses the scalar TBAA format, we upgrade it to the struct-pa...
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool isPowerOf2_32(uint32_t Value)
isPowerOf2_32 - This function returns true if the argument is a power of two > 0. ...
Definition: MathExtras.h:354
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:164
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
static ManagedStatic< BitcodeErrorCategoryType > ErrorCategory
A single uniqued string.
Definition: Metadata.h:508
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:31
AttrBuilder & addAlignmentAttr(unsigned Align)
This turns an int alignment (which must be a power of 2) into the form used internally in Attribute...
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
Value * UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy)
This is an auto-upgrade for bitcast constant expression between pointers with different address space...
Root of the metadata hierarchy.
Definition: Metadata.h:45
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
Definition: APInt.h:1069
void setSection(StringRef S)
Definition: Globals.cpp:126
void setAliasee(Constant *Aliasee)
These methods retrive and set alias target.
Definition: Globals.cpp:281
TLM
Definition: LLParser.cpp:1199
reference get()
Definition: ErrorOr.h:175
static FastMathFlags getDecodedFastMathFlags(unsigned Val)
ArrayRef< Type * > subtypes() const
Definition: Type.h:316
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:137
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:64
Basic type, like 'int' or 'float'.
bool isMetadataTy() const
isMetadataTy - Return true if this is 'metadata'.
Definition: Type.h:189