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, MaybeAlign &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_FNEG:
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  MaybeAlign &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 = decodeMaybeAlign(Exponent);
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];
3115  MaybeAlign 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  MaybeAlign 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
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  // Upgrade data layout string.
3653  std::string DL = llvm::UpgradeDataLayoutString(
3654  TheModule->getDataLayoutStr(), TheModule->getTargetTriple());
3655  TheModule->setDataLayout(DL);
3656  }
3657 }
3658 
3659 Error BitcodeReader::parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata,
3660  bool IsImporting) {
3661  TheModule = M;
3662  MDLoader = MetadataLoader(Stream, *M, ValueList, IsImporting,
3663  [&](unsigned ID) { return getTypeByID(ID); });
3664  return parseModule(0, ShouldLazyLoadMetadata);
3665 }
3666 
3667 Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) {
3668  if (!isa<PointerType>(PtrType))
3669  return error("Load/Store operand is not a pointer type");
3670  Type *ElemType = cast<PointerType>(PtrType)->getElementType();
3671 
3672  if (ValType && ValType != ElemType)
3673  return error("Explicit load/store type does not match pointee "
3674  "type of pointer operand");
3676  return error("Cannot load/store from pointer");
3677  return Error::success();
3678 }
3679 
3680 void BitcodeReader::propagateByValTypes(CallBase *CB,
3681  ArrayRef<Type *> ArgsFullTys) {
3682  for (unsigned i = 0; i != CB->arg_size(); ++i) {
3683  if (!CB->paramHasAttr(i, Attribute::ByVal))
3684  continue;
3685 
3686  CB->removeParamAttr(i, Attribute::ByVal);
3687  CB->addParamAttr(
3689  Context, getPointerElementFlatType(ArgsFullTys[i])));
3690  }
3691 }
3692 
3693 /// Lazily parse the specified function body block.
3694 Error BitcodeReader::parseFunctionBody(Function *F) {
3695  if (Error Err = Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
3696  return Err;
3697 
3698  // Unexpected unresolved metadata when parsing function.
3699  if (MDLoader->hasFwdRefs())
3700  return error("Invalid function metadata: incoming forward references");
3701 
3702  InstructionList.clear();
3703  unsigned ModuleValueListSize = ValueList.size();
3704  unsigned ModuleMDLoaderSize = MDLoader->size();
3705 
3706  // Add all the function arguments to the value table.
3707  unsigned ArgNo = 0;
3708  FunctionType *FullFTy = FunctionTypes[F];
3709  for (Argument &I : F->args()) {
3710  assert(I.getType() == flattenPointerTypes(FullFTy->getParamType(ArgNo)) &&
3711  "Incorrect fully specified type for Function Argument");
3712  ValueList.push_back(&I, FullFTy->getParamType(ArgNo++));
3713  }
3714  unsigned NextValueNo = ValueList.size();
3715  BasicBlock *CurBB = nullptr;
3716  unsigned CurBBNo = 0;
3717 
3718  DebugLoc LastLoc;
3719  auto getLastInstruction = [&]() -> Instruction * {
3720  if (CurBB && !CurBB->empty())
3721  return &CurBB->back();
3722  else if (CurBBNo && FunctionBBs[CurBBNo - 1] &&
3723  !FunctionBBs[CurBBNo - 1]->empty())
3724  return &FunctionBBs[CurBBNo - 1]->back();
3725  return nullptr;
3726  };
3727 
3728  std::vector<OperandBundleDef> OperandBundles;
3729 
3730  // Read all the records.
3732 
3733  while (true) {
3734  Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
3735  if (!MaybeEntry)
3736  return MaybeEntry.takeError();
3737  llvm::BitstreamEntry Entry = MaybeEntry.get();
3738 
3739  switch (Entry.Kind) {
3740  case BitstreamEntry::Error:
3741  return error("Malformed block");
3743  goto OutOfRecordLoop;
3744 
3746  switch (Entry.ID) {
3747  default: // Skip unknown content.
3748  if (Error Err = Stream.SkipBlock())
3749  return Err;
3750  break;
3752  if (Error Err = parseConstants())
3753  return Err;
3754  NextValueNo = ValueList.size();
3755  break;
3757  if (Error Err = parseValueSymbolTable())
3758  return Err;
3759  break;
3761  if (Error Err = MDLoader->parseMetadataAttachment(*F, InstructionList))
3762  return Err;
3763  break;
3765  assert(DeferredMetadataInfo.empty() &&
3766  "Must read all module-level metadata before function-level");
3767  if (Error Err = MDLoader->parseFunctionMetadata())
3768  return Err;
3769  break;
3771  if (Error Err = parseUseLists())
3772  return Err;
3773  break;
3774  }
3775  continue;
3776 
3778  // The interesting case.
3779  break;
3780  }
3781 
3782  // Read a record.
3783  Record.clear();
3784  Instruction *I = nullptr;
3785  Type *FullTy = nullptr;
3786  Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
3787  if (!MaybeBitCode)
3788  return MaybeBitCode.takeError();
3789  switch (unsigned BitCode = MaybeBitCode.get()) {
3790  default: // Default behavior: reject
3791  return error("Invalid value");
3792  case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
3793  if (Record.size() < 1 || Record[0] == 0)
3794  return error("Invalid record");
3795  // Create all the basic blocks for the function.
3796  FunctionBBs.resize(Record[0]);
3797 
3798  // See if anything took the address of blocks in this function.
3799  auto BBFRI = BasicBlockFwdRefs.find(F);
3800  if (BBFRI == BasicBlockFwdRefs.end()) {
3801  for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
3802  FunctionBBs[i] = BasicBlock::Create(Context, "", F);
3803  } else {
3804  auto &BBRefs = BBFRI->second;
3805  // Check for invalid basic block references.
3806  if (BBRefs.size() > FunctionBBs.size())
3807  return error("Invalid ID");
3808  assert(!BBRefs.empty() && "Unexpected empty array");
3809  assert(!BBRefs.front() && "Invalid reference to entry block");
3810  for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
3811  ++I)
3812  if (I < RE && BBRefs[I]) {
3813  BBRefs[I]->insertInto(F);
3814  FunctionBBs[I] = BBRefs[I];
3815  } else {
3816  FunctionBBs[I] = BasicBlock::Create(Context, "", F);
3817  }
3818 
3819  // Erase from the table.
3820  BasicBlockFwdRefs.erase(BBFRI);
3821  }
3822 
3823  CurBB = FunctionBBs[0];
3824  continue;
3825  }
3826 
3827  case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN
3828  // This record indicates that the last instruction is at the same
3829  // location as the previous instruction with a location.
3830  I = getLastInstruction();
3831 
3832  if (!I)
3833  return error("Invalid record");
3834  I->setDebugLoc(LastLoc);
3835  I = nullptr;
3836  continue;
3837 
3838  case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
3839  I = getLastInstruction();
3840  if (!I || Record.size() < 4)
3841  return error("Invalid record");
3842 
3843  unsigned Line = Record[0], Col = Record[1];
3844  unsigned ScopeID = Record[2], IAID = Record[3];
3845  bool isImplicitCode = Record.size() == 5 && Record[4];
3846 
3847  MDNode *Scope = nullptr, *IA = nullptr;
3848  if (ScopeID) {
3849  Scope = dyn_cast_or_null<MDNode>(
3850  MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1));
3851  if (!Scope)
3852  return error("Invalid record");
3853  }
3854  if (IAID) {
3855  IA = dyn_cast_or_null<MDNode>(
3856  MDLoader->getMetadataFwdRefOrLoad(IAID - 1));
3857  if (!IA)
3858  return error("Invalid record");
3859  }
3860  LastLoc = DebugLoc::get(Line, Col, Scope, IA, isImplicitCode);
3861  I->setDebugLoc(LastLoc);
3862  I = nullptr;
3863  continue;
3864  }
3865  case bitc::FUNC_CODE_INST_UNOP: { // UNOP: [opval, ty, opcode]
3866  unsigned OpNum = 0;
3867  Value *LHS;
3868  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
3869  OpNum+1 > Record.size())
3870  return error("Invalid record");
3871 
3872  int Opc = getDecodedUnaryOpcode(Record[OpNum++], LHS->getType());
3873  if (Opc == -1)
3874  return error("Invalid record");
3876  InstructionList.push_back(I);
3877  if (OpNum < Record.size()) {
3878  if (isa<FPMathOperator>(I)) {
3879  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
3880  if (FMF.any())
3881  I->setFastMathFlags(FMF);
3882  }
3883  }
3884  break;
3885  }
3886  case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
3887  unsigned OpNum = 0;
3888  Value *LHS, *RHS;
3889  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
3890  popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
3891  OpNum+1 > Record.size())
3892  return error("Invalid record");
3893 
3894  int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
3895  if (Opc == -1)
3896  return error("Invalid record");
3897  I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3898  InstructionList.push_back(I);
3899  if (OpNum < Record.size()) {
3900  if (Opc == Instruction::Add ||
3901  Opc == Instruction::Sub ||
3902  Opc == Instruction::Mul ||
3903  Opc == Instruction::Shl) {
3904  if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
3905  cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
3906  if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
3907  cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
3908  } else if (Opc == Instruction::SDiv ||
3909  Opc == Instruction::UDiv ||
3910  Opc == Instruction::LShr ||
3911  Opc == Instruction::AShr) {
3912  if (Record[OpNum] & (1 << bitc::PEO_EXACT))
3913  cast<BinaryOperator>(I)->setIsExact(true);
3914  } else if (isa<FPMathOperator>(I)) {
3915  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
3916  if (FMF.any())
3917  I->setFastMathFlags(FMF);
3918  }
3919 
3920  }
3921  break;
3922  }
3923  case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
3924  unsigned OpNum = 0;
3925  Value *Op;
3926  if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
3927  OpNum+2 != Record.size())
3928  return error("Invalid record");
3929 
3930  FullTy = getFullyStructuredTypeByID(Record[OpNum]);
3931  Type *ResTy = flattenPointerTypes(FullTy);
3932  int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
3933  if (Opc == -1 || !ResTy)
3934  return error("Invalid record");
3935  Instruction *Temp = nullptr;
3936  if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
3937  if (Temp) {
3938  InstructionList.push_back(Temp);
3939  CurBB->getInstList().push_back(Temp);
3940  }
3941  } else {
3942  auto CastOp = (Instruction::CastOps)Opc;
3943  if (!CastInst::castIsValid(CastOp, Op, ResTy))
3944  return error("Invalid cast");
3945  I = CastInst::Create(CastOp, Op, ResTy);
3946  }
3947  InstructionList.push_back(I);
3948  break;
3949  }
3952  case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands]
3953  unsigned OpNum = 0;
3954 
3955  Type *Ty;
3956  bool InBounds;
3957 
3958  if (BitCode == bitc::FUNC_CODE_INST_GEP) {
3959  InBounds = Record[OpNum++];
3960  FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
3961  Ty = flattenPointerTypes(FullTy);
3962  } else {
3963  InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD;
3964  Ty = nullptr;
3965  }
3966 
3967  Value *BasePtr;
3968  Type *FullBaseTy = nullptr;
3969  if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, &FullBaseTy))
3970  return error("Invalid record");
3971 
3972  if (!Ty) {
3973  std::tie(FullTy, Ty) =
3974  getPointerElementTypes(FullBaseTy->getScalarType());
3975  } else if (Ty != getPointerElementFlatType(FullBaseTy->getScalarType()))
3976  return error(
3977  "Explicit gep type does not match pointee type of pointer operand");
3978 
3979  SmallVector<Value*, 16> GEPIdx;
3980  while (OpNum != Record.size()) {
3981  Value *Op;
3982  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
3983  return error("Invalid record");
3984  GEPIdx.push_back(Op);
3985  }
3986 
3987  I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);
3988  FullTy = GetElementPtrInst::getGEPReturnType(FullTy, I, GEPIdx);
3989 
3990  InstructionList.push_back(I);
3991  if (InBounds)
3992  cast<GetElementPtrInst>(I)->setIsInBounds(true);
3993  break;
3994  }
3995 
3997  // EXTRACTVAL: [opty, opval, n x indices]
3998  unsigned OpNum = 0;
3999  Value *Agg;
4000  if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
4001  return error("Invalid record");
4002 
4003  unsigned RecSize = Record.size();
4004  if (OpNum == RecSize)
4005  return error("EXTRACTVAL: Invalid instruction with 0 indices");
4006 
4007  SmallVector<unsigned, 4> EXTRACTVALIdx;
4008  for (; OpNum != RecSize; ++OpNum) {
4009  bool IsArray = FullTy->isArrayTy();
4010  bool IsStruct = FullTy->isStructTy();
4011  uint64_t Index = Record[OpNum];
4012 
4013  if (!IsStruct && !IsArray)
4014  return error("EXTRACTVAL: Invalid type");
4015  if ((unsigned)Index != Index)
4016  return error("Invalid value");
4017  if (IsStruct && Index >= FullTy->getStructNumElements())
4018  return error("EXTRACTVAL: Invalid struct index");
4019  if (IsArray && Index >= FullTy->getArrayNumElements())
4020  return error("EXTRACTVAL: Invalid array index");
4021  EXTRACTVALIdx.push_back((unsigned)Index);
4022 
4023  if (IsStruct)
4024  FullTy = FullTy->getStructElementType(Index);
4025  else
4026  FullTy = FullTy->getArrayElementType();
4027  }
4028 
4029  I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
4030  InstructionList.push_back(I);
4031  break;
4032  }
4033 
4035  // INSERTVAL: [opty, opval, opty, opval, n x indices]
4036  unsigned OpNum = 0;
4037  Value *Agg;
4038  if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
4039  return error("Invalid record");
4040  Value *Val;
4041  if (getValueTypePair(Record, OpNum, NextValueNo, Val))
4042  return error("Invalid record");
4043 
4044  unsigned RecSize = Record.size();
4045  if (OpNum == RecSize)
4046  return error("INSERTVAL: Invalid instruction with 0 indices");
4047 
4048  SmallVector<unsigned, 4> INSERTVALIdx;
4049  Type *CurTy = Agg->getType();
4050  for (; OpNum != RecSize; ++OpNum) {
4051  bool IsArray = CurTy->isArrayTy();
4052  bool IsStruct = CurTy->isStructTy();
4053  uint64_t Index = Record[OpNum];
4054 
4055  if (!IsStruct && !IsArray)
4056  return error("INSERTVAL: Invalid type");
4057  if ((unsigned)Index != Index)
4058  return error("Invalid value");
4059  if (IsStruct && Index >= CurTy->getStructNumElements())
4060  return error("INSERTVAL: Invalid struct index");
4061  if (IsArray && Index >= CurTy->getArrayNumElements())
4062  return error("INSERTVAL: Invalid array index");
4063 
4064  INSERTVALIdx.push_back((unsigned)Index);
4065  if (IsStruct)
4066  CurTy = CurTy->getStructElementType(Index);
4067  else
4068  CurTy = CurTy->getArrayElementType();
4069  }
4070 
4071  if (CurTy != Val->getType())
4072  return error("Inserted value type doesn't match aggregate type");
4073 
4074  I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);
4075  InstructionList.push_back(I);
4076  break;
4077  }
4078 
4079  case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
4080  // obsolete form of select
4081  // handles select i1 ... in old bitcode
4082  unsigned OpNum = 0;
4083  Value *TrueVal, *FalseVal, *Cond;
4084  if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
4085  popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
4086  popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
4087  return error("Invalid record");
4088 
4089  I = SelectInst::Create(Cond, TrueVal, FalseVal);
4090  InstructionList.push_back(I);
4091  break;
4092  }
4093 
4094  case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
4095  // new form of select
4096  // handles select i1 or select [N x i1]
4097  unsigned OpNum = 0;
4098  Value *TrueVal, *FalseVal, *Cond;
4099  if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
4100  popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
4101  getValueTypePair(Record, OpNum, NextValueNo, Cond))
4102  return error("Invalid record");
4103 
4104  // select condition can be either i1 or [N x i1]
4105  if (VectorType* vector_type =
4106  dyn_cast<VectorType>(Cond->getType())) {
4107  // expect <n x i1>
4108  if (vector_type->getElementType() != Type::getInt1Ty(Context))
4109  return error("Invalid type for value");
4110  } else {
4111  // expect i1
4112  if (Cond->getType() != Type::getInt1Ty(Context))
4113  return error("Invalid type for value");
4114  }
4115 
4116  I = SelectInst::Create(Cond, TrueVal, FalseVal);
4117  InstructionList.push_back(I);
4118  if (OpNum < Record.size() && isa<FPMathOperator>(I)) {
4119  FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
4120  if (FMF.any())
4121  I->setFastMathFlags(FMF);
4122  }
4123  break;
4124  }
4125 
4126  case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
4127  unsigned OpNum = 0;
4128  Value *Vec, *Idx;
4129  if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy) ||
4130  getValueTypePair(Record, OpNum, NextValueNo, Idx))
4131  return error("Invalid record");
4132  if (!Vec->getType()->isVectorTy())
4133  return error("Invalid type for value");
4134  I = ExtractElementInst::Create(Vec, Idx);
4135  FullTy = FullTy->getVectorElementType();
4136  InstructionList.push_back(I);
4137  break;
4138  }
4139 
4140  case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
4141  unsigned OpNum = 0;
4142  Value *Vec, *Elt, *Idx;
4143  if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy))
4144  return error("Invalid record");
4145  if (!Vec->getType()->isVectorTy())
4146  return error("Invalid type for value");
4147  if (popValue(Record, OpNum, NextValueNo,
4148  cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
4149  getValueTypePair(Record, OpNum, NextValueNo, Idx))
4150  return error("Invalid record");
4151  I = InsertElementInst::Create(Vec, Elt, Idx);
4152  InstructionList.push_back(I);
4153  break;
4154  }
4155 
4156  case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
4157  unsigned OpNum = 0;
4158  Value *Vec1, *Vec2, *Mask;
4159  if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, &FullTy) ||
4160  popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
4161  return error("Invalid record");
4162 
4163  if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
4164  return error("Invalid record");
4165  if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())
4166  return error("Invalid type for value");
4167  I = new ShuffleVectorInst(Vec1, Vec2, Mask);
4168  FullTy = VectorType::get(FullTy->getVectorElementType(),
4169  Mask->getType()->getVectorNumElements());
4170  InstructionList.push_back(I);
4171  break;
4172  }
4173 
4174  case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred]
4175  // Old form of ICmp/FCmp returning bool
4176  // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
4177  // both legal on vectors but had different behaviour.
4178  case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
4179  // FCmp/ICmp returning bool or vector of bool
4180 
4181  unsigned OpNum = 0;
4182  Value *LHS, *RHS;
4183  if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
4184  popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
4185  return error("Invalid record");
4186 
4187  if (OpNum >= Record.size())
4188  return error(
4189  "Invalid record: operand number exceeded available operands");
4190 
4191  unsigned PredVal = Record[OpNum];
4192  bool IsFP = LHS->getType()->isFPOrFPVectorTy();
4193  FastMathFlags FMF;
4194  if (IsFP && Record.size() > OpNum+1)
4195  FMF = getDecodedFastMathFlags(Record[++OpNum]);
4196 
4197  if (OpNum+1 != Record.size())
4198  return error("Invalid record");
4199 
4200  if (LHS->getType()->isFPOrFPVectorTy())
4201  I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS);
4202  else
4203  I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS);
4204 
4205  if (FMF.any())
4206  I->setFastMathFlags(FMF);
4207  InstructionList.push_back(I);
4208  break;
4209  }
4210 
4211  case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
4212  {
4213  unsigned Size = Record.size();
4214  if (Size == 0) {
4215  I = ReturnInst::Create(Context);
4216  InstructionList.push_back(I);
4217  break;
4218  }
4219 
4220  unsigned OpNum = 0;
4221  Value *Op = nullptr;
4222  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
4223  return error("Invalid record");
4224  if (OpNum != Record.size())
4225  return error("Invalid record");
4226 
4227  I = ReturnInst::Create(Context, Op);
4228  InstructionList.push_back(I);
4229  break;
4230  }
4231  case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
4232  if (Record.size() != 1 && Record.size() != 3)
4233  return error("Invalid record");
4234  BasicBlock *TrueDest = getBasicBlock(Record[0]);
4235  if (!TrueDest)
4236  return error("Invalid record");
4237 
4238  if (Record.size() == 1) {
4239  I = BranchInst::Create(TrueDest);
4240  InstructionList.push_back(I);
4241  }
4242  else {
4243  BasicBlock *FalseDest = getBasicBlock(Record[1]);
4244  Value *Cond = getValue(Record, 2, NextValueNo,
4245  Type::getInt1Ty(Context));
4246  if (!FalseDest || !Cond)
4247  return error("Invalid record");
4248  I = BranchInst::Create(TrueDest, FalseDest, Cond);
4249  InstructionList.push_back(I);
4250  }
4251  break;
4252  }
4253  case bitc::FUNC_CODE_INST_CLEANUPRET: { // CLEANUPRET: [val] or [val,bb#]
4254  if (Record.size() != 1 && Record.size() != 2)
4255  return error("Invalid record");
4256  unsigned Idx = 0;
4257  Value *CleanupPad =
4258  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4259  if (!CleanupPad)
4260  return error("Invalid record");
4261  BasicBlock *UnwindDest = nullptr;
4262  if (Record.size() == 2) {
4263  UnwindDest = getBasicBlock(Record[Idx++]);
4264  if (!UnwindDest)
4265  return error("Invalid record");
4266  }
4267 
4268  I = CleanupReturnInst::Create(CleanupPad, UnwindDest);
4269  InstructionList.push_back(I);
4270  break;
4271  }
4272  case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [val,bb#]
4273  if (Record.size() != 2)
4274  return error("Invalid record");
4275  unsigned Idx = 0;
4276  Value *CatchPad =
4277  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4278  if (!CatchPad)
4279  return error("Invalid record");
4280  BasicBlock *BB = getBasicBlock(Record[Idx++]);
4281  if (!BB)
4282  return error("Invalid record");
4283 
4284  I = CatchReturnInst::Create(CatchPad, BB);
4285  InstructionList.push_back(I);
4286  break;
4287  }
4288  case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?]
4289  // We must have, at minimum, the outer scope and the number of arguments.
4290  if (Record.size() < 2)
4291  return error("Invalid record");
4292 
4293  unsigned Idx = 0;
4294 
4295  Value *ParentPad =
4296  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4297 
4298  unsigned NumHandlers = Record[Idx++];
4299 
4301  for (unsigned Op = 0; Op != NumHandlers; ++Op) {
4302  BasicBlock *BB = getBasicBlock(Record[Idx++]);
4303  if (!BB)
4304  return error("Invalid record");
4305  Handlers.push_back(BB);
4306  }
4307 
4308  BasicBlock *UnwindDest = nullptr;
4309  if (Idx + 1 == Record.size()) {
4310  UnwindDest = getBasicBlock(Record[Idx++]);
4311  if (!UnwindDest)
4312  return error("Invalid record");
4313  }
4314 
4315  if (Record.size() != Idx)
4316  return error("Invalid record");
4317 
4318  auto *CatchSwitch =
4319  CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers);
4320  for (BasicBlock *Handler : Handlers)
4321  CatchSwitch->addHandler(Handler);
4322  I = CatchSwitch;
4323  InstructionList.push_back(I);
4324  break;
4325  }
4327  case bitc::FUNC_CODE_INST_CLEANUPPAD: { // [tok,num,(ty,val)*]
4328  // We must have, at minimum, the outer scope and the number of arguments.
4329  if (Record.size() < 2)
4330  return error("Invalid record");
4331 
4332  unsigned Idx = 0;
4333 
4334  Value *ParentPad =
4335  getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4336 
4337  unsigned NumArgOperands = Record[Idx++];
4338 
4340  for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
4341  Value *Val;
4342  if (getValueTypePair(Record, Idx, NextValueNo, Val))
4343  return error("Invalid record");
4344  Args.push_back(Val);
4345  }
4346 
4347  if (Record.size() != Idx)
4348  return error("Invalid record");
4349 
4350  if (BitCode == bitc::FUNC_CODE_INST_CLEANUPPAD)
4351  I = CleanupPadInst::Create(ParentPad, Args);
4352  else
4353  I = CatchPadInst::Create(ParentPad, Args);
4354  InstructionList.push_back(I);
4355  break;
4356  }
4357  case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
4358  // Check magic
4359  if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
4360  // "New" SwitchInst format with case ranges. The changes to write this
4361  // format were reverted but we still recognize bitcode that uses it.
4362  // Hopefully someday we will have support for case ranges and can use
4363  // this format again.
4364 
4365  Type *OpTy = getTypeByID(Record[1]);
4366  unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
4367 
4368  Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
4369  BasicBlock *Default = getBasicBlock(Record[3]);
4370  if (!OpTy || !Cond || !Default)
4371  return error("Invalid record");
4372 
4373  unsigned NumCases = Record[4];
4374 
4375  SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
4376  InstructionList.push_back(SI);
4377 
4378  unsigned CurIdx = 5;
4379  for (unsigned i = 0; i != NumCases; ++i) {
4381  unsigned NumItems = Record[CurIdx++];
4382  for (unsigned ci = 0; ci != NumItems; ++ci) {
4383  bool isSingleNumber = Record[CurIdx++];
4384 
4385  APInt Low;
4386  unsigned ActiveWords = 1;
4387  if (ValueBitWidth > 64)
4388  ActiveWords = Record[CurIdx++];
4389  Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
4390  ValueBitWidth);
4391  CurIdx += ActiveWords;
4392 
4393  if (!isSingleNumber) {
4394  ActiveWords = 1;
4395  if (ValueBitWidth > 64)
4396  ActiveWords = Record[CurIdx++];
4398  makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth);
4399  CurIdx += ActiveWords;
4400 
4401  // FIXME: It is not clear whether values in the range should be
4402  // compared as signed or unsigned values. The partially
4403  // implemented changes that used this format in the past used
4404  // unsigned comparisons.
4405  for ( ; Low.ule(High); ++Low)
4406  CaseVals.push_back(ConstantInt::get(Context, Low));
4407  } else
4408  CaseVals.push_back(ConstantInt::get(Context, Low));
4409  }
4410  BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
4411  for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
4412  cve = CaseVals.end(); cvi != cve; ++cvi)
4413  SI->addCase(*cvi, DestBB);
4414  }
4415  I = SI;
4416  break;
4417  }
4418 
4419  // Old SwitchInst format without case ranges.
4420 
4421  if (Record.size() < 3 || (Record.size() & 1) == 0)
4422  return error("Invalid record");
4423  Type *OpTy = getTypeByID(Record[0]);
4424  Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
4425  BasicBlock *Default = getBasicBlock(Record[2]);
4426  if (!OpTy || !Cond || !Default)
4427  return error("Invalid record");
4428  unsigned NumCases = (Record.size()-3)/2;
4429  SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
4430  InstructionList.push_back(SI);
4431  for (unsigned i = 0, e = NumCases; i != e; ++i) {
4432  ConstantInt *CaseVal =
4433  dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
4434  BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
4435  if (!CaseVal || !DestBB) {
4436  delete SI;
4437  return error("Invalid record");
4438  }
4439  SI->addCase(CaseVal, DestBB);
4440  }
4441  I = SI;
4442  break;
4443  }
4444  case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
4445  if (Record.size() < 2)
4446  return error("Invalid record");
4447  Type *OpTy = getTypeByID(Record[0]);
4448  Value *Address = getValue(Record, 1, NextValueNo, OpTy);
4449  if (!OpTy || !Address)
4450  return error("Invalid record");
4451  unsigned NumDests = Record.size()-2;
4452  IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
4453  InstructionList.push_back(IBI);
4454  for (unsigned i = 0, e = NumDests; i != e; ++i) {
4455  if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
4456  IBI->addDestination(DestBB);
4457  } else {
4458  delete IBI;
4459  return error("Invalid record");
4460  }
4461  }
4462  I = IBI;
4463  break;
4464  }
4465 
4467  // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
4468  if (Record.size() < 4)
4469  return error("Invalid record");
4470  unsigned OpNum = 0;
4471  AttributeList PAL = getAttributes(Record[OpNum++]);
4472  unsigned CCInfo = Record[OpNum++];
4473  BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
4474  BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
4475 
4476  FunctionType *FTy = nullptr;
4477  FunctionType *FullFTy = nullptr;
4478  if ((CCInfo >> 13) & 1) {
4479  FullFTy =
4480  dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
4481  if (!FullFTy)
4482  return error("Explicit invoke type is not a function type");
4483  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4484  }
4485 
4486  Value *Callee;
4487  if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
4488  return error("Invalid record");
4489 
4490  PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
4491  if (!CalleeTy)
4492  return error("Callee is not a pointer");
4493  if (!FTy) {
4494  FullFTy =
4495  dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
4496  if (!FullFTy)
4497  return error("Callee is not of pointer to function type");
4498  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4499  } else if (getPointerElementFlatType(FullTy) != FTy)
4500  return error("Explicit invoke type does not match pointee type of "
4501  "callee operand");
4502  if (Record.size() < FTy->getNumParams() + OpNum)
4503  return error("Insufficient operands to call");
4504 
4506  SmallVector<Type *, 16> ArgsFullTys;
4507  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
4508  Ops.push_back(getValue(Record, OpNum, NextValueNo,
4509  FTy->getParamType(i)));
4510  ArgsFullTys.push_back(FullFTy->getParamType(i));
4511  if (!Ops.back())
4512  return error("Invalid record");
4513  }
4514 
4515  if (!FTy->isVarArg()) {
4516  if (Record.size() != OpNum)
4517  return error("Invalid record");
4518  } else {
4519  // Read type/value pairs for varargs params.
4520  while (OpNum != Record.size()) {
4521  Value *Op;
4522  Type *FullTy;
4523  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
4524  return error("Invalid record");
4525  Ops.push_back(Op);
4526  ArgsFullTys.push_back(FullTy);
4527  }
4528  }
4529 
4530  I = InvokeInst::Create(FTy, Callee, NormalBB, UnwindBB, Ops,
4531  OperandBundles);
4532  FullTy = FullFTy->getReturnType();
4533  OperandBundles.clear();
4534  InstructionList.push_back(I);
4535  cast<InvokeInst>(I)->setCallingConv(
4536  static_cast<CallingConv::ID>(CallingConv::MaxID & CCInfo));
4537  cast<InvokeInst>(I)->setAttributes(PAL);
4538  propagateByValTypes(cast<CallBase>(I), ArgsFullTys);
4539 
4540  break;
4541  }
4542  case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
4543  unsigned Idx = 0;
4544  Value *Val = nullptr;
4545  if (getValueTypePair(Record, Idx, NextValueNo, Val))
4546  return error("Invalid record");
4547  I = ResumeInst::Create(Val);
4548  InstructionList.push_back(I);
4549  break;
4550  }
4552  // CALLBR: [attr, cc, norm, transfs, fty, fnid, args]
4553  unsigned OpNum = 0;
4554  AttributeList PAL = getAttributes(Record[OpNum++]);
4555  unsigned CCInfo = Record[OpNum++];
4556 
4557  BasicBlock *DefaultDest = getBasicBlock(Record[OpNum++]);
4558  unsigned NumIndirectDests = Record[OpNum++];
4559  SmallVector<BasicBlock *, 16> IndirectDests;
4560  for (unsigned i = 0, e = NumIndirectDests; i != e; ++i)
4561  IndirectDests.push_back(getBasicBlock(Record[OpNum++]));
4562 
4563  FunctionType *FTy = nullptr;
4564  FunctionType *FullFTy = nullptr;
4565  if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
4566  FullFTy =
4567  dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
4568  if (!FullFTy)
4569  return error("Explicit call type is not a function type");
4570  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4571  }
4572 
4573  Value *Callee;
4574  if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
4575  return error("Invalid record");
4576 
4577  PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
4578  if (!OpTy)
4579  return error("Callee is not a pointer type");
4580  if (!FTy) {
4581  FullFTy =
4582  dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
4583  if (!FullFTy)
4584  return error("Callee is not of pointer to function type");
4585  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
4586  } else if (getPointerElementFlatType(FullTy) != FTy)
4587  return error("Explicit call type does not match pointee type of "
4588  "callee operand");
4589  if (Record.size() < FTy->getNumParams() + OpNum)
4590  return error("Insufficient operands to call");
4591 
4593  // Read the fixed params.
4594  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
4595  if (FTy->getParamType(i)->isLabelTy())
4596  Args.push_back(getBasicBlock(Record[OpNum]));
4597  else
4598  Args.push_back(getValue(Record, OpNum, NextValueNo,
4599  FTy->getParamType(i)));
4600  if (!Args.back())
4601  return error("Invalid record");
4602  }
4603 
4604  // Read type/value pairs for varargs params.
4605  if (!FTy->isVarArg()) {
4606  if (OpNum != Record.size())
4607  return error("Invalid record");
4608  } else {
4609  while (OpNum != Record.size()) {
4610  Value *Op;
4611  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
4612  return error("Invalid record");
4613  Args.push_back(Op);
4614  }
4615  }
4616 
4617  I = CallBrInst::Create(FTy, Callee, DefaultDest, IndirectDests, Args,
4618  OperandBundles);
4619  FullTy = FullFTy->getReturnType();
4620  OperandBundles.clear();
4621  InstructionList.push_back(I);
4622  cast<CallBrInst>(I)->setCallingConv(
4623  static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV));
4624  cast<CallBrInst>(I)->setAttributes(PAL);
4625  break;
4626  }
4627  case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
4628  I = new UnreachableInst(Context);
4629  InstructionList.push_back(I);
4630  break;
4631  case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
4632  if (Record.size() < 1)
4633  return error("Invalid record");
4634  // The first record specifies the type.
4635  FullTy = getFullyStructuredTypeByID(Record[0]);
4636  Type *Ty = flattenPointerTypes(FullTy);
4637  if (!Ty)
4638  return error("Invalid record");
4639 
4640  // Phi arguments are pairs of records of [value, basic block].
4641  // There is an optional final record for fast-math-flags if this phi has a
4642  // floating-point type.
4643  size_t NumArgs = (Record.size() - 1) / 2;
4644  if ((Record.size() - 1) % 2 == 1 && !Ty->isFPOrFPVectorTy())
4645  return error("Invalid record");
4646 
4647  PHINode *PN = PHINode::Create(Ty, NumArgs);
4648  InstructionList.push_back(PN);
4649 
4650  for (unsigned i = 0; i != NumArgs; i++) {
4651  Value *V;
4652  // With the new function encoding, it is possible that operands have
4653  // negative IDs (for forward references). Use a signed VBR
4654  // representation to keep the encoding small.
4655  if (UseRelativeIDs)
4656  V = getValueSigned(Record, i * 2 + 1, NextValueNo, Ty);
4657  else
4658  V = getValue(Record, i * 2 + 1, NextValueNo, Ty);
4659  BasicBlock *BB = getBasicBlock(Record[i * 2 + 2]);
4660  if (!V || !BB)
4661  return error("Invalid record");
4662  PN->addIncoming(V, BB);
4663  }
4664  I = PN;
4665 
4666  // If there are an even number of records, the final record must be FMF.
4667  if (Record.size() % 2 == 0) {
4668  assert(isa<FPMathOperator>(I) && "Unexpected phi type");
4669  FastMathFlags FMF = getDecodedFastMathFlags(Record[Record.size() - 1]);
4670  if (FMF.any())
4671  I->setFastMathFlags(FMF);
4672  }
4673 
4674  break;
4675  }
4676 
4679  // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
4680  unsigned Idx = 0;
4681  if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD) {
4682  if (Record.size() < 3)
4683  return error("Invalid record");
4684  } else {
4686  if (Record.size() < 4)
4687  return error("Invalid record");
4688  }
4689  FullTy = getFullyStructuredTypeByID(Record[Idx++]);
4690  Type *Ty = flattenPointerTypes(FullTy);
4691  if (!Ty)
4692  return error("Invalid record");
4693  if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {
4694  Value *PersFn = nullptr;
4695  if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
4696  return error("Invalid record");
4697 
4698  if (!F->hasPersonalityFn())
4699  F->setPersonalityFn(cast<Constant>(PersFn));
4700  else if (F->getPersonalityFn() != cast<Constant>(PersFn))
4701  return error("Personality function mismatch");
4702  }
4703 
4704  bool IsCleanup = !!Record[Idx++];
4705  unsigned NumClauses = Record[Idx++];
4706  LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses);
4707  LP->setCleanup(IsCleanup);
4708  for (unsigned J = 0; J != NumClauses; ++J) {
4710  LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
4711  Value *Val;
4712 
4713  if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
4714  delete LP;
4715  return error("Invalid record");
4716  }
4717 
4718  assert((CT != LandingPadInst::Catch ||
4719  !isa<ArrayType>(Val->getType())) &&
4720  "Catch clause has a invalid type!");
4721  assert((CT != LandingPadInst::Filter ||
4722  isa<ArrayType>(Val->getType())) &&
4723  "Filter clause has invalid type!");
4724  LP->addClause(cast<Constant>(Val));
4725  }
4726 
4727  I = LP;
4728  InstructionList.push_back(I);
4729  break;
4730  }
4731 
4732  case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
4733  if (Record.size() != 4)
4734  return error("Invalid record");
4735  uint64_t AlignRecord = Record[3];
4736  const uint64_t InAllocaMask = uint64_t(1) << 5;
4737  const uint64_t ExplicitTypeMask = uint64_t(1) << 6;
4738  const uint64_t SwiftErrorMask = uint64_t(1) << 7;
4739  const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask |
4740  SwiftErrorMask;
4741  bool InAlloca = AlignRecord & InAllocaMask;
4742  bool SwiftError = AlignRecord & SwiftErrorMask;
4743  FullTy = getFullyStructuredTypeByID(Record[0]);
4744  Type *Ty = flattenPointerTypes(FullTy);
4745  if ((AlignRecord & ExplicitTypeMask) == 0) {
4746  auto *PTy = dyn_cast_or_null<PointerType>(Ty);
4747  if (!PTy)
4748  return error("Old-style alloca with a non-pointer type");
4749  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
4750  }
4751  Type *OpTy = getTypeByID(Record[1]);
4752  Value *Size = getFnValueByID(Record[2], OpTy);
4753  MaybeAlign Align;
4754  if (Error Err = parseAlignmentValue(AlignRecord & ~FlagMask, Align)) {
4755  return Err;
4756  }
4757  if (!Ty || !Size)
4758  return error("Invalid record");
4759 
4760  // FIXME: Make this an optional field.
4761  const DataLayout &DL = TheModule->getDataLayout();
4762  unsigned AS = DL.getAllocaAddrSpace();
4763 
4764  AllocaInst *AI = new AllocaInst(Ty, AS, Size, Align ? Align->value() : 0);
4765  AI->setUsedWithInAlloca(InAlloca);
4766  AI->setSwiftError(SwiftError);
4767  I = AI;
4768  FullTy = PointerType::get(FullTy, AS);
4769  InstructionList.push_back(I);
4770  break;
4771  }
4772  case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
4773  unsigned OpNum = 0;
4774  Value *Op;
4775  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
4776  (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
4777  return error("Invalid record");
4778 
4779  if (!isa<PointerType>(Op->getType()))
4780  return error("Load operand is not a pointer type");
4781 
4782  Type *Ty = nullptr;
4783  if (OpNum + 3 == Record.size()) {
4784  FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
4785  Ty = flattenPointerTypes(FullTy);
4786  } else
4787  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
4788 
4789  if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
4790  return Err;
4791 
4792  MaybeAlign Align;
4793  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4794  return Err;
4795  I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
4796  InstructionList.push_back(I);
4797  break;
4798  }
4800  // LOADATOMIC: [opty, op, align, vol, ordering, ssid]
4801  unsigned OpNum = 0;
4802  Value *Op;
4803  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
4804  (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
4805  return error("Invalid record");
4806 
4807  if (!isa<PointerType>(Op->getType()))
4808  return error("Load operand is not a pointer type");
4809 
4810  Type *Ty = nullptr;
4811  if (OpNum + 5 == Record.size()) {
4812  FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
4813  Ty = flattenPointerTypes(FullTy);
4814  } else
4815  std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
4816 
4817  if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
4818  return Err;
4819 
4820  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4821  if (Ordering == AtomicOrdering::NotAtomic ||
4822  Ordering == AtomicOrdering::Release ||
4823  Ordering == AtomicOrdering::AcquireRelease)
4824  return error("Invalid record");
4825  if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
4826  return error("Invalid record");
4827  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
4828 
4829  MaybeAlign Align;
4830  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4831  return Err;
4832  I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align, Ordering, SSID);
4833  InstructionList.push_back(I);
4834  break;
4835  }
4837  case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol]
4838  unsigned OpNum = 0;
4839  Value *Val, *Ptr;
4840  Type *FullTy;
4841  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
4842  (BitCode == bitc::FUNC_CODE_INST_STORE
4843  ? getValueTypePair(Record, OpNum, NextValueNo, Val)
4844  : popValue(Record, OpNum, NextValueNo,
4845  getPointerElementFlatType(FullTy), Val)) ||
4846  OpNum + 2 != Record.size())
4847  return error("Invalid record");
4848 
4849  if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
4850  return Err;
4851  MaybeAlign Align;
4852  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4853  return Err;
4854  I = new StoreInst(Val, Ptr, Record[OpNum + 1], Align);
4855  InstructionList.push_back(I);
4856  break;
4857  }
4860  // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, ssid]
4861  unsigned OpNum = 0;
4862  Value *Val, *Ptr;
4863  Type *FullTy;
4864  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
4865  !isa<PointerType>(Ptr->getType()) ||
4867  ? getValueTypePair(Record, OpNum, NextValueNo, Val)
4868  : popValue(Record, OpNum, NextValueNo,
4869  getPointerElementFlatType(FullTy), Val)) ||
4870  OpNum + 4 != Record.size())
4871  return error("Invalid record");
4872 
4873  if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
4874  return Err;
4875  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4876  if (Ordering == AtomicOrdering::NotAtomic ||
4877  Ordering == AtomicOrdering::Acquire ||
4878  Ordering == AtomicOrdering::AcquireRelease)
4879  return error("Invalid record");
4880  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
4881  if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
4882  return error("Invalid record");
4883 
4884  MaybeAlign Align;
4885  if (Error Err = parseAlignmentValue(Record[OpNum], Align))
4886  return Err;
4887  I = new StoreInst(Val, Ptr, Record[OpNum + 1], Align, Ordering, SSID);
4888  InstructionList.push_back(I);
4889  break;
4890  }
4893  // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, ssid,
4894  // failureordering?, isweak?]
4895  unsigned OpNum = 0;
4896  Value *Ptr, *Cmp, *New;
4897  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy))
4898  return error("Invalid record");
4899 
4900  if (!isa<PointerType>(Ptr->getType()))
4901  return error("Cmpxchg operand is not a pointer type");
4902 
4903  if (BitCode == bitc::FUNC_CODE_INST_CMPXCHG) {
4904  if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, &FullTy))
4905  return error("Invalid record");
4906  } else if (popValue(Record, OpNum, NextValueNo,
4907  getPointerElementFlatType(FullTy), Cmp))
4908  return error("Invalid record");
4909  else
4910  FullTy = cast<PointerType>(FullTy)->getElementType();
4911 
4912  if (popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
4913  Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
4914  return error("Invalid record");
4915 
4916  AtomicOrdering SuccessOrdering = getDecodedOrdering(Record[OpNum + 1]);
4917  if (SuccessOrdering == AtomicOrdering::NotAtomic ||
4918  SuccessOrdering == AtomicOrdering::Unordered)
4919  return error("Invalid record");
4920  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
4921 
4922  if (Error Err = typeCheckLoadStoreInst(Cmp->getType(), Ptr->getType()))
4923  return Err;
4924  AtomicOrdering FailureOrdering;
4925  if (Record.size() < 7)
4926  FailureOrdering =
4928  else
4929  FailureOrdering = getDecodedOrdering(Record[OpNum + 3]);
4930 
4931  I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering,
4932  SSID);
4933  FullTy = StructType::get(Context, {FullTy, Type::getInt1Ty(Context)});
4934  cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
4935 
4936  if (Record.size() < 8) {
4937  // Before weak cmpxchgs existed, the instruction simply returned the
4938  // value loaded from memory, so bitcode files from that era will be
4939  // expecting the first component of a modern cmpxchg.
4940  CurBB->getInstList().push_back(I);
4941  I = ExtractValueInst::Create(I, 0);
4942  FullTy = cast<StructType>(FullTy)->getElementType(0);
4943  } else {
4944  cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
4945  }
4946 
4947  InstructionList.push_back(I);
4948  break;
4949  }
4951  // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, ssid]
4952  unsigned OpNum = 0;
4953  Value *Ptr, *Val;
4954  if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
4955  !isa<PointerType>(Ptr->getType()) ||
4956  popValue(Record, OpNum, NextValueNo,
4957  getPointerElementFlatType(FullTy), Val) ||
4958  OpNum + 4 != Record.size())
4959  return error("Invalid record");
4961  if (Operation < AtomicRMWInst::FIRST_BINOP ||
4962  Operation > AtomicRMWInst::LAST_BINOP)
4963  return error("Invalid record");
4964  AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
4965  if (Ordering == AtomicOrdering::NotAtomic ||
4966  Ordering == AtomicOrdering::Unordered)
4967  return error("Invalid record");
4968  SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
4969  I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SSID);
4970  FullTy = getPointerElementFlatType(FullTy);
4971  cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
4972  InstructionList.push_back(I);
4973  break;
4974  }
4975  case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, ssid]
4976  if (2 != Record.size())
4977  return error("Invalid record");
4978  AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
4979  if (Ordering == AtomicOrdering::NotAtomic ||
4980  Ordering == AtomicOrdering::Unordered ||
4981  Ordering == AtomicOrdering::Monotonic)
4982  return error("Invalid record");
4983  SyncScope::ID SSID = getDecodedSyncScopeID(Record[1]);
4984  I = new FenceInst(Context, Ordering, SSID);
4985  InstructionList.push_back(I);
4986  break;
4987  }
4989  // CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...]
4990  if (Record.size() < 3)
4991  return error("Invalid record");
4992 
4993  unsigned OpNum = 0;
4994  AttributeList PAL = getAttributes(Record[OpNum++]);
4995  unsigned CCInfo = Record[OpNum++];
4996 
4997  FastMathFlags FMF;
4998  if ((CCInfo >> bitc::CALL_FMF) & 1) {
4999  FMF = getDecodedFastMathFlags(Record[OpNum++]);
5000  if (!FMF.any())
5001  return error("Fast math flags indicator set for call with no FMF");
5002  }
5003 
5004  FunctionType *FTy = nullptr;
5005  FunctionType *FullFTy = nullptr;
5006  if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
5007  FullFTy =
5008  dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
5009  if (!FullFTy)
5010  return error("Explicit call type is not a function type");
5011  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
5012  }
5013 
5014  Value *Callee;
5015  if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
5016  return error("Invalid record");
5017 
5018  PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
5019  if (!OpTy)
5020  return error("Callee is not a pointer type");
5021  if (!FTy) {
5022  FullFTy =
5023  dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
5024  if (!FullFTy)
5025  return error("Callee is not of pointer to function type");
5026  FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
5027  } else if (getPointerElementFlatType(FullTy) != FTy)
5028  return error("Explicit call type does not match pointee type of "
5029  "callee operand");
5030  if (Record.size() < FTy->getNumParams() + OpNum)
5031  return error("Insufficient operands to call");
5032 
5034  SmallVector<Type*, 16> ArgsFullTys;
5035  // Read the fixed params.
5036  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
5037  if (FTy->getParamType(i)->isLabelTy())
5038  Args.push_back(getBasicBlock(Record[OpNum]));
5039  else
5040  Args.push_back(getValue(Record, OpNum, NextValueNo,
5041  FTy->getParamType(i)));
5042  ArgsFullTys.push_back(FullFTy->getParamType(i));
5043  if (!Args.back())
5044  return error("Invalid record");
5045  }
5046 
5047  // Read type/value pairs for varargs params.
5048  if (!FTy->isVarArg()) {
5049  if (OpNum != Record.size())
5050  return error("Invalid record");
5051  } else {
5052  while (OpNum != Record.size()) {
5053  Value *Op;
5054  Type *FullTy;
5055  if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
5056  return error("Invalid record");
5057  Args.push_back(Op);
5058  ArgsFullTys.push_back(FullTy);
5059  }
5060  }
5061 
5062  I = CallInst::Create(FTy, Callee, Args, OperandBundles);
5063  FullTy = FullFTy->getReturnType();
5064  OperandBundles.clear();
5065  InstructionList.push_back(I);
5066  cast<CallInst>(I)->setCallingConv(
5067  static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV));
5069  if (CCInfo & 1 << bitc::CALL_TAIL)
5070  TCK = CallInst::TCK_Tail;
5071  if (CCInfo & (1 << bitc::CALL_MUSTTAIL))
5072  TCK = CallInst::TCK_MustTail;
5073  if (CCInfo & (1 << bitc::CALL_NOTAIL))
5074  TCK = CallInst::TCK_NoTail;
5075  cast<CallInst>(I)->setTailCallKind(TCK);
5076  cast<CallInst>(I)->setAttributes(PAL);
5077  propagateByValTypes(cast<CallBase>(I), ArgsFullTys);
5078  if (FMF.any()) {
5079  if (!isa<FPMathOperator>(I))
5080  return error("Fast-math-flags specified for call without "
5081  "floating-point scalar or vector return type");
5082  I->setFastMathFlags(FMF);
5083  }
5084  break;
5085  }
5086  case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
5087  if (Record.size() < 3)
5088  return error("Invalid record");
5089  Type *OpTy = getTypeByID(Record[0]);
5090  Value *Op = getValue(Record, 1, NextValueNo, OpTy);
5091  FullTy = getFullyStructuredTypeByID(Record[2]);
5092  Type *ResTy = flattenPointerTypes(FullTy);
5093  if (!OpTy || !Op || !ResTy)
5094  return error("Invalid record");
5095  I = new VAArgInst(Op, ResTy);
5096  InstructionList.push_back(I);
5097  break;
5098  }
5099 
5101  // A call or an invoke can be optionally prefixed with some variable
5102  // number of operand bundle blocks. These blocks are read into
5103  // OperandBundles and consumed at the next call or invoke instruction.
5104 
5105  if (Record.size() < 1 || Record[0] >= BundleTags.size())
5106  return error("Invalid record");
5107 
5108  std::vector<Value *> Inputs;
5109 
5110  unsigned OpNum = 1;
5111  while (OpNum != Record.size()) {
5112  Value *Op;
5113  if (getValueTypePair(Record, OpNum, NextValueNo, Op))
5114  return error("Invalid record");
5115  Inputs.push_back(Op);
5116  }
5117 
5118  OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));
5119  continue;
5120  }
5121  }
5122 
5123  // Add instruction to end of current BB. If there is no current BB, reject
5124  // this file.
5125  if (!CurBB) {
5126  I->deleteValue();
5127  return error("Invalid instruction with no BB");
5128  }
5129  if (!OperandBundles.empty()) {
5130  I->deleteValue();
5131  return error("Operand bundles found with no consumer");
5132  }
5133  CurBB->getInstList().push_back(I);
5134 
5135  // If this was a terminator instruction, move to the next block.
5136  if (I->isTerminator()) {
5137  ++CurBBNo;
5138  CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
5139  }
5140 
5141  // Non-void values get registered in the value table for future use.
5142  if (I && !I->getType()->isVoidTy()) {
5143  if (!FullTy) {
5144  FullTy = I->getType();
5145  assert(
5146  !FullTy->isPointerTy() && !isa<StructType>(FullTy) &&
5147  !isa<ArrayType>(FullTy) &&
5148  (!isa<VectorType>(FullTy) ||
5149  FullTy->getVectorElementType()->isFloatingPointTy() ||
5150  FullTy->getVectorElementType()->isIntegerTy()) &&
5151  "Structured types must be assigned with corresponding non-opaque "
5152  "pointer type");
5153  }
5154 
5155  assert(I->getType() == flattenPointerTypes(FullTy) &&
5156  "Incorrect fully structured type provided for Instruction");
5157  ValueList.assignValue(I, NextValueNo++, FullTy);
5158  }
5159  }
5160 
5161 OutOfRecordLoop:
5162 
5163  if (!OperandBundles.empty())
5164  return error("Operand bundles found with no consumer");
5165 
5166  // Check the function list for unresolved values.
5167  if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
5168  if (!A->getParent()) {
5169  // We found at least one unresolved value. Nuke them all to avoid leaks.
5170  for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
5171  if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {
5172  A->replaceAllUsesWith(UndefValue::get(A->getType()));
5173  delete A;
5174  }
5175  }
5176  return error("Never resolved value found in function");
5177  }
5178  }
5179 
5180  // Unexpected unresolved metadata about to be dropped.
5181  if (MDLoader->hasFwdRefs())
5182  return error("Invalid function metadata: outgoing forward refs");
5183 
5184  // Trim the value list down to the size it was before we parsed this function.
5185  ValueList.shrinkTo(ModuleValueListSize);
5186  MDLoader->shrinkTo(ModuleMDLoaderSize);
5187  std::vector<BasicBlock*>().swap(FunctionBBs);
5188  return Error::success();
5189 }
5190 
5191 /// Find the function body in the bitcode stream
5192 Error BitcodeReader::findFunctionInStream(
5193  Function *F,
5194  DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
5195  while (DeferredFunctionInfoIterator->second == 0) {
5196  // This is the fallback handling for the old format bitcode that
5197  // didn't contain the function index in the VST, or when we have
5198  // an anonymous function which would not have a VST entry.
5199  // Assert that we have one of those two cases.
5200  assert(VSTOffset == 0 || !F->hasName());
5201  // Parse the next body in the stream and set its position in the
5202  // DeferredFunctionInfo map.
5203  if (Error Err = rememberAndSkipFunctionBodies())
5204  return Err;
5205  }
5206  return Error::success();
5207 }
5208 
5209 SyncScope::ID BitcodeReader::getDecodedSyncScopeID(unsigned Val) {
5210  if (Val == SyncScope::SingleThread || Val == SyncScope::System)
5211  return SyncScope::ID(Val);
5212  if (Val >= SSIDs.size())
5213  return SyncScope::System; // Map unknown synchronization scopes to system.
5214  return SSIDs[Val];
5215 }
5216 
5217 //===----------------------------------------------------------------------===//
5218 // GVMaterializer implementation
5219 //===----------------------------------------------------------------------===//
5220 
5221 Error BitcodeReader::materialize(GlobalValue *GV) {
5222  Function *F = dyn_cast<Function>(GV);
5223  // If it's not a function or is already material, ignore the request.
5224  if (!F || !F->isMaterializable())
5225  return Error::success();
5226 
5227  DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
5228  assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
5229  // If its position is recorded as 0, its body is somewhere in the stream
5230  // but we haven't seen it yet.
5231  if (DFII->second == 0)
5232  if (Error Err = findFunctionInStream(F, DFII))
5233  return Err;
5234 
5235  // Materialize metadata before parsing any function bodies.
5236  if (Error Err = materializeMetadata())
5237  return Err;
5238 
5239  // Move the bit stream to the saved position of the deferred function body.
5240  if (Error JumpFailed = Stream.JumpToBit(DFII->second))
5241  return JumpFailed;
5242  if (Error Err = parseFunctionBody(F))
5243  return Err;
5244  F->setIsMaterializable(false);
5245 
5246  if (StripDebugInfo)
5247  stripDebugInfo(*F);
5248 
5249  // Upgrade any old intrinsic calls in the function.
5250  for (auto &I : UpgradedIntrinsics) {
5251  for (auto UI = I.first->materialized_user_begin(), UE = I.first->user_end();
5252  UI != UE;) {
5253  User *U = *UI;
5254  ++UI;
5255  if (CallInst *CI = dyn_cast<CallInst>(U))
5256  UpgradeIntrinsicCall(CI, I.second);
5257  }
5258  }
5259 
5260  // Update calls to the remangled intrinsics
5261  for (auto &I : RemangledIntrinsics)
5262  for (auto UI = I.first->materialized_user_begin(), UE = I.first->user_end();
5263  UI != UE;)
5264  // Don't expect any other users than call sites
5265  CallSite(*UI++).setCalledFunction(I.second);
5266 
5267  // Finish fn->subprogram upgrade for materialized functions.
5268  if (DISubprogram *SP = MDLoader->lookupSubprogramForFunction(F))
5269  F->setSubprogram(SP);
5270 
5271  // Check if the TBAA Metadata are valid, otherwise we will need to strip them.
5272  if (!MDLoader->isStrippingTBAA()) {
5273  for (auto &I : instructions(F)) {
5274  MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa);
5275  if (!TBAA || TBAAVerifyHelper.visitTBAAMetadata(I, TBAA))
5276  continue;
5277  MDLoader->setStripTBAA(true);
5278  stripTBAA(F->getParent());
5279  }
5280  }
5281 
5282  // Bring in any functions that this function forward-referenced via
5283  // blockaddresses.
5284  return materializeForwardReferencedFunctions();
5285 }
5286 
5287 Error BitcodeReader::materializeModule() {
5288  if (Error Err = materializeMetadata())
5289  return Err;
5290 
5291  // Promise to materialize all forward references.
5292  WillMaterializeAllForwardRefs = true;
5293 
5294  // Iterate over the module, deserializing any functions that are still on
5295  // disk.
5296  for (Function &F : *TheModule) {
5297  if (Error Err = materialize(&F))
5298  return Err;
5299  }
5300  // At this point, if there are any function bodies, parse the rest of
5301  // the bits in the module past the last function block we have recorded
5302  // through either lazy scanning or the VST.
5303  if (LastFunctionBlockBit || NextUnreadBit)
5304  if (Error Err = parseModule(LastFunctionBlockBit > NextUnreadBit
5305  ? LastFunctionBlockBit
5306  : NextUnreadBit))
5307  return Err;
5308 
5309  // Check that all block address forward references got resolved (as we
5310  // promised above).
5311  if (!BasicBlockFwdRefs.empty())
5312  return error("Never resolved function from blockaddress");
5313 
5314  // Upgrade any intrinsic calls that slipped through (should not happen!) and
5315  // delete the old functions to clean up. We can't do this unless the entire
5316  // module is materialized because there could always be another function body
5317  // with calls to the old function.
5318  for (auto &I : UpgradedIntrinsics) {
5319  for (auto *U : I.first->users()) {
5320  if (CallInst *CI = dyn_cast<CallInst>(U))
5321  UpgradeIntrinsicCall(CI, I.second);
5322  }
5323  if (!I.first->use_empty())
5324  I.first->replaceAllUsesWith(I.second);
5325  I.first->eraseFromParent();
5326  }
5327  UpgradedIntrinsics.clear();
5328  // Do the same for remangled intrinsics
5329  for (auto &I : RemangledIntrinsics) {
5330  I.first->replaceAllUsesWith(I.second);
5331  I.first->eraseFromParent();
5332  }
5333  RemangledIntrinsics.clear();
5334 
5335  UpgradeDebugInfo(*TheModule);
5336 
5337  UpgradeModuleFlags(*TheModule);
5338 
5339  UpgradeARCRuntime(*TheModule);
5340 
5341  return Error::success();
5342 }
5343 
5344 std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const {
5345  return IdentifiedStructTypes;
5346 }
5347 
5348 ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(
5349  BitstreamCursor Cursor, StringRef Strtab, ModuleSummaryIndex &TheIndex,
5350  StringRef ModulePath, unsigned ModuleId)
5351  : BitcodeReaderBase(std::move(Cursor), Strtab), TheIndex(TheIndex),
5352  ModulePath(ModulePath), ModuleId(ModuleId) {}
5353 
5354 void ModuleSummaryIndexBitcodeReader::addThisModule() {
5355  TheIndex.addModule(ModulePath, ModuleId);
5356 }
5357 
5359 ModuleSummaryIndexBitcodeReader::getThisModule() {
5360  return TheIndex.getModule(ModulePath);
5361 }
5362 
5363 std::pair<ValueInfo, GlobalValue::GUID>
5364 ModuleSummaryIndexBitcodeReader::getValueInfoFromValueId(unsigned ValueId) {
5365  auto VGI = ValueIdToValueInfoMap[ValueId];
5366  assert(VGI.first);
5367  return VGI;
5368 }
5369 
5370 void ModuleSummaryIndexBitcodeReader::setValueGUID(
5372  StringRef SourceFileName) {
5373  std::string GlobalId =
5374  GlobalValue::getGlobalIdentifier(ValueName, Linkage, SourceFileName);
5375  auto ValueGUID = GlobalValue::getGUID(GlobalId);
5376  auto OriginalNameID = ValueGUID;
5377  if (GlobalValue::isLocalLinkage(Linkage))
5378  OriginalNameID = GlobalValue::getGUID(ValueName);
5379  if (PrintSummaryGUIDs)
5380  dbgs() << "GUID " << ValueGUID << "(" << OriginalNameID << ") is "
5381  << ValueName << &