LLVM  10.0.0svn
BitcodeReader.cpp
Go to the documentation of this file.
1 //===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "MetadataLoader.h"
11 #include "ValueList.h"
12 #include "llvm/ADT/APFloat.h"
13 #include "llvm/ADT/APInt.h"
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/DenseMap.h"
16 #include "llvm/ADT/Optional.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallString.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/ADT/Twine.h"
25 #include "llvm/Config/llvm-config.h"
26 #include "llvm/IR/Argument.h"
27 #include "llvm/IR/Attributes.h"
28 #include "llvm/IR/AutoUpgrade.h"
29 #include "llvm/IR/BasicBlock.h"
30 #include "llvm/IR/CallSite.h"
31 #include "llvm/IR/CallingConv.h"
32 #include "llvm/IR/Comdat.h"
33 #include "llvm/IR/Constant.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DataLayout.h"
36 #include "llvm/IR/DebugInfo.h"
38 #include "llvm/IR/DebugLoc.h"
39 #include "llvm/IR/DerivedTypes.h"
40 #include "llvm/IR/Function.h"
41 #include "llvm/IR/GVMaterializer.h"
42 #include "llvm/IR/GlobalAlias.h"
43 #include "llvm/IR/GlobalIFunc.h"
45 #include "llvm/IR/GlobalObject.h"
46 #include "llvm/IR/GlobalValue.h"
47 #include "llvm/IR/GlobalVariable.h"
48 #include "llvm/IR/InlineAsm.h"
49 #include "llvm/IR/InstIterator.h"
50 #include "llvm/IR/InstrTypes.h"
51 #include "llvm/IR/Instruction.h"
52 #include "llvm/IR/Instructions.h"
53 #include "llvm/IR/Intrinsics.h"
54 #include "llvm/IR/LLVMContext.h"
55 #include "llvm/IR/Metadata.h"
56 #include "llvm/IR/Module.h"
58 #include "llvm/IR/Operator.h"
59 #include "llvm/IR/Type.h"
60 #include "llvm/IR/Value.h"
61 #include "llvm/IR/Verifier.h"
63 #include "llvm/Support/Casting.h"
65 #include "llvm/Support/Compiler.h"
66 #include "llvm/Support/Debug.h"
67 #include "llvm/Support/Error.h"
69 #include "llvm/Support/ErrorOr.h"
74 #include <algorithm>
75 #include <cassert>
76 #include <cstddef>
77 #include <cstdint>
78 #include <deque>
79 #include <map>
80 #include <memory>
81 #include <set>
82 #include <string>
83 #include <system_error>
84 #include <tuple>
85 #include <utility>
86 #include <vector>
87 
88 using namespace llvm;
89 
91  "print-summary-global-ids", cl::init(false), cl::Hidden,
92  cl::desc(
93  "Print the global id for each value when reading the module summary"));
94 
95 namespace {
96 
97 enum {
98  SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
99 };
100 
101 } // end anonymous namespace
102 
103 static Error error(const Twine &Message) {
104  return make_error<StringError>(
106 }
107 
109  if (!Stream.canSkipToPos(4))
110  return createStringError(std::errc::illegal_byte_sequence,
111  "file too small to contain bitcode header");
112  for (unsigned C : {'B', 'C'})
113  if (Expected<SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {
114  if (Res.get() != C)
115  return createStringError(std::errc::illegal_byte_sequence,
116  "file doesn't start with bitcode header");
117  } else
118  return Res.takeError();
119  for (unsigned C : {0x0, 0xC, 0xE, 0xD})
120  if (Expected<SimpleBitstreamCursor::word_t> Res = Stream.Read(4)) {
121  if (Res.get() != C)
122  return createStringError(std::errc::illegal_byte_sequence,
123  "file doesn't start with bitcode header");
124  } else
125  return Res.takeError();
126  return Error::success();
127 }
128 
130  const unsigned char *BufPtr = (const unsigned char *)Buffer.getBufferStart();
131  const unsigned char *BufEnd = BufPtr + Buffer.getBufferSize();
132 
133  if (Buffer.getBufferSize() & 3)
134  return error("Invalid bitcode signature");
135 
136  // If we have a wrapper header, parse it and ignore the non-bc file contents.
137  // The magic number is 0x0B17C0DE stored in little endian.
138  if (isBitcodeWrapper(BufPtr, BufEnd))
139  if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
140  return error("Invalid bitcode wrapper header");
141 
142  BitstreamCursor Stream(ArrayRef<uint8_t>(BufPtr, BufEnd));
143  if (Error Err = hasInvalidBitcodeHeader(Stream))
144  return std::move(Err);
145 
146  return std::move(Stream);
147 }
148 
149 /// Convert a string from a record into an std::string, return true on failure.
150 template <typename StrTy>
151 static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx,
152  StrTy &Result) {
153  if (Idx > Record.size())
154  return true;
155 
156  for (unsigned i = Idx, e = Record.size(); i != e; ++i)
157  Result += (char)Record[i];
158  return false;
159 }
160 
161 // Strip all the TBAA attachment for the module.
162 static void stripTBAA(Module *M) {
163  for (auto &F : *M) {
164  if (F.isMaterializable())
165  continue;
166  for (auto &I : instructions(F))
167  I.setMetadata(LLVMContext::MD_tbaa, nullptr);
168  }
169 }
170 
171 /// Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the
172 /// "epoch" encoded in the bitcode, and return the producer name if any.
175  return std::move(Err);
176 
177  // Read all the records.
179 
180  std::string ProducerIdentification;
181 
182  while (true) {
184  if (Expected<BitstreamEntry> Res = Stream.advance())
185  Entry = Res.get();
186  else
187  return Res.takeError();
188 
189  switch (Entry.Kind) {
190  default:
192  return error("Malformed block");
194  return ProducerIdentification;
196  // The interesting case.
197  break;
198  }
199 
200  // Read a record.
201  Record.clear();
202  Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
203  if (!MaybeBitCode)
204  return MaybeBitCode.takeError();
205  switch (MaybeBitCode.get()) {
206  default: // Default behavior: reject
207  return error("Invalid value");
208  case bitc::IDENTIFICATION_CODE_STRING: // IDENTIFICATION: [strchr x N]
209  convertToString(Record, 0, ProducerIdentification);
210  break;
211  case bitc::IDENTIFICATION_CODE_EPOCH: { // EPOCH: [epoch#]
212  unsigned epoch = (unsigned)Record[0];
213  if (epoch != bitc::BITCODE_CURRENT_EPOCH) {
214  return error(
215  Twine("Incompatible epoch: Bitcode '") + Twine(epoch) +
216  "' vs current: '" + Twine(bitc::BITCODE_CURRENT_EPOCH) + "'");
217  }
218  }
219  }
220  }
221 }
222 
224  // We expect a number of well-defined blocks, though we don't necessarily
225  // need to understand them all.
226  while (true) {
227  if (Stream.AtEndOfStream())
228  return "";
229 
231  if (Expected<BitstreamEntry> Res = Stream.advance())
232  Entry = std::move(Res.get());
233  else
234  return Res.takeError();
235 
236  switch (Entry.Kind) {
239  return error("Malformed block");
240 
242  if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID)
243  return readIdentificationBlock(Stream);
244 
245  // Ignore other sub-blocks.
246  if (Error Err = Stream.SkipBlock())
247  return std::move(Err);
248  continue;
250  if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
251  continue;
252  else
253  return Skipped.takeError();
254  }
255  }
256 }
257 
259  if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
260  return std::move(Err);
261 
263  // Read all the records for this module.
264 
265  while (true) {
267  if (!MaybeEntry)
268  return MaybeEntry.takeError();
269  BitstreamEntry Entry = MaybeEntry.get();
270 
271  switch (Entry.Kind) {
272  case BitstreamEntry::SubBlock: // Handled for us already.
274  return error("Malformed block");
276  return false;
278  // The interesting case.
279  break;
280  }
281 
282  // Read a record.
283  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
284  if (!MaybeRecord)
285  return MaybeRecord.takeError();
286  switch (MaybeRecord.get()) {
287  default:
288  break; // Default behavior, ignore unknown content.
289  case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
290  std::string S;
291  if (convertToString(Record, 0, S))
292  return error("Invalid record");
293  // Check for the i386 and other (x86_64, ARM) conventions
294  if (S.find("__DATA,__objc_catlist") != std::string::npos ||
295  S.find("__OBJC,__category") != std::string::npos)
296  return true;
297  break;
298  }
299  }
300  Record.clear();
301  }
302  llvm_unreachable("Exit infinite loop");
303 }
304 
306  // We expect a number of well-defined blocks, though we don't necessarily
307  // need to understand them all.
308  while (true) {
310  if (Expected<BitstreamEntry> Res = Stream.advance())
311  Entry = std::move(Res.get());
312  else
313  return Res.takeError();
314 
315  switch (Entry.Kind) {
317  return error("Malformed block");
319  return false;
320 
322  if (Entry.ID == bitc::MODULE_BLOCK_ID)
323  return hasObjCCategoryInModule(Stream);
324 
325  // Ignore other sub-blocks.
326  if (Error Err = Stream.SkipBlock())
327  return std::move(Err);
328  continue;
329 
331  if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
332  continue;
333  else
334  return Skipped.takeError();
335  }
336  }
337 }
338 
340  if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
341  return std::move(Err);
342 
344 
345  std::string Triple;
346 
347  // Read all the records for this module.
348  while (true) {
350  if (!MaybeEntry)
351  return MaybeEntry.takeError();
352  BitstreamEntry Entry = MaybeEntry.get();
353 
354  switch (Entry.Kind) {
355  case BitstreamEntry::SubBlock: // Handled for us already.
357  return error("Malformed block");
359  return Triple;
361  // The interesting case.
362  break;
363  }
364 
365  // Read a record.
366  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
367  if (!MaybeRecord)
368  return MaybeRecord.takeError();
369  switch (MaybeRecord.get()) {
370  default: break; // Default behavior, ignore unknown content.
371  case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
372  std::string S;
373  if (convertToString(Record, 0, S))
374  return error("Invalid record");
375  Triple = S;
376  break;
377  }
378  }
379  Record.clear();
380  }
381  llvm_unreachable("Exit infinite loop");
382 }
383 
385  // We expect a number of well-defined blocks, though we don't necessarily
386  // need to understand them all.
387  while (true) {
388  Expected<BitstreamEntry> MaybeEntry = Stream.advance();
389  if (!MaybeEntry)
390  return MaybeEntry.takeError();
391  BitstreamEntry Entry = MaybeEntry.get();
392 
393  switch (Entry.Kind) {
395  return error("Malformed block");
397  return "";
398 
400  if (Entry.ID == bitc::MODULE_BLOCK_ID)
401  return readModuleTriple(Stream);
402 
403  // Ignore other sub-blocks.
404  if (Error Err = Stream.SkipBlock())
405  return std::move(Err);
406  continue;
407 
409  if (llvm::Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
410  continue;
411  else
412  return Skipped.takeError();
413  }
414  }
415 }
416 
417 namespace {
418 
419 class BitcodeReaderBase {
420 protected:
421  BitcodeReaderBase(BitstreamCursor Stream, StringRef Strtab)
422  : Stream(std::move(Stream)), Strtab(Strtab) {
423  this->Stream.setBlockInfo(&BlockInfo);
424  }
425 
426  BitstreamBlockInfo BlockInfo;
427  BitstreamCursor Stream;
428  StringRef Strtab;
429 
430  /// In version 2 of the bitcode we store names of global values and comdats in
431  /// a string table rather than in the VST.
432  bool UseStrtab = false;
433 
434  Expected<unsigned> parseVersionRecord(ArrayRef<uint64_t> Record);
435 
436  /// If this module uses a string table, pop the reference to the string table
437  /// and return the referenced string and the rest of the record. Otherwise
438  /// just return the record itself.
439  std::pair<StringRef, ArrayRef<uint64_t>>
440  readNameFromStrtab(ArrayRef<uint64_t> Record);
441 
442  bool readBlockInfo();
443 
444  // Contains an arbitrary and optional string identifying the bitcode producer
445  std::string ProducerIdentification;
446 
447  Error error(const Twine &Message);
448 };
449 
450 } // end anonymous namespace
451 
452 Error BitcodeReaderBase::error(const Twine &Message) {
453  std::string FullMsg = Message.str();
454  if (!ProducerIdentification.empty())
455  FullMsg += " (Producer: '" + ProducerIdentification + "' Reader: 'LLVM " +
456  LLVM_VERSION_STRING "')";
457  return ::error(FullMsg);
458 }
459 
461 BitcodeReaderBase::parseVersionRecord(ArrayRef<uint64_t> Record) {
462  if (Record.empty())
463  return error("Invalid record");
464  unsigned ModuleVersion = Record[0];
465  if (ModuleVersion > 2)
466  return error("Invalid value");
467  UseStrtab = ModuleVersion >= 2;
468  return ModuleVersion;
469 }
470 
471 std::pair<StringRef, ArrayRef<uint64_t>>
472 BitcodeReaderBase::readNameFromStrtab(ArrayRef<uint64_t> Record) {
473  if (!UseStrtab)
474  return {"", Record};
475  // Invalid reference. Let the caller complain about the record being empty.
476  if (Record[0] + Record[1] > Strtab.size())
477  return {"", {}};
478  return {StringRef(Strtab.data() + Record[0], Record[1]), Record.slice(2)};
479 }
480 
481 namespace {
482 
483 class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
485  Module *TheModule = nullptr;
486  // Next offset to start scanning for lazy parsing of function bodies.
487  uint64_t NextUnreadBit = 0;
488  // Last function offset found in the VST.
489  uint64_t LastFunctionBlockBit = 0;
490  bool SeenValueSymbolTable = false;
491  uint64_t VSTOffset = 0;
492 
493  std::vector<std::string> SectionTable;
494  std::vector<std::string> GCTable;
495 
496  std::vector<Type*> TypeList;
498  BitcodeReaderValueList ValueList;
499  Optional<MetadataLoader> MDLoader;
500  std::vector<Comdat *> ComdatList;
501  SmallVector<Instruction *, 64> InstructionList;
502 
503  std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInits;
504  std::vector<std::pair<GlobalIndirectSymbol *, unsigned>> IndirectSymbolInits;
505  std::vector<std::pair<Function *, unsigned>> FunctionPrefixes;
506  std::vector<std::pair<Function *, unsigned>> FunctionPrologues;
507  std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFns;
508 
509  /// The set of attributes by index. Index zero in the file is for null, and
510  /// is thus not represented here. As such all indices are off by one.
511  std::vector<AttributeList> MAttributes;
512 
513  /// The set of attribute groups.
514  std::map<unsigned, AttributeList> MAttributeGroups;
515 
516  /// While parsing a function body, this is a list of the basic blocks for the
517  /// function.
518  std::vector<BasicBlock*> FunctionBBs;
519 
520  // When reading the module header, this list is populated with functions that
521  // have bodies later in the file.
522  std::vector<Function*> FunctionsWithBodies;
523 
524  // When intrinsic functions are encountered which require upgrading they are
525  // stored here with their replacement function.
526  using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
527  UpdatedIntrinsicMap UpgradedIntrinsics;
528  // Intrinsics which were remangled because of types rename
529  UpdatedIntrinsicMap RemangledIntrinsics;
530 
531  // Several operations happen after the module header has been read, but
532  // before function bodies are processed. This keeps track of whether
533  // we've done this yet.
534  bool SeenFirstFunctionBody = false;
535 
536  /// When function bodies are initially scanned, this map contains info about
537  /// where to find deferred function body in the stream.
538  DenseMap<Function*, uint64_t> DeferredFunctionInfo;
539 
540  /// When Metadata block is initially scanned when parsing the module, we may
541  /// choose to defer parsing of the metadata. This vector contains info about
542  /// which Metadata blocks are deferred.
543  std::vector<uint64_t> DeferredMetadataInfo;
544 
545  /// These are basic blocks forward-referenced by block addresses. They are
546  /// inserted lazily into functions when they're loaded. The basic block ID is
547  /// its index into the vector.
549  std::deque<Function *> BasicBlockFwdRefQueue;
550 
551  /// Indicates that we are using a new encoding for instruction operands where
552  /// most operands in the current FUNCTION_BLOCK are encoded relative to the
553  /// instruction number, for a more compact encoding. Some instruction
554  /// operands are not relative to the instruction ID: basic block numbers, and
555  /// types. Once the old style function blocks have been phased out, we would
556  /// not need this flag.
557  bool UseRelativeIDs = false;
558 
559  /// True if all functions will be materialized, negating the need to process
560  /// (e.g.) blockaddress forward references.
561  bool WillMaterializeAllForwardRefs = false;
562 
563  bool StripDebugInfo = false;
564  TBAAVerifier TBAAVerifyHelper;
565 
566  std::vector<std::string> BundleTags;
568 
569 public:
570  BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
571  StringRef ProducerIdentification, LLVMContext &Context);
572 
573  Error materializeForwardReferencedFunctions();
574 
575  Error materialize(GlobalValue *GV) override;
576  Error materializeModule() override;
577  std::vector<StructType *> getIdentifiedStructTypes() const override;
578 
579  /// Main interface to parsing a bitcode buffer.
580  /// \returns true if an error occurred.
581  Error parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata = false,
582  bool IsImporting = false);
583 
584  static uint64_t decodeSignRotatedValue(uint64_t V);
585 
586  /// Materialize any deferred Metadata block.
587  Error materializeMetadata() override;
588 
589  void setStripDebugInfo() override;
590 
591 private:
592  std::vector<StructType *> IdentifiedStructTypes;
593  StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
594  StructType *createIdentifiedStructType(LLVMContext &Context);
595 
596  /// Map all pointer types within \param Ty to the opaque pointer
597  /// type in the same address space if opaque pointers are being
598  /// used, otherwise nop. This converts a bitcode-reader internal
599  /// type into one suitable for use in a Value.
600  Type *flattenPointerTypes(Type *Ty) {
601  return Ty;
602  }
603 
604  /// Given a fully structured pointer type (i.e. not opaque), return
605  /// the flattened form of its element, suitable for use in a Value.
606  Type *getPointerElementFlatType(Type *Ty) {
607  return flattenPointerTypes(cast<PointerType>(Ty)->getElementType());
608  }
609 
610  /// Given a fully structured pointer type, get its element type in
611  /// both fully structured form, and flattened form suitable for use
612  /// in a Value.
613  std::pair<Type *, Type *> getPointerElementTypes(Type *FullTy) {
614  Type *ElTy = cast<PointerType>(FullTy)->getElementType();
615  return std::make_pair(ElTy, flattenPointerTypes(ElTy));
616  }
617 
618  /// Return the flattened type (suitable for use in a Value)
619  /// specified by the given \param ID .
620  Type *getTypeByID(unsigned ID) {
621  return flattenPointerTypes(getFullyStructuredTypeByID(ID));
622  }
623 
624  /// Return the fully structured (bitcode-reader internal) type
625  /// corresponding to the given \param ID .
626  Type *getFullyStructuredTypeByID(unsigned ID);
627 
628  Value *getFnValueByID(unsigned ID, Type *Ty, Type **FullTy = nullptr) {
629  if (Ty && Ty->isMetadataTy())
630  return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
631  return ValueList.getValueFwdRef(ID, Ty, FullTy);
632  }
633 
634  Metadata *getFnMetadataByID(unsigned ID) {
635  return MDLoader->getMetadataFwdRefOrLoad(ID);
636  }
637 
638  BasicBlock *getBasicBlock(unsigned ID) const {
639  if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
640  return FunctionBBs[ID];
641  }
642 
643  AttributeList getAttributes(unsigned i) const {
644  if (i-1 < MAttributes.size())
645  return MAttributes[i-1];
646  return AttributeList();
647  }
648 
649  /// Read a value/type pair out of the specified record from slot 'Slot'.
650  /// Increment Slot past the number of slots used in the record. Return true on
651  /// failure.
652  bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
653  unsigned InstNum, Value *&ResVal,
654  Type **FullTy = nullptr) {
655  if (Slot == Record.size()) return true;
656  unsigned ValNo = (unsigned)Record[Slot++];
657  // Adjust the ValNo, if it was encoded relative to the InstNum.
658  if (UseRelativeIDs)
659  ValNo = InstNum - ValNo;
660  if (ValNo < InstNum) {
661  // If this is not a forward reference, just return the value we already
662  // have.
663  ResVal = getFnValueByID(ValNo, nullptr, FullTy);
664  return ResVal == nullptr;
665  }
666  if (Slot == Record.size())
667  return true;
668 
669  unsigned TypeNo = (unsigned)Record[Slot++];
670  ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
671  if (FullTy)
672  *FullTy = getFullyStructuredTypeByID(TypeNo);
673  return ResVal == nullptr;
674  }
675 
676  /// Read a value out of the specified record from slot 'Slot'. Increment Slot
677  /// past the number of slots used by the value in the record. Return true if
678  /// there is an error.
679  bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
680  unsigned InstNum, Type *Ty, Value *&ResVal) {
681  if (getValue(Record, Slot, InstNum, Ty, ResVal))
682  return true;
683  // All values currently take a single record slot.
684  ++Slot;
685  return false;
686  }
687 
688  /// Like popValue, but does not increment the Slot number.
689  bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
690  unsigned InstNum, Type *Ty, Value *&ResVal) {
691  ResVal = getValue(Record, Slot, InstNum, Ty);
692  return ResVal == nullptr;
693  }
694 
695  /// Version of getValue that returns ResVal directly, or 0 if there is an
696  /// error.
697  Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
698  unsigned InstNum, Type *Ty) {
699  if (Slot == Record.size()) return nullptr;
700  unsigned ValNo = (unsigned)Record[Slot];
701  // Adjust the ValNo, if it was encoded relative to the InstNum.
702  if (UseRelativeIDs)
703  ValNo = InstNum - ValNo;
704  return getFnValueByID(ValNo, Ty);
705  }
706 
707  /// Like getValue, but decodes signed VBRs.
708  Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
709  unsigned InstNum, Type *Ty) {
710  if (Slot == Record.size()) return nullptr;
711  unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
712  // Adjust the ValNo, if it was encoded relative to the InstNum.
713  if (UseRelativeIDs)
714  ValNo = InstNum - ValNo;
715  return getFnValueByID(ValNo, Ty);
716  }
717 
718  /// Upgrades old-style typeless byval attributes by adding the corresponding
719  /// argument's pointee type.
720  void propagateByValTypes(CallBase *CB, ArrayRef<Type *> ArgsFullTys);
721 
722  /// Converts alignment exponent (i.e. power of two (or zero)) to the
723  /// corresponding alignment to use. If alignment is too large, returns
724  /// a corresponding error code.
725  Error parseAlignmentValue(uint64_t Exponent, unsigned &Alignment);
726  Error parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
727  Error parseModule(uint64_t ResumeBit, bool ShouldLazyLoadMetadata = false);
728 
729  Error parseComdatRecord(ArrayRef<uint64_t> Record);
730  Error parseGlobalVarRecord(ArrayRef<uint64_t> Record);
731  Error parseFunctionRecord(ArrayRef<uint64_t> Record);
732  Error parseGlobalIndirectSymbolRecord(unsigned BitCode,
733  ArrayRef<uint64_t> Record);
734 
735  Error parseAttributeBlock();
736  Error parseAttributeGroupBlock();
737  Error parseTypeTable();
738  Error parseTypeTableBody();
739  Error parseOperandBundleTags();
740  Error parseSyncScopeNames();
741 
742  Expected<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,
743  unsigned NameIndex, Triple &TT);
744  void setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta, Function *F,
745  ArrayRef<uint64_t> Record);
746  Error parseValueSymbolTable(uint64_t Offset = 0);
747  Error parseGlobalValueSymbolTable();
748  Error parseConstants();
749  Error rememberAndSkipFunctionBodies();
750  Error rememberAndSkipFunctionBody();
751  /// Save the positions of the Metadata blocks and skip parsing the blocks.
752  Error rememberAndSkipMetadata();
753  Error typeCheckLoadStoreInst(Type *ValType, Type *PtrType);
754  Error parseFunctionBody(Function *F);
755  Error globalCleanup();
756  Error resolveGlobalAndIndirectSymbolInits();
757  Error parseUseLists();
758  Error findFunctionInStream(
759  Function *F,
760  DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
761 
762  SyncScope::ID getDecodedSyncScopeID(unsigned Val);
763 };
764 
765 /// Class to manage reading and parsing function summary index bitcode
766 /// files/sections.
767 class ModuleSummaryIndexBitcodeReader : public BitcodeReaderBase {
768  /// The module index built during parsing.
769  ModuleSummaryIndex &TheIndex;
770 
771  /// Indicates whether we have encountered a global value summary section
772  /// yet during parsing.
773  bool SeenGlobalValSummary = false;
774 
775  /// Indicates whether we have already parsed the VST, used for error checking.
776  bool SeenValueSymbolTable = false;
777 
778  /// Set to the offset of the VST recorded in the MODULE_CODE_VSTOFFSET record.
779  /// Used to enable on-demand parsing of the VST.
780  uint64_t VSTOffset = 0;
781 
782  // Map to save ValueId to ValueInfo association that was recorded in the
783  // ValueSymbolTable. It is used after the VST is parsed to convert
784  // call graph edges read from the function summary from referencing
785  // callees by their ValueId to using the ValueInfo instead, which is how
786  // they are recorded in the summary index being built.
787  // We save a GUID which refers to the same global as the ValueInfo, but
788  // ignoring the linkage, i.e. for values other than local linkage they are
789  // identical.
791  ValueIdToValueInfoMap;
792 
793  /// Map populated during module path string table parsing, from the
794  /// module ID to a string reference owned by the index's module
795  /// path string table, used to correlate with combined index
796  /// summary records.
797  DenseMap<uint64_t, StringRef> ModuleIdMap;
798 
799  /// Original source file name recorded in a bitcode record.
800  std::string SourceFileName;
801 
802  /// The string identifier given to this module by the client, normally the
803  /// path to the bitcode file.
804  StringRef ModulePath;
805 
806  /// For per-module summary indexes, the unique numerical identifier given to
807  /// this module by the client.
808  unsigned ModuleId;
809 
810 public:
811  ModuleSummaryIndexBitcodeReader(BitstreamCursor Stream, StringRef Strtab,
812  ModuleSummaryIndex &TheIndex,
813  StringRef ModulePath, unsigned ModuleId);
814 
815  Error parseModule();
816 
817 private:
818  void setValueGUID(uint64_t ValueID, StringRef ValueName,
820  StringRef SourceFileName);
821  Error parseValueSymbolTable(
822  uint64_t Offset,
823  DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);
824  std::vector<ValueInfo> makeRefList(ArrayRef<uint64_t> Record);
825  std::vector<FunctionSummary::EdgeTy> makeCallList(ArrayRef<uint64_t> Record,
826  bool IsOldProfileFormat,
827  bool HasProfile,
828  bool HasRelBF);
829  Error parseEntireSummary(unsigned ID);
830  Error parseModuleStringTable();
831  void parseTypeIdCompatibleVtableSummaryRecord(ArrayRef<uint64_t> Record);
832  void parseTypeIdCompatibleVtableInfo(ArrayRef<uint64_t> Record, size_t &Slot,
834 
835  std::pair<ValueInfo, GlobalValue::GUID>
836  getValueInfoFromValueId(unsigned ValueId);
837 
838  void addThisModule();
839  ModuleSummaryIndex::ModuleInfo *getThisModule();
840 };
841 
842 } // end anonymous namespace
843 
845  Error Err) {
846  if (Err) {
847  std::error_code EC;
848  handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
849  EC = EIB.convertToErrorCode();
850  Ctx.emitError(EIB.message());
851  });
852  return EC;
853  }
854  return std::error_code();
855 }
856 
857 BitcodeReader::BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
858  StringRef ProducerIdentification,
860  : BitcodeReaderBase(std::move(Stream), Strtab), Context(Context),
861  ValueList(Context, Stream.SizeInBytes()) {
862  this->ProducerIdentification = ProducerIdentification;
863 }
864 
865 Error BitcodeReader::materializeForwardReferencedFunctions() {
866  if (WillMaterializeAllForwardRefs)
867  return Error::success();
868 
869  // Prevent recursion.
870  WillMaterializeAllForwardRefs = true;
871 
872  while (!BasicBlockFwdRefQueue.empty()) {
873  Function *F = BasicBlockFwdRefQueue.front();
874  BasicBlockFwdRefQueue.pop_front();
875  assert(F && "Expected valid function");
876  if (!BasicBlockFwdRefs.count(F))
877  // Already materialized.
878  continue;
879 
880  // Check for a function that isn't materializable to prevent an infinite
881  // loop. When parsing a blockaddress stored in a global variable, there
882  // isn't a trivial way to check if a function will have a body without a
883  // linear search through FunctionsWithBodies, so just check it here.
884  if (!F->isMaterializable())
885  return error("Never resolved function from blockaddress");
886 
887  // Try to materialize F.
888  if (Error Err = materialize(F))
889  return Err;
890  }
891  assert(BasicBlockFwdRefs.empty() && "Function missing from queue");
892 
893  // Reset state.
894  WillMaterializeAllForwardRefs = false;
895  return Error::success();
896 }
897 
898 //===----------------------------------------------------------------------===//
899 // Helper functions to implement forward reference resolution, etc.
900 //===----------------------------------------------------------------------===//
901 
902 static bool hasImplicitComdat(size_t Val) {
903  switch (Val) {
904  default:
905  return false;
906  case 1: // Old WeakAnyLinkage
907  case 4: // Old LinkOnceAnyLinkage
908  case 10: // Old WeakODRLinkage
909  case 11: // Old LinkOnceODRLinkage
910  return true;
911  }
912 }
913 
915  switch (Val) {
916  default: // Map unknown/new linkages to external
917  case 0:
919  case 2:
921  case 3:
923  case 5:
924  return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage
925  case 6:
926  return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage
927  case 7:
929  case 8:
931  case 9:
933  case 12:
935  case 13:
936  return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage
937  case 14:
938  return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage
939  case 15:
940  return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage
941  case 1: // Old value with implicit comdat.
942  case 16:
944  case 10: // Old value with implicit comdat.
945  case 17:
947  case 4: // Old value with implicit comdat.
948  case 18:
950  case 11: // Old value with implicit comdat.
951  case 19:
953  }
954 }
955 
956 static FunctionSummary::FFlags getDecodedFFlags(uint64_t RawFlags) {
958  Flags.ReadNone = RawFlags & 0x1;
959  Flags.ReadOnly = (RawFlags >> 1) & 0x1;
960  Flags.NoRecurse = (RawFlags >> 2) & 0x1;
961  Flags.ReturnDoesNotAlias = (RawFlags >> 3) & 0x1;
962  Flags.NoInline = (RawFlags >> 4) & 0x1;
963  return Flags;
964 }
965 
966 /// Decode the flags for GlobalValue in the summary.
968  uint64_t Version) {
969  // Summary were not emitted before LLVM 3.9, we don't need to upgrade Linkage
970  // like getDecodedLinkage() above. Any future change to the linkage enum and
971  // to getDecodedLinkage() will need to be taken into account here as above.
972  auto Linkage = GlobalValue::LinkageTypes(RawFlags & 0xF); // 4 bits
973  RawFlags = RawFlags >> 4;
974  bool NotEligibleToImport = (RawFlags & 0x1) || Version < 3;
975  // The Live flag wasn't introduced until version 3. For dead stripping
976  // to work correctly on earlier versions, we must conservatively treat all
977  // values as live.
978  bool Live = (RawFlags & 0x2) || Version < 3;
979  bool Local = (RawFlags & 0x4);
980  bool AutoHide = (RawFlags & 0x8);
981 
982  return GlobalValueSummary::GVFlags(Linkage, NotEligibleToImport, Live, Local, AutoHide);
983 }
984 
985 // Decode the flags for GlobalVariable in the summary
987  return GlobalVarSummary::GVarFlags((RawFlags & 0x1) ? true : false,
988  (RawFlags & 0x2) ? true : false);
989 }
990 
992  switch (Val) {
993  default: // Map unknown visibilities to default.
994  case 0: return GlobalValue::DefaultVisibility;
995  case 1: return GlobalValue::HiddenVisibility;
996  case 2: return GlobalValue::ProtectedVisibility;
997  }
998 }
999 
1002  switch (Val) {
1003  default: // Map unknown values to default.
1004  case 0: return GlobalValue::DefaultStorageClass;
1005  case 1: return GlobalValue::DLLImportStorageClass;
1006  case 2: return GlobalValue::DLLExportStorageClass;
1007  }
1008 }
1009 
1010 static bool getDecodedDSOLocal(unsigned Val) {
1011  switch(Val) {
1012  default: // Map unknown values to preemptable.
1013  case 0: return false;
1014  case 1: return true;
1015  }
1016 }
1017 
1019  switch (Val) {
1020  case 0: return GlobalVariable::NotThreadLocal;
1021  default: // Map unknown non-zero value to general dynamic.
1023  case 2: return GlobalVariable::LocalDynamicTLSModel;
1024  case 3: return GlobalVariable::InitialExecTLSModel;
1025  case 4: return GlobalVariable::LocalExecTLSModel;
1026  }
1027 }
1028 
1030  switch (Val) {
1031  default: // Map unknown to UnnamedAddr::None.
1032  case 0: return GlobalVariable::UnnamedAddr::None;
1033  case 1: return GlobalVariable::UnnamedAddr::Global;
1034  case 2: return GlobalVariable::UnnamedAddr::Local;
1035  }
1036 }
1037 
1038 static int getDecodedCastOpcode(unsigned Val) {
1039  switch (Val) {
1040  default: return -1;
1041  case bitc::CAST_TRUNC : return Instruction::Trunc;
1042  case bitc::CAST_ZEXT : return Instruction::ZExt;
1043  case bitc::CAST_SEXT : return Instruction::SExt;
1044  case bitc::CAST_FPTOUI : return Instruction::FPToUI;
1045  case bitc::CAST_FPTOSI : return Instruction::FPToSI;
1046  case bitc::CAST_UITOFP : return Instruction::UIToFP;
1047  case bitc::CAST_SITOFP : return Instruction::SIToFP;
1048  case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
1049  case bitc::CAST_FPEXT : return Instruction::FPExt;
1050  case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
1051  case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
1052  case bitc::CAST_BITCAST : return Instruction::BitCast;
1053  case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast;
1054  }
1055 }
1056 
1057 static int getDecodedUnaryOpcode(unsigned Val, Type *Ty) {
1058  bool IsFP = Ty->isFPOrFPVectorTy();
1059  // UnOps are only valid for int/fp or vector of int/fp types
1060  if (!IsFP && !Ty->isIntOrIntVectorTy())
1061  return -1;
1062 
1063  switch (Val) {
1064  default:
1065  return -1;
1066  case bitc::UNOP_NEG:
1067  return IsFP ? Instruction::FNeg : -1;
1068  }
1069 }
1070 
1071 static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) {
1072  bool IsFP = Ty->isFPOrFPVectorTy();
1073  // BinOps are only valid for int/fp or vector of int/fp types
1074  if (!IsFP && !Ty->isIntOrIntVectorTy())
1075  return -1;
1076 
1077  switch (Val) {
1078  default:
1079  return -1;
1080  case bitc::BINOP_ADD:
1081  return IsFP ? Instruction::FAdd : Instruction::Add;
1082  case bitc::BINOP_SUB:
1083  return IsFP ? Instruction::FSub : Instruction::Sub;
1084  case bitc::BINOP_MUL:
1085  return IsFP ? Instruction::FMul : Instruction::Mul;
1086  case bitc::BINOP_UDIV:
1087  return IsFP ? -1 : Instruction::UDiv;
1088  case bitc::BINOP_SDIV:
1089  return IsFP ? Instruction::FDiv : Instruction::SDiv;
1090  case bitc::BINOP_UREM:
1091  return IsFP ? -1 : Instruction::URem;
1092  case bitc::BINOP_SREM:
1093  return IsFP ? Instruction::FRem : Instruction::SRem;
1094  case bitc::BINOP_SHL:
1095  return IsFP ? -1 : Instruction::Shl;
1096  case bitc::BINOP_LSHR:
1097  return IsFP ? -1 : Instruction::LShr;
1098  case bitc::BINOP_ASHR:
1099  return IsFP ? -1 : Instruction::AShr;
1100  case bitc::BINOP_AND:
1101  return IsFP ? -1 : Instruction::And;
1102  case bitc::BINOP_OR:
1103  return IsFP ? -1 : Instruction::Or;
1104  case bitc::BINOP_XOR:
1105  return IsFP ? -1 : Instruction::Xor;
1106  }
1107 }
1108 
1110  switch (Val) {
1111  default: return AtomicRMWInst::BAD_BINOP;
1112  case bitc::RMW_XCHG: return AtomicRMWInst::Xchg;
1113  case bitc::RMW_ADD: return AtomicRMWInst::Add;
1114  case bitc::RMW_SUB: return AtomicRMWInst::Sub;
1115  case bitc::RMW_AND: return AtomicRMWInst::And;
1116  case bitc::RMW_NAND: return AtomicRMWInst::Nand;
1117  case bitc::RMW_OR: return AtomicRMWInst::Or;
1118  case bitc::RMW_XOR: return AtomicRMWInst::Xor;
1119  case bitc::RMW_MAX: return AtomicRMWInst::Max;
1120  case bitc::RMW_MIN: return AtomicRMWInst::Min;
1121  case bitc::RMW_UMAX: return AtomicRMWInst::UMax;
1122  case bitc::RMW_UMIN: return AtomicRMWInst::UMin;
1123  case bitc::RMW_FADD: return AtomicRMWInst::FAdd;
1124  case bitc::RMW_FSUB: return AtomicRMWInst::FSub;
1125  }
1126 }
1127 
1128 static AtomicOrdering getDecodedOrdering(unsigned Val) {
1129  switch (Val) {
1136  default: // Map unknown orderings to sequentially-consistent.
1138  }
1139 }
1140 
1142  switch (Val) {
1143  default: // Map unknown selection kinds to any.
1145  return Comdat::Any;
1147  return Comdat::ExactMatch;
1149  return Comdat::Largest;
1151  return Comdat::NoDuplicates;
1153  return Comdat::SameSize;
1154  }
1155 }
1156 
1158  FastMathFlags FMF;
1159  if (0 != (Val & bitc::UnsafeAlgebra))
1160  FMF.setFast();
1161  if (0 != (Val & bitc::AllowReassoc))
1162  FMF.setAllowReassoc();
1163  if (0 != (Val & bitc::NoNaNs))
1164  FMF.setNoNaNs();
1165  if (0 != (Val & bitc::NoInfs))
1166  FMF.setNoInfs();
1167  if (0 != (Val & bitc::NoSignedZeros))
1168  FMF.setNoSignedZeros();
1169  if (0 != (Val & bitc::AllowReciprocal))
1170  FMF.setAllowReciprocal();
1171  if (0 != (Val & bitc::AllowContract))
1172  FMF.setAllowContract(true);
1173  if (0 != (Val & bitc::ApproxFunc))
1174  FMF.setApproxFunc();
1175  return FMF;
1176 }
1177 
1178 static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val) {
1179  switch (Val) {
1182  }
1183 }
1184 
1185 Type *BitcodeReader::getFullyStructuredTypeByID(unsigned ID) {
1186  // The type table size is always specified correctly.
1187  if (ID >= TypeList.size())
1188  return nullptr;
1189 
1190  if (Type *Ty = TypeList[ID])
1191  return Ty;
1192 
1193  // If we have a forward reference, the only possible case is when it is to a
1194  // named struct. Just create a placeholder for now.
1195  return TypeList[ID] = createIdentifiedStructType(Context);
1196 }
1197 
1198 StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context,
1199  StringRef Name) {
1200  auto *Ret = StructType::create(Context, Name);
1201  IdentifiedStructTypes.push_back(Ret);
1202  return Ret;
1203 }
1204 
1205 StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) {
1206  auto *Ret = StructType::create(Context);
1207  IdentifiedStructTypes.push_back(Ret);
1208  return Ret;
1209 }
1210 
1211 //===----------------------------------------------------------------------===//
1212 // Functions for parsing blocks from the bitcode file
1213 //===----------------------------------------------------------------------===//
1214 
1216  switch (Val) {
1218  llvm_unreachable("Synthetic enumerators which should never get here");
1219 
1220  case Attribute::None: return 0;
1221  case Attribute::ZExt: return 1 << 0;
1222  case Attribute::SExt: return 1 << 1;
1223  case Attribute::NoReturn: return 1 << 2;
1224  case Attribute::InReg: return 1 << 3;
1225  case Attribute::StructRet: return 1 << 4;
1226  case Attribute::NoUnwind: return 1 << 5;
1227  case Attribute::NoAlias: return 1 << 6;
1228  case Attribute::ByVal: return 1 << 7;
1229  case Attribute::Nest: return 1 << 8;
1230  case Attribute::ReadNone: return 1 << 9;
1231  case Attribute::ReadOnly: return 1 << 10;
1232  case Attribute::NoInline: return 1 << 11;
1233  case Attribute::AlwaysInline: return 1 << 12;
1234  case Attribute::OptimizeForSize: return 1 << 13;
1235  case Attribute::StackProtect: return 1 << 14;
1236  case Attribute::StackProtectReq: return 1 << 15;
1237  case Attribute::Alignment: return 31 << 16;
1238  case Attribute::NoCapture: return 1 << 21;
1239  case Attribute::NoRedZone: return 1 << 22;
1240  case Attribute::NoImplicitFloat: return 1 << 23;
1241  case Attribute::Naked: return 1 << 24;
1242  case Attribute::InlineHint: return 1 << 25;
1243  case Attribute::StackAlignment: return 7 << 26;
1244  case Attribute::ReturnsTwice: return 1 << 29;
1245  case Attribute::UWTable: return 1 << 30;
1246  case Attribute::NonLazyBind: return 1U << 31;
1247  case Attribute::SanitizeAddress: return 1ULL << 32;
1248  case Attribute::MinSize: return 1ULL << 33;
1249  case Attribute::NoDuplicate: return 1ULL << 34;
1250  case Attribute::StackProtectStrong: return 1ULL << 35;
1251  case Attribute::SanitizeThread: return 1ULL << 36;
1252  case Attribute::SanitizeMemory: return 1ULL << 37;
1253  case Attribute::NoBuiltin: return 1ULL << 38;
1254  case Attribute::Returned: return 1ULL << 39;
1255  case Attribute::Cold: return 1ULL << 40;
1256  case Attribute::Builtin: return 1ULL << 41;
1257  case Attribute::OptimizeNone: return 1ULL << 42;
1258  case Attribute::InAlloca: return 1ULL << 43;
1259  case Attribute::NonNull: return 1ULL << 44;
1260  case Attribute::JumpTable: return 1ULL << 45;
1261  case Attribute::Convergent: return 1ULL << 46;
1262  case Attribute::SafeStack: return 1ULL << 47;
1263  case Attribute::NoRecurse: return 1ULL << 48;
1264  case Attribute::InaccessibleMemOnly: return 1ULL << 49;
1265  case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50;
1266  case Attribute::SwiftSelf: return 1ULL << 51;
1267  case Attribute::SwiftError: return 1ULL << 52;
1268  case Attribute::WriteOnly: return 1ULL << 53;
1269  case Attribute::Speculatable: return 1ULL << 54;
1270  case Attribute::StrictFP: return 1ULL << 55;
1271  case Attribute::SanitizeHWAddress: return 1ULL << 56;
1272  case Attribute::NoCfCheck: return 1ULL << 57;
1273  case Attribute::OptForFuzzing: return 1ULL << 58;
1274  case Attribute::ShadowCallStack: return 1ULL << 59;
1275  case Attribute::SpeculativeLoadHardening:
1276  return 1ULL << 60;
1277  case Attribute::ImmArg:
1278  return 1ULL << 61;
1279  case Attribute::WillReturn:
1280  return 1ULL << 62;
1281  case Attribute::NoFree:
1282  return 1ULL << 63;
1283  case Attribute::NoSync:
1284  llvm_unreachable("nosync attribute not supported in raw format");
1285  break;
1286  case Attribute::Dereferenceable:
1287  llvm_unreachable("dereferenceable attribute not supported in raw format");
1288  break;
1289  case Attribute::DereferenceableOrNull:
1290  llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
1291  "format");
1292  break;
1293  case Attribute::ArgMemOnly:
1294  llvm_unreachable("argmemonly attribute not supported in raw format");
1295  break;
1296  case Attribute::AllocSize:
1297  llvm_unreachable("allocsize not supported in raw format");
1298  break;
1299  case Attribute::SanitizeMemTag:
1300  llvm_unreachable("sanitize_memtag attribute not supported in raw format");
1301  break;
1302  }
1303  llvm_unreachable("Unsupported attribute type");
1304 }
1305 
1306 static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) {
1307  if (!Val) return;
1308 
1310  I = Attribute::AttrKind(I + 1)) {
1311  if (I == Attribute::SanitizeMemTag ||
1312  I == Attribute::Dereferenceable ||
1313  I == Attribute::DereferenceableOrNull ||
1314  I == Attribute::ArgMemOnly ||
1315  I == Attribute::AllocSize ||
1316  I == Attribute::NoSync)
1317  continue;
1318  if (uint64_t A = (Val & getRawAttributeMask(I))) {
1319  if (I == Attribute::Alignment)
1320  B.addAlignmentAttr(1ULL << ((A >> 16) - 1));
1321  else if (I == Attribute::StackAlignment)
1322  B.addStackAlignmentAttr(1ULL << ((A >> 26)-1));
1323  else
1324  B.addAttribute(I);
1325  }
1326  }
1327 }
1328 
1329 /// This fills an AttrBuilder object with the LLVM attributes that have
1330 /// been decoded from the given integer. This function must stay in sync with
1331 /// 'encodeLLVMAttributesForBitcode'.
1333  uint64_t EncodedAttrs) {
1334  // FIXME: Remove in 4.0.
1335 
1336  // The alignment is stored as a 16-bit raw value from bits 31--16. We shift
1337  // the bits above 31 down by 11 bits.
1338  unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
1339  assert((!Alignment || isPowerOf2_32(Alignment)) &&
1340  "Alignment must be a power of two.");
1341 
1342  if (Alignment)
1343  B.addAlignmentAttr(Alignment);
1344  addRawAttributeValue(B, ((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
1345  (EncodedAttrs & 0xffff));
1346 }
1347 
1348 Error BitcodeReader::parseAttributeBlock() {
1349  if (Error Err = Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
1350  return Err;
1351 
1352  if (!MAttributes.empty())
1353  return error("Invalid multiple blocks");
1354 
1356 
1358 
1359  // Read all the records.
1360  while (true) {
1361  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
1362  if (!MaybeEntry)
1363  return MaybeEntry.takeError();
1364  BitstreamEntry Entry = MaybeEntry.get();
1365 
1366  switch (Entry.Kind) {
1367  case BitstreamEntry::SubBlock: // Handled for us already.
1368  case BitstreamEntry::Error:
1369  return error("Malformed block");
1371  return Error::success();
1373  // The interesting case.
1374  break;
1375  }
1376 
1377  // Read a record.
1378  Record.clear();
1379  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
1380  if (!MaybeRecord)
1381  return MaybeRecord.takeError();
1382  switch (MaybeRecord.get()) {
1383  default: // Default behavior: ignore.
1384  break;
1385  case bitc::PARAMATTR_CODE_ENTRY_OLD: // ENTRY: [paramidx0, attr0, ...]
1386  // FIXME: Remove in 4.0.
1387  if (Record.size() & 1)
1388  return error("Invalid record");
1389 
1390  for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
1391  AttrBuilder B;
1392  decodeLLVMAttributesForBitcode(B, Record[i+1]);
1393  Attrs.push_back(AttributeList::get(Context, Record[i], B));
1394  }
1395 
1396  MAttributes.push_back(AttributeList::get(Context, Attrs));
1397  Attrs.clear();
1398  break;
1399  case bitc::PARAMATTR_CODE_ENTRY: // ENTRY: [attrgrp0, attrgrp1, ...]
1400  for (unsigned i = 0, e = Record.size(); i != e; ++i)
1401  Attrs.push_back(MAttributeGroups[Record[i]]);
1402 
1403  MAttributes.push_back(AttributeList::get(Context, Attrs));
1404  Attrs.clear();
1405  break;
1406  }
1407  }
1408 }
1409 
1410 // Returns Attribute::None on unrecognized codes.
1411 static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
1412  switch (Code) {
1413  default:
1414  return Attribute::None;
1416  return Attribute::Alignment;
1418  return Attribute::AlwaysInline;
1420  return Attribute::ArgMemOnly;
1422  return Attribute::Builtin;
1424  return Attribute::ByVal;
1426  return Attribute::InAlloca;
1427  case bitc::ATTR_KIND_COLD:
1428  return Attribute::Cold;
1430  return Attribute::Convergent;
1432  return Attribute::InaccessibleMemOnly;
1434  return Attribute::InaccessibleMemOrArgMemOnly;
1436  return Attribute::InlineHint;
1438  return Attribute::InReg;
1440  return Attribute::JumpTable;
1442  return Attribute::MinSize;
1443  case bitc::ATTR_KIND_NAKED:
1444  return Attribute::Naked;
1445  case bitc::ATTR_KIND_NEST:
1446  return Attribute::Nest;
1448  return Attribute::NoAlias;
1450  return Attribute::NoBuiltin;
1452  return Attribute::NoCapture;
1454  return Attribute::NoDuplicate;
1456  return Attribute::NoFree;
1458  return Attribute::NoImplicitFloat;
1460  return Attribute::NoInline;
1462  return Attribute::NoRecurse;
1464  return Attribute::NonLazyBind;
1466  return Attribute::NonNull;
1468  return Attribute::Dereferenceable;
1470  return Attribute::DereferenceableOrNull;
1472  return Attribute::AllocSize;
1474  return Attribute::NoRedZone;
1476  return Attribute::NoReturn;
1478  return Attribute::NoSync;
1480  return Attribute::NoCfCheck;
1482  return Attribute::NoUnwind;
1484  return Attribute::OptForFuzzing;
1486  return Attribute::OptimizeForSize;
1488  return Attribute::OptimizeNone;
1490  return Attribute::ReadNone;
1492  return Attribute::ReadOnly;
1494  return Attribute::Returned;
1496  return Attribute::ReturnsTwice;
1497  case bitc::ATTR_KIND_S_EXT:
1498  return Attribute::SExt;
1500  return Attribute::Speculatable;
1502  return Attribute::StackAlignment;
1504  return Attribute::StackProtect;
1506  return Attribute::StackProtectReq;
1508  return Attribute::StackProtectStrong;
1510  return Attribute::SafeStack;
1512  return Attribute::ShadowCallStack;
1514  return Attribute::StrictFP;
1516  return Attribute::StructRet;
1518  return Attribute::SanitizeAddress;
1520  return Attribute::SanitizeHWAddress;
1522  return Attribute::SanitizeThread;
1524  return Attribute::SanitizeMemory;
1526  return Attribute::SpeculativeLoadHardening;
1528  return Attribute::SwiftError;
1530  return Attribute::SwiftSelf;
1532  return Attribute::UWTable;
1534  return Attribute::WillReturn;
1536  return Attribute::WriteOnly;
1537  case bitc::ATTR_KIND_Z_EXT:
1538  return Attribute::ZExt;
1540  return Attribute::ImmArg;
1542  return Attribute::SanitizeMemTag;
1543  }
1544 }
1545 
1546 Error BitcodeReader::parseAlignmentValue(uint64_t Exponent,
1547  unsigned &Alignment) {
1548  // Note: Alignment in bitcode files is incremented by 1, so that zero
1549  // can be used for default alignment.
1550  if (Exponent > Value::MaxAlignmentExponent + 1)
1551  return error("Invalid alignment value");
1552  Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1;
1553  return Error::success();
1554 }
1555 
1557  *Kind = getAttrFromCode(Code);
1558  if (*Kind == Attribute::None)
1559  return error("Unknown attribute kind (" + Twine(Code) + ")");
1560  return Error::success();
1561 }
1562 
1563 Error BitcodeReader::parseAttributeGroupBlock() {
1565  return Err;
1566 
1567  if (!MAttributeGroups.empty())
1568  return error("Invalid multiple blocks");
1569 
1571 
1572  // Read all the records.
1573  while (true) {
1574  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
1575  if (!MaybeEntry)
1576  return MaybeEntry.takeError();
1577  BitstreamEntry Entry = MaybeEntry.get();
1578 
1579  switch (Entry.Kind) {
1580  case BitstreamEntry::SubBlock: // Handled for us already.
1581  case BitstreamEntry::Error:
1582  return error("Malformed block");
1584  return Error::success();
1586  // The interesting case.
1587  break;
1588  }
1589 
1590  // Read a record.
1591  Record.clear();
1592  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
1593  if (!MaybeRecord)
1594  return MaybeRecord.takeError();
1595  switch (MaybeRecord.get()) {
1596  default: // Default behavior: ignore.
1597  break;
1598  case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
1599  if (Record.size() < 3)
1600  return error("Invalid record");
1601 
1602  uint64_t GrpID = Record[0];
1603  uint64_t Idx = Record[1]; // Index of the object this attribute refers to.
1604 
1605  AttrBuilder B;
1606  for (unsigned i = 2, e = Record.size(); i != e; ++i) {
1607  if (Record[i] == 0) { // Enum attribute
1609  if (Error Err = parseAttrKind(Record[++i], &Kind))
1610  return Err;
1611 
1612  // Upgrade old-style byval attribute to one with a type, even if it's
1613  // nullptr. We will have to insert the real type when we associate
1614  // this AttributeList with a function.
1615  if (Kind == Attribute::ByVal)
1616  B.addByValAttr(nullptr);
1617 
1618  B.addAttribute(Kind);
1619  } else if (Record[i] == 1) { // Integer attribute
1621  if (Error Err = parseAttrKind(Record[++i], &Kind))
1622  return Err;
1623  if (Kind == Attribute::Alignment)
1624  B.addAlignmentAttr(Record[++i]);
1625  else if (Kind == Attribute::StackAlignment)
1626  B.addStackAlignmentAttr(Record[++i]);
1627  else if (Kind == Attribute::Dereferenceable)
1628  B.addDereferenceableAttr(Record[++i]);
1629  else if (Kind == Attribute::DereferenceableOrNull)
1630  B.addDereferenceableOrNullAttr(Record[++i]);
1631  else if (Kind == Attribute::AllocSize)
1632  B.addAllocSizeAttrFromRawRepr(Record[++i]);
1633  } else if (Record[i] == 3 || Record[i] == 4) { // String attribute
1634  bool HasValue = (Record[i++] == 4);
1635  SmallString<64> KindStr;
1636  SmallString<64> ValStr;
1637 
1638  while (Record[i] != 0 && i != e)
1639  KindStr += Record[i++];
1640  assert(Record[i] == 0 && "Kind string not null terminated");
1641 
1642  if (HasValue) {
1643  // Has a value associated with it.
1644  ++i; // Skip the '0' that terminates the "kind" string.
1645  while (Record[i] != 0 && i != e)
1646  ValStr += Record[i++];
1647  assert(Record[i] == 0 && "Value string not null terminated");
1648  }
1649 
1650  B.addAttribute(KindStr.str(), ValStr.str());
1651  } else {
1652  assert((Record[i] == 5 || Record[i] == 6) &&
1653  "Invalid attribute group entry");
1654  bool HasType = Record[i] == 6;
1656  if (Error Err = parseAttrKind(Record[++i], &Kind))
1657  return Err;
1658  if (Kind == Attribute::ByVal)
1659  B.addByValAttr(HasType ? getTypeByID(Record[++i]) : nullptr);
1660  }
1661  }
1662 
1663  MAttributeGroups[GrpID] = AttributeList::get(Context, Idx, B);
1664  break;
1665  }
1666  }
1667  }
1668 }
1669 
1670 Error BitcodeReader::parseTypeTable() {
1671  if (Error Err = Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
1672  return Err;
1673 
1674  return parseTypeTableBody();
1675 }
1676 
1677 Error BitcodeReader::parseTypeTableBody() {
1678  if (!TypeList.empty())
1679  return error("Invalid multiple blocks");
1680 
1682  unsigned NumRecords = 0;
1683 
1685 
1686  // Read all the records for this type table.
1687  while (true) {
1688  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
1689  if (!MaybeEntry)
1690  return MaybeEntry.takeError();
1691  BitstreamEntry Entry = MaybeEntry.get();
1692 
1693  switch (Entry.Kind) {
1694  case BitstreamEntry::SubBlock: // Handled for us already.
1695  case BitstreamEntry::Error:
1696  return error("Malformed block");
1698  if (NumRecords != TypeList.size())
1699  return error("Malformed block");
1700  return Error::success();
1702  // The interesting case.
1703  break;
1704  }
1705 
1706  // Read a record.
1707  Record.clear();
1708  Type *ResultTy = nullptr;
1709  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
1710  if (!MaybeRecord)
1711  return MaybeRecord.takeError();
1712  switch (MaybeRecord.get()) {
1713  default:
1714  return error("Invalid value");
1715  case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
1716  // TYPE_CODE_NUMENTRY contains a count of the number of types in the
1717  // type list. This allows us to reserve space.
1718  if (Record.size() < 1)
1719  return error("Invalid record");
1720  TypeList.resize(Record[0]);
1721  continue;
1722  case bitc::TYPE_CODE_VOID: // VOID
1723  ResultTy = Type::getVoidTy(Context);
1724  break;
1725  case bitc::TYPE_CODE_HALF: // HALF
1726  ResultTy = Type::getHalfTy(Context);
1727  break;
1728  case bitc::TYPE_CODE_FLOAT: // FLOAT
1729  ResultTy = Type::getFloatTy(Context);
1730  break;
1731  case bitc::TYPE_CODE_DOUBLE: // DOUBLE
1732  ResultTy = Type::getDoubleTy(Context);
1733  break;
1734  case bitc::TYPE_CODE_X86_FP80: // X86_FP80
1735  ResultTy = Type::getX86_FP80Ty(Context);
1736  break;
1737  case bitc::TYPE_CODE_FP128: // FP128
1738  ResultTy = Type::getFP128Ty(Context);
1739  break;
1740  case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
1741  ResultTy = Type::getPPC_FP128Ty(Context);
1742  break;
1743  case bitc::TYPE_CODE_LABEL: // LABEL
1744  ResultTy = Type::getLabelTy(Context);
1745  break;
1746  case bitc::TYPE_CODE_METADATA: // METADATA
1747  ResultTy = Type::getMetadataTy(Context);
1748  break;
1749  case bitc::TYPE_CODE_X86_MMX: // X86_MMX
1750  ResultTy = Type::getX86_MMXTy(Context);
1751  break;
1752  case bitc::TYPE_CODE_TOKEN: // TOKEN
1753  ResultTy = Type::getTokenTy(Context);
1754  break;
1755  case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
1756  if (Record.size() < 1)
1757  return error("Invalid record");
1758 
1759  uint64_t NumBits = Record[0];
1760  if (NumBits < IntegerType::MIN_INT_BITS ||
1761  NumBits > IntegerType::MAX_INT_BITS)
1762  return error("Bitwidth for integer type out of range");
1763  ResultTy = IntegerType::get(Context, NumBits);
1764  break;
1765  }
1766  case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
1767  // [pointee type, address space]
1768  if (Record.size() < 1)
1769  return error("Invalid record");
1770  unsigned AddressSpace = 0;
1771  if (Record.size() == 2)
1772  AddressSpace = Record[1];
1773  ResultTy = getTypeByID(Record[0]);
1774  if (!ResultTy ||
1776  return error("Invalid type");
1777  ResultTy = PointerType::get(ResultTy, AddressSpace);
1778  break;
1779  }
1781  // FIXME: attrid is dead, remove it in LLVM 4.0
1782  // FUNCTION: [vararg, attrid, retty, paramty x N]
1783  if (Record.size() < 3)
1784  return error("Invalid record");
1785  SmallVector<Type*, 8> ArgTys;
1786  for (unsigned i = 3, e = Record.size(); i != e; ++i) {
1787  if (Type *T = getTypeByID(Record[i]))
1788  ArgTys.push_back(T);
1789  else
1790  break;
1791  }
1792 
1793  ResultTy = getTypeByID(Record[2]);
1794  if (!ResultTy || ArgTys.size() < Record.size()-3)
1795  return error("Invalid type");
1796 
1797  ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
1798  break;
1799  }
1800  case bitc::TYPE_CODE_FUNCTION: {
1801  // FUNCTION: [vararg, retty, paramty x N]
1802  if (Record.size() < 2)
1803  return error("Invalid record");
1804  SmallVector<Type*, 8> ArgTys;
1805  for (unsigned i = 2, e = Record.size(); i != e; ++i) {
1806  if (Type *T = getTypeByID(Record[i])) {
1808  return error("Invalid function argument type");
1809  ArgTys.push_back(T);
1810  }
1811  else
1812  break;
1813  }
1814 
1815  ResultTy = getTypeByID(Record[1]);
1816  if (!ResultTy || ArgTys.size() < Record.size()-2)
1817  return error("Invalid type");
1818 
1819  ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
1820  break;
1821  }
1822  case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N]
1823  if (Record.size() < 1)
1824  return error("Invalid record");
1825  SmallVector<Type*, 8> EltTys;
1826  for (unsigned i = 1, e = Record.size(); i != e; ++i) {
1827  if (Type *T = getTypeByID(Record[i]))
1828  EltTys.push_back(T);
1829  else
1830  break;
1831  }
1832  if (EltTys.size() != Record.size()-1)
1833  return error("Invalid type");
1834  ResultTy = StructType::get(Context, EltTys, Record[0]);
1835  break;
1836  }
1837  case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N]
1838  if (convertToString(Record, 0, TypeName))
1839  return error("Invalid record");
1840  continue;
1841 
1842  case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
1843  if (Record.size() < 1)
1844  return error("Invalid record");
1845 
1846  if (NumRecords >= TypeList.size())
1847  return error("Invalid TYPE table");
1848 
1849  // Check to see if this was forward referenced, if so fill in the temp.
1850  StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
1851  if (Res) {
1852  Res->setName(TypeName);
1853  TypeList[NumRecords] = nullptr;
1854  } else // Otherwise, create a new struct.
1855  Res = createIdentifiedStructType(Context, TypeName);
1856  TypeName.clear();
1857 
1858  SmallVector<Type*, 8> EltTys;
1859  for (unsigned i = 1, e = Record.size(); i != e; ++i) {
1860  if (Type *T = getTypeByID(Record[i]))
1861  EltTys.push_back(T);
1862  else
1863  break;
1864  }
1865  if (EltTys.size() != Record.size()-1)
1866  return error("Invalid record");
1867  Res->setBody(EltTys, Record[0]);
1868  ResultTy = Res;
1869  break;
1870  }
1871  case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
1872  if (Record.size() != 1)
1873  return error("Invalid record");
1874 
1875  if (NumRecords >= TypeList.size())
1876  return error("Invalid TYPE table");
1877 
1878  // Check to see if this was forward referenced, if so fill in the temp.
1879  StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
1880  if (Res) {
1881  Res->setName(TypeName);
1882  TypeList[NumRecords] = nullptr;
1883  } else // Otherwise, create a new struct with no body.
1884  Res = createIdentifiedStructType(Context, TypeName);
1885  TypeName.clear();
1886  ResultTy = Res;
1887  break;
1888  }
1889  case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
1890  if (Record.size() < 2)
1891  return error("Invalid record");
1892  ResultTy = getTypeByID(Record[1]);
1893  if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
1894  return error("Invalid type");
1895  ResultTy = ArrayType::get(ResultTy, Record[0]);
1896  break;
1897  case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] or
1898  // [numelts, eltty, scalable]
1899  if (Record.size() < 2)
1900  return error("Invalid record");
1901  if (Record[0] == 0)
1902  return error("Invalid vector length");
1903  ResultTy = getTypeByID(Record[1]);
1904  if (!ResultTy || !StructType::isValidElementType(ResultTy))
1905  return error("Invalid type");
1906  bool Scalable = Record.size() > 2 ? Record[2] : false;
1907  ResultTy = VectorType::get(ResultTy, Record[0], Scalable);
1908  break;
1909  }
1910 
1911  if (NumRecords >= TypeList.size())
1912  return error("Invalid TYPE table");
1913  if (TypeList[NumRecords])
1914  return error(
1915  "Invalid TYPE table: Only named structs can be forward referenced");
1916  assert(ResultTy && "Didn't read a type?");
1917  TypeList[NumRecords++] = ResultTy;
1918  }
1919 }
1920 
1921 Error BitcodeReader::parseOperandBundleTags() {
1923  return Err;
1924 
1925  if (!BundleTags.empty())
1926  return error("Invalid multiple blocks");
1927 
1929 
1930  while (true) {
1931  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
1932  if (!MaybeEntry)
1933  return MaybeEntry.takeError();
1934  BitstreamEntry Entry = MaybeEntry.get();
1935 
1936  switch (Entry.Kind) {
1937  case BitstreamEntry::SubBlock: // Handled for us already.
1938  case BitstreamEntry::Error:
1939  return error("Malformed block");
1941  return Error::success();
1943  // The interesting case.
1944  break;
1945  }
1946 
1947  // Tags are implicitly mapped to integers by their order.
1948 
1949  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
1950  if (!MaybeRecord)
1951  return MaybeRecord.takeError();
1952  if (MaybeRecord.get() != bitc::OPERAND_BUNDLE_TAG)
1953  return error("Invalid record");
1954 
1955  // OPERAND_BUNDLE_TAG: [strchr x N]
1956  BundleTags.emplace_back();
1957  if (convertToString(Record, 0, BundleTags.back()))
1958  return error("Invalid record");
1959  Record.clear();
1960  }
1961 }
1962 
1963 Error BitcodeReader::parseSyncScopeNames() {
1965  return Err;
1966 
1967  if (!SSIDs.empty())
1968  return error("Invalid multiple synchronization scope names blocks");
1969 
1971  while (true) {
1972  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
1973  if (!MaybeEntry)
1974  return MaybeEntry.takeError();
1975  BitstreamEntry Entry = MaybeEntry.get();
1976 
1977  switch (Entry.Kind) {
1978  case BitstreamEntry::SubBlock: // Handled for us already.
1979  case BitstreamEntry::Error:
1980  return error("Malformed block");
1982  if (SSIDs.empty())
1983  return error("Invalid empty synchronization scope names block");
1984  return Error::success();
1986  // The interesting case.
1987  break;
1988  }
1989 
1990  // Synchronization scope names are implicitly mapped to synchronization
1991  // scope IDs by their order.
1992 
1993  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
1994  if (!MaybeRecord)
1995  return MaybeRecord.takeError();
1996  if (MaybeRecord.get() != bitc::SYNC_SCOPE_NAME)
1997  return error("Invalid record");
1998 
1999  SmallString<16> SSN;
2000  if (convertToString(Record, 0, SSN))
2001  return error("Invalid record");
2002 
2003  SSIDs.push_back(Context.getOrInsertSyncScopeID(SSN));
2004  Record.clear();
2005  }
2006 }
2007 
2008 /// Associate a value with its name from the given index in the provided record.
2009 Expected<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record,
2010  unsigned NameIndex, Triple &TT) {
2012  if (convertToString(Record, NameIndex, ValueName))
2013  return error("Invalid record");
2014  unsigned ValueID = Record[0];
2015  if (ValueID >= ValueList.size() || !ValueList[ValueID])
2016  return error("Invalid record");
2017  Value *V = ValueList[ValueID];
2018 
2019  StringRef NameStr(ValueName.data(), ValueName.size());
2020  if (NameStr.find_first_of(0) != StringRef::npos)
2021  return error("Invalid value name");
2022  V->setName(NameStr);
2023  auto *GO = dyn_cast<GlobalObject>(V);
2024  if (GO) {
2025  if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
2026  if (TT.supportsCOMDAT())
2027  GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
2028  else
2029  GO->setComdat(nullptr);
2030  }
2031  }
2032  return V;
2033 }
2034 
2035 /// Helper to note and return the current location, and jump to the given
2036 /// offset.
2038  BitstreamCursor &Stream) {
2039  // Save the current parsing location so we can jump back at the end
2040  // of the VST read.
2041  uint64_t CurrentBit = Stream.GetCurrentBitNo();
2042  if (Error JumpFailed = Stream.JumpToBit(Offset * 32))
2043  return std::move(JumpFailed);
2044  Expected<BitstreamEntry> MaybeEntry = Stream.advance();
2045  if (!MaybeEntry)
2046  return MaybeEntry.takeError();
2047  assert(MaybeEntry.get().Kind == BitstreamEntry::SubBlock);
2048  assert(MaybeEntry.get().ID == bitc::VALUE_SYMTAB_BLOCK_ID);
2049  return CurrentBit;
2050 }
2051 
2052 void BitcodeReader::setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta,
2053  Function *F,
2054  ArrayRef<uint64_t> Record) {
2055  // Note that we subtract 1 here because the offset is relative to one word
2056  // before the start of the identification or module block, which was
2057  // historically always the start of the regular bitcode header.
2058  uint64_t FuncWordOffset = Record[1] - 1;
2059  uint64_t FuncBitOffset = FuncWordOffset * 32;
2060  DeferredFunctionInfo[F] = FuncBitOffset + FuncBitcodeOffsetDelta;
2061  // Set the LastFunctionBlockBit to point to the last function block.
2062  // Later when parsing is resumed after function materialization,
2063  // we can simply skip that last function block.
2064  if (FuncBitOffset > LastFunctionBlockBit)
2065  LastFunctionBlockBit = FuncBitOffset;
2066 }
2067 
2068 /// Read a new-style GlobalValue symbol table.
2069 Error BitcodeReader::parseGlobalValueSymbolTable() {
2070  unsigned FuncBitcodeOffsetDelta =
2072 
2074  return Err;
2075 
2077  while (true) {
2078  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2079  if (!MaybeEntry)
2080  return MaybeEntry.takeError();
2081  BitstreamEntry Entry = MaybeEntry.get();
2082 
2083  switch (Entry.Kind) {
2085  case BitstreamEntry::Error:
2086  return error("Malformed block");
2088  return Error::success();
2090  break;
2091  }
2092 
2093  Record.clear();
2094  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2095  if (!MaybeRecord)
2096  return MaybeRecord.takeError();
2097  switch (MaybeRecord.get()) {
2098  case bitc::VST_CODE_FNENTRY: // [valueid, offset]
2099  setDeferredFunctionInfo(FuncBitcodeOffsetDelta,
2100  cast<Function>(ValueList[Record[0]]), Record);
2101  break;
2102  }
2103  }
2104 }
2105 
2106 /// Parse the value symbol table at either the current parsing location or
2107 /// at the given bit offset if provided.
2108 Error BitcodeReader::parseValueSymbolTable(uint64_t Offset) {
2109  uint64_t CurrentBit;
2110  // Pass in the Offset to distinguish between calling for the module-level
2111  // VST (where we want to jump to the VST offset) and the function-level
2112  // VST (where we don't).
2113  if (Offset > 0) {
2114  Expected<uint64_t> MaybeCurrentBit = jumpToValueSymbolTable(Offset, Stream);
2115  if (!MaybeCurrentBit)
2116  return MaybeCurrentBit.takeError();
2117  CurrentBit = MaybeCurrentBit.get();
2118  // If this module uses a string table, read this as a module-level VST.
2119  if (UseStrtab) {
2120  if (Error Err = parseGlobalValueSymbolTable())
2121  return Err;
2122  if (Error JumpFailed = Stream.JumpToBit(CurrentBit))
2123  return JumpFailed;
2124  return Error::success();
2125  }
2126  // Otherwise, the VST will be in a similar format to a function-level VST,
2127  // and will contain symbol names.
2128  }
2129 
2130  // Compute the delta between the bitcode indices in the VST (the word offset
2131  // to the word-aligned ENTER_SUBBLOCK for the function block, and that
2132  // expected by the lazy reader. The reader's EnterSubBlock expects to have
2133  // already read the ENTER_SUBBLOCK code (size getAbbrevIDWidth) and BlockID
2134  // (size BlockIDWidth). Note that we access the stream's AbbrevID width here
2135  // just before entering the VST subblock because: 1) the EnterSubBlock
2136  // changes the AbbrevID width; 2) the VST block is nested within the same
2137  // outer MODULE_BLOCK as the FUNCTION_BLOCKs and therefore have the same
2138  // AbbrevID width before calling EnterSubBlock; and 3) when we want to
2139  // jump to the FUNCTION_BLOCK using this offset later, we don't want
2140  // to rely on the stream's AbbrevID width being that of the MODULE_BLOCK.
2141  unsigned FuncBitcodeOffsetDelta =
2143 
2145  return Err;
2146 
2148 
2149  Triple TT(TheModule->getTargetTriple());
2150 
2151  // Read all the records for this value table.
2153 
2154  while (true) {
2155  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2156  if (!MaybeEntry)
2157  return MaybeEntry.takeError();
2158  BitstreamEntry Entry = MaybeEntry.get();
2159 
2160  switch (Entry.Kind) {
2161  case BitstreamEntry::SubBlock: // Handled for us already.
2162  case BitstreamEntry::Error:
2163  return error("Malformed block");
2165  if (Offset > 0)
2166  if (Error JumpFailed = Stream.JumpToBit(CurrentBit))
2167  return JumpFailed;
2168  return Error::success();
2170  // The interesting case.
2171  break;
2172  }
2173 
2174  // Read a record.
2175  Record.clear();
2176  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2177  if (!MaybeRecord)
2178  return MaybeRecord.takeError();
2179  switch (MaybeRecord.get()) {
2180  default: // Default behavior: unknown type.
2181  break;
2182  case bitc::VST_CODE_ENTRY: { // VST_CODE_ENTRY: [valueid, namechar x N]
2183  Expected<Value *> ValOrErr = recordValue(Record, 1, TT);
2184  if (Error Err = ValOrErr.takeError())
2185  return Err;
2186  ValOrErr.get();
2187  break;
2188  }
2189  case bitc::VST_CODE_FNENTRY: {
2190  // VST_CODE_FNENTRY: [valueid, offset, namechar x N]
2191  Expected<Value *> ValOrErr = recordValue(Record, 2, TT);
2192  if (Error Err = ValOrErr.takeError())
2193  return Err;
2194  Value *V = ValOrErr.get();
2195 
2196  // Ignore function offsets emitted for aliases of functions in older
2197  // versions of LLVM.
2198  if (auto *F = dyn_cast<Function>(V))
2199  setDeferredFunctionInfo(FuncBitcodeOffsetDelta, F, Record);
2200  break;
2201  }
2202  case bitc::VST_CODE_BBENTRY: {
2203  if (convertToString(Record, 1, ValueName))
2204  return error("Invalid record");
2205  BasicBlock *BB = getBasicBlock(Record[0]);
2206  if (!BB)
2207  return error("Invalid record");
2208 
2209  BB->setName(StringRef(ValueName.data(), ValueName.size()));
2210  ValueName.clear();
2211  break;
2212  }
2213  }
2214  }
2215 }
2216 
2217 /// Decode a signed value stored with the sign bit in the LSB for dense VBR
2218 /// encoding.
2219 uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {
2220  if ((V & 1) == 0)
2221  return V >> 1;
2222  if (V != 1)
2223  return -(V >> 1);
2224  // There is no such thing as -0 with integers. "-0" really means MININT.
2225  return 1ULL << 63;
2226 }
2227 
2228 /// Resolve all of the initializers for global values and aliases that we can.
2229 Error BitcodeReader::resolveGlobalAndIndirectSymbolInits() {
2230  std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInitWorklist;
2231  std::vector<std::pair<GlobalIndirectSymbol *, unsigned>>
2232  IndirectSymbolInitWorklist;
2233  std::vector<std::pair<Function *, unsigned>> FunctionPrefixWorklist;
2234  std::vector<std::pair<Function *, unsigned>> FunctionPrologueWorklist;
2235  std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFnWorklist;
2236 
2237  GlobalInitWorklist.swap(GlobalInits);
2238  IndirectSymbolInitWorklist.swap(IndirectSymbolInits);
2239  FunctionPrefixWorklist.swap(FunctionPrefixes);
2240  FunctionPrologueWorklist.swap(FunctionPrologues);
2241  FunctionPersonalityFnWorklist.swap(FunctionPersonalityFns);
2242 
2243  while (!GlobalInitWorklist.empty()) {
2244  unsigned ValID = GlobalInitWorklist.back().second;
2245  if (ValID >= ValueList.size()) {
2246  // Not ready to resolve this yet, it requires something later in the file.
2247  GlobalInits.push_back(GlobalInitWorklist.back());
2248  } else {
2249  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2250  GlobalInitWorklist.back().first->setInitializer(C);
2251  else
2252  return error("Expected a constant");
2253  }
2254  GlobalInitWorklist.pop_back();
2255  }
2256 
2257  while (!IndirectSymbolInitWorklist.empty()) {
2258  unsigned ValID = IndirectSymbolInitWorklist.back().second;
2259  if (ValID >= ValueList.size()) {
2260  IndirectSymbolInits.push_back(IndirectSymbolInitWorklist.back());
2261  } else {
2262  Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]);
2263  if (!C)
2264  return error("Expected a constant");
2265  GlobalIndirectSymbol *GIS = IndirectSymbolInitWorklist.back().first;
2266  if (isa<GlobalAlias>(GIS) && C->getType() != GIS->getType())
2267  return error("Alias and aliasee types don't match");
2268  GIS->setIndirectSymbol(C);
2269  }
2270  IndirectSymbolInitWorklist.pop_back();
2271  }
2272 
2273  while (!FunctionPrefixWorklist.empty()) {
2274  unsigned ValID = FunctionPrefixWorklist.back().second;
2275  if (ValID >= ValueList.size()) {
2276  FunctionPrefixes.push_back(FunctionPrefixWorklist.back());
2277  } else {
2278  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2279  FunctionPrefixWorklist.back().first->setPrefixData(C);
2280  else
2281  return error("Expected a constant");
2282  }
2283  FunctionPrefixWorklist.pop_back();
2284  }
2285 
2286  while (!FunctionPrologueWorklist.empty()) {
2287  unsigned ValID = FunctionPrologueWorklist.back().second;
2288  if (ValID >= ValueList.size()) {
2289  FunctionPrologues.push_back(FunctionPrologueWorklist.back());
2290  } else {
2291  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2292  FunctionPrologueWorklist.back().first->setPrologueData(C);
2293  else
2294  return error("Expected a constant");
2295  }
2296  FunctionPrologueWorklist.pop_back();
2297  }
2298 
2299  while (!FunctionPersonalityFnWorklist.empty()) {
2300  unsigned ValID = FunctionPersonalityFnWorklist.back().second;
2301  if (ValID >= ValueList.size()) {
2302  FunctionPersonalityFns.push_back(FunctionPersonalityFnWorklist.back());
2303  } else {
2304  if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
2305  FunctionPersonalityFnWorklist.back().first->setPersonalityFn(C);
2306  else
2307  return error("Expected a constant");
2308  }
2309  FunctionPersonalityFnWorklist.pop_back();
2310  }
2311 
2312  return Error::success();
2313 }
2314 
2315 static APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
2316  SmallVector<uint64_t, 8> Words(Vals.size());
2317  transform(Vals, Words.begin(),
2318  BitcodeReader::decodeSignRotatedValue);
2319 
2320  return APInt(TypeBits, Words);
2321 }
2322 
2323 Error BitcodeReader::parseConstants() {
2324  if (Error Err = Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
2325  return Err;
2326 
2328 
2329  // Read all the records for this value table.
2330  Type *CurTy = Type::getInt32Ty(Context);
2331  Type *CurFullTy = Type::getInt32Ty(Context);
2332  unsigned NextCstNo = ValueList.size();
2333 
2334  while (true) {
2335  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2336  if (!MaybeEntry)
2337  return MaybeEntry.takeError();
2338  BitstreamEntry Entry = MaybeEntry.get();
2339 
2340  switch (Entry.Kind) {
2341  case BitstreamEntry::SubBlock: // Handled for us already.
2342  case BitstreamEntry::Error:
2343  return error("Malformed block");
2345  if (NextCstNo != ValueList.size())
2346  return error("Invalid constant reference");
2347 
2348  // Once all the constants have been read, go through and resolve forward
2349  // references.
2350  ValueList.resolveConstantForwardRefs();
2351  return Error::success();
2353  // The interesting case.
2354  break;
2355  }
2356 
2357  // Read a record.
2358  Record.clear();
2359  Type *VoidType = Type::getVoidTy(Context);
2360  Value *V = nullptr;
2361  Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
2362  if (!MaybeBitCode)
2363  return MaybeBitCode.takeError();
2364  switch (unsigned BitCode = MaybeBitCode.get()) {
2365  default: // Default behavior: unknown constant
2366  case bitc::CST_CODE_UNDEF: // UNDEF
2367  V = UndefValue::get(CurTy);
2368  break;
2369  case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
2370  if (Record.empty())
2371  return error("Invalid record");
2372  if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
2373  return error("Invalid record");
2374  if (TypeList[Record[0]] == VoidType)
2375  return error("Invalid constant type");
2376  CurFullTy = TypeList[Record[0]];
2377  CurTy = flattenPointerTypes(CurFullTy);
2378  continue; // Skip the ValueList manipulation.
2379  case bitc::CST_CODE_NULL: // NULL
2380  if (CurTy->isVoidTy() || CurTy->isFunctionTy() || CurTy->isLabelTy())
2381  return error("Invalid type for a constant null value");
2382  V = Constant::getNullValue(CurTy);
2383  break;
2384  case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
2385  if (!CurTy->isIntegerTy() || Record.empty())
2386  return error("Invalid record");
2387  V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
2388  break;
2389  case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
2390  if (!CurTy->isIntegerTy() || Record.empty())
2391  return error("Invalid record");
2392 
2393  APInt VInt =
2394  readWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth());
2395  V = ConstantInt::get(Context, VInt);
2396 
2397  break;
2398  }
2399  case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
2400  if (Record.empty())
2401  return error("Invalid record");
2402  if (CurTy->isHalfTy())
2403  V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf(),
2404  APInt(16, (uint16_t)Record[0])));
2405  else if (CurTy->isFloatTy())
2407  APInt(32, (uint32_t)Record[0])));
2408  else if (CurTy->isDoubleTy())
2410  APInt(64, Record[0])));
2411  else if (CurTy->isX86_FP80Ty()) {
2412  // Bits are not stored the same way as a normal i80 APInt, compensate.
2413  uint64_t Rearrange[2];
2414  Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
2415  Rearrange[1] = Record[0] >> 48;
2417  APInt(80, Rearrange)));
2418  } else if (CurTy->isFP128Ty())
2419  V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad(),
2420  APInt(128, Record)));
2421  else if (CurTy->isPPC_FP128Ty())
2423  APInt(128, Record)));
2424  else
2425  V = UndefValue::get(CurTy);
2426  break;
2427  }
2428 
2429  case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
2430  if (Record.empty())
2431  return error("Invalid record");
2432 
2433  unsigned Size = Record.size();
2435 
2436  if (StructType *STy = dyn_cast<StructType>(CurTy)) {
2437  for (unsigned i = 0; i != Size; ++i)
2438  Elts.push_back(ValueList.getConstantFwdRef(Record[i],
2439  STy->getElementType(i)));
2440  V = ConstantStruct::get(STy, Elts);
2441  } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
2442  Type *EltTy = ATy->getElementType();
2443  for (unsigned i = 0; i != Size; ++i)
2444  Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
2445  V = ConstantArray::get(ATy, Elts);
2446  } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
2447  Type *EltTy = VTy->getElementType();
2448  for (unsigned i = 0; i != Size; ++i)
2449  Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
2450  V = ConstantVector::get(Elts);
2451  } else {
2452  V = UndefValue::get(CurTy);
2453  }
2454  break;
2455  }
2456  case bitc::CST_CODE_STRING: // STRING: [values]
2457  case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
2458  if (Record.empty())
2459  return error("Invalid record");
2460 
2461  SmallString<16> Elts(Record.begin(), Record.end());
2462  V = ConstantDataArray::getString(Context, Elts,
2463  BitCode == bitc::CST_CODE_CSTRING);
2464  break;
2465  }
2466  case bitc::CST_CODE_DATA: {// DATA: [n x value]
2467  if (Record.empty())
2468  return error("Invalid record");
2469 
2470  Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
2471  if (EltTy->isIntegerTy(8)) {
2472  SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
2473  if (isa<VectorType>(CurTy))
2474  V = ConstantDataVector::get(Context, Elts);
2475  else
2476  V = ConstantDataArray::get(Context, Elts);
2477  } else if (EltTy->isIntegerTy(16)) {
2478  SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
2479  if (isa<VectorType>(CurTy))
2480  V = ConstantDataVector::get(Context, Elts);
2481  else
2482  V = ConstantDataArray::get(Context, Elts);
2483  } else if (EltTy->isIntegerTy(32)) {
2484  SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
2485  if (isa<VectorType>(CurTy))
2486  V = ConstantDataVector::get(Context, Elts);
2487  else
2488  V = ConstantDataArray::get(Context, Elts);
2489  } else if (EltTy->isIntegerTy(64)) {
2490  SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
2491  if (isa<VectorType>(CurTy))
2492  V = ConstantDataVector::get(Context, Elts);
2493  else
2494  V = ConstantDataArray::get(Context, Elts);
2495  } else if (EltTy->isHalfTy()) {
2496  SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
2497  if (isa<VectorType>(CurTy))
2498  V = ConstantDataVector::getFP(Context, Elts);
2499  else
2500  V = ConstantDataArray::getFP(Context, Elts);
2501  } else if (EltTy->isFloatTy()) {
2502  SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
2503  if (isa<VectorType>(CurTy))
2504  V = ConstantDataVector::getFP(Context, Elts);
2505  else
2506  V = ConstantDataArray::getFP(Context, Elts);
2507  } else if (EltTy->isDoubleTy()) {
2508  SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
2509  if (isa<VectorType>(CurTy))
2510  V = ConstantDataVector::getFP(Context, Elts);
2511  else
2512  V = ConstantDataArray::getFP(Context, Elts);
2513  } else {
2514  return error("Invalid type for value");
2515  }
2516  break;
2517  }
2518  case bitc::CST_CODE_CE_UNOP: { // CE_UNOP: [opcode, opval]
2519  if (Record.size() < 2)
2520  return error("Invalid record");
2521  int Opc = getDecodedUnaryOpcode(Record[0], CurTy);
2522  if (Opc < 0) {
2523  V = UndefValue::get(CurTy); // Unknown unop.
2524  } else {
2525  Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
2526  unsigned Flags = 0;
2527  V = ConstantExpr::get(Opc, LHS, Flags);
2528  }
2529  break;
2530  }
2531  case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
2532  if (Record.size() < 3)
2533  return error("Invalid record");
2534  int Opc = getDecodedBinaryOpcode(Record[0], CurTy);
2535  if (Opc < 0) {
2536  V = UndefValue::get(CurTy); // Unknown binop.
2537  } else {
2538  Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
2539  Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
2540  unsigned Flags = 0;
2541  if (Record.size() >= 4) {
2542  if (Opc == Instruction::Add ||
2543  Opc == Instruction::Sub ||
2544  Opc == Instruction::Mul ||
2545  Opc == Instruction::Shl) {
2546  if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP))
2548  if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
2550  } else if (Opc == Instruction::SDiv ||
2551  Opc == Instruction::UDiv ||
2552  Opc == Instruction::LShr ||
2553  Opc == Instruction::AShr) {
2554  if (Record[3] & (1 << bitc::PEO_EXACT))
2555  Flags |= SDivOperator::IsExact;
2556  }
2557  }
2558  V = ConstantExpr::get(Opc, LHS, RHS, Flags);
2559  }
2560  break;
2561  }
2562  case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
2563  if (Record.size() < 3)
2564  return error("Invalid record");
2565  int Opc = getDecodedCastOpcode(Record[0]);
2566  if (Opc < 0) {
2567  V = UndefValue::get(CurTy); // Unknown cast.
2568  } else {
2569  Type *OpTy = getTypeByID(Record[1]);
2570  if (!OpTy)
2571  return error("Invalid record");
2572  Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
2573  V = UpgradeBitCastExpr(Opc, Op, CurTy);
2574  if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy);
2575  }
2576  break;
2577  }
2578  case bitc::CST_CODE_CE_INBOUNDS_GEP: // [ty, n x operands]
2579  case bitc::CST_CODE_CE_GEP: // [ty, n x operands]
2580  case bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX: { // [ty, flags, n x
2581  // operands]
2582  unsigned OpNum = 0;
2583  Type *PointeeType = nullptr;
2585  Record.size() % 2)
2586  PointeeType = getTypeByID(Record[OpNum++]);
2587 
2588  bool InBounds = false;
2589  Optional<unsigned> InRangeIndex;
2591  uint64_t Op = Record[OpNum++];
2592  InBounds = Op & 1;
2593  InRangeIndex = Op >> 1;
2594  } else if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP)
2595  InBounds = true;
2596 
2598  Type *Elt0FullTy = nullptr;
2599  while (OpNum != Record.size()) {
2600  if (!Elt0FullTy)
2601  Elt0FullTy = getFullyStructuredTypeByID(Record[OpNum]);
2602  Type *ElTy = getTypeByID(Record[OpNum++]);
2603  if (!ElTy)
2604  return error("Invalid record");
2605  Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy));
2606  }
2607 
2608  if (Elts.size() < 1)
2609  return error("Invalid gep with no operands");
2610 
2611  Type *ImplicitPointeeType =
2612  getPointerElementFlatType(Elt0FullTy->getScalarType());
2613  if (!PointeeType)
2614  PointeeType = ImplicitPointeeType;
2615  else if (PointeeType != ImplicitPointeeType)
2616  return error("Explicit gep operator type does not match pointee type "
2617  "of pointer operand");
2618 
2619  ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
2620  V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices,
2621  InBounds, InRangeIndex);
2622  break;
2623  }
2624  case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#]
2625  if (Record.size() < 3)
2626  return error("Invalid record");
2627 
2628  Type *SelectorTy = Type::getInt1Ty(Context);
2629 
2630  // The selector might be an i1 or an <n x i1>
2631  // Get the type from the ValueList before getting a forward ref.
2632  if (VectorType *VTy = dyn_cast<VectorType>(CurTy))
2633  if (Value *V = ValueList[Record[0]])
2634  if (SelectorTy != V->getType())
2635  SelectorTy = VectorType::get(SelectorTy, VTy->getNumElements());
2636 
2637  V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
2638  SelectorTy),
2639  ValueList.getConstantFwdRef(Record[1],CurTy),
2640  ValueList.getConstantFwdRef(Record[2],CurTy));
2641  break;
2642  }
2644  : { // CE_EXTRACTELT: [opty, opval, opty, opval]
2645  if (Record.size() < 3)
2646  return error("Invalid record");
2647  VectorType *OpTy =
2648  dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
2649  if (!OpTy)
2650  return error("Invalid record");
2651  Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
2652  Constant *Op1 = nullptr;
2653  if (Record.size() == 4) {
2654  Type *IdxTy = getTypeByID(Record[2]);
2655  if (!IdxTy)
2656  return error("Invalid record");
2657  Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy);
2658  } else // TODO: Remove with llvm 4.0
2659  Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
2660  if (!Op1)
2661  return error("Invalid record");
2662  V = ConstantExpr::getExtractElement(Op0, Op1);
2663  break;
2664  }
2666  : { // CE_INSERTELT: [opval, opval, opty, opval]
2667  VectorType *OpTy = dyn_cast<VectorType>(CurTy);
2668  if (Record.size() < 3 || !OpTy)
2669  return error("Invalid record");
2670  Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
2671  Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
2672  OpTy->getElementType());
2673  Constant *Op2 = nullptr;
2674  if (Record.size() == 4) {
2675  Type *IdxTy = getTypeByID(Record[2]);
2676  if (!IdxTy)
2677  return error("Invalid record");
2678  Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy);
2679  } else // TODO: Remove with llvm 4.0
2680  Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
2681  if (!Op2)
2682  return error("Invalid record");
2683  V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
2684  break;
2685  }
2686  case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
2687  VectorType *OpTy = dyn_cast<VectorType>(CurTy);
2688  if (Record.size() < 3 || !OpTy)
2689  return error("Invalid record");
2690  Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
2691  Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
2692  Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2693  OpTy->getNumElements());
2694  Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
2695  V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
2696  break;
2697  }
2698  case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
2699  VectorType *RTy = dyn_cast<VectorType>(CurTy);
2700  VectorType *OpTy =
2701  dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
2702  if (Record.size() < 4 || !RTy || !OpTy)
2703  return error("Invalid record");
2704  Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
2705  Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
2706  Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2707  RTy->getNumElements());
2708  Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
2709  V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
2710  break;
2711  }
2712  case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
2713  if (Record.size() < 4)
2714  return error("Invalid record");
2715  Type *OpTy = getTypeByID(Record[0]);
2716  if (!OpTy)
2717  return error("Invalid record");
2718  Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
2719  Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
2720 
2721  if (OpTy->isFPOrFPVectorTy())
2722  V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
2723  else
2724  V = ConstantExpr::getICmp(Record[3], Op0, Op1);
2725  break;
2726  }
2727  // This maintains backward compatibility, pre-asm dialect keywords.
2728  // FIXME: Remove with the 4.0 release.
2730  if (Record.size() < 2)
2731  return error("Invalid record");
2732  std::string AsmStr, ConstrStr;
2733  bool HasSideEffects = Record[0] & 1;
2734  bool IsAlignStack = Record[0] >> 1;
2735  unsigned AsmStrSize = Record[1];
2736  if (2+AsmStrSize >= Record.size())
2737  return error("Invalid record");
2738  unsigned ConstStrSize = Record[2+AsmStrSize];
2739  if (3+AsmStrSize+ConstStrSize > Record.size())
2740  return error("Invalid record");
2741 
2742  for (unsigned i = 0; i != AsmStrSize; ++i)
2743  AsmStr += (char)Record[2+i];
2744  for (unsigned i = 0; i != ConstStrSize; ++i)
2745  ConstrStr += (char)Record[3+AsmStrSize+i];
2746  UpgradeInlineAsmString(&AsmStr);
2747  V = InlineAsm::get(
2748  cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
2749  ConstrStr, HasSideEffects, IsAlignStack);
2750  break;
2751  }
2752  // This version adds support for the asm dialect keywords (e.g.,
2753  // inteldialect).
2754  case bitc::CST_CODE_INLINEASM: {
2755  if (Record.size() < 2)
2756  return error("Invalid record");
2757  std::string AsmStr, ConstrStr;
2758  bool HasSideEffects = Record[0] & 1;
2759  bool IsAlignStack = (Record[0] >> 1) & 1;
2760  unsigned AsmDialect = Record[0] >> 2;
2761  unsigned AsmStrSize = Record[1];
2762  if (2+AsmStrSize >= Record.size())
2763  return error("Invalid record");
2764  unsigned ConstStrSize = Record[2+AsmStrSize];
2765  if (3+AsmStrSize+ConstStrSize > Record.size())
2766  return error("Invalid record");
2767 
2768  for (unsigned i = 0; i != AsmStrSize; ++i)
2769  AsmStr += (char)Record[2+i];
2770  for (unsigned i = 0; i != ConstStrSize; ++i)
2771  ConstrStr += (char)Record[3+AsmStrSize+i];
2772  UpgradeInlineAsmString(&AsmStr);
2773  V = InlineAsm::get(
2774  cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
2775  ConstrStr, HasSideEffects, IsAlignStack,
2776  InlineAsm::AsmDialect(AsmDialect));
2777  break;
2778  }
2780  if (Record.size() < 3)
2781  return error("Invalid record");
2782  Type *FnTy = getTypeByID(Record[0]);
2783  if (!FnTy)
2784  return error("Invalid record");
2785  Function *Fn =
2786  dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
2787  if (!Fn)
2788  return error("Invalid record");
2789 
2790  // If the function is already parsed we can insert the block address right
2791  // away.
2792  BasicBlock *BB;
2793  unsigned BBID = Record[2];
2794  if (!BBID)
2795  // Invalid reference to entry block.
2796  return error("Invalid ID");
2797  if (!Fn->empty()) {
2798  Function::iterator BBI = Fn->begin(), BBE = Fn->end();
2799  for (size_t I = 0, E = BBID; I != E; ++I) {
2800  if (BBI == BBE)
2801  return error("Invalid ID");
2802  ++BBI;
2803  }
2804  BB = &*BBI;
2805  } else {
2806  // Otherwise insert a placeholder and remember it so it can be inserted
2807  // when the function is parsed.
2808  auto &FwdBBs = BasicBlockFwdRefs[Fn];
2809  if (FwdBBs.empty())
2810  BasicBlockFwdRefQueue.push_back(Fn);
2811  if (FwdBBs.size() < BBID + 1)
2812  FwdBBs.resize(BBID + 1);
2813  if (!FwdBBs[BBID])
2814  FwdBBs[BBID] = BasicBlock::Create(Context);
2815  BB = FwdBBs[BBID];
2816  }
2817  V = BlockAddress::get(Fn, BB);
2818  break;
2819  }
2820  }
2821 
2822  assert(V->getType() == flattenPointerTypes(CurFullTy) &&
2823  "Incorrect fully structured type provided for Constant");
2824  ValueList.assignValue(V, NextCstNo, CurFullTy);
2825  ++NextCstNo;
2826  }
2827 }
2828 
2829 Error BitcodeReader::parseUseLists() {
2830  if (Error Err = Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
2831  return Err;
2832 
2833  // Read all the records.
2835 
2836  while (true) {
2837  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2838  if (!MaybeEntry)
2839  return MaybeEntry.takeError();
2840  BitstreamEntry Entry = MaybeEntry.get();
2841 
2842  switch (Entry.Kind) {
2843  case BitstreamEntry::SubBlock: // Handled for us already.
2844  case BitstreamEntry::Error:
2845  return error("Malformed block");
2847  return Error::success();
2849  // The interesting case.
2850  break;
2851  }
2852 
2853  // Read a use list record.
2854  Record.clear();
2855  bool IsBB = false;
2856  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2857  if (!MaybeRecord)
2858  return MaybeRecord.takeError();
2859  switch (MaybeRecord.get()) {
2860  default: // Default behavior: unknown type.
2861  break;
2862  case bitc::USELIST_CODE_BB:
2863  IsBB = true;
2866  unsigned RecordLength = Record.size();
2867  if (RecordLength < 3)
2868  // Records should have at least an ID and two indexes.
2869  return error("Invalid record");
2870  unsigned ID = Record.back();
2871  Record.pop_back();
2872 
2873  Value *V;
2874  if (IsBB) {
2875  assert(ID < FunctionBBs.size() && "Basic block not found");
2876  V = FunctionBBs[ID];
2877  } else
2878  V = ValueList[ID];
2879  unsigned NumUses = 0;
2881  for (const Use &U : V->materialized_uses()) {
2882  if (++NumUses > Record.size())
2883  break;
2884  Order[&U] = Record[NumUses - 1];
2885  }
2886  if (Order.size() != Record.size() || NumUses > Record.size())
2887  // Mismatches can happen if the functions are being materialized lazily
2888  // (out-of-order), or a value has been upgraded.
2889  break;
2890 
2891  V->sortUseList([&](const Use &L, const Use &R) {
2892  return Order.lookup(&L) < Order.lookup(&R);
2893  });
2894  break;
2895  }
2896  }
2897  }
2898 }
2899 
2900 /// When we see the block for metadata, remember where it is and then skip it.
2901 /// This lets us lazily deserialize the metadata.
2902 Error BitcodeReader::rememberAndSkipMetadata() {
2903  // Save the current stream state.
2904  uint64_t CurBit = Stream.GetCurrentBitNo();
2905  DeferredMetadataInfo.push_back(CurBit);
2906 
2907  // Skip over the block for now.
2908  if (Error Err = Stream.SkipBlock())
2909  return Err;
2910  return Error::success();
2911 }
2912 
2913 Error BitcodeReader::materializeMetadata() {
2914  for (uint64_t BitPos : DeferredMetadataInfo) {
2915  // Move the bit stream to the saved position.
2916  if (Error JumpFailed = Stream.JumpToBit(BitPos))
2917  return JumpFailed;
2918  if (Error Err = MDLoader->parseModuleMetadata())
2919  return Err;
2920  }
2921 
2922  // Upgrade "Linker Options" module flag to "llvm.linker.options" module-level
2923  // metadata.
2924  if (Metadata *Val = TheModule->getModuleFlag("Linker Options")) {
2925  NamedMDNode *LinkerOpts =
2926  TheModule->getOrInsertNamedMetadata("llvm.linker.options");
2927  for (const MDOperand &MDOptions : cast<MDNode>(Val)->operands())
2928  LinkerOpts->addOperand(cast<MDNode>(MDOptions));
2929  }
2930 
2931  DeferredMetadataInfo.clear();
2932  return Error::success();
2933 }
2934 
2935 void BitcodeReader::setStripDebugInfo() { StripDebugInfo = true; }
2936 
2937 /// When we see the block for a function body, remember where it is and then
2938 /// skip it. This lets us lazily deserialize the functions.
2939 Error BitcodeReader::rememberAndSkipFunctionBody() {
2940  // Get the function we are talking about.
2941  if (FunctionsWithBodies.empty())
2942  return error("Insufficient function protos");
2943 
2944  Function *Fn = FunctionsWithBodies.back();
2945  FunctionsWithBodies.pop_back();
2946 
2947  // Save the current stream state.
2948  uint64_t CurBit = Stream.GetCurrentBitNo();
2949  assert(
2950  (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) &&
2951  "Mismatch between VST and scanned function offsets");
2952  DeferredFunctionInfo[Fn] = CurBit;
2953 
2954  // Skip over the function block for now.
2955  if (Error Err = Stream.SkipBlock())
2956  return Err;
2957  return Error::success();
2958 }
2959 
2960 Error BitcodeReader::globalCleanup() {
2961  // Patch the initializers for globals and aliases up.
2962  if (Error Err = resolveGlobalAndIndirectSymbolInits())
2963  return Err;
2964  if (!GlobalInits.empty() || !IndirectSymbolInits.empty())
2965  return error("Malformed global initializer set");
2966 
2967  // Look for intrinsic functions which need to be upgraded at some point
2968  for (Function &F : *TheModule) {
2969  MDLoader->upgradeDebugIntrinsics(F);
2970  Function *NewFn;
2971  if (UpgradeIntrinsicFunction(&F, NewFn))
2972  UpgradedIntrinsics[&F] = NewFn;
2973  else if (auto Remangled = Intrinsic::remangleIntrinsicFunction(&F))
2974  // Some types could be renamed during loading if several modules are
2975  // loaded in the same LLVMContext (LTO scenario). In this case we should
2976  // remangle intrinsics names as well.
2977  RemangledIntrinsics[&F] = Remangled.getValue();
2978  }
2979 
2980  // Look for global variables which need to be renamed.
2981  std::vector<std::pair<GlobalVariable *, GlobalVariable *>> UpgradedVariables;
2982  for (GlobalVariable &GV : TheModule->globals())
2983  if (GlobalVariable *Upgraded = UpgradeGlobalVariable(&GV))
2984  UpgradedVariables.emplace_back(&GV, Upgraded);
2985  for (auto &Pair : UpgradedVariables) {
2986  Pair.first->eraseFromParent();
2987  TheModule->getGlobalList().push_back(Pair.second);
2988  }
2989 
2990  // Force deallocation of memory for these vectors to favor the client that
2991  // want lazy deserialization.
2992  std::vector<std::pair<GlobalVariable *, unsigned>>().swap(GlobalInits);
2993  std::vector<std::pair<GlobalIndirectSymbol *, unsigned>>().swap(
2994  IndirectSymbolInits);
2995  return Error::success();
2996 }
2997 
2998 /// Support for lazy parsing of function bodies. This is required if we
2999 /// either have an old bitcode file without a VST forward declaration record,
3000 /// or if we have an anonymous function being materialized, since anonymous
3001 /// functions do not have a name and are therefore not in the VST.
3002 Error BitcodeReader::rememberAndSkipFunctionBodies() {
3003  if (Error JumpFailed = Stream.JumpToBit(NextUnreadBit))
3004  return JumpFailed;
3005 
3006  if (Stream.AtEndOfStream())
3007  return error("Could not find function in stream");
3008 
3009  if (!SeenFirstFunctionBody)
3010  return error("Trying to materialize functions before seeing function blocks");
3011 
3012  // An old bitcode file with the symbol table at the end would have
3013  // finished the parse greedily.
3014  assert(SeenValueSymbolTable);
3015 
3017 
3018  while (true) {
3019  Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
3020  if (!MaybeEntry)
3021  return MaybeEntry.takeError();
3022  llvm::BitstreamEntry Entry = MaybeEntry.get();
3023 
3024  switch (Entry.Kind) {
3025  default:
3026  return error("Expect SubBlock");
3028  switch (Entry.ID) {
3029  default:
3030  return error("Expect function block");
3032  if (Error Err = rememberAndSkipFunctionBody())
3033  return Err;
3034  NextUnreadBit = Stream.GetCurrentBitNo();
3035  return Error::success();
3036  }
3037  }
3038  }
3039 }
3040 
3041 bool BitcodeReaderBase::readBlockInfo() {
3042  Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
3043  Stream.ReadBlockInfoBlock();
3044  if (!MaybeNewBlockInfo)
3045  return true; // FIXME Handle the error.
3046  Optional<BitstreamBlockInfo> NewBlockInfo =
3047  std::move(MaybeNewBlockInfo.get());
3048  if (!NewBlockInfo)
3049  return true;
3050  BlockInfo = std::move(*NewBlockInfo);
3051  return false;
3052 }
3053 
3054 Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t> Record) {
3055  // v1: [selection_kind, name]
3056  // v2: [strtab_offset, strtab_size, selection_kind]
3057  StringRef Name;
3058  std::tie(Name, Record) = readNameFromStrtab(Record);
3059 
3060  if (Record.empty())
3061  return error("Invalid record");
3063  std::string OldFormatName;
3064  if (!UseStrtab) {
3065  if (Record.size() < 2)
3066  return error("Invalid record");
3067  unsigned ComdatNameSize = Record[1];
3068  OldFormatName.reserve(ComdatNameSize);
3069  for (unsigned i = 0; i != ComdatNameSize; ++i)
3070  OldFormatName += (char)Record[2 + i];
3071  Name = OldFormatName;
3072  }
3073  Comdat *C = TheModule->getOrInsertComdat(Name);
3074  C->setSelectionKind(SK);
3075  ComdatList.push_back(C);
3076  return Error::success();
3077 }
3078 
3079 static void inferDSOLocal(GlobalValue *GV) {
3080  // infer dso_local from linkage and visibility if it is not encoded.
3081  if (GV->hasLocalLinkage() ||
3082  (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage()))
3083  GV->setDSOLocal(true);
3084 }
3085 
3086 Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
3087  // v1: [pointer type, isconst, initid, linkage, alignment, section,
3088  // visibility, threadlocal, unnamed_addr, externally_initialized,
3089  // dllstorageclass, comdat, attributes, preemption specifier,
3090  // partition strtab offset, partition strtab size] (name in VST)
3091  // v2: [strtab_offset, strtab_size, v1]
3092  StringRef Name;
3093  std::tie(Name, Record) = readNameFromStrtab(Record);
3094 
3095  if (Record.size() < 6)
3096  return error("Invalid record");
3097  Type *FullTy = getFullyStructuredTypeByID(Record[0]);
3098  Type *Ty = flattenPointerTypes(FullTy);
3099  if (!Ty)
3100  return error("Invalid record");
3101  bool isConstant = Record[1] & 1;
3102  bool explicitType = Record[1] & 2;
3103  unsigned AddressSpace;
3104  if (explicitType) {
3105  AddressSpace = Record[1] >> 2;
3106  } else {
3107  if (!Ty->isPointerTy())
3108  return error("Invalid type for value");
3109  AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
3110  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
3111  }
3112 
3113  uint64_t RawLinkage = Record[3];
3114  GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
3115  unsigned Alignment;
3116  if (Error Err = parseAlignmentValue(Record[4], Alignment))
3117  return Err;
3118  std::string Section;
3119  if (Record[5]) {
3120  if (Record[5] - 1 >= SectionTable.size())
3121  return error("Invalid ID");
3122  Section = SectionTable[Record[5] - 1];
3123  }
3125  // Local linkage must have default visibility.
3126  if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
3127  // FIXME: Change to an error if non-default in 4.0.
3128  Visibility = getDecodedVisibility(Record[6]);
3129 
3131  if (Record.size() > 7)
3132  TLM = getDecodedThreadLocalMode(Record[7]);
3133 
3135  if (Record.size() > 8)
3136  UnnamedAddr = getDecodedUnnamedAddrType(Record[8]);
3137 
3138  bool ExternallyInitialized = false;
3139  if (Record.size() > 9)
3140  ExternallyInitialized = Record[9];
3141 
3142  GlobalVariable *NewGV =
3143  new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, Name,
3144  nullptr, TLM, AddressSpace, ExternallyInitialized);
3145  NewGV->setAlignment(Alignment);
3146  if (!Section.empty())
3147  NewGV->setSection(Section);
3148  NewGV->setVisibility(Visibility);
3149  NewGV->setUnnamedAddr(UnnamedAddr);
3150 
3151  if (Record.size() > 10)
3152  NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10]));
3153  else
3154  upgradeDLLImportExportLinkage(NewGV, RawLinkage);
3155 
3156  FullTy = PointerType::get(FullTy, AddressSpace);
3157  assert(NewGV->getType() == flattenPointerTypes(FullTy) &&
3158  "Incorrect fully specified type for GlobalVariable");
3159  ValueList.push_back(NewGV, FullTy);
3160 
3161  // Remember which value to use for the global initializer.
3162  if (unsigned InitID = Record[2])
3163  GlobalInits.push_back(std::make_pair(NewGV, InitID - 1));
3164 
3165  if (Record.size() > 11) {
3166  if (unsigned ComdatID = Record[11]) {
3167  if (ComdatID > ComdatList.size())
3168  return error("Invalid global variable comdat ID");
3169  NewGV->setComdat(ComdatList[ComdatID - 1]);
3170  }
3171  } else if (hasImplicitComdat(RawLinkage)) {
3172  NewGV->setComdat(reinterpret_cast<Comdat *>(1));
3173  }
3174 
3175  if (Record.size() > 12) {
3176  auto AS = getAttributes(Record[12]).getFnAttributes();
3177  NewGV->setAttributes(AS);
3178  }
3179 
3180  if (Record.size() > 13) {
3181  NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));
3182  }
3183  inferDSOLocal(NewGV);
3184 
3185  // Check whether we have enough values to read a partition name.
3186  if (Record.size() > 15)
3187  NewGV->setPartition(StringRef(Strtab.data() + Record[14], Record[15]));
3188 
3189  return Error::success();
3190 }
3191 
3192 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
3193  // v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
3194  // visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
3195  // prefixdata, personalityfn, preemption specifier, addrspace] (name in VST)
3196  // v2: [strtab_offset, strtab_size, v1]
3197  StringRef Name;
3198  std::tie(Name, Record) = readNameFromStrtab(Record);
3199 
3200  if (Record.size() < 8)
3201  return error("Invalid record");
3202  Type *FullFTy = getFullyStructuredTypeByID(Record[0]);
3203  Type *FTy = flattenPointerTypes(FullFTy);
3204  if (!FTy)
3205  return error("Invalid record");
3206  if (isa<PointerType>(FTy))
3207  std::tie(FullFTy, FTy) = getPointerElementTypes(FullFTy);
3208 
3209  if (!isa<FunctionType>(FTy))
3210  return error("Invalid type for value");
3211  auto CC = static_cast<CallingConv::ID>(Record[1]);
3212  if (CC & ~CallingConv::MaxID)
3213  return error("Invalid calling convention ID");
3214 
3215  unsigned AddrSpace = TheModule->getDataLayout().getProgramAddressSpace();
3216  if (Record.size() > 16)
3217  AddrSpace = Record[16];
3218 
3219  Function *Func =
3220  Function::Create(cast<FunctionType>(FTy), GlobalValue::ExternalLinkage,
3221  AddrSpace, Name, TheModule);
3222 
3223  assert(Func->getFunctionType() == flattenPointerTypes(FullFTy) &&
3224  "Incorrect fully specified type provided for function");
3225  FunctionTypes[Func] = cast<FunctionType>(FullFTy);
3226 
3227  Func->setCallingConv(CC);
3228  bool isProto = Record[2];
3229  uint64_t RawLinkage = Record[3];
3230  Func->setLinkage(getDecodedLinkage(RawLinkage));
3231  Func->setAttributes(getAttributes(Record[4]));
3232 
3233  // Upgrade any old-style byval without a type by propagating the argument's
3234  // pointee type. There should be no opaque pointers where the byval type is
3235  // implicit.
3236  for (unsigned i = 0; i != Func->arg_size(); ++i) {
3237  if (!Func->hasParamAttribute(i, Attribute::ByVal))
3238  continue;
3239 
3240  Type *PTy = cast<FunctionType>(FullFTy)->getParamType(i);
3241  Func->removeParamAttr(i, Attribute::ByVal);
3243  Context, getPointerElementFlatType(PTy)));
3244  }
3245 
3246  unsigned Alignment;
3247  if (Error Err = parseAlignmentValue(Record[5], Alignment))
3248  return Err;
3249  Func->setAlignment(Alignment);
3250  if (Record[6]) {
3251  if (Record[6] - 1 >= SectionTable.size())
3252  return error("Invalid ID");
3253  Func->setSection(SectionTable[Record[6] - 1]);
3254  }
3255  // Local linkage must have default visibility.
3256  if (!Func->hasLocalLinkage())
3257  // FIXME: Change to an error if non-default in 4.0.
3258  Func->setVisibility(getDecodedVisibility(Record[7]));
3259  if (Record.size() > 8 && Record[8]) {
3260  if (Record[8] - 1 >= GCTable.size())
3261  return error("Invalid ID");
3262  Func->setGC(GCTable[Record[8] - 1]);
3263  }
3265  if (Record.size() > 9)
3266  UnnamedAddr = getDecodedUnnamedAddrType(Record[9]);
3267  Func->setUnnamedAddr(UnnamedAddr);
3268  if (Record.size() > 10 && Record[10] != 0)
3269  FunctionPrologues.push_back(std::make_pair(Func, Record[10] - 1));
3270 
3271  if (Record.size() > 11)
3272  Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
3273  else
3274  upgradeDLLImportExportLinkage(Func, RawLinkage);
3275 
3276  if (Record.size() > 12) {
3277  if (unsigned ComdatID = Record[12]) {
3278  if (ComdatID > ComdatList.size())
3279  return error("Invalid function comdat ID");
3280  Func->setComdat(ComdatList[ComdatID - 1]);
3281  }
3282  } else if (hasImplicitComdat(RawLinkage)) {
3283  Func->setComdat(reinterpret_cast<Comdat *>(1));
3284  }
3285 
3286  if (Record.size() > 13 && Record[13] != 0)
3287  FunctionPrefixes.push_back(std::make_pair(Func, Record[13] - 1));
3288 
3289  if (Record.size() > 14 && Record[14] != 0)
3290  FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));
3291 
3292  if (Record.size() > 15) {
3293  Func->setDSOLocal(getDecodedDSOLocal(Record[15]));
3294  }
3295  inferDSOLocal(Func);
3296 
3297  // Record[16] is the address space number.
3298 
3299  // Check whether we have enough values to read a partition name.
3300  if (Record.size() > 18)
3301  Func->setPartition(StringRef(Strtab.data() + Record[17], Record[18]));
3302 
3303  Type *FullTy = PointerType::get(FullFTy, AddrSpace);
3304  assert(Func->getType() == flattenPointerTypes(FullTy) &&
3305  "Incorrect fully specified type provided for Function");
3306  ValueList.push_back(Func, FullTy);
3307 
3308  // If this is a function with a body, remember the prototype we are
3309  // creating now, so that we can match up the body with them later.
3310  if (!isProto) {
3311  Func->setIsMaterializable(true);
3312  FunctionsWithBodies.push_back(Func);
3313  DeferredFunctionInfo[Func] = 0;
3314  }
3315  return Error::success();
3316 }
3317 
3318 Error BitcodeReader::parseGlobalIndirectSymbolRecord(
3319  unsigned BitCode, ArrayRef<uint64_t> Record) {
3320  // v1 ALIAS_OLD: [alias type, aliasee val#, linkage] (name in VST)
3321  // v1 ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility,
3322  // dllstorageclass, threadlocal, unnamed_addr,
3323  // preemption specifier] (name in VST)
3324  // v1 IFUNC: [alias type, addrspace, aliasee val#, linkage,
3325  // visibility, dllstorageclass, threadlocal, unnamed_addr,
3326  // preemption specifier] (name in VST)
3327  // v2: [strtab_offset, strtab_size, v1]
3328  StringRef Name;
3329  std::tie(Name, Record) = readNameFromStrtab(Record);
3330 
3331  bool NewRecord = BitCode != bitc::MODULE_CODE_ALIAS_OLD;
3332  if (Record.size() < (3 + (unsigned)NewRecord))
3333  return error("Invalid record");
3334  unsigned OpNum = 0;
3335  Type *FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
3336  Type *Ty = flattenPointerTypes(FullTy);
3337  if (!Ty)
3338  return error("Invalid record");
3339 
3340  unsigned AddrSpace;
3341  if (!NewRecord) {
3342  auto *PTy = dyn_cast<PointerType>(Ty);
3343  if (!PTy)
3344  return error("Invalid type for value");
3345  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
3346  AddrSpace = PTy->getAddressSpace();
3347  } else {
3348  AddrSpace = Record[OpNum++];
3349  }
3350 
3351  auto Val = Record[OpNum++];
3352  auto Linkage = Record[OpNum++];
3353  GlobalIndirectSymbol *NewGA;
3354  if (BitCode == bitc::MODULE_CODE_ALIAS ||
3355  BitCode == bitc::MODULE_CODE_ALIAS_OLD)
3356  NewGA = GlobalAlias::create(Ty, AddrSpace, getDecodedLinkage(Linkage), Name,
3357  TheModule);
3358  else
3359  NewGA = GlobalIFunc::create(Ty, AddrSpace, getDecodedLinkage(Linkage), Name,
3360  nullptr, TheModule);
3361 
3362  assert(NewGA->getValueType() == flattenPointerTypes(FullTy) &&
3363  "Incorrect fully structured type provided for GlobalIndirectSymbol");
3364  // Old bitcode files didn't have visibility field.
3365  // Local linkage must have default visibility.
3366  if (OpNum != Record.size()) {
3367  auto VisInd = OpNum++;
3368  if (!NewGA->hasLocalLinkage())
3369  // FIXME: Change to an error if non-default in 4.0.
3370  NewGA->setVisibility(getDecodedVisibility(Record[VisInd]));
3371  }
3372  if (BitCode == bitc::MODULE_CODE_ALIAS ||
3373  BitCode == bitc::MODULE_CODE_ALIAS_OLD) {
3374  if (OpNum != Record.size())
3375  NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
3376  else
3377  upgradeDLLImportExportLinkage(NewGA, Linkage);
3378  if (OpNum != Record.size())
3379  NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
3380  if (OpNum != Record.size())
3381  NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
3382  }
3383  if (OpNum != Record.size())
3384  NewGA->setDSOLocal(getDecodedDSOLocal(Record[OpNum++]));
3385  inferDSOLocal(NewGA);
3386 
3387  // Check whether we have enough values to read a partition name.
3388  if (OpNum + 1 < Record.size()) {
3389  NewGA->setPartition(
3390  StringRef(Strtab.data() + Record[OpNum], Record[OpNum + 1]));
3391  OpNum += 2;
3392  }
3393 
3394  FullTy = PointerType::get(FullTy, AddrSpace);
3395  assert(NewGA->getType() == flattenPointerTypes(FullTy) &&
3396  "Incorrect fully structured type provided for GlobalIndirectSymbol");
3397  ValueList.push_back(NewGA, FullTy);
3398  IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
3399  return Error::success();
3400 }
3401 
3402 Error BitcodeReader::parseModule(uint64_t ResumeBit,
3403  bool ShouldLazyLoadMetadata) {
3404  if (ResumeBit) {
3405  if (Error JumpFailed = Stream.JumpToBit(ResumeBit))
3406  return JumpFailed;
3407  } else if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
3408  return Err;
3409 
3411 
3412  // Read all the records for this module.
3413  while (true) {
3414  Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
3415  if (!MaybeEntry)
3416  return MaybeEntry.takeError();
3417  llvm::BitstreamEntry Entry = MaybeEntry.get();
3418 
3419  switch (Entry.Kind) {
3420  case BitstreamEntry::Error:
3421  return error("Malformed block");
3423  return globalCleanup();
3424 
3426  switch (Entry.ID) {
3427  default: // Skip unknown content.
3428  if (Error Err = Stream.SkipBlock())
3429  return Err;
3430  break;
3432  if (readBlockInfo())
3433  return error("Malformed block");
3434  break;
3436  if (Error Err = parseAttributeBlock())
3437  return Err;
3438  break;
3440  if (Error Err = parseAttributeGroupBlock())
3441  return Err;
3442  break;
3444  if (Error Err = parseTypeTable())
3445  return Err;
3446  break;
3448  if (!SeenValueSymbolTable) {
3449  // Either this is an old form VST without function index and an
3450  // associated VST forward declaration record (which would have caused
3451  // the VST to be jumped to and parsed before it was encountered
3452  // normally in the stream), or there were no function blocks to
3453  // trigger an earlier parsing of the VST.
3454  assert(VSTOffset == 0 || FunctionsWithBodies.empty());
3455  if (Error Err = parseValueSymbolTable())
3456  return Err;
3457  SeenValueSymbolTable = true;
3458  } else {
3459  // We must have had a VST forward declaration record, which caused
3460  // the parser to jump to and parse the VST earlier.
3461  assert(VSTOffset > 0);
3462  if (Error Err = Stream.SkipBlock())
3463  return Err;
3464  }
3465  break;
3467  if (Error Err = parseConstants())
3468  return Err;
3469  if (Error Err = resolveGlobalAndIndirectSymbolInits())
3470  return Err;
3471  break;
3473  if (ShouldLazyLoadMetadata) {
3474  if (Error Err = rememberAndSkipMetadata())
3475  return Err;
3476  break;
3477  }
3478  assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata");
3479  if (Error Err = MDLoader->parseModuleMetadata())
3480  return Err;
3481  break;
3483  if (Error Err = MDLoader->parseMetadataKinds())
3484  return Err;
3485  break;
3487  // If this is the first function body we've seen, reverse the
3488  // FunctionsWithBodies list.
3489  if (!SeenFirstFunctionBody) {
3490  std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
3491  if (Error Err = globalCleanup())
3492  return Err;
3493  SeenFirstFunctionBody = true;
3494  }
3495 
3496  if (VSTOffset > 0) {
3497  // If we have a VST forward declaration record, make sure we
3498  // parse the VST now if we haven't already. It is needed to
3499  // set up the DeferredFunctionInfo vector for lazy reading.
3500  if (!SeenValueSymbolTable) {
3501  if (Error Err = BitcodeReader::parseValueSymbolTable(VSTOffset))
3502  return Err;
3503  SeenValueSymbolTable = true;
3504  // Fall through so that we record the NextUnreadBit below.
3505  // This is necessary in case we have an anonymous function that
3506  // is later materialized. Since it will not have a VST entry we
3507  // need to fall back to the lazy parse to find its offset.
3508  } else {
3509  // If we have a VST forward declaration record, but have already
3510  // parsed the VST (just above, when the first function body was
3511  // encountered here), then we are resuming the parse after
3512  // materializing functions. The ResumeBit points to the
3513  // start of the last function block recorded in the
3514  // DeferredFunctionInfo map. Skip it.
3515  if (Error Err = Stream.SkipBlock())
3516  return Err;
3517  continue;
3518  }
3519  }
3520 
3521  // Support older bitcode files that did not have the function
3522  // index in the VST, nor a VST forward declaration record, as
3523  // well as anonymous functions that do not have VST entries.
3524  // Build the DeferredFunctionInfo vector on the fly.
3525  if (Error Err = rememberAndSkipFunctionBody())
3526  return Err;
3527 
3528  // Suspend parsing when we reach the function bodies. Subsequent
3529  // materialization calls will resume it when necessary. If the bitcode
3530  // file is old, the symbol table will be at the end instead and will not
3531  // have been seen yet. In this case, just finish the parse now.
3532  if (SeenValueSymbolTable) {
3533  NextUnreadBit = Stream.GetCurrentBitNo();
3534  // After the VST has been parsed, we need to make sure intrinsic name
3535  // are auto-upgraded.
3536  return globalCleanup();
3537  }
3538  break;
3540  if (Error Err = parseUseLists())
3541  return Err;
3542  break;
3544  if (Error Err = parseOperandBundleTags())
3545  return Err;
3546  break;
3548  if (Error Err = parseSyncScopeNames())
3549  return Err;
3550  break;
3551  }
3552  continue;
3553 
3555  // The interesting case.
3556  break;
3557  }
3558 
3559  // Read a record.
3560  Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
3561  if (!MaybeBitCode)
3562  return MaybeBitCode.takeError();
3563  switch (unsigned BitCode = MaybeBitCode.get()) {
3564  default: break; // Default behavior, ignore unknown content.
3566  Expected<unsigned> VersionOrErr = parseVersionRecord(Record);
3567  if (!VersionOrErr)
3568  return VersionOrErr.takeError();
3569  UseRelativeIDs = *VersionOrErr >= 1;
3570  break;
3571  }
3572  case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
3573  std::string S;
3574  if (convertToString(Record, 0, S))
3575  return error("Invalid record");
3576  TheModule->setTargetTriple(S);
3577  break;
3578  }
3579  case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
3580  std::string S;
3581  if (convertToString(Record, 0, S))
3582  return error("Invalid record");
3583  TheModule->setDataLayout(S);
3584  break;
3585  }
3586  case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
3587  std::string S;
3588  if (convertToString(Record, 0, S))
3589  return error("Invalid record");
3590  TheModule->setModuleInlineAsm(S);
3591  break;
3592  }
3593  case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
3594  // FIXME: Remove in 4.0.
3595  std::string S;
3596  if (convertToString(Record, 0, S))
3597  return error("Invalid record");
3598  // Ignore value.
3599  break;
3600  }
3601  case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
3602  std::string S;
3603  if (convertToString(Record, 0, S))
3604  return error("Invalid record");
3605  SectionTable.push_back(S);
3606  break;
3607  }
3608  case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N]
3609  std::string S;
3610  if (convertToString(Record, 0, S))
3611  return error("Invalid record");
3612  GCTable.push_back(S);
3613  break;
3614  }
3616  if (Error Err = parseComdatRecord(Record))
3617  return Err;
3618  break;
3620  if (Error Err = parseGlobalVarRecord(Record))
3621  return Err;
3622  break;
3624  if (Error Err = parseFunctionRecord(Record))
3625  return Err;
3626  break;
3630  if (Error Err = parseGlobalIndirectSymbolRecord(BitCode, Record))
3631  return Err;
3632  break;
3633  /// MODULE_CODE_VSTOFFSET: [offset]
3635  if (Record.size() < 1)
3636  return error("Invalid record");
3637  // Note that we subtract 1 here because the offset is relative to one word
3638  // before the start of the identification or module block, which was
3639  // historically always the start of the regular bitcode header.
3640  VSTOffset = Record[0] - 1;
3641  break;
3642  /// MODULE_CODE_SOURCE_FILENAME: [namechar x N]
3645  if (convertToString(Record, 0, ValueName))
3646  return error("Invalid record");
3647  TheModule->setSourceFileName(ValueName);
3648  break;
3649  }
3650  Record.clear();
3651  }
3652 }
3653 
3654 Error BitcodeReader::parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata,
3655  bool IsImporting) {
3656  TheModule = M;
3657  MDLoader = MetadataLoader(Stream, *M, ValueList, IsImporting,
3658  [&](unsigned ID) { return getTypeByID(ID); });
3659  return parseModule(0, ShouldLazyLoadMetadata);
3660 }
3661 
3662 Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) {
3663  if (!isa<PointerType>(PtrType))
3664  return error("Load/Store operand is not a pointer type");
3665  Type *ElemType = cast<PointerType>(PtrType)->getElementType();
3666 
3667  if (ValType && ValType != ElemType)
3668  return error("Explicit load/store type does not match pointee "
3669  "type of pointer operand");
3671  return error("Cannot load/store from pointer");
3672  return Error::success();
3673 }
3674 
3675 void BitcodeReader::propagateByValTypes(CallBase *CB,
3676  ArrayRef<Type *> ArgsFullTys) {
3677  for (unsigned i = 0; i != CB->arg_size(); ++i) {
3678  if (!CB->paramHasAttr(i, Attribute::ByVal))
3679  continue;
3680 
3681  CB->removeParamAttr(i, Attribute::ByVal);
3682  CB->addParamAttr(
3684  Context, getPointerElementFlatType(ArgsFullTys[i])));
3685  }
3686 }
3687 
3688 /// Lazily parse the specified function body block.
3689 Error BitcodeReader::parseFunctionBody(Function *F) {
3690  if (Error Err = Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
3691  return Err;
3692 
3693  // Unexpected unresolved metadata when parsing function.
3694  if (MDLoader->hasFwdRefs())
3695  return error("Invalid function metadata: incoming forward references");
3696 
3697  InstructionList.clear();
3698  unsigned ModuleValueListSize = ValueList.size();
3699  unsigned ModuleMDLoaderSize = MDLoader->size();
3700 
3701  // Add all the function arguments to the value table.
3702  unsigned ArgNo = 0;
3703  FunctionType *FullFTy = FunctionTypes[F];
3704  for (Argument &I : F->args()) {
3705  assert(I.getType() == flattenPointerTypes(FullFTy->getParamType(ArgNo)) &&
3706  "Incorrect fully specified type for Function Argument");
3707  ValueList.push_back(&I, FullFTy->getParamType(ArgNo++));
3708  }
3709  unsigned NextValueNo = ValueList.size();
3710  BasicBlock *CurBB = nullptr;
3711  unsigned CurBBNo = 0;
3712 
3713  DebugLoc LastLoc;
3714  auto getLastInstruction = [&]() -> Instruction * {
3715  if (CurBB && !CurBB->empty())
3716  return &CurBB->back();
3717  else if (CurBBNo && FunctionBBs[CurBBNo - 1] &&
3718  !FunctionBBs[CurBBNo - 1]->empty())
3719  return &FunctionBBs[CurBBNo - 1]->back();
3720  return nullptr;
3721  };
3722 
3723  std::vector<OperandBundleDef> OperandBundles;
3724 
3725  // Read all the records.
3727 
3728  while (true) {
3729  Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
3730  if (!MaybeEntry)
3731  return MaybeEntry.takeError();
3732  llvm::BitstreamEntry Entry = MaybeEntry.get();
3733 
3734  switch (Entry.Kind) {
3735  case BitstreamEntry::Error:
3736  return error("Malformed block");
3738  goto OutOfRecordLoop;
3739 
3741  switch (Entry.ID) {
3742  default: // Skip unknown content.
3743  if (Error Err = Stream.SkipBlock())
3744  return Err;
3745  break;
3747  if (Error Err = parseConstants())
3748  return Err;
3749  NextValueNo = ValueList.size();
3750  break;
3752  if (Error Err = parseValueSymbolTable())
3753  return Err;
3754  break;
3756  if (Error Err = MDLoader->parseMetadataAttachment(*F, InstructionList))
3757  return Err;
3758  break;
3760  assert(DeferredMetadataInfo.empty() &&
3761  "Must read all module-level metadata before function-level");
3762  if (Error Err = MDLoader->parseFunctionMetadata())
3763  return Err;
3764  break;
3766  if (Error Err = parseUseLists())
3767  return Err;
3768  break;
3769  }
3770  continue;
3771 
3773  // The interesting case.
3774  break;
3775  }
3776 
3777  // Read a record.
3778  Record.clear();
3779  Instruction *I = nullptr;
3780  Type *FullTy = nullptr;
3781  Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
3782  if (!MaybeBitCode)
3783  return MaybeBitCode.takeError();
3784  switch (unsigned BitCode = MaybeBitCode.get()) {
3785  default: // Default behavior: reject
3786  return error("Invalid value");
3787  case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
3788  if (Record.size() < 1 || Record[0] == 0)
3789  return error("Invalid record");
3790  // Create all the basic blocks for the function.
3791  FunctionBBs.resize(Record[0]);
3792 
3793  // See if anything took the address of blocks in this function.
3794  auto BBFRI = BasicBlockFwdRefs.find(F);
3795  if (BBFRI == BasicBlockFwdRefs.end()) {
3796  for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
3797  FunctionBBs[i] = BasicBlock::Create(Context, "", F);
3798  } else {
3799  auto &BBRefs = BBFRI->second;
3800  // Check for invalid basic block references.
3801  if (BBRefs.size() > FunctionBBs.size())
3802  return error("Invalid ID");
3803  assert(!BBRefs.empty() && "Unexpected empty array");
3804  assert(!BBRefs.front() && "Invalid reference to entry block");
3805  for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
3806  ++I)
3807  if (I < RE && BBRefs[I]) {
3808  BBRefs[I]->insertInto(F);
3809  FunctionBBs[I] = BBRefs[I];
3810  } else {
3811  FunctionBBs[I] = BasicBlock::Create(Context, "", F);
3812  }
3813 
3814  // Erase from the table.
3815  BasicBlockFwdRefs.erase(BBFRI);
3816  }
3817 
3818  CurBB = FunctionBBs[0];
3819  continue;
3820  }
3821 
3822  case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN
3823  // This record indicates that the last instruction is at the same
3824  // location as the previous instruction with a location.
3825  I = getLastInstruction();
3826 
3827  if (!I)
3828  return error("Invalid record");
3829  I->setDebugLoc(LastLoc);
3830  I = nullptr;
3831  continue;
3832 
3833  case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
3834  I = getLastInstruction();
3835  if (!I || Record.size() < 4)
3836  return error("Invalid record");
3837 
3838  unsigned Line = Record[0], Col = Record[1];
3839  unsigned ScopeID = Record[2], IAID = Record[3];
3840  bool isImplicitCode = Record.size() == 5 && Record[4];
3841 
3842  MDNode *Scope = nullptr, *IA = nullptr;
3843  if (ScopeID) {
3844  Scope = dyn_cast_or_null<MDNode>(
3845  MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1));
3846  if (!Scope)
3847  return error("Invalid record");
3848  }
3849  if (IAID) {
3850  IA = dyn_cast_or_null<MDNode>(
3851  MDLoader->getMetadataFwdRefOrLoad(IAID - 1));
3852  if (!IA)
3853  return error("Invalid record");
3854  }
3855  LastLoc = DebugLoc::get(Line, Col, Scope, IA, isImplicitCode);
3856  I->setDebugLoc(LastLoc);
3857  I = nullptr;
3858  continue;
3859  }
3860  case bitc::FUNC_CODE_INST_UNOP: { // UNOP: [opval, ty, opcode]
3861  unsigned OpNum = 0;
3862  Value *LHS;
3863  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
3864  OpNum+1 > Record.size())
3865  return error("Invalid record");
3866 
3867  int Opc = getDecodedUnaryOpcode(Record[OpNum++], LHS->getType());
3868  if (Opc == -1)
3869  return error("Invalid record");
3871  InstructionList.push_back(I);
3872  if (OpNum < Record.size()) {
3873  if (isa<FPMathOperator>(I)) {
3874  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
3875  if (FMF.any())
3876  I->setFastMathFlags(FMF);
3877  }
3878  }
3879  break;
3880  }
3881  case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
3882  unsigned OpNum = 0;
3883  Value *LHS, *RHS;
3884  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
3885  popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
3886  OpNum+1 > Record.size())
3887  return error("Invalid record");
3888 
3889  int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
3890  if (Opc == -1)
3891  return error("Invalid record");
3892  I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3893  InstructionList.push_back(I);
3894  if (OpNum < Record.size()) {
3895  if (Opc == Instruction::Add ||
3896  Opc == Instruction::Sub ||
3897  Opc == Instruction::Mul ||
3898  Opc == Instruction::Shl) {
3899  if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
3900  cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
3901  if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
3902  cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
3903  } else if (Opc == Instruction::SDiv ||
3904  Opc == Instruction::UDiv ||
3905  Opc == Instruction::LShr ||
3906  Opc == Instruction::AShr) {
3907  if (Record[OpNum] & (1 << bitc::PEO_EXACT))
3908  cast<BinaryOperator>(I)->setIsExact(true);
3909  } else if (isa<FPMathOperator>(I)) {
3910  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
3911  if (FMF.any())
3912  I->setFastMathFlags(FMF);
3913  }
3914 
3915  }
3916  break;
3917  }
3918  case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
3919  unsigned OpNum = 0;
3920  Value *Op;
3921  if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
3922  OpNum+2 != Record.size())
3923  return error("Invalid record");
3924 
3925  FullTy = getFullyStructuredTypeByID(Record[OpNum]);
3926  Type *ResTy = flattenPointerTypes(FullTy);
3927  int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
3928  if (Opc == -1 || !ResTy)
3929  return error("Invalid record");
3930  Instruction *Temp = nullptr;
3931  if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
3932  if (Temp) {
3933  InstructionList.push_back(Temp);
3934  CurBB->getInstList().push_back(Temp);
3935  }
3936  } else {
3937  auto CastOp = (Instruction::CastOps)Opc;
3938  if (!CastInst::castIsValid(CastOp, Op, ResTy))
3939  return error("Invalid cast");
3940  I = CastInst::Create(CastOp, Op, ResTy);
3941  }
3942  InstructionList.push_back(I);
3943  break;
3944  }
3947  case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands]
3948  unsigned OpNum = 0;
3949 
3950  Type *Ty;
3951  bool InBounds;
3952 
3953  if (BitCode == bitc::FUNC_CODE_INST_GEP) {
3954  InBounds = Record[OpNum++];
3955  FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
3956  Ty = flattenPointerTypes(FullTy);
3957  } else {
3958  InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD;
3959  Ty = nullptr;
3960  }
3961 
3962  Value *BasePtr;
3963  Type *FullBaseTy = nullptr;
3964  if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, &FullBaseTy))
3965  return error("Invalid record");
3966 
3967  if (!Ty) {
3968  std::tie(FullTy, Ty) =
3969  getPointerElementTypes(FullBaseTy->getScalarType());
3970  } else if (Ty != getPointerElementFlatType(FullBaseTy->getScalarType()))
3971  return error(
3972  "Explicit gep type does not match pointee type of pointer operand");
3973 
3974  SmallVector<Value*, 16> GEPIdx;
3975  while (OpNum != Record.size()) {
3976  Value *Op;
3977  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
3978  return error("Invalid record");
3979  GEPIdx.push_back(Op);
3980  }
3981 
3982  I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);
3983  FullTy = GetElementPtrInst::getGEPReturnType(FullTy, I, GEPIdx);
3984 
3985  InstructionList.push_back(I);
3986  if (InBounds)
3987  cast<GetElementPtrInst>(I)->setIsInBounds(true);
3988  break;
3989  }
3990 
3992  // EXTRACTVAL: [opty, opval, n x indices]
3993  unsigned OpNum = 0;
3994  Value *Agg;
3995  if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
3996  return error("Invalid record");
3997 
3998  unsigned RecSize = Record.size();
3999  if (OpNum == RecSize)
4000  return error("EXTRACTVAL: Invalid instruction with 0 indices");
4001 
4002  SmallVector<unsigned, 4> EXTRACTVALIdx;
4003  for (; OpNum != RecSize; ++OpNum) {
4004  bool IsArray = FullTy->isArrayTy();
4005  bool IsStruct = FullTy->isStructTy();
4006  uint64_t Index = Record[OpNum];
4007 
4008  if (!IsStruct && !IsArray)
4009  return error("EXTRACTVAL: Invalid type");
4010  if ((unsigned)Index != Index)
4011  return error("Invalid value");
4012  if (IsStruct && Index >= FullTy->getStructNumElements())
4013  return error("EXTRACTVAL: Invalid struct index");
4014  if (IsArray && Index >= FullTy->getArrayNumElements())
4015  return error("EXTRACTVAL: Invalid array index");
4016  EXTRACTVALIdx.push_back((unsigned)Index);
4017 
4018  if (IsStruct)
4019  FullTy = FullTy->getStructElementType(Index);
4020  else
4021  FullTy = FullTy->getArrayElementType();
4022  }
4023 
4024  I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
4025  InstructionList.push_back(I);
4026  break;
4027  }
4028 
4030  // INSERTVAL: [opty, opval, opty, opval, n x indices]
4031  unsigned OpNum = 0;
4032  Value *Agg;
4033  if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
4034  return error("Invalid record");
4035  Value *Val;
4036  if (getValueTypePair(Record, OpNum, NextValueNo, Val))
4037  return error("Invalid record");
4038 
4039  unsigned RecSize = Record.size();
4040  if (OpNum == RecSize)
4041  return error("INSERTVAL: Invalid instruction with 0 indices");
4042 
4043  SmallVector<unsigned, 4> INSERTVALIdx;
4044  Type *CurTy = Agg->getType();
4045  for (; OpNum != RecSize; ++OpNum) {
4046  bool IsArray = CurTy->isArrayTy();
4047  bool IsStruct = CurTy->isStructTy();
4048  uint64_t Index = Record[OpNum];
4049 
4050  if (!IsStruct && !IsArray)
4051  return error("INSERTVAL: Invalid type");
4052  if ((unsigned)Index != Index)
4053  return error("Invalid value");
4054  if (IsStruct && Index >= CurTy->getStructNumElements())
4055  return error("INSERTVAL: Invalid struct index");
4056  if (IsArray && Index >= CurTy->getArrayNumElements())
4057  return error("INSERTVAL: Invalid array index");
4058 
4059  INSERTVALIdx.push_back((unsigned)Index);
4060  if (IsStruct)
4061  CurTy = CurTy->getStructElementType(Index);
4062  else
4063  CurTy = CurTy->getArrayElementType();
4064  }
4065 
4066  if (CurTy != Val->getType())
4067  return error("Inserted value type doesn't match aggregate type");
4068 
4069  I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);
4070  InstructionList.push_back(I);
4071  break;
4072  }
4073 
4074  case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
4075  // obsolete form of select
4076  // handles select i1 ... in old bitcode
4077  unsigned OpNum = 0;
4078  Value *TrueVal, *FalseVal, *Cond;
4079  if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
4080  popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
4081  popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
4082  return error("Invalid record");
4083 
4084  I = SelectInst::Create(Cond, TrueVal, FalseVal);
4085  InstructionList.push_back(I);
4086  break;
4087  }
4088 
4089  case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
4090  // new form of select
4091  // handles select i1 or select [N x i1]
4092  unsigned OpNum = 0;
4093  Value *TrueVal, *FalseVal, *Cond;
4094  if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
4095  popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
4096  getValueTypePair(Record, OpNum, NextValueNo, Cond))
4097  return error("Invalid record");
4098 
4099  // select condition can be either i1 or [N x i1]
4100  if (VectorType* vector_type =
4101  dyn_cast<VectorType>(Cond->getType())) {
4102  // expect <n x i1>
4103  if (vector_type->getElementType() != Type::getInt1Ty(Context))
4104  return error("Invalid type for value");
4105  } else {
4106  // expect i1
4107  if (Cond->getType() != Type::getInt1Ty(Context))
4108  return error("Invalid type for value");
4109  }
4110 
4111  I = SelectInst::Create(Cond, TrueVal, FalseVal);
4112  InstructionList.push_back(I);
4113  if (OpNum < Record.size() && isa<FPMathOperator>(I)) {
4114  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
4115  if (FMF.any())
4116  I->setFastMathFlags(FMF);
4117  }
4118  break;
4119  }
4120 
4121  case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
4122  unsigned OpNum = 0;
4123  Value *Vec, *Idx;
4124  if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy) ||
4125  getValueTypePair(Record, OpNum, NextValueNo, Idx))
4126  return error("Invalid record");
4127  if (!Vec->getType()->isVectorTy())
4128  return error("Invalid type for value");
4129  I = ExtractElementInst::Create(Vec, Idx);
4130  FullTy = FullTy->getVectorElementType();
4131  InstructionList.push_back(I);
4132  break;
4133  }
4134 
4135  case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
4136  unsigned OpNum = 0;
4137  Value *Vec, *Elt, *Idx;
4138  if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy))
4139  return error("Invalid record");
4140  if (!Vec->getType()->isVectorTy())
4141  return error("Invalid type for value");
4142  if (popValue(Record, OpNum, NextValueNo,
4143  cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
4144  getValueTypePair(Record, OpNum, NextValueNo, Idx))
4145  return error("Invalid record");
4146  I = InsertElementInst::Create(Vec, Elt, Idx);
4147  InstructionList.push_back(I);
4148  break;
4149  }
4150 
4151  case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
4152  unsigned OpNum = 0;
4153  Value *Vec1, *Vec2, *Mask;
4154  if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, &FullTy) ||
4155  popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
4156  return error("Invalid record");
4157 
4158  if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
4159  return error("Invalid record");
4160  if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())
4161  return error("Invalid type for value");
4162  I = new ShuffleVectorInst(Vec1, Vec2, Mask);
4163  FullTy = VectorType::get(FullTy->getVectorElementType(),
4164  Mask->getType()->getVectorNumElements());
4165  InstructionList.push_back(I);
4166  break;
4167  }
4168 
4169  case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred]
4170  // Old form of ICmp/FCmp returning bool
4171  // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
4172  // both legal on vectors but had different behaviour.
4173  case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
4174  // FCmp/ICmp returning bool or vector of bool
4175 
4176  unsigned OpNum = 0;
4177  Value *LHS, *RHS;
4178  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
4179  popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
4180  return error("Invalid record");
4181 
4182  if (OpNum >= Record.size())
4183  return error(
4184  "Invalid record: operand number exceeded available operands");
4185 
4186  unsigned PredVal = Record[OpNum];
4187  bool IsFP = LHS->getType()->isFPOrFPVectorTy();
4188  FastMathFlags FMF;
4189  if (IsFP && Record.size() > OpNum+1)
4190  FMF = getDecodedFastMathFlags(Record[++OpNum]);
4191 
4192  if (OpNum+1 != Record.size())
4193  return error("Invalid record");
4194 
4195  if (LHS->getType()->isFPOrFPVectorTy())
4196  I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS);
4197  else
4198  I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS);
4199 
4200  if (FMF.any())
4201  I->setFastMathFlags(FMF);
4202  InstructionList.push_back(I);
4203  break;
4204  }
4205 
4206  case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
4207  {
4208  unsigned Size = Record.size();
4209  if (Size == 0) {
4210  I = ReturnInst::Create(Context);
4211  InstructionList.push_back(I);
4212  break;
4213  }
4214 
4215  unsigned OpNum = 0;
4216  Value *Op = nullptr;
4217  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
4218  return error("Invalid record");
4219  if (OpNum != Record.size())
4220  return error("Invalid record");
4221 
4222  I = ReturnInst::Create(Context, Op);
4223  InstructionList.push_back(I);
4224  break;
4225  }
4226  case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
4227  if (Record.size() != 1 && Record.size() != 3)
4228  return error("Invalid record");
4229  BasicBlock *TrueDest = getBasicBlock(Record[0]);
4230  if (!TrueDest)
4231  return error("Invalid record");
4232 
4233  if (Record.size() == 1) {
4234  I = BranchInst::Create(TrueDest);
4235  InstructionList.push_back(I);
4236  }
4237  else {
4238  BasicBlock *FalseDest = getBasicBlock(Record[1]);
4239  Value *Cond = getValue(Record, 2, NextValueNo,
4240  Type::getInt1Ty(Context));
4241  if (!FalseDest || !Cond)
4242  return error("Invalid record");
4243  I = BranchInst::Create(TrueDest, FalseDest, Cond);
4244  InstructionList.push_back(I);
4245  }
4246  break;
4247  }
4248  case bitc::FUNC_CODE_INST_CLEANUPRET: { // CLEANUPRET: [val] or [val,bb#]
4249  if (Record.size() != 1 && Record.size() != 2)
4250  return error("Invalid record");
4251  unsigned Idx = 0;
4252  Value *CleanupPad =
4253  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4254  if (!CleanupPad)
4255  return error("Invalid record");
4256  BasicBlock *UnwindDest = nullptr;
4257  if (Record.size() == 2) {
4258  UnwindDest = getBasicBlock(Record[Idx++]);
4259  if (!UnwindDest)
4260  return error("Invalid record");
4261  }
4262 
4263  I = CleanupReturnInst::Create(CleanupPad, UnwindDest);
4264  InstructionList.push_back(I);
4265  break;
4266  }
4267  case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [val,bb#]
4268  if (Record.size() != 2)
4269  return error("Invalid record");
4270  unsigned Idx = 0;
4271  Value *CatchPad =
4272  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4273  if (!CatchPad)
4274  return error("Invalid record");
4275  BasicBlock *BB = getBasicBlock(Record[Idx++]);
4276  if (!BB)
4277  return error("Invalid record");
4278 
4279  I = CatchReturnInst::Create(CatchPad, BB);
4280  InstructionList.push_back(I);
4281  break;
4282  }
4283  case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?]
4284  // We must have, at minimum, the outer scope and the number of arguments.
4285  if (Record.size() < 2)
4286  return error("Invalid record");
4287 
4288  unsigned Idx = 0;
4289 
4290  Value *ParentPad =
4291  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4292 
4293  unsigned NumHandlers = Record[Idx++];
4294 
4296  for (unsigned Op = 0; Op != NumHandlers; ++Op) {
4297  BasicBlock *BB = getBasicBlock(Record[Idx++]);
4298  if (!BB)
4299  return error("Invalid record");
4300  Handlers.push_back(BB);
4301  }
4302 
4303  BasicBlock *UnwindDest = nullptr;
4304  if (Idx + 1 == Record.size()) {
4305  UnwindDest = getBasicBlock(Record[Idx++]);
4306  if (!UnwindDest)
4307  return error("Invalid record");
4308  }
4309 
4310  if (Record.size() != Idx)
4311  return error("Invalid record");
4312 
4313  auto *CatchSwitch =
4314  CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers);
4315  for (BasicBlock *Handler : Handlers)
4316  CatchSwitch->addHandler(Handler);
4317  I = CatchSwitch;
4318  InstructionList.push_back(I);
4319  break;
4320  }
4322  case bitc::FUNC_CODE_INST_CLEANUPPAD: { // [tok,num,(ty,val)*]
4323  // We must have, at minimum, the outer scope and the number of arguments.
4324  if (Record.size() < 2)
4325  return error("Invalid record");
4326 
4327  unsigned Idx = 0;
4328 
4329  Value *ParentPad =
4330  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4331 
4332  unsigned NumArgOperands = Record[Idx++];
4333 
4335  for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
4336  Value *Val;
4337  if (getValueTypePair(Record, Idx, NextValueNo, Val))
4338  return error("Invalid record");
4339  Args.push_back(Val);
4340  }
4341 
4342  if (Record.size() != Idx)
4343  return error("Invalid record");
4344 
4345  if (BitCode == bitc::FUNC_CODE_INST_CLEANUPPAD)
4346  I = CleanupPadInst::Create(ParentPad, Args);
4347  else
4348  I = CatchPadInst::Create(ParentPad, Args);
4349  InstructionList.push_back(I);
4350  break;
4351  }
4352  case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
4353  // Check magic
4354  if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
4355  // "New" SwitchInst format with case ranges. The changes to write this
4356  // format were reverted but we still recognize bitcode that uses it.
4357  // Hopefully someday we will have support for case ranges and can use
4358  // this format again.
4359 
4360  Type *OpTy = getTypeByID(Record[1]);
4361  unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
4362 
4363  Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
4364  BasicBlock *Default = getBasicBlock(Record[3]);
4365  if (!OpTy || !Cond || !Default)
4366  return error("Invalid record");
4367 
4368  unsigned NumCases = Record[4];
4369 
4370  SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
4371  InstructionList.push_back(SI);
4372 
4373  unsigned CurIdx = 5;
4374  for (unsigned i = 0; i != NumCases; ++i) {
4376  unsigned NumItems = Record[CurIdx++];
4377  for (unsigned ci = 0; ci != NumItems; ++ci) {
4378  bool isSingleNumber = Record[CurIdx++];
4379 
4380  APInt Low;
4381  unsigned ActiveWords = 1;
4382  if (ValueBitWidth > 64)
4383  ActiveWords = Record[CurIdx++];
4384  Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
4385  ValueBitWidth);
4386  CurIdx += ActiveWords;
4387 
4388  if (!isSingleNumber) {
4389  ActiveWords = 1;
4390  if (ValueBitWidth > 64)
4391  ActiveWords = Record[CurIdx++];
4393  makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth);
4394  CurIdx += ActiveWords;
4395 
4396  // FIXME: It is not clear whether values in the range should be
4397  // compared as signed or unsigned values. The partially
4398  // implemented changes that used this format in the past used
4399  // unsigned comparisons.
4400  for ( ; Low.ule(High); ++Low)
4401  CaseVals.push_back(ConstantInt::get(Context, Low));
4402  } else
4403  CaseVals.push_back(ConstantInt::get(Context, Low));
4404  }
4405  BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
4406  for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
4407  cve = CaseVals.end(); cvi != cve; ++cvi)
4408  SI->addCase(*cvi, DestBB);
4409  }
4410  I = SI;
4411  break;
4412  }
4413 
4414  // Old SwitchInst format without case ranges.
4415 
4416  if (Record.size() < 3 || (Record.size() & 1) == 0)
4417  return error("Invalid record");
4418  Type *OpTy = getTypeByID(Record[0]);
4419  Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
4420  BasicBlock *Default = getBasicBlock(Record[2]);
4421  if (!OpTy || !Cond || !Default)
4422  return error("Invalid record");
4423  unsigned NumCases = (Record.size()-3)/2;
4424  SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
4425  InstructionList.push_back(SI);
4426  for (unsigned i = 0, e = NumCases; i != e; ++i) {
4427  ConstantInt *CaseVal =
4428  dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
4429  BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
4430  if (!CaseVal || !DestBB) {
4431  delete SI;
4432  return error("Invalid record");
4433  }
4434  SI->addCase(CaseVal, DestBB);
4435  }
4436  I = SI;
4437  break;
4438  }
4439  case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
4440  if (Record.size() < 2)
4441  return error("Invalid record");
4442  Type *OpTy = getTypeByID(Record[0]);
4443  Value *Address = getValue(Record, 1, NextValueNo, OpTy);
4444  if (!OpTy || !Address)
4445  return error("Invalid record");
4446  unsigned NumDests = Record.size()-2;
4447  IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
4448  InstructionList.push_back(IBI);
4449  for (unsigned i = 0, e = NumDests; i != e; ++i) {
4450  if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
4451  IBI->addDestination(DestBB);
4452  } else {
4453  delete IBI;
4454  return error("Invalid record");
4455  }
4456  }
4457  I = IBI;
4458  break;
4459  }
4460 
4462  // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
4463  if (Record.size() < 4)
4464  return error("Invalid record");
4465  unsigned OpNum = 0;
4466  AttributeList PAL = getAttributes(Record[OpNum++]);
4467  unsigned CCInfo = Record[OpNum++];
4468  BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
4469  BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
4470 
4471  FunctionType *FTy = nullptr;
4472  FunctionType *FullFTy = nullptr;
4473  if ((CCInfo >> 13) & 1) {
4474  FullFTy =
4475  dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
4476  if (!FullFTy)
4477  return error("Explicit invoke type is not a function type");
4478  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4479  }
4480 
4481  Value *Callee;
4482  if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
4483  return error("Invalid record");
4484 
4485  PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
4486  if (!CalleeTy)
4487  return error("Callee is not a pointer");
4488  if (!FTy) {
4489  FullFTy =
4490  dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
4491  if (!FullFTy)
4492  return error("Callee is not of pointer to function type");
4493  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4494  } else if (getPointerElementFlatType(FullTy) != FTy)
4495  return error("Explicit invoke type does not match pointee type of "
4496  "callee operand");
4497  if (Record.size() < FTy->getNumParams() + OpNum)
4498  return error("Insufficient operands to call");
4499 
4501  SmallVector<Type *, 16> ArgsFullTys;
4502  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
4503  Ops.push_back(getValue(Record, OpNum, NextValueNo,
4504  FTy->getParamType(i)));
4505  ArgsFullTys.push_back(FullFTy->getParamType(i));
4506  if (!Ops.back())
4507  return error("Invalid record");
4508  }
4509 
4510  if (!FTy->isVarArg()) {
4511  if (Record.size() != OpNum)
4512  return error("Invalid record");
4513  } else {
4514  // Read type/value pairs for varargs params.
4515  while (OpNum != Record.size()) {
4516  Value *Op;
4517  Type *FullTy;
4518  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
4519  return error("Invalid record");
4520  Ops.push_back(Op);
4521  ArgsFullTys.push_back(FullTy);
4522  }
4523  }
4524 
4525  I = InvokeInst::Create(FTy, Callee, NormalBB, UnwindBB, Ops,
4526  OperandBundles);
4527  FullTy = FullFTy->getReturnType();
4528  OperandBundles.clear();
4529  InstructionList.push_back(I);
4530  cast<InvokeInst>(I)->setCallingConv(
4531  static_cast<CallingConv::ID>(CallingConv::MaxID & CCInfo));
4532  cast<InvokeInst>(I)->setAttributes(PAL);
4533  propagateByValTypes(cast<CallBase>(I), ArgsFullTys);
4534 
4535  break;
4536  }
4537  case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
4538  unsigned Idx = 0;
4539  Value *Val = nullptr;
4540  if (getValueTypePair(Record, Idx, NextValueNo, Val))
4541  return error("Invalid record");
4542  I = ResumeInst::Create(Val);
4543  InstructionList.push_back(I);
4544  break;
4545  }
4547  // CALLBR: [attr, cc, norm, transfs, fty, fnid, args]
4548  unsigned OpNum = 0;
4549  AttributeList PAL = getAttributes(Record[OpNum++]);
4550  unsigned CCInfo = Record[OpNum++];
4551 
4552  BasicBlock *DefaultDest = getBasicBlock(Record[OpNum++]);
4553  unsigned NumIndirectDests = Record[OpNum++];
4554  SmallVector<BasicBlock *, 16> IndirectDests;
4555  for (unsigned i = 0, e = NumIndirectDests; i != e; ++i)
4556  IndirectDests.push_back(getBasicBlock(Record[OpNum++]));
4557 
4558  FunctionType *FTy = nullptr;
4559  FunctionType *FullFTy = nullptr;
4560  if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
4561  FullFTy =
4562  dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
4563  if (!FullFTy)
4564  return error("Explicit call type is not a function type");
4565  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4566  }
4567 
4568  Value *Callee;
4569  if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
4570  return error("Invalid record");
4571 
4572  PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
4573  if (!OpTy)
4574  return error("Callee is not a pointer type");
4575  if (!FTy) {
4576  FullFTy =
4577  dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
4578  if (!FullFTy)
4579  return error("Callee is not of pointer to function type");
4580  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4581  } else if (getPointerElementFlatType(FullTy) != FTy)
4582  return error("Explicit call type does not match pointee type of "
4583  "callee operand");
4584  if (Record.size() < FTy->getNumParams() + OpNum)
4585  return error("Insufficient operands to call");
4586 
4588  // Read the fixed params.
4589  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
4590  if (FTy->getParamType(i)->isLabelTy())
4591  Args.push_back(getBasicBlock(Record[OpNum]));
4592  else
4593  Args.push_back(getValue(Record, OpNum, NextValueNo,
4594  FTy->getParamType(i)));
4595  if (!Args.back())
4596  return error("Invalid record");
4597  }
4598 
4599  // Read type/value pairs for varargs params.
4600  if (!FTy->isVarArg()) {
4601  if (OpNum != Record.size())
4602  return error("Invalid record");
4603  } else {
4604  while (OpNum != Record.size()) {
4605  Value *Op;
4606  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
4607  return error("Invalid record");
4608  Args.push_back(Op);
4609  }
4610  }
4611 
4612  I = CallBrInst::Create(FTy, Callee, DefaultDest, IndirectDests, Args,
4613  OperandBundles);
4614  FullTy = FullFTy->getReturnType();
4615  OperandBundles.clear();
4616  InstructionList.push_back(I);
4617  cast<CallBrInst>(I)->setCallingConv(
4618  static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV));
4619  cast<CallBrInst>(I)->setAttributes(PAL);
4620  break;
4621  }
4622  case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
4623  I = new UnreachableInst(Context);
4624  InstructionList.push_back(I);
4625  break;
4626  case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
4627  if (Record.size() < 1 || ((Record.size()-1)&1))
4628  return error("Invalid record");
4629  FullTy = getFullyStructuredTypeByID(Record[0]);
4630  Type *Ty = flattenPointerTypes(FullTy);
4631  if (!Ty)
4632  return error("Invalid record");
4633 
4634  PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
4635  InstructionList.push_back(PN);
4636 
4637  for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
4638  Value *V;
4639  // With the new function encoding, it is possible that operands have
4640  // negative IDs (for forward references). Use a signed VBR
4641  // representation to keep the encoding small.
4642  if (UseRelativeIDs)
4643  V = getValueSigned(Record, 1+i, NextValueNo, Ty);
4644  else
4645  V = getValue(Record, 1+i, NextValueNo, Ty);
4646  BasicBlock *BB = getBasicBlock(Record[2+i]);
4647  if (!V || !BB)
4648  return error("Invalid record");
4649  PN->addIncoming(V, BB);
4650  }
4651  I = PN;
4652  break;
4653  }
4654 
4657  // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
4658  unsigned Idx = 0;
4659  if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD) {
4660  if (Record.size() < 3)
4661  return error("Invalid record");
4662  } else {
4664  if (Record.size() < 4)
4665  return error("Invalid record");
4666  }
4667  FullTy = getFullyStructuredTypeByID(Record[Idx++]);
4668  Type *Ty = flattenPointerTypes(FullTy);
4669  if (!Ty)
4670  return error("Invalid record");
4671  if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {
4672  Value *PersFn = nullptr;
4673  if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
4674  return error("Invalid record");
4675 
4676  if (!F->hasPersonalityFn())
4677  F->setPersonalityFn(cast<Constant>(PersFn));
4678  else if (F->getPersonalityFn() != cast<Constant>(PersFn))
4679  return error("Personality function mismatch");
4680  }
4681 
4682  bool IsCleanup = !!Record[Idx++];
4683  unsigned NumClauses = Record[Idx++];
4684  LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses);
4685  LP->setCleanup(IsCleanup);
4686  for (unsigned J = 0; J != NumClauses; ++J) {
4688  LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
4689  Value *Val;
4690 
4691  if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
4692  delete LP;
4693  return error("Invalid record");
4694  }
4695 
4696  assert((CT != LandingPadInst::Catch ||
4697  !isa<ArrayType>(Val->getType())) &&
4698  "Catch clause has a invalid type!");
4699  assert((CT != LandingPadInst::Filter ||
4700  isa<ArrayType>(Val->getType())) &&
4701  "Filter clause has invalid type!");
4702  LP->addClause(cast<Constant>(Val));
4703  }
4704 
4705  I = LP;
4706  InstructionList.push_back(I);
4707  break;
4708  }
4709 
4710  case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
4711  if (Record.size() != 4)
4712  return error("Invalid record");
4713  uint64_t AlignRecord = Record[3];
4714  const uint64_t InAllocaMask = uint64_t(1) << 5;
4715  const uint64_t ExplicitTypeMask = uint64_t(1) << 6;
4716  const uint64_t SwiftErrorMask = uint64_t(1) << 7;
4717  const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask |
4718  SwiftErrorMask;
4719  bool InAlloca = AlignRecord & InAllocaMask;
4720  bool SwiftError = AlignRecord & SwiftErrorMask;
4721  FullTy = getFullyStructuredTypeByID(Record[0]);
4722  Type *Ty = flattenPointerTypes(FullTy);
4723  if ((AlignRecord & ExplicitTypeMask) == 0) {
4724  auto *PTy = dyn_cast_or_null<PointerType>(Ty);
4725  if (!PTy)
4726  return error("Old-style alloca with a non-pointer type");
4727  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
4728  }
4729  Type *OpTy = getTypeByID(Record[1]);
4730  Value *Size = getFnValueByID(Record[2], OpTy);
4731  unsigned Align;
4732  if (Error Err = parseAlignmentValue(AlignRecord & ~FlagMask, Align)) {
4733  return Err;
4734  }
4735  if (!Ty || !Size)
4736  return error("Invalid record");
4737 
4738  // FIXME: Make this an optional field.
4739  const DataLayout &DL = TheModule->getDataLayout();
4740  unsigned AS = DL.getAllocaAddrSpace();
4741 
4742  AllocaInst *AI = new AllocaInst(Ty, AS, Size, Align);
4743  AI->setUsedWithInAlloca(InAlloca);
4744  AI->setSwiftError(SwiftError);
4745  I = AI;
4746  FullTy = PointerType::get(FullTy, AS);
4747  InstructionList.push_back(I);
4748  break;
4749  }
4750  case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
4751  unsigned OpNum = 0;
4752  Value *Op;
4753  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
4754  (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
4755  return error("Invalid record");
4756 
4757  if (!isa<PointerType>(Op->getType()))
4758  return error("Load operand is not a pointer type");
4759 
4760  Type *Ty = nullptr;
4761  if (OpNum + 3 == Record.size()) {
4762  FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
4763  Ty = flattenPointerTypes(FullTy);
4764  } else
4765  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
4766 
4767  if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
4768  return Err;
4769 
4770  unsigned Align;
4771  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4772  return Err;
4773  I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
4774  InstructionList.push_back(I);
4775  break;
4776  }
4778  // LOADATOMIC: [opty, op, align, vol, ordering, ssid]
4779  unsigned OpNum = 0;
4780  Value *Op;
4781  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
4782  (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
4783  return error("Invalid record");
4784 
4785  if (!isa<PointerType>(Op->getType()))
4786  return error("Load operand is not a pointer type");
4787 
4788  Type *Ty = nullptr;
4789  if (OpNum + 5 == Record.size()) {
4790  FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
4791  Ty = flattenPointerTypes(FullTy);
4792  } else
4793  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
4794 
4795  if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
4796  return Err;
4797 
4798  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4799  if (Ordering == AtomicOrdering::NotAtomic ||
4800  Ordering == AtomicOrdering::Release ||
4801  Ordering == AtomicOrdering::AcquireRelease)
4802  return error("Invalid record");
4803  if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
4804  return error("Invalid record");
4805  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
4806 
4807  unsigned Align;
4808  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4809  return Err;
4810  I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align, Ordering, SSID);
4811  InstructionList.push_back(I);
4812  break;
4813  }
4815  case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol]
4816  unsigned OpNum = 0;
4817  Value *Val, *Ptr;
4818  Type *FullTy;
4819  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
4820  (BitCode == bitc::FUNC_CODE_INST_STORE
4821  ? getValueTypePair(Record, OpNum, NextValueNo, Val)
4822  : popValue(Record, OpNum, NextValueNo,
4823  getPointerElementFlatType(FullTy), Val)) ||
4824  OpNum + 2 != Record.size())
4825  return error("Invalid record");
4826 
4827  if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
4828  return Err;
4829  unsigned Align;
4830  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4831  return Err;
4832  I = new StoreInst(Val, Ptr, Record[OpNum+1], Align);
4833  InstructionList.push_back(I);
4834  break;
4835  }
4838  // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, ssid]
4839  unsigned OpNum = 0;
4840  Value *Val, *Ptr;
4841  Type *FullTy;
4842  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
4843  !isa<PointerType>(Ptr->getType()) ||
4845  ? getValueTypePair(Record, OpNum, NextValueNo, Val)
4846  : popValue(Record, OpNum, NextValueNo,
4847  getPointerElementFlatType(FullTy), Val)) ||
4848  OpNum + 4 != Record.size())
4849  return error("Invalid record");
4850 
4851  if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
4852  return Err;
4853  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4854  if (Ordering == AtomicOrdering::NotAtomic ||
4855  Ordering == AtomicOrdering::Acquire ||
4856  Ordering == AtomicOrdering::AcquireRelease)
4857  return error("Invalid record");
4858  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
4859  if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
4860  return error("Invalid record");
4861 
4862  unsigned Align;
4863  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4864  return Err;
4865  I = new StoreInst(Val, Ptr, Record[OpNum+1], Align, Ordering, SSID);
4866  InstructionList.push_back(I);
4867  break;
4868  }
4871  // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, ssid,
4872  // failureordering?, isweak?]
4873  unsigned OpNum = 0;
4874  Value *Ptr, *Cmp, *New;
4875  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy))
4876  return error("Invalid record");
4877 
4878  if (!isa<PointerType>(Ptr->getType()))
4879  return error("Cmpxchg operand is not a pointer type");
4880 
4881  if (BitCode == bitc::FUNC_CODE_INST_CMPXCHG) {
4882  if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, &FullTy))
4883  return error("Invalid record");
4884  } else if (popValue(Record, OpNum, NextValueNo,
4885  getPointerElementFlatType(FullTy), Cmp))
4886  return error("Invalid record");
4887  else
4888  FullTy = cast<PointerType>(FullTy)->getElementType();
4889 
4890  if (popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
4891  Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
4892  return error("Invalid record");
4893 
4894  AtomicOrdering SuccessOrdering = getDecodedOrdering(Record[OpNum + 1]);
4895  if (SuccessOrdering == AtomicOrdering::NotAtomic ||
4896  SuccessOrdering == AtomicOrdering::Unordered)
4897  return error("Invalid record");
4898  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
4899 
4900  if (Error Err = typeCheckLoadStoreInst(Cmp->getType(), Ptr->getType()))
4901  return Err;
4902  AtomicOrdering FailureOrdering;
4903  if (Record.size() < 7)
4904  FailureOrdering =
4906  else
4907  FailureOrdering = getDecodedOrdering(Record[OpNum + 3]);
4908 
4909  I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering,
4910  SSID);
4911  FullTy = StructType::get(Context, {FullTy, Type::getInt1Ty(Context)});
4912  cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
4913 
4914  if (Record.size() < 8) {
4915  // Before weak cmpxchgs existed, the instruction simply returned the
4916  // value loaded from memory, so bitcode files from that era will be
4917  // expecting the first component of a modern cmpxchg.
4918  CurBB->getInstList().push_back(I);
4919  I = ExtractValueInst::Create(I, 0);
4920  FullTy = cast<StructType>(FullTy)->getElementType(0);
4921  } else {
4922  cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
4923  }
4924 
4925  InstructionList.push_back(I);
4926  break;
4927  }
4929  // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, ssid]
4930  unsigned OpNum = 0;
4931  Value *Ptr, *Val;
4932  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
4933  !isa<PointerType>(Ptr->getType()) ||
4934  popValue(Record, OpNum, NextValueNo,
4935  getPointerElementFlatType(FullTy), Val) ||
4936  OpNum + 4 != Record.size())
4937  return error("Invalid record");
4939  if (Operation < AtomicRMWInst::FIRST_BINOP ||
4940  Operation > AtomicRMWInst::LAST_BINOP)
4941  return error("Invalid record");
4942  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4943  if (Ordering == AtomicOrdering::NotAtomic ||
4944  Ordering == AtomicOrdering::Unordered)
4945  return error("Invalid record");
4946  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
4947  I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SSID);
4948  FullTy = getPointerElementFlatType(FullTy);
4949  cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
4950  InstructionList.push_back(I);
4951  break;
4952  }
4953  case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, ssid]
4954  if (2 != Record.size())
4955  return error("Invalid record");
4956  AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
4957  if (Ordering == AtomicOrdering::NotAtomic ||
4958  Ordering == AtomicOrdering::Unordered ||
4959  Ordering == AtomicOrdering::Monotonic)
4960  return error("Invalid record");
4961  SyncScope::ID SSID = getDecodedSyncScopeID(Record[1]);
4962  I = new FenceInst(Context, Ordering, SSID);
4963  InstructionList.push_back(I);
4964  break;
4965  }
4967  // CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...]
4968  if (Record.size() < 3)
4969  return error("Invalid record");
4970 
4971  unsigned OpNum = 0;
4972  AttributeList PAL = getAttributes(Record[OpNum++]);
4973  unsigned CCInfo = Record[OpNum++];
4974 
4975  FastMathFlags FMF;
4976  if ((CCInfo >> bitc::CALL_FMF) & 1) {
4977  FMF = getDecodedFastMathFlags(Record[OpNum++]);
4978  if (!FMF.any())
4979  return error("Fast math flags indicator set for call with no FMF");
4980  }
4981 
4982  FunctionType *FTy = nullptr;
4983  FunctionType *FullFTy = nullptr;
4984  if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
4985  FullFTy =
4986  dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
4987  if (!FullFTy)
4988  return error("Explicit call type is not a function type");
4989  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4990  }
4991 
4992  Value *Callee;
4993  if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
4994  return error("Invalid record");
4995 
4996  PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
4997  if (!OpTy)
4998  return error("Callee is not a pointer type");
4999  if (!FTy) {
5000  FullFTy =
5001  dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
5002  if (!FullFTy)
5003  return error("Callee is not of pointer to function type");
5004  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
5005  } else if (getPointerElementFlatType(FullTy) != FTy)
5006  return error("Explicit call type does not match pointee type of "
5007  "callee operand");
5008  if (Record.size() < FTy->getNumParams() + OpNum)
5009  return error("Insufficient operands to call");
5010 
5012  SmallVector<Type*, 16> ArgsFullTys;
5013  // Read the fixed params.
5014  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
5015  if (FTy->getParamType(i)->isLabelTy())
5016  Args.push_back(getBasicBlock(Record[OpNum]));
5017  else
5018  Args.push_back(getValue(Record, OpNum, NextValueNo,
5019  FTy->getParamType(i)));
5020  ArgsFullTys.push_back(FullFTy->getParamType(i));
5021  if (!Args.back())
5022  return error("Invalid record");
5023  }
5024 
5025  // Read type/value pairs for varargs params.
5026  if (!FTy->isVarArg()) {
5027  if (OpNum != Record.size())
5028  return error("Invalid record");
5029  } else {
5030  while (OpNum != Record.size()) {
5031  Value *Op;
5032  Type *FullTy;
5033  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
5034  return error("Invalid record");
5035  Args.push_back(Op);
5036  ArgsFullTys.push_back(FullTy);
5037  }
5038  }
5039 
5040  I = CallInst::Create(FTy, Callee, Args, OperandBundles);
5041  FullTy = FullFTy->getReturnType();
5042  OperandBundles.clear();
5043  InstructionList.push_back(I);
5044  cast<CallInst>(I)->setCallingConv(
5045  static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV));
5047  if (CCInfo & 1 << bitc::CALL_TAIL)
5048  TCK = CallInst::TCK_Tail;
5049  if (CCInfo & (1 << bitc::CALL_MUSTTAIL))
5050  TCK = CallInst::TCK_MustTail;
5051  if (CCInfo & (1 << bitc::CALL_NOTAIL))
5052  TCK = CallInst::TCK_NoTail;
5053  cast<CallInst>(I)->setTailCallKind(TCK);
5054  cast<CallInst>(I)->setAttributes(PAL);
5055  propagateByValTypes(cast<CallBase>(I), ArgsFullTys);
5056  if (FMF.any()) {
5057  if (!isa<FPMathOperator>(I))
5058  return error("Fast-math-flags specified for call without "
5059  "floating-point scalar or vector return type");
5060  I->setFastMathFlags(FMF);
5061  }
5062  break;
5063  }
5064  case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
5065  if (Record.size() < 3)
5066  return error("Invalid record");
5067  Type *OpTy = getTypeByID(Record[0]);
5068  Value *Op = getValue(Record, 1, NextValueNo, OpTy);
5069  FullTy = getFullyStructuredTypeByID(Record[2]);
5070  Type *ResTy = flattenPointerTypes(FullTy);
5071  if (!OpTy || !Op || !ResTy)
5072  return error("Invalid record");
5073  I = new VAArgInst(Op, ResTy);
5074  InstructionList.push_back(I);
5075  break;
5076  }
5077 
5079  // A call or an invoke can be optionally prefixed with some variable
5080  // number of operand bundle blocks. These blocks are read into
5081  // OperandBundles and consumed at the next call or invoke instruction.
5082 
5083  if (Record.size() < 1 || Record[0] >= BundleTags.size())
5084  return error("Invalid record");
5085 
5086  std::vector<Value *> Inputs;
5087 
5088  unsigned OpNum = 1;
5089  while (OpNum != Record.size()) {
5090  Value *Op;
5091  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
5092  return error("Invalid record");
5093  Inputs.push_back(Op);
5094  }
5095 
5096  OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));
5097  continue;
5098  }
5099  }
5100 
5101  // Add instruction to end of current BB. If there is no current BB, reject
5102  // this file.
5103  if (!CurBB) {
5104  I->deleteValue();
5105  return error("Invalid instruction with no BB");
5106  }
5107  if (!OperandBundles.empty()) {
5108  I->deleteValue();
5109  return error("Operand bundles found with no consumer");
5110  }
5111  CurBB->getInstList().push_back(I);
5112 
5113  // If this was a terminator instruction, move to the next block.
5114  if (I->isTerminator()) {
5115  ++CurBBNo;
5116  CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
5117  }
5118 
5119  // Non-void values get registered in the value table for future use.
5120  if (I && !I->getType()->isVoidTy()) {
5121  if (!FullTy) {
5122  FullTy = I->getType();
5123  assert(
5124  !FullTy->isPointerTy() && !isa<StructType>(FullTy) &&
5125  !isa<ArrayType>(FullTy) &&
5126  (!isa<VectorType>(FullTy) ||
5127  FullTy->getVectorElementType()->isFloatingPointTy() ||
5128  FullTy->getVectorElementType()->isIntegerTy()) &&
5129  "Structured types must be assigned with corresponding non-opaque "
5130  "pointer type");
5131  }
5132 
5133  assert(I->getType() == flattenPointerTypes(FullTy) &&
5134  "Incorrect fully structured type provided for Instruction");
5135  ValueList.assignValue(I, NextValueNo++, FullTy);
5136  }
5137  }
5138 
5139 OutOfRecordLoop:
5140 
5141  if (!OperandBundles.empty())
5142  return error("Operand bundles found with no consumer");
5143 
5144  // Check the function list for unresolved values.
5145  if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
5146  if (!A->getParent()) {
5147  // We found at least one unresolved value. Nuke them all to avoid leaks.
5148  for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
5149  if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {
5150  A->replaceAllUsesWith(UndefValue::get(A->getType()));
5151  delete A;
5152  }
5153  }
5154  return error("Never resolved value found in function");
5155  }
5156  }
5157 
5158  // Unexpected unresolved metadata about to be dropped.
5159  if (MDLoader->hasFwdRefs())
5160  return error("Invalid function metadata: outgoing forward refs");
5161 
5162  // Trim the value list down to the size it was before we parsed this function.
5163  ValueList.shrinkTo(ModuleValueListSize);
5164  MDLoader->shrinkTo(ModuleMDLoaderSize);
5165  std::vector<BasicBlock*>().swap(FunctionBBs);
5166  return Error::success();
5167 }
5168 
5169 /// Find the function body in the bitcode stream
5170 Error BitcodeReader::findFunctionInStream(
5171  Function *F,
5172  DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
5173  while (DeferredFunctionInfoIterator->second == 0) {
5174  // This is the fallback handling for the old format bitcode that
5175  // didn't contain the function index in the VST, or when we have
5176  // an anonymous function which would not have a VST entry.
5177  // Assert that we have one of those two cases.
5178  assert(VSTOffset == 0 || !F->hasName());
5179  // Parse the next body in the stream and set its position in the
5180  // DeferredFunctionInfo map.
5181  if (Error Err = rememberAndSkipFunctionBodies())
5182  return Err;
5183  }
5184  return Error::success();
5185 }
5186 
5187 SyncScope::ID BitcodeReader::getDecodedSyncScopeID(unsigned Val) {
5188  if (Val == SyncScope::SingleThread || Val == SyncScope::System)
5189  return SyncScope::ID(Val);
5190  if (Val >= SSIDs.size())
5191  return SyncScope::System; // Map unknown synchronization scopes to system.
5192  return SSIDs[Val];
5193 }
5194 
5195 //===----------------------------------------------------------------------===//
5196 // GVMaterializer implementation
5197 //===----------------------------------------------------------------------===//
5198 
5199 Error BitcodeReader::materialize(GlobalValue *GV) {
5200  Function *F = dyn_cast<Function>(GV);
5201  // If it's not a function or is already material, ignore the request.
5202  if (!F || !F->isMaterializable())
5203  return Error::success();
5204 
5205  DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
5206  assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
5207  // If its position is recorded as 0, its body is somewhere in the stream
5208  // but we haven't seen it yet.
5209  if (DFII->second == 0)
5210  if (Error Err = findFunctionInStream(F, DFII))
5211  return Err;
5212 
5213  // Materialize metadata before parsing any function bodies.
5214  if (Error Err = materializeMetadata())
5215  return Err;
5216 
5217  // Move the bit stream to the saved position of the deferred function body.
5218  if (Error JumpFailed = Stream.JumpToBit(DFII->second))
5219  return JumpFailed;
5220  if (Error Err = parseFunctionBody(F))
5221  return Err;
5222  F->setIsMaterializable(false);
5223 
5224  if (StripDebugInfo)
5225  stripDebugInfo(*F);
5226 
5227  // Upgrade any old intrinsic calls in the function.
5228  for (auto &I : UpgradedIntrinsics) {
5229  for (auto UI = I.first->materialized_user_begin(), UE = I.first->user_end();
5230  UI != UE;) {
5231  User *U = *UI;
5232  ++UI;
5233  if (CallInst *CI = dyn_cast<CallInst>(U))
5234  UpgradeIntrinsicCall(CI, I.second);
5235  }
5236  }
5237 
5238  // Update calls to the remangled intrinsics
5239  for (auto &I : RemangledIntrinsics)
5240  for (auto UI = I.first->materialized_user_begin(), UE = I.first->user_end();
5241  UI != UE;)
5242  // Don't expect any other users than call sites
5243  CallSite(*UI++).setCalledFunction(I.second);
5244 
5245  // Finish fn->subprogram upgrade for materialized functions.
5246  if (DISubprogram *SP = MDLoader->lookupSubprogramForFunction(F))
5247  F->setSubprogram(SP);
5248 
5249  // Check if the TBAA Metadata are valid, otherwise we will need to strip them.
5250  if (!MDLoader->isStrippingTBAA()) {
5251  for (auto &I : instructions(F)) {
5252  MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa);
5253  if (!TBAA || TBAAVerifyHelper.visitTBAAMetadata(I, TBAA))
5254  continue;
5255  MDLoader->setStripTBAA(true);
5256  stripTBAA(F->getParent());
5257  }
5258  }
5259 
5260  // Bring in any functions that this function forward-referenced via
5261  // blockaddresses.
5262  return materializeForwardReferencedFunctions();
5263 }
5264 
5265 Error BitcodeReader::materializeModule() {
5266  if (Error Err = materializeMetadata())
5267  return Err;
5268 
5269  // Promise to materialize all forward references.
5270  WillMaterializeAllForwardRefs = true;
5271 
5272  // Iterate over the module, deserializing any functions that are still on
5273  // disk.
5274  for (Function &F : *TheModule) {
5275  if (Error Err = materialize(&F))
5276  return Err;
5277  }
5278  // At this point, if there are any function bodies, parse the rest of
5279  // the bits in the module past the last function block we have recorded
5280  // through either lazy scanning or the VST.
5281  if (LastFunctionBlockBit || NextUnreadBit)
5282  if (Error Err = parseModule(LastFunctionBlockBit > NextUnreadBit
5283  ? LastFunctionBlockBit
5284  : NextUnreadBit))
5285  return Err;
5286 
5287  // Check that all block address forward references got resolved (as we
5288  // promised above).
5289  if (!BasicBlockFwdRefs.empty())
5290  return error("Never resolved function from blockaddress");
5291 
5292  // Upgrade any intrinsic calls that slipped through (should not happen!) and
5293  // delete the old functions to clean up. We can't do this unless the entire
5294  // module is materialized because there could always be another function body
5295  // with calls to the old function.
5296  for (auto &I : UpgradedIntrinsics) {
5297  for (auto *U : I.first->users()) {
5298  if (CallInst *CI = dyn_cast<CallInst>(U))
5299  UpgradeIntrinsicCall(CI, I.second);
5300  }
5301  if (!I.first->use_empty())
5302  I.first->replaceAllUsesWith(I.second);
5303  I.first->eraseFromParent();
5304  }
5305  UpgradedIntrinsics.clear();
5306  // Do the same for remangled intrinsics
5307  for (auto &I : RemangledIntrinsics) {
5308  I.first->replaceAllUsesWith(I.second);
5309  I.first->eraseFromParent();
5310  }
5311  RemangledIntrinsics.clear();
5312 
5313  UpgradeDebugInfo(*TheModule);
5314 
5315  UpgradeModuleFlags(*TheModule);
5316 
5317  UpgradeARCRuntime(*TheModule);
5318 
5319  return Error::success();
5320 }
5321 
5322 std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const {
5323  return IdentifiedStructTypes;
5324 }
5325 
5326 ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(
5327  BitstreamCursor Cursor, StringRef Strtab, ModuleSummaryIndex &TheIndex,
5328  StringRef ModulePath, unsigned ModuleId)
5329  : BitcodeReaderBase(std::move(Cursor), Strtab), TheIndex(TheIndex),
5330  ModulePath(ModulePath), ModuleId(ModuleId) {}
5331 
5332 void ModuleSummaryIndexBitcodeReader::addThisModule() {
5333  TheIndex.addModule(ModulePath, ModuleId);
5334 }
5335 
5337 ModuleSummaryIndexBitcodeReader::getThisModule() {
5338  return TheIndex.getModule(ModulePath);
5339 }
5340 
5341 std::pair<ValueInfo, GlobalValue::GUID>
5342 ModuleSummaryIndexBitcodeReader::getValueInfoFromValueId(unsigned ValueId) {
5343  auto VGI = ValueIdToValueInfoMap[ValueId];
5344  assert(VGI.first);
5345  return VGI;
5346 }
5347 
5348 void ModuleSummaryIndexBitcodeReader::setValueGUID(
5349  uint64_t ValueID, StringRef ValueName, GlobalValue::LinkageTypes Linkage,
5350  StringRef SourceFileName) {
5351  std::string GlobalId =
5352  GlobalValue::getGlobalIdentifier(ValueName, Linkage, SourceFileName);
5353  auto ValueGUID = GlobalValue::getGUID(GlobalId);
5354  auto OriginalNameID = ValueGUID;
5355  if (GlobalValue::isLocalLinkage(Linkage))
5356  OriginalNameID = GlobalValue::getGUID(ValueName);
5357  if (PrintSummaryGUIDs)
5358  dbgs() << "GUID " << ValueGUID << "(" << OriginalNameID << ") is "
5359  << ValueName << "\n";
5360 
5361  // UseStrtab is false for legacy summary formats and value names are
5362  // created on stack. In that case we save the name in a string saver in
5363  // the index so that the value name can be recorded.
5364  ValueIdToValueInfoMap[ValueID] = std::make_pair(
5365  TheIndex.getOrInsertValueInfo(
5366  ValueGUID,
5367  UseStrtab ? ValueName : TheIndex.saveString(ValueName)),
5368  OriginalNameID);
5369 }
5370 
5371 // Specialized value symbol table parser used when reading module index
5372 // blocks where we don't actually create global values. The parsed information
5373 // is saved in the bitcode reader for use when later parsing summaries.
5374 Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable(
5375  uint64_t Offset,
5376  DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) {
5377  // With a strtab the VST is not required to parse the summary.
5378  if (UseStrtab)
5379  return Error::success();
5380 
5381  assert(Offset > 0 && "Expected non-zero VST offset");
5382  Expected<uint64_t> MaybeCurrentBit = jumpToValueSymbolTable(Offset, Stream);
5383  if (!MaybeCurrentBit)
5384  return MaybeCurrentBit.takeError();
5385  uint64_t CurrentBit = MaybeCurrentBit.get();
5386 
5388  return Err;
5389 
5391 
5392  // Read all the records for this value table.
5394 
5395  while (true) {
5396  Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
5397  if (!MaybeEntry)
5398  return MaybeEntry.takeError();
5399  BitstreamEntry Entry = MaybeEntry.get();
5400 
5401  switch (Entry.Kind) {
5402  case BitstreamEntry::SubBlock: // Handled for us already.
5403  case