Make parseBitcodeFile use a named StructType, if it exists and matches.

[arnt]

Summary

Until now, parseBitcodeFile() would use an already-existing StructType if
it EITHER had the right structure and no name, OR the right name and no
structure, but not if it had both the right name and the right structure.
This change makes parseBitcodeFile() check the struct and use it if
appropriate.

It still creates a new StructType with a new name if the existing type and
what it needs to read differs in structure.

It also add a new function to retrieve a named StructType by name. The new
function is a lookup-only function; it doesn't change anything at all.

[arnt]

I added lebedev.ri and the last two people to touch the file as reviewers, I hope that's not too much of an imposition.

[dnsampaio]

Sorry, I don't believe I ever touched these files before.

[lebedev.ri]

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1717

Pass by non-const value

1718

ArrayRef

1719

I'm not sure this is clang-formatted

1724–1727

if(!EltTys.equals(Candidate->elements()))
  return nullptr;

llvm/lib/IR/Type.cpp

342

nullptr

348

sporadic newline

[arnt]

more LLVM-y style, and better style too. Modern.

[arnt]

@dnsampaio Sorry about that. I looked at my shell history now, and I think I added you because I got a wildcard wrong and picked the most recent two committers for the wrong set of files.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1724–1727

Oh, that's neat. I hadn't noticed that being done elsewhere, but I like it better. I'll push as soon as the unit tests have run.

[lebedev.ri]

(not all inline remarks were addressed)

llvm/include/llvm/IR/DerivedTypes.h

272–277

This probably deserves a /// doxygen comment

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1718–1719

here and elsewhere - not from clang-format
(you can just setup a git pre-commit hook so all your commits will have correct formatting)

[arnt]

I didn't mean to suggest that I'd done all of them, I just ran out of working time on Friday. I attended to the rest now and will push a new revision as soon as the tests have run.

llvm/include/llvm/IR/DerivedTypes.h

272–277

Yes.

There could be a lot more of them in general. Doxygen sucks.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1718–1719

I added the emacs integration. I'll try the git commit hook before my next pull request, thanks for the suggestion.

[arnt]

Attended to the rest of Lebedev.ri's comments, plus clang-format

[lebedev.ri]

For reference, there is a trivial way to correctly format all the changed code:
https://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting

llvm/unittests/Bitcode/BitReaderTest.cpp

217

EXPECT_EQ() / EXPECT_ME() ?

[arnt]

Thanks.

FWIW I noticed that the author of the git-commit hook suggested using an emacs-lisp clang-format wrapper, and decided to try that first, until I grow unhappy.

llvm/unittests/Bitcode/BitReaderTest.cpp

217

Yes, OK, will fix, although YAGNI and so on.

[arnt]

This revision uses more appropriate gtest matchers.

[arnt]

This patch overlooks a case and should not be merged for now.

Specifically, forward references in the bitcode file cause BitcodeReader::createIdentifiedStructType(LLVMContext &) to create a type, even though the intended type might already exist in the LLVMContext. I'm not sure how to create a test that exercises this clearly and cleanly, or whether this can really be solved. Will have a coffee and a think.

JFYI, my eventual purpose is to do things like reading a class's superclass's Module into the same LLVMContext as the class's own Module.

[arnt]

This modifies the patch to handle forward type references, and adds
relevant unit testing.

Unfortunately this is a rather large change.

[arnt]

Whitespace changes only.

It appears that the emacs clang-format stuff is too demanding for me; I'll
try to the git precommit hook instead and see if that agrees better with
me.

[lebedev.ri]

This patch seems to make sense but as it is all but guaranteed for LLVM patches, it is stalling and is starting to bitrot.
If you're still interested in it i'd maybe recommend posting to llvm-dev, or llvm-weekly review-wanted section

[arnt]

Rebased on top of today's LLVM.

No functional changes, I just had to fix a couple of merge conflicts.

I'll continue rebasing this (I really need it myself) and I'd be happy to
see it reviewed and merged. But if noone else cares about the
functionality, then I don't think I ought to pester anyone for reviews...
so I won't, at least not in the near future.

[t.p.northover]

I think the clang-format should be restricted to the actual diff. Doing the whole file makes this change really hard to read, and disrupts the blame for the future. git-clang-format in the Clang repo does the right thing by default I think.

[arnt]

Sorry about that; I'll revisit. But I won't have time to do this today. FWIW the patch looked right (ie. only my lines were touched by clang-format) immediately before I ran arc diff.

Sigh.

[arnt]

This should avoid clang-formatting the entire files. Should.

Awfully sorry about that.

[t.p.northover]

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1940–1942

Really? I thought loading multiple bitcode files into the same LLVMContext was fine and conflicting types were automatically renamed.

Am I misreading or will this turn that situation into an error?

[t.p.northover]

Sorry for the double reply, Phab ate my comment.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1720–1721

This looks like it owns the SmallVector so it would be a lot simpler to make it a simple value type and std::move when emplacing into the std::vector. Reduce the size of the diff substantially too, I think.

[arnt]

I have to type this in order to publish the comments above?

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1720–1721

Sure, I can do that... if this is going to be merged at all. But I have a feeling that this isn't going to be merged anywway, for substantive reasons. It rocks an important boat and only I have a reason for wanting it. So I'll wait with this.

1940–1942

The test for "conflicting type" was not terribly sensible. It assumed that if all modules contained opaque references to the same opaque type, then the the same name meant the same type. However, if one module had a defined type and the others had opaque types, then it was a naming conflict, which was silently resolved by renaming.

The case that blew up for me involved loading the superclasses for a class into the same context. Suppose that C inherits B, which inherits A, and each has its own type and module. A's module contains one or more A-related struct types, B's and C's module contain opaque references. B's module contains, etc. Loading B and C into the same context would break, because C's references to B would be renamed, while those to A would be preserved. I struggled to find a rationale for this.

I chose to make it an error because there are cases where renaming isn't safe, and I can't see a way to detect it. Suppose modules D and E both contain defined struct types T, and module F contains an opaque T. What is intended? The existing code would behave differently depending on load order. If you load only D and E, renaming is safe. But when loading the second of D/E, the reader doesn't know whether F will appear.

[t.p.northover]

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1940–1942

Loading B and C into the same context would break, because C's references to B would be renamed, while those to A would be preserved. I struggled to find a rationale for this.

It sounds like it'd result in weird names and inconsistent usage of each type, but not fundamentally change the semantics of the IR. I believe this is how LTO actually works.

Suppose modules D and E both contain defined struct types T, and module F contains an opaque T. What is intended?

D and E would continue to use a type structurally equivalent to their version of T, but one of them would have to give up the name (and get something like %T.1).

I don't believe there are any constraints on what happens to F: it could use yet another (still) opaque %T.2 or either of the versions from D/E. Because the type was opaque it can't be doing any operations that actually care.

llvm/include/llvm/IR/DerivedTypes.h

public:
   template <class... Tys>
   static typename std::enable_if<are_base_of<Type, Tys...>::value,
                                  StructType *>::type
   create(StringRef Name, Type *elt1, Tys *... elts) {
     assert(elt1 && "Cannot create a struct type with no elements with this");
     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
     return create(StructFields, Name);
   }
 
+  /// This static method returns a StructType by that name if one exists, and a
+  /// null pointer otherwise.
+  static StructType *getIfExists(LLVMContext &Context, StringRef Name);
+
   /// This static method is the primary way to create a literal StructType.
   static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements,
                          bool isPacked = false);
 
   /// Create an empty structure type.
   static StructType *get(LLVMContext &Context, bool isPacked = false);
 
   /// This static method is a convenience method for creating structure types by
   /// specifying the elements as arguments. Note that this method always returns

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

while (true) {
     default: // Default behavior: reject
       return error("Invalid value");
     case bitc::IDENTIFICATION_CODE_STRING: // IDENTIFICATION: [strchr x N]
       convertToString(Record, 0, ProducerIdentification);
       break;
     case bitc::IDENTIFICATION_CODE_EPOCH: { // EPOCH: [epoch#]
       unsigned epoch = (unsigned)Record[0];
       if (epoch != bitc::BITCODE_CURRENT_EPOCH) {
-        return error(
-          Twine("Incompatible epoch: Bitcode '") + Twine(epoch) +
-          "' vs current: '" + Twine(bitc::BITCODE_CURRENT_EPOCH) + "'");
+        return error(Twine("Incompatible epoch: Bitcode '") + Twine(epoch) +
+                     "' vs current: '" + Twine(bitc::BITCODE_CURRENT_EPOCH) +
+                     "'");
       }
     }
     }
   }
 }
 
 static Expected<std::string> readIdentificationCode(BitstreamCursor &Stream) {
   // We expect a number of well-defined blocks, though we don't necessarily
case BitstreamEntry::Record:
       break;
     }
 
     // Read a record.
     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
     if (!MaybeRecord)
       return MaybeRecord.takeError();
     switch (MaybeRecord.get()) {
-    default: break;  // Default behavior, ignore unknown content.
-    case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
+    default:
+      break; // Default behavior, ignore unknown content.
+    case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       Triple = S;
       break;
     }
     }
     Record.clear();
class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
   // Last function offset found in the VST.
   uint64_t LastFunctionBlockBit = 0;
   bool SeenValueSymbolTable = false;
   uint64_t VSTOffset = 0;
 
   std::vector<std::string> SectionTable;
   std::vector<std::string> GCTable;
 
-  std::vector<Type*> TypeList;
+  std::vector<Type *> TypeList;
   BitcodeReaderValueList ValueList;
   Optional<MetadataLoader> MDLoader;
   std::vector<Comdat *> ComdatList;
   SmallVector<Instruction *, 64> InstructionList;
 
   std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInits;
   std::vector<std::pair<GlobalIndirectSymbol *, unsigned>> IndirectSymbolInits;
   std::vector<std::pair<Function *, unsigned>> FunctionPrefixes;
   std::vector<std::pair<Function *, unsigned>> FunctionPrologues;
   std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFns;
 
   /// The set of attributes by index.  Index zero in the file is for null, and
   /// is thus not represented here.  As such all indices are off by one.
   std::vector<AttributeList> MAttributes;
 
   /// The set of attribute groups.
   std::map<unsigned, AttributeList> MAttributeGroups;
 
   /// While parsing a function body, this is a list of the basic blocks for the
   /// function.
-  std::vector<BasicBlock*> FunctionBBs;
+  std::vector<BasicBlock *> FunctionBBs;
 
   // When reading the module header, this list is populated with functions that
   // have bodies later in the file.
-  std::vector<Function*> FunctionsWithBodies;
+  std::vector<Function *> FunctionsWithBodies;
 
   // When intrinsic functions are encountered which require upgrading they are
   // stored here with their replacement function.
   using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
   UpdatedIntrinsicMap UpgradedIntrinsics;
   // Intrinsics which were remangled because of types rename
   UpdatedIntrinsicMap RemangledIntrinsics;
 
   // Several operations happen after the module header has been read, but
   // before function bodies are processed. This keeps track of whether
   // we've done this yet.
   bool SeenFirstFunctionBody = false;
 
   /// When function bodies are initially scanned, this map contains info about
   /// where to find deferred function body in the stream.
-  DenseMap<Function*, uint64_t> DeferredFunctionInfo;
+  DenseMap<Function *, uint64_t> DeferredFunctionInfo;
 
   /// When Metadata block is initially scanned when parsing the module, we may
   /// choose to defer parsing of the metadata. This vector contains info about
   /// which Metadata blocks are deferred.
   std::vector<uint64_t> DeferredMetadataInfo;
 
   /// These are basic blocks forward-referenced by block addresses.  They are
   /// inserted lazily into functions when they're loaded.  The basic block ID is
public:
 
   /// Materialize any deferred Metadata block.
   Error materializeMetadata() override;
 
   void setStripDebugInfo() override;
 
 private:
   std::vector<StructType *> IdentifiedStructTypes;
-  StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
-  StructType *createIdentifiedStructType(LLVMContext &Context);
 
   Type *getTypeByID(unsigned ID);
 
   Value *getFnValueByID(unsigned ID, Type *Ty) {
     if (Ty && Ty->isMetadataTy())
       return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
     return ValueList.getValueFwdRef(ID, Ty);
   }
 
   Metadata *getFnMetadataByID(unsigned ID) {
     return MDLoader->getMetadataFwdRefOrLoad(ID);
   }
 
   BasicBlock *getBasicBlock(unsigned ID) const {
-    if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
+    if (ID >= FunctionBBs.size())
+      return nullptr; // Invalid ID
     return FunctionBBs[ID];
   }
 
   AttributeList getAttributes(unsigned i) const {
-    if (i-1 < MAttributes.size())
-      return MAttributes[i-1];
+    if (i - 1 < MAttributes.size())
+      return MAttributes[i - 1];
     return AttributeList();
   }
 
   /// Read a value/type pair out of the specified record from slot 'Slot'.
   /// Increment Slot past the number of slots used in the record. Return true on
   /// failure.
   bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
                         unsigned InstNum, Value *&ResVal) {
-    if (Slot == Record.size()) return true;
+    if (Slot == Record.size())
+      return true;
     unsigned ValNo = (unsigned)Record[Slot++];
     // Adjust the ValNo, if it was encoded relative to the InstNum.
     if (UseRelativeIDs)
       ValNo = InstNum - ValNo;
     if (ValNo < InstNum) {
       // If this is not a forward reference, just return the value we already
       // have.
       ResVal = getFnValueByID(ValNo, nullptr);
bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
     ResVal = getValue(Record, Slot, InstNum, Ty);
     return ResVal == nullptr;
   }
 
   /// Version of getValue that returns ResVal directly, or 0 if there is an
   /// error.
   Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
                   unsigned InstNum, Type *Ty) {
-    if (Slot == Record.size()) return nullptr;
+    if (Slot == Record.size())
+      return nullptr;
     unsigned ValNo = (unsigned)Record[Slot];
     // Adjust the ValNo, if it was encoded relative to the InstNum.
     if (UseRelativeIDs)
       ValNo = InstNum - ValNo;
     return getFnValueByID(ValNo, Ty);
   }
 
   /// Like getValue, but decodes signed VBRs.
   Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
                         unsigned InstNum, Type *Ty) {
-    if (Slot == Record.size()) return nullptr;
+    if (Slot == Record.size())
+      return nullptr;
     unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
     // Adjust the ValNo, if it was encoded relative to the InstNum.
     if (UseRelativeIDs)
       ValNo = InstNum - ValNo;
     return getFnValueByID(ValNo, Ty);
   }
 
   /// Upgrades old-style typeless byval attributes by adding the corresponding
static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) {
   case 12:
     return GlobalValue::AvailableExternallyLinkage;
   case 13:
     return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage
   case 14:
     return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage
   case 15:
     return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage
-  case 1: // Old value with implicit comdat.
+  case 1:                                // Old value with implicit comdat.
   case 16:
     return GlobalValue::WeakAnyLinkage;
   case 10: // Old value with implicit comdat.
   case 17:
     return GlobalValue::WeakODRLinkage;
   case 4: // Old value with implicit comdat.
   case 18:
     return GlobalValue::LinkOnceAnyLinkage;
static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags,
   bool NotEligibleToImport = (RawFlags & 0x1) || Version < 3;
   // The Live flag wasn't introduced until version 3. For dead stripping
   // to work correctly on earlier versions, we must conservatively treat all
   // values as live.
   bool Live = (RawFlags & 0x2) || Version < 3;
   bool Local = (RawFlags & 0x4);
   bool AutoHide = (RawFlags & 0x8);
 
-  return GlobalValueSummary::GVFlags(Linkage, NotEligibleToImport, Live, Local, AutoHide);
+  return GlobalValueSummary::GVFlags(Linkage, NotEligibleToImport, Live, Local,
+                                     AutoHide);
 }
 
 // Decode the flags for GlobalVariable in the summary
 static GlobalVarSummary::GVarFlags getDecodedGVarFlags(uint64_t RawFlags) {
   return GlobalVarSummary::GVarFlags((RawFlags & 0x1) ? true : false);
 }
 
 static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) {
   switch (Val) {
   default: // Map unknown visibilities to default.
-  case 0: return GlobalValue::DefaultVisibility;
-  case 1: return GlobalValue::HiddenVisibility;
-  case 2: return GlobalValue::ProtectedVisibility;
+  case 0:
+    return GlobalValue::DefaultVisibility;
+  case 1:
+    return GlobalValue::HiddenVisibility;
+  case 2:
+    return GlobalValue::ProtectedVisibility;
   }
 }
 
 static GlobalValue::DLLStorageClassTypes
 getDecodedDLLStorageClass(unsigned Val) {
   switch (Val) {
   default: // Map unknown values to default.
-  case 0: return GlobalValue::DefaultStorageClass;
-  case 1: return GlobalValue::DLLImportStorageClass;
-  case 2: return GlobalValue::DLLExportStorageClass;
+  case 0:
+    return GlobalValue::DefaultStorageClass;
+  case 1:
+    return GlobalValue::DLLImportStorageClass;
+  case 2:
+    return GlobalValue::DLLExportStorageClass;
   }
 }
 
 static bool getDecodedDSOLocal(unsigned Val) {
-  switch(Val) {
+  switch (Val) {
   default: // Map unknown values to preemptable.
-  case 0:  return false;
-  case 1:  return true;
+  case 0:
+    return false;
+  case 1:
+    return true;
   }
 }
 
 static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) {
   switch (Val) {
-    case 0: return GlobalVariable::NotThreadLocal;
-    default: // Map unknown non-zero value to general dynamic.
-    case 1: return GlobalVariable::GeneralDynamicTLSModel;
-    case 2: return GlobalVariable::LocalDynamicTLSModel;
-    case 3: return GlobalVariable::InitialExecTLSModel;
-    case 4: return GlobalVariable::LocalExecTLSModel;
+  case 0:
+    return GlobalVariable::NotThreadLocal;
+  case 1:
+    return GlobalVariable::GeneralDynamicTLSModel;
+  case 2:
+    return GlobalVariable::LocalDynamicTLSModel;
+  case 3:
+    return GlobalVariable::InitialExecTLSModel;
+  case 4:
+    return GlobalVariable::LocalExecTLSModel;
   }
 }
 
 static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) {
   switch (Val) {
-    default: // Map unknown to UnnamedAddr::None.
-    case 0: return GlobalVariable::UnnamedAddr::None;
-    case 1: return GlobalVariable::UnnamedAddr::Global;
-    case 2: return GlobalVariable::UnnamedAddr::Local;
+  case 0:
+    return GlobalVariable::UnnamedAddr::None;
+  case 1:
+    return GlobalVariable::UnnamedAddr::Global;
+  case 2:
+    return GlobalVariable::UnnamedAddr::Local;
   }
 }
 
 static int getDecodedCastOpcode(unsigned Val) {
   switch (Val) {
-  default: return -1;
-  case bitc::CAST_TRUNC   : return Instruction::Trunc;
-  case bitc::CAST_ZEXT    : return Instruction::ZExt;
-  case bitc::CAST_SEXT    : return Instruction::SExt;
-  case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
-  case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
-  case bitc::CAST_UITOFP  : return Instruction::UIToFP;
-  case bitc::CAST_SITOFP  : return Instruction::SIToFP;
-  case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
-  case bitc::CAST_FPEXT   : return Instruction::FPExt;
-  case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
-  case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
-  case bitc::CAST_BITCAST : return Instruction::BitCast;
-  case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast;
+  default:
+    return -1;
+  case bitc::CAST_TRUNC:
+    return Instruction::Trunc;
+  case bitc::CAST_ZEXT:
+    return Instruction::ZExt;
+  case bitc::CAST_SEXT:
+    return Instruction::SExt;
+  case bitc::CAST_FPTOUI:
+    return Instruction::FPToUI;
+  case bitc::CAST_FPTOSI:
+    return Instruction::FPToSI;
+  case bitc::CAST_UITOFP:
+    return Instruction::UIToFP;
+  case bitc::CAST_SITOFP:
+    return Instruction::SIToFP;
+  case bitc::CAST_FPTRUNC:
+    return Instruction::FPTrunc;
+  case bitc::CAST_FPEXT:
+    return Instruction::FPExt;
+  case bitc::CAST_PTRTOINT:
+    return Instruction::PtrToInt;
+  case bitc::CAST_INTTOPTR:
+    return Instruction::IntToPtr;
+  case bitc::CAST_BITCAST:
+    return Instruction::BitCast;
+  case bitc::CAST_ADDRSPACECAST:
+    return Instruction::AddrSpaceCast;
   }
 }
 
 static int getDecodedUnaryOpcode(unsigned Val, Type *Ty) {
   bool IsFP = Ty->isFPOrFPVectorTy();
   // UnOps are only valid for int/fp or vector of int/fp types
   if (!IsFP && !Ty->isIntOrIntVectorTy())
     return -1;
case bitc::BINOP_OR:
     return IsFP ? -1 : Instruction::Or;
   case bitc::BINOP_XOR:
     return IsFP ? -1 : Instruction::Xor;
   }
 }
 
 static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val) {
   switch (Val) {
-  default: return AtomicRMWInst::BAD_BINOP;
-  case bitc::RMW_XCHG: return AtomicRMWInst::Xchg;
-  case bitc::RMW_ADD: return AtomicRMWInst::Add;
-  case bitc::RMW_SUB: return AtomicRMWInst::Sub;
-  case bitc::RMW_AND: return AtomicRMWInst::And;
-  case bitc::RMW_NAND: return AtomicRMWInst::Nand;
-  case bitc::RMW_OR: return AtomicRMWInst::Or;
-  case bitc::RMW_XOR: return AtomicRMWInst::Xor;
-  case bitc::RMW_MAX: return AtomicRMWInst::Max;
-  case bitc::RMW_MIN: return AtomicRMWInst::Min;
-  case bitc::RMW_UMAX: return AtomicRMWInst::UMax;
-  case bitc::RMW_UMIN: return AtomicRMWInst::UMin;
-  case bitc::RMW_FADD: return AtomicRMWInst::FAdd;
-  case bitc::RMW_FSUB: return AtomicRMWInst::FSub;
+  default:
+    return AtomicRMWInst::BAD_BINOP;
+  case bitc::RMW_XCHG:
+    return AtomicRMWInst::Xchg;
+  case bitc::RMW_ADD:
+    return AtomicRMWInst::Add;
+  case bitc::RMW_SUB:
+    return AtomicRMWInst::Sub;
+  case bitc::RMW_AND:
+    return AtomicRMWInst::And;
+  case bitc::RMW_NAND:
+    return AtomicRMWInst::Nand;
+  case bitc::RMW_OR:
+    return AtomicRMWInst::Or;
+  case bitc::RMW_XOR:
+    return AtomicRMWInst::Xor;
+  case bitc::RMW_MAX:
+    return AtomicRMWInst::Max;
+  case bitc::RMW_MIN:
+    return AtomicRMWInst::Min;
+  case bitc::RMW_UMAX:
+    return AtomicRMWInst::UMax;
+  case bitc::RMW_UMIN:
+    return AtomicRMWInst::UMin;
+  case bitc::RMW_FADD:
+    return AtomicRMWInst::FAdd;
+  case bitc::RMW_FSUB:
+    return AtomicRMWInst::FSub;
   }
 }
 
 static AtomicOrdering getDecodedOrdering(unsigned Val) {
   switch (Val) {
-  case bitc::ORDERING_NOTATOMIC: return AtomicOrdering::NotAtomic;
-  case bitc::ORDERING_UNORDERED: return AtomicOrdering::Unordered;
-  case bitc::ORDERING_MONOTONIC: return AtomicOrdering::Monotonic;
-  case bitc::ORDERING_ACQUIRE: return AtomicOrdering::Acquire;
-  case bitc::ORDERING_RELEASE: return AtomicOrdering::Release;
-  case bitc::ORDERING_ACQREL: return AtomicOrdering::AcquireRelease;
+  case bitc::ORDERING_NOTATOMIC:
+    return AtomicOrdering::NotAtomic;
+  case bitc::ORDERING_UNORDERED:
+    return AtomicOrdering::Unordered;
+  case bitc::ORDERING_MONOTONIC:
+    return AtomicOrdering::Monotonic;
+  case bitc::ORDERING_ACQUIRE:
+    return AtomicOrdering::Acquire;
+  case bitc::ORDERING_RELEASE:
+    return AtomicOrdering::Release;
+  case bitc::ORDERING_ACQREL:
+    return AtomicOrdering::AcquireRelease;
   default: // Map unknown orderings to sequentially-consistent.
-  case bitc::ORDERING_SEQCST: return AtomicOrdering::SequentiallyConsistent;
+  case bitc::ORDERING_SEQCST:
+    return AtomicOrdering::SequentiallyConsistent;
   }
 }
 
 static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
   switch (Val) {
   default: // Map unknown selection kinds to any.
   case bitc::COMDAT_SELECTION_KIND_ANY:
     return Comdat::Any;
if (0 != (Val & bitc::AllowContract))
     FMF.setAllowContract(true);
   if (0 != (Val & bitc::ApproxFunc))
     FMF.setApproxFunc();
   return FMF;
 }
 
 static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val) {
   switch (Val) {
-  case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break;
-  case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break;
+  case 5:
+    GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
+    break;
+  case 6:
+    GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass);
+    break;
   }
 }
 
 Type *BitcodeReader::getTypeByID(unsigned ID) {
   // The type table size is always specified correctly.
   if (ID >= TypeList.size())
     return nullptr;
 
-  if (Type *Ty = TypeList[ID])
-    return Ty;
-
-  // If we have a forward reference, the only possible case is when it is to a
-  // named struct.  Just create a placeholder for now.
-  return TypeList[ID] = createIdentifiedStructType(Context);
-}
-
-StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context,
-                                                      StringRef Name) {
-  auto *Ret = StructType::create(Context, Name);
-  IdentifiedStructTypes.push_back(Ret);
-  return Ret;
-}
-
-StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) {
-  auto *Ret = StructType::create(Context);
-  IdentifiedStructTypes.push_back(Ret);
-  return Ret;
+  return TypeList[ID];
 }
 
 //===----------------------------------------------------------------------===//
 //  Functions for parsing blocks from the bitcode file
 //===----------------------------------------------------------------------===//
 
 static uint64_t getRawAttributeMask(Attribute::AttrKind Val) {
   switch (Val) {
   case Attribute::EndAttrKinds:
     llvm_unreachable("Synthetic enumerators which should never get here");
 
-  case Attribute::None:            return 0;
-  case Attribute::ZExt:            return 1 << 0;
-  case Attribute::SExt:            return 1 << 1;
-  case Attribute::NoReturn:        return 1 << 2;
-  case Attribute::InReg:           return 1 << 3;
-  case Attribute::StructRet:       return 1 << 4;
-  case Attribute::NoUnwind:        return 1 << 5;
-  case Attribute::NoAlias:         return 1 << 6;
-  case Attribute::ByVal:           return 1 << 7;
-  case Attribute::Nest:            return 1 << 8;
-  case Attribute::ReadNone:        return 1 << 9;
-  case Attribute::ReadOnly:        return 1 << 10;
-  case Attribute::NoInline:        return 1 << 11;
-  case Attribute::AlwaysInline:    return 1 << 12;
-  case Attribute::OptimizeForSize: return 1 << 13;
-  case Attribute::StackProtect:    return 1 << 14;
-  case Attribute::StackProtectReq: return 1 << 15;
-  case Attribute::Alignment:       return 31 << 16;
-  case Attribute::NoCapture:       return 1 << 21;
-  case Attribute::NoRedZone:       return 1 << 22;
-  case Attribute::NoImplicitFloat: return 1 << 23;
-  case Attribute::Naked:           return 1 << 24;
-  case Attribute::InlineHint:      return 1 << 25;
-  case Attribute::StackAlignment:  return 7 << 26;
-  case Attribute::ReturnsTwice:    return 1 << 29;
-  case Attribute::UWTable:         return 1 << 30;
-  case Attribute::NonLazyBind:     return 1U << 31;
-  case Attribute::SanitizeAddress: return 1ULL << 32;
-  case Attribute::MinSize:         return 1ULL << 33;
-  case Attribute::NoDuplicate:     return 1ULL << 34;
-  case Attribute::StackProtectStrong: return 1ULL << 35;
-  case Attribute::SanitizeThread:  return 1ULL << 36;
-  case Attribute::SanitizeMemory:  return 1ULL << 37;
-  case Attribute::NoBuiltin:       return 1ULL << 38;
-  case Attribute::Returned:        return 1ULL << 39;
-  case Attribute::Cold:            return 1ULL << 40;
-  case Attribute::Builtin:         return 1ULL << 41;
-  case Attribute::OptimizeNone:    return 1ULL << 42;
-  case Attribute::InAlloca:        return 1ULL << 43;
-  case Attribute::NonNull:         return 1ULL << 44;
-  case Attribute::JumpTable:       return 1ULL << 45;
-  case Attribute::Convergent:      return 1ULL << 46;
-  case Attribute::SafeStack:       return 1ULL << 47;
-  case Attribute::NoRecurse:       return 1ULL << 48;
-  case Attribute::InaccessibleMemOnly:         return 1ULL << 49;
-  case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50;
-  case Attribute::SwiftSelf:       return 1ULL << 51;
-  case Attribute::SwiftError:      return 1ULL << 52;
-  case Attribute::WriteOnly:       return 1ULL << 53;
-  case Attribute::Speculatable:    return 1ULL << 54;
-  case Attribute::StrictFP:        return 1ULL << 55;
-  case Attribute::SanitizeHWAddress: return 1ULL << 56;
-  case Attribute::NoCfCheck:       return 1ULL << 57;
-  case Attribute::OptForFuzzing:   return 1ULL << 58;
-  case Attribute::ShadowCallStack: return 1ULL << 59;
+  case Attribute::None:
+    return 0;
+  case Attribute::ZExt:
+    return 1 << 0;
+  case Attribute::SExt:
+    return 1 << 1;
+  case Attribute::NoReturn:
+    return 1 << 2;
+  case Attribute::InReg:
+    return 1 << 3;
+  case Attribute::StructRet:
+    return 1 << 4;
+  case Attribute::NoUnwind:
+    return 1 << 5;
+  case Attribute::NoAlias:
+    return 1 << 6;
+  case Attribute::ByVal:
+    return 1 << 7;
+  case Attribute::Nest:
+    return 1 << 8;
+  case Attribute::ReadNone:
+    return 1 << 9;
+  case Attribute::ReadOnly:
+    return 1 << 10;
+  case Attribute::NoInline:
+    return 1 << 11;
+  case Attribute::AlwaysInline:
+    return 1 << 12;
+  case Attribute::OptimizeForSize:
+    return 1 << 13;
+  case Attribute::StackProtect:
+    return 1 << 14;
+  case Attribute::StackProtectReq:
+    return 1 << 15;
+  case Attribute::Alignment:
+    return 31 << 16;
+  case Attribute::NoCapture:
+    return 1 << 21;
+  case Attribute::NoRedZone:
+    return 1 << 22;
+  case Attribute::NoImplicitFloat:
+    return 1 << 23;
+  case Attribute::Naked:
+    return 1 << 24;
+  case Attribute::InlineHint:
+    return 1 << 25;
+  case Attribute::StackAlignment:
+    return 7 << 26;
+  case Attribute::ReturnsTwice:
+    return 1 << 29;
+  case Attribute::UWTable:
+    return 1 << 30;
+  case Attribute::NonLazyBind:
+    return 1U << 31;
+  case Attribute::SanitizeAddress:
+    return 1ULL << 32;
+  case Attribute::MinSize:
+    return 1ULL << 33;
+  case Attribute::NoDuplicate:
+    return 1ULL << 34;
+  case Attribute::StackProtectStrong:
+    return 1ULL << 35;
+  case Attribute::SanitizeThread:
+    return 1ULL << 36;
+  case Attribute::SanitizeMemory:
+    return 1ULL << 37;
+  case Attribute::NoBuiltin:
+    return 1ULL << 38;
+  case Attribute::Returned:
+    return 1ULL << 39;
+  case Attribute::Cold:
+    return 1ULL << 40;
+  case Attribute::Builtin:
+    return 1ULL << 41;
+  case Attribute::OptimizeNone:
+    return 1ULL << 42;
+  case Attribute::InAlloca:
+    return 1ULL << 43;
+  case Attribute::NonNull:
+    return 1ULL << 44;
+  case Attribute::JumpTable:
+    return 1ULL << 45;
+  case Attribute::Convergent:
+    return 1ULL << 46;
+  case Attribute::SafeStack:
+    return 1ULL << 47;
+  case Attribute::NoRecurse:
+    return 1ULL << 48;
+  case Attribute::InaccessibleMemOnly:
+    return 1ULL << 49;
+  case Attribute::InaccessibleMemOrArgMemOnly:
+    return 1ULL << 50;
+  case Attribute::SwiftSelf:
+    return 1ULL << 51;
+  case Attribute::SwiftError:
+    return 1ULL << 52;
+  case Attribute::WriteOnly:
+    return 1ULL << 53;
+  case Attribute::Speculatable:
+    return 1ULL << 54;
+  case Attribute::StrictFP:
+    return 1ULL << 55;
+  case Attribute::SanitizeHWAddress:
+    return 1ULL << 56;
+  case Attribute::NoCfCheck:
+    return 1ULL << 57;
+  case Attribute::OptForFuzzing:
+    return 1ULL << 58;
+  case Attribute::ShadowCallStack:
+    return 1ULL << 59;
   case Attribute::SpeculativeLoadHardening:
     return 1ULL << 60;
   case Attribute::ImmArg:
     return 1ULL << 61;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
     break;
   case Attribute::DereferenceableOrNull:
     llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
                      "format");
     break;
   case Attribute::ArgMemOnly:
     llvm_unreachable("argmemonly attribute not supported in raw format");
     break;
   case Attribute::AllocSize:
     llvm_unreachable("allocsize not supported in raw format");
     break;
   }
   llvm_unreachable("Unsupported attribute type");
 }
 
 static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) {
-  if (!Val) return;
+  if (!Val)
+    return;
 
   for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
        I = Attribute::AttrKind(I + 1)) {
     if (I == Attribute::Dereferenceable ||
-        I == Attribute::DereferenceableOrNull ||
-        I == Attribute::ArgMemOnly ||
+        I == Attribute::DereferenceableOrNull || I == Attribute::ArgMemOnly ||
         I == Attribute::AllocSize)
       continue;
     if (uint64_t A = (Val & getRawAttributeMask(I))) {
       if (I == Attribute::Alignment)
         B.addAlignmentAttr(1ULL << ((A >> 16) - 1));
       else if (I == Attribute::StackAlignment)
-        B.addStackAlignmentAttr(1ULL << ((A >> 26)-1));
+        B.addStackAlignmentAttr(1ULL << ((A >> 26) - 1));
       else
         B.addAttribute(I);
     }
   }
 }
 
 /// This fills an AttrBuilder object with the LLVM attributes that have
 /// been decoded from the given integer. This function must stay in sync with
 /// 'encodeLLVMAttributesForBitcode'.
 static void decodeLLVMAttributesForBitcode(AttrBuilder &B,
                                            uint64_t EncodedAttrs) {
   // FIXME: Remove in 4.0.
 
   // The alignment is stored as a 16-bit raw value from bits 31--16.  We shift
   // the bits above 31 down by 11 bits.
   unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
   assert((!Alignment || isPowerOf2_32(Alignment)) &&
          "Alignment must be a power of two.");
 
   if (Alignment)
     B.addAlignmentAttr(Alignment);
   addRawAttributeValue(B, ((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
                               (EncodedAttrs & 0xffff));
 }
 
 Error BitcodeReader::parseAttributeBlock() {
   if (Error Err = Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
     return Err;
 
   if (!MAttributes.empty())
     return error("Invalid multiple blocks");
while (true) {
     }
 
     // Read a record.
     Record.clear();
     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
     if (!MaybeRecord)
       return MaybeRecord.takeError();
     switch (MaybeRecord.get()) {
-    default:  // Default behavior: ignore.
+    default: // Default behavior: ignore.
       break;
     case bitc::PARAMATTR_CODE_ENTRY_OLD: // ENTRY: [paramidx0, attr0, ...]
       // FIXME: Remove in 4.0.
       if (Record.size() & 1)
         return error("Invalid record");
 
       for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
         AttrBuilder B;
-        decodeLLVMAttributesForBitcode(B, Record[i+1]);
+        decodeLLVMAttributesForBitcode(B, Record[i + 1]);
         Attrs.push_back(AttributeList::get(Context, Record[i], B));
       }
 
       MAttributes.push_back(AttributeList::get(Context, Attrs));
       Attrs.clear();
       break;
     case bitc::PARAMATTR_CODE_ENTRY: // ENTRY: [attrgrp0, attrgrp1, ...]
       for (unsigned i = 0, e = Record.size(); i != e; ++i)
while (true) {
     }
 
     // Read a record.
     Record.clear();
     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
     if (!MaybeRecord)
       return MaybeRecord.takeError();
     switch (MaybeRecord.get()) {
-    default:  // Default behavior: ignore.
+    default: // Default behavior: ignore.
       break;
     case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
       if (Record.size() < 3)
         return error("Invalid record");
 
       uint64_t GrpID = Record[0];
       uint64_t Idx = Record[1]; // Index of the object this attribute refers to.
 
       AttrBuilder B;
       for (unsigned i = 2, e = Record.size(); i != e; ++i) {
-        if (Record[i] == 0) {        // Enum attribute
+        if (Record[i] == 0) { // Enum attribute
           Attribute::AttrKind Kind;
           if (Error Err = parseAttrKind(Record[++i], &Kind))
             return Err;
 
           // Upgrade old-style byval attribute to one with a type, even if it's
           // nullptr. We will have to insert the real type when we associate
           // this AttributeList with a function.
           if (Kind == Attribute::ByVal)
Error BitcodeReader::parseTypeTable() {
   if (Error Err = Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
     return Err;
 
   return parseTypeTableBody();
 }
 
 Error BitcodeReader::parseTypeTableBody() {
   if (!TypeList.empty())
     return error("Invalid multiple blocks");
 
-  SmallVector<uint64_t, 64> Record;
-  unsigned NumRecords = 0;
-
   SmallString<64> TypeName;
+  std::vector<std::pair<unsigned, std::shared_ptr<SmallVector<uint64_t, 64>>>>
+      TypeRecords;
 
   // Read all the records for this type table.
-  while (true) {
+  bool Done = false;
+  while (!Done) {
     Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
     if (!MaybeEntry)
       return MaybeEntry.takeError();
     BitstreamEntry Entry = MaybeEntry.get();
 
     switch (Entry.Kind) {
     case BitstreamEntry::SubBlock: // Handled for us already.
     case BitstreamEntry::Error:
       return error("Malformed block");
     case BitstreamEntry::EndBlock:
-      if (NumRecords != TypeList.size())
+      if (TypeRecords.size() != TypeList.size())
         return error("Malformed block");
-      return Error::success();
+      Done = true;
+      break;
     case BitstreamEntry::Record:
-      // The interesting case.
+      std::shared_ptr<SmallVector<uint64_t, 64>> Record(
+          new SmallVector<uint64_t, 64>());
+      Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, *Record);
+      if (!MaybeCode)
+        return MaybeCode.takeError();
+      unsigned Code = MaybeCode.get();
+      switch (Code) {
+      case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
+        // TYPE_CODE_NUMENTRY contains a count of the number of types in the
+        // type list.  This allows us to reserve space.
+        if (Record->size() < 1)
+          return error("Invalid record");
+        TypeList.resize((*Record)[0]);
+        break;
+      case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N]
+        // TYPE_CODE_STRUCT_NAME provides a name for the next struct type. We
+        // provide that type already, so forward references can reach it. If
+        // necessary the type is left opaque for now.
+        if (convertToString(*Record, 0, TypeName))
+          return error("Invalid record");
+        break;
+      case bitc::TYPE_CODE_STRUCT_NAMED:
+      case bitc::TYPE_CODE_OPAQUE: {
+        StructType *NamedStructType = nullptr;
+        if (!TypeName.empty())
+          NamedStructType = StructType::getIfExists(Context, TypeName);
+        if (!NamedStructType)
+          NamedStructType = StructType::create(Context, TypeName);
+        TypeList[TypeRecords.size()] = NamedStructType;
+        IdentifiedStructTypes.push_back(NamedStructType);
+        TypeName.clear();
+      }
+        LLVM_FALLTHROUGH;
+      default:
+        // All other records are left to process once the forward references are
+        // resolvable.
+        TypeRecords.push_back(make_pair(Code, Record));
+        break;
+      }
       break;
     }
+  }
 
-    // Read a record.
-    Record.clear();
+  unsigned NumRecords = 0;
+  // Process the deferred type records.
+  for (auto TypeRecord : TypeRecords) {
+    auto Record = TypeRecord.second;
     Type *ResultTy = nullptr;
-    Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
-    if (!MaybeRecord)
-      return MaybeRecord.takeError();
-    switch (MaybeRecord.get()) {
+    switch (TypeRecord.first) {
     default:
       return error("Invalid value");
-    case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
-      // TYPE_CODE_NUMENTRY contains a count of the number of types in the
-      // type list.  This allows us to reserve space.
-      if (Record.size() < 1)
-        return error("Invalid record");
-      TypeList.resize(Record[0]);
-      continue;
-    case bitc::TYPE_CODE_VOID:      // VOID
+    case bitc::TYPE_CODE_VOID: // VOID
       ResultTy = Type::getVoidTy(Context);
       break;
-    case bitc::TYPE_CODE_HALF:     // HALF
+    case bitc::TYPE_CODE_HALF: // HALF
       ResultTy = Type::getHalfTy(Context);
       break;
-    case bitc::TYPE_CODE_FLOAT:     // FLOAT
+    case bitc::TYPE_CODE_FLOAT: // FLOAT
       ResultTy = Type::getFloatTy(Context);
       break;
-    case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
+    case bitc::TYPE_CODE_DOUBLE: // DOUBLE
       ResultTy = Type::getDoubleTy(Context);
       break;
-    case bitc::TYPE_CODE_X86_FP80:  // X86_FP80
+    case bitc::TYPE_CODE_X86_FP80: // X86_FP80
       ResultTy = Type::getX86_FP80Ty(Context);
       break;
-    case bitc::TYPE_CODE_FP128:     // FP128
+    case bitc::TYPE_CODE_FP128: // FP128
       ResultTy = Type::getFP128Ty(Context);
       break;
     case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
       ResultTy = Type::getPPC_FP128Ty(Context);
       break;
-    case bitc::TYPE_CODE_LABEL:     // LABEL
+    case bitc::TYPE_CODE_LABEL: // LABEL
       ResultTy = Type::getLabelTy(Context);
       break;
-    case bitc::TYPE_CODE_METADATA:  // METADATA
+    case bitc::TYPE_CODE_METADATA: // METADATA
       ResultTy = Type::getMetadataTy(Context);
       break;
-    case bitc::TYPE_CODE_X86_MMX:   // X86_MMX
+    case bitc::TYPE_CODE_X86_MMX: // X86_MMX
       ResultTy = Type::getX86_MMXTy(Context);
       break;
-    case bitc::TYPE_CODE_TOKEN:     // TOKEN
+    case bitc::TYPE_CODE_TOKEN: // TOKEN
       ResultTy = Type::getTokenTy(Context);
       break;
     case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
-      if (Record.size() < 1)
+      if (Record->size() < 1)
         return error("Invalid record");
 
-      uint64_t NumBits = Record[0];
+      uint64_t NumBits = (*Record)[0];
       if (NumBits < IntegerType::MIN_INT_BITS ||
           NumBits > IntegerType::MAX_INT_BITS)
         return error("Bitwidth for integer type out of range");
       ResultTy = IntegerType::get(Context, NumBits);
       break;
     }
     case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
                                     //          [pointee type, address space]
-      if (Record.size() < 1)
+      if (Record->size() < 1)
         return error("Invalid record");
       unsigned AddressSpace = 0;
-      if (Record.size() == 2)
-        AddressSpace = Record[1];
-      ResultTy = getTypeByID(Record[0]);
-      if (!ResultTy ||
-          !PointerType::isValidElementType(ResultTy))
+      if (Record->size() == 2)
+        AddressSpace = (*Record)[1];
+      ResultTy = getTypeByID((*Record)[0]);
+      if (!ResultTy || !PointerType::isValidElementType(ResultTy))
         return error("Invalid type");
       ResultTy = PointerType::get(ResultTy, AddressSpace);
       break;
     }
     case bitc::TYPE_CODE_FUNCTION_OLD: {
       // FIXME: attrid is dead, remove it in LLVM 4.0
       // FUNCTION: [vararg, attrid, retty, paramty x N]
-      if (Record.size() < 3)
+      if (Record->size() < 3)
         return error("Invalid record");
-      SmallVector<Type*, 8> ArgTys;
-      for (unsigned i = 3, e = Record.size(); i != e; ++i) {
-        if (Type *T = getTypeByID(Record[i]))
+      SmallVector<Type *, 8> ArgTys;
+      for (unsigned i = 3, e = Record->size(); i != e; ++i) {
+        if (Type *T = getTypeByID((*Record)[i]))
           ArgTys.push_back(T);
         else
           break;
       }
 
-      ResultTy = getTypeByID(Record[2]);
-      if (!ResultTy || ArgTys.size() < Record.size()-3)
+      ResultTy = getTypeByID((*Record)[2]);
+      if (!ResultTy || ArgTys.size() < Record->size() - 3)
         return error("Invalid type");
 
-      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
+      ResultTy = FunctionType::get(ResultTy, ArgTys, (*Record)[0]);
       break;
     }
     case bitc::TYPE_CODE_FUNCTION: {
       // FUNCTION: [vararg, retty, paramty x N]
-      if (Record.size() < 2)
+      if (Record->size() < 2)
         return error("Invalid record");
-      SmallVector<Type*, 8> ArgTys;
-      for (unsigned i = 2, e = Record.size(); i != e; ++i) {
-        if (Type *T = getTypeByID(Record[i])) {
+      SmallVector<Type *, 8> ArgTys;
+      for (unsigned i = 2, e = Record->size(); i != e; ++i) {
+        if (Type *T = getTypeByID((*Record)[i])) {
           if (!FunctionType::isValidArgumentType(T))
             return error("Invalid function argument type");
           ArgTys.push_back(T);
-        }
-        else
+        } else
           break;
       }
 
-      ResultTy = getTypeByID(Record[1]);
-      if (!ResultTy || ArgTys.size() < Record.size()-2)
+      ResultTy = getTypeByID((*Record)[1]);
+      if (!ResultTy || ArgTys.size() < Record->size() - 2)
         return error("Invalid type");
 
-      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
+      ResultTy = FunctionType::get(ResultTy, ArgTys, (*Record)[0]);
       break;
     }
-    case bitc::TYPE_CODE_STRUCT_ANON: {  // STRUCT: [ispacked, eltty x N]
-      if (Record.size() < 1)
+    case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N]
+      if (Record->size() < 1)
         return error("Invalid record");
-      SmallVector<Type*, 8> EltTys;
-      for (unsigned i = 1, e = Record.size(); i != e; ++i) {
-        if (Type *T = getTypeByID(Record[i]))
+      SmallVector<Type *, 8> EltTys;
+      for (unsigned i = 1, e = Record->size(); i != e; ++i) {
+        if (Type *T = getTypeByID((*Record)[i]))
           EltTys.push_back(T);
         else
           break;
       }
-      if (EltTys.size() != Record.size()-1)
+      if (EltTys.size() != Record->size() - 1)
         return error("Invalid type");
-      ResultTy = StructType::get(Context, EltTys, Record[0]);
+      ResultTy = StructType::get(Context, EltTys, (*Record)[0]);
       break;
     }
-    case bitc::TYPE_CODE_STRUCT_NAME:   // STRUCT_NAME: [strchr x N]
-      if (convertToString(Record, 0, TypeName))
-        return error("Invalid record");
-      continue;
-
     case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
-      if (Record.size() < 1)
+      if (Record->size() < 1)
         return error("Invalid record");
 
       if (NumRecords >= TypeList.size())
         return error("Invalid TYPE table");
 
-      // Check to see if this was forward referenced, if so fill in the temp.
-      StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
-      if (Res) {
-        Res->setName(TypeName);
-        TypeList[NumRecords] = nullptr;
-      } else  // Otherwise, create a new struct.
-        Res = createIdentifiedStructType(Context, TypeName);
-      TypeName.clear();
-
-      SmallVector<Type*, 8> EltTys;
-      for (unsigned i = 1, e = Record.size(); i != e; ++i) {
-        if (Type *T = getTypeByID(Record[i]))
+      SmallVector<Type *, 8> EltTys;
+      for (unsigned i = 1, e = Record->size(); i != e; ++i) {
+        if (Type *T = getTypeByID((*Record)[i]))
           EltTys.push_back(T);
         else
           break;
       }
-      if (EltTys.size() != Record.size()-1)
+      if (EltTys.size() != Record->size() - 1)
         return error("Invalid record");
-      Res->setBody(EltTys, Record[0]);
+
+      StructType *Res = cast<StructType>(TypeList[NumRecords]);
+      TypeList[NumRecords] = nullptr;
+      if (Res->isOpaque()) {
+        Res->setBody(EltTys, (*Record)[0]);
+      } else if (!Res->elements().equals(EltTys)) {
+        // Ouch! The LLVMContext's existing named struct type and the one being
+        // read have different structures. This must mean that the LLVMContext
+        // contains more than one module, and there is disagreement.  Several
+        // possibilities: 1a. There are no opaque references to structs. In this
+        // case renaming either type is safe (but perhaps not desirable).
+        // 1b. There are opaque references, but no further Modules will be read.
+        // In this case renaming the type in the new module is safe. 2a. There
+        // may be opaque references, and all are to the type that's already in
+        // the Context. In this case renaming the new type is safe. 2b. There
+        // may be opaque references, and all are to the type that's being
+        // read. In this case renaming the existing type is safe. 2c. There may
+        // be opaque references to either. In this case nothing is safe.
+
+        // 3. This kind of conflict should not happen.
+        return error(
+            "named struct types match by name and differ by structure");
+      }
+
       ResultTy = Res;
       break;
     }
-    case bitc::TYPE_CODE_OPAQUE: {       // OPAQUE: []
-      if (Record.size() != 1)
+    case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
+      if (Record->size() != 1)
         return error("Invalid record");
 
       if (NumRecords >= TypeList.size())
         return error("Invalid TYPE table");
 
-      // Check to see if this was forward referenced, if so fill in the temp.
-      StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
-      if (Res) {
-        Res->setName(TypeName);
-        TypeList[NumRecords] = nullptr;
-      } else  // Otherwise, create a new struct with no body.
-        Res = createIdentifiedStructType(Context, TypeName);
-      TypeName.clear();
+      StructType *Res = cast<StructType>(TypeList[NumRecords]);
       ResultTy = Res;
       break;
     }
-    case bitc::TYPE_CODE_ARRAY:     // ARRAY: [numelts, eltty]
-      if (Record.size() < 2)
+    case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
+      if (Record->size() < 2)
         return error("Invalid record");
-      ResultTy = getTypeByID(Record[1]);
+      ResultTy = getTypeByID((*Record)[1]);
       if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
         return error("Invalid type");
-      ResultTy = ArrayType::get(ResultTy, Record[0]);
+      ResultTy = ArrayType::get(ResultTy, (*Record)[0]);
       break;
-    case bitc::TYPE_CODE_VECTOR:    // VECTOR: [numelts, eltty] or
-                                    //         [numelts, eltty, scalable]
-      if (Record.size() < 2)
+    case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] or
+      if (Record->size() < 2)
         return error("Invalid record");
-      if (Record[0] == 0)
+      if ((*Record)[0] == 0)
         return error("Invalid vector length");
-      ResultTy = getTypeByID(Record[1]);
+      ResultTy = getTypeByID((*Record)[1]);
       if (!ResultTy || !StructType::isValidElementType(ResultTy))
         return error("Invalid type");
-      bool Scalable = Record.size() > 2 ? Record[2] : false;
-      ResultTy = VectorType::get(ResultTy, Record[0], Scalable);
+      bool Scalable = Record->size() > 2 ? (*Record)[2] : false;
+      ResultTy = VectorType::get(ResultTy, (*Record)[0], Scalable);
       break;
     }
 
     if (NumRecords >= TypeList.size())
       return error("Invalid TYPE table");
     if (TypeList[NumRecords])
       return error(
           "Invalid TYPE table: Only named structs can be forward referenced");
     assert(ResultTy && "Didn't read a type?");
     TypeList[NumRecords++] = ResultTy;
   }
+  if (NumRecords < TypeList.size())
+    return error("Invalid TYPE table");
+  return Error::success();
 }
 
 Error BitcodeReader::parseOperandBundleTags() {
   if (Error Err = Stream.EnterSubBlock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID))
     return Err;
 
   if (!BundleTags.empty())
     return error("Invalid multiple blocks");
while (true) {
     }
 
     // Read a record.
     Record.clear();
     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
     if (!MaybeRecord)
       return MaybeRecord.takeError();
     switch (MaybeRecord.get()) {
-    default:  // Default behavior: unknown type.
+    default: // Default behavior: unknown type.
       break;
-    case bitc::VST_CODE_ENTRY: {  // VST_CODE_ENTRY: [valueid, namechar x N]
+    case bitc::VST_CODE_ENTRY: { // VST_CODE_ENTRY: [valueid, namechar x N]
       Expected<Value *> ValOrErr = recordValue(Record, 1, TT);
       if (Error Err = ValOrErr.takeError())
         return Err;
       ValOrErr.get();
       break;
     }
     case bitc::VST_CODE_FNENTRY: {
       // VST_CODE_FNENTRY: [valueid, offset, namechar x N]
while (!FunctionPersonalityFnWorklist.empty()) {
     FunctionPersonalityFnWorklist.pop_back();
   }
 
   return Error::success();
 }
 
 static APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
   SmallVector<uint64_t, 8> Words(Vals.size());
-  transform(Vals, Words.begin(),
-                 BitcodeReader::decodeSignRotatedValue);
+  transform(Vals, Words.begin(), BitcodeReader::decodeSignRotatedValue);
 
   return APInt(TypeBits, Words);
 }
 
 Error BitcodeReader::parseConstants() {
   if (Error Err = Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
     return Err;
 
while (true) {
     // Read a record.
     Record.clear();
     Type *VoidType = Type::getVoidTy(Context);
     Value *V = nullptr;
     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
     if (!MaybeBitCode)
       return MaybeBitCode.takeError();
     switch (unsigned BitCode = MaybeBitCode.get()) {
-    default:  // Default behavior: unknown constant
-    case bitc::CST_CODE_UNDEF:     // UNDEF
+    default:                   // Default behavior: unknown constant
+    case bitc::CST_CODE_UNDEF: // UNDEF
       V = UndefValue::get(CurTy);
       break;
-    case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
+    case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
       if (Record.empty())
         return error("Invalid record");
       if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
         return error("Invalid record");
       if (TypeList[Record[0]] == VoidType)
         return error("Invalid constant type");
       CurTy = TypeList[Record[0]];
-      continue;  // Skip the ValueList manipulation.
-    case bitc::CST_CODE_NULL:      // NULL
+      continue;               // Skip the ValueList manipulation.
+    case bitc::CST_CODE_NULL: // NULL
       V = Constant::getNullValue(CurTy);
       break;
-    case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
+    case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
       if (!CurTy->isIntegerTy() || Record.empty())
         return error("Invalid record");
       V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
       break;
-    case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
+    case bitc::CST_CODE_WIDE_INTEGER: { // WIDE_INTEGER: [n x intval]
       if (!CurTy->isIntegerTy() || Record.empty())
         return error("Invalid record");
 
       APInt VInt =
           readWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth());
       V = ConstantInt::get(Context, VInt);
 
       break;
     }
-    case bitc::CST_CODE_FLOAT: {    // FLOAT: [fpval]
+    case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
       if (Record.empty())
         return error("Invalid record");
       if (CurTy->isHalfTy())
         V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf(),
                                              APInt(16, (uint16_t)Record[0])));
       else if (CurTy->isFloatTy())
         V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle(),
                                              APInt(32, (uint32_t)Record[0])));
       else if (CurTy->isDoubleTy())
-        V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble(),
-                                             APInt(64, Record[0])));
+        V = ConstantFP::get(
+            Context, APFloat(APFloat::IEEEdouble(), APInt(64, Record[0])));
       else if (CurTy->isX86_FP80Ty()) {
         // Bits are not stored the same way as a normal i80 APInt, compensate.
         uint64_t Rearrange[2];
         Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
         Rearrange[1] = Record[0] >> 48;
         V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended(),
                                              APInt(80, Rearrange)));
       } else if (CurTy->isFP128Ty())
-        V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad(),
-                                             APInt(128, Record)));
+        V = ConstantFP::get(Context,
+                            APFloat(APFloat::IEEEquad(), APInt(128, Record)));
       else if (CurTy->isPPC_FP128Ty())
-        V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble(),
-                                             APInt(128, Record)));
+        V = ConstantFP::get(
+            Context, APFloat(APFloat::PPCDoubleDouble(), APInt(128, Record)));
       else
         V = UndefValue::get(CurTy);
       break;
     }
 
-    case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
+    case bitc::CST_CODE_AGGREGATE: { // AGGREGATE: [n x value number]
       if (Record.empty())
         return error("Invalid record");
 
       unsigned Size = Record.size();
-      SmallVector<Constant*, 16> Elts;
+      SmallVector<Constant *, 16> Elts;
 
       if (StructType *STy = dyn_cast<StructType>(CurTy)) {
         for (unsigned i = 0; i != Size; ++i)
-          Elts.push_back(ValueList.getConstantFwdRef(Record[i],
-                                                     STy->getElementType(i)));
+          Elts.push_back(
+              ValueList.getConstantFwdRef(Record[i], STy->getElementType(i)));
         V = ConstantStruct::get(STy, Elts);
       } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
         Type *EltTy = ATy->getElementType();
         for (unsigned i = 0; i != Size; ++i)
           Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
         V = ConstantArray::get(ATy, Elts);
       } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
         Type *EltTy = VTy->getElementType();
case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
       if (Record.empty())
         return error("Invalid record");
 
       SmallString<16> Elts(Record.begin(), Record.end());
       V = ConstantDataArray::getString(Context, Elts,
                                        BitCode == bitc::CST_CODE_CSTRING);
       break;
     }
-    case bitc::CST_CODE_DATA: {// DATA: [n x value]
+    case bitc::CST_CODE_DATA: { // DATA: [n x value]
       if (Record.empty())
         return error("Invalid record");
 
       Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
       if (EltTy->isIntegerTy(8)) {
         SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
         if (isa<VectorType>(CurTy))
           V = ConstantDataVector::get(Context, Elts);
case bitc::CST_CODE_DATA: { // DATA: [n x value]
           V = ConstantDataVector::getFP(Context, Elts);
         else
           V = ConstantDataArray::getFP(Context, Elts);
       } else {
         return error("Invalid type for value");
       }
       break;
     }
-    case bitc::CST_CODE_CE_UNOP: {  // CE_UNOP: [opcode, opval]
+    case bitc::CST_CODE_CE_UNOP: { // CE_UNOP: [opcode, opval]
       if (Record.size() < 2)
         return error("Invalid record");
       int Opc = getDecodedUnaryOpcode(Record[0], CurTy);
       if (Opc < 0) {
-        V = UndefValue::get(CurTy);  // Unknown unop.
+        V = UndefValue::get(CurTy); // Unknown unop.
       } else {
         Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
         unsigned Flags = 0;
         V = ConstantExpr::get(Opc, LHS, Flags);
       }
       break;
     }
-    case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
+    case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
       if (Record.size() < 3)
         return error("Invalid record");
       int Opc = getDecodedBinaryOpcode(Record[0], CurTy);
       if (Opc < 0) {
-        V = UndefValue::get(CurTy);  // Unknown binop.
+        V = UndefValue::get(CurTy); // Unknown binop.
       } else {
         Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
         Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
         unsigned Flags = 0;
         if (Record.size() >= 4) {
-          if (Opc == Instruction::Add ||
-              Opc == Instruction::Sub ||
-              Opc == Instruction::Mul ||
-              Opc == Instruction::Shl) {
+          if (Opc == Instruction::Add || Opc == Instruction::Sub ||
+              Opc == Instruction::Mul || Opc == Instruction::Shl) {
             if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP))
               Flags |= OverflowingBinaryOperator::NoSignedWrap;
             if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
               Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
-          } else if (Opc == Instruction::SDiv ||
-                     Opc == Instruction::UDiv ||
-                     Opc == Instruction::LShr ||
-                     Opc == Instruction::AShr) {
+          } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
+                     Opc == Instruction::LShr || Opc == Instruction::AShr) {
             if (Record[3] & (1 << bitc::PEO_EXACT))
               Flags |= SDivOperator::IsExact;
           }
         }
         V = ConstantExpr::get(Opc, LHS, RHS, Flags);
       }
       break;
     }
-    case bitc::CST_CODE_CE_CAST: {  // CE_CAST: [opcode, opty, opval]
+    case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
       if (Record.size() < 3)
         return error("Invalid record");
       int Opc = getDecodedCastOpcode(Record[0]);
       if (Opc < 0) {
-        V = UndefValue::get(CurTy);  // Unknown cast.
+        V = UndefValue::get(CurTy); // Unknown cast.
       } else {
         Type *OpTy = getTypeByID(Record[1]);
         if (!OpTy)
           return error("Invalid record");
         Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
         V = UpgradeBitCastExpr(Opc, Op, CurTy);
-        if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy);
+        if (!V)
+          V = ConstantExpr::getCast(Opc, Op, CurTy);
       }
       break;
     }
-    case bitc::CST_CODE_CE_INBOUNDS_GEP: // [ty, n x operands]
-    case bitc::CST_CODE_CE_GEP: // [ty, n x operands]
+    case bitc::CST_CODE_CE_INBOUNDS_GEP:             // [ty, n x operands]
+    case bitc::CST_CODE_CE_GEP:                      // [ty, n x operands]
     case bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX: { // [ty, flags, n x
                                                      // operands]
       unsigned OpNum = 0;
       Type *PointeeType = nullptr;
       if (BitCode == bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX ||
           Record.size() % 2)
         PointeeType = getTypeByID(Record[OpNum++]);
 
       bool InBounds = false;
       Optional<unsigned> InRangeIndex;
       if (BitCode == bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX) {
         uint64_t Op = Record[OpNum++];
         InBounds = Op & 1;
         InRangeIndex = Op >> 1;
       } else if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP)
         InBounds = true;
 
-      SmallVector<Constant*, 16> Elts;
+      SmallVector<Constant *, 16> Elts;
       while (OpNum != Record.size()) {
         Type *ElTy = getTypeByID(Record[OpNum++]);
         if (!ElTy)
           return error("Invalid record");
         Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy));
       }
 
       if (Elts.size() < 1)
         return error("Invalid gep with no operands");
 
       Type *ImplicitPointeeType =
           cast<PointerType>(Elts[0]->getType()->getScalarType())
               ->getElementType();
       if (!PointeeType)
         PointeeType = ImplicitPointeeType;
       else if (PointeeType != ImplicitPointeeType)
         return error("Explicit gep operator type does not match pointee type "
                      "of pointer operand");
 
       ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
       V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices,
                                          InBounds, InRangeIndex);
       break;
     }
-    case bitc::CST_CODE_CE_SELECT: {  // CE_SELECT: [opval#, opval#, opval#]
+    case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#]
       if (Record.size() < 3)
         return error("Invalid record");
 
       Type *SelectorTy = Type::getInt1Ty(Context);
 
       // The selector might be an i1 or an <n x i1>
       // Get the type from the ValueList before getting a forward ref.
       if (VectorType *VTy = dyn_cast<VectorType>(CurTy))
         if (Value *V = ValueList[Record[0]])
           if (SelectorTy != V->getType())
             SelectorTy = VectorType::get(SelectorTy, VTy->getNumElements());
 
-      V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
-                                                              SelectorTy),
-                                  ValueList.getConstantFwdRef(Record[1],CurTy),
-                                  ValueList.getConstantFwdRef(Record[2],CurTy));
+      V = ConstantExpr::getSelect(
+          ValueList.getConstantFwdRef(Record[0], SelectorTy),
+          ValueList.getConstantFwdRef(Record[1], CurTy),
+          ValueList.getConstantFwdRef(Record[2], CurTy));
       break;
     }
-    case bitc::CST_CODE_CE_EXTRACTELT
-        : { // CE_EXTRACTELT: [opty, opval, opty, opval]
+    case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opty,
+                                         // opval]
       if (Record.size() < 3)
         return error("Invalid record");
-      VectorType *OpTy =
-        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
       if (!OpTy)
         return error("Invalid record");
       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
       Constant *Op1 = nullptr;
       if (Record.size() == 4) {
         Type *IdxTy = getTypeByID(Record[2]);
         if (!IdxTy)
           return error("Invalid record");
         Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy);
       } else // TODO: Remove with llvm 4.0
         Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
       if (!Op1)
         return error("Invalid record");
       V = ConstantExpr::getExtractElement(Op0, Op1);
       break;
     }
-    case bitc::CST_CODE_CE_INSERTELT
-        : { // CE_INSERTELT: [opval, opval, opty, opval]
+    case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opty,
+                                        // opval]
       VectorType *OpTy = dyn_cast<VectorType>(CurTy);
       if (Record.size() < 3 || !OpTy)
         return error("Invalid record");
       Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
-      Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
-                                                  OpTy->getElementType());
+      Constant *Op1 =
+          ValueList.getConstantFwdRef(Record[1], OpTy->getElementType());
       Constant *Op2 = nullptr;
       if (Record.size() == 4) {
         Type *IdxTy = getTypeByID(Record[2]);
         if (!IdxTy)
           return error("Invalid record");
         Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy);
       } else // TODO: Remove with llvm 4.0
         Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
       if (!Op2)
         return error("Invalid record");
       V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
       break;
     }
     case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
       VectorType *OpTy = dyn_cast<VectorType>(CurTy);
       if (Record.size() < 3 || !OpTy)
         return error("Invalid record");
       Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
       Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
-      Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
-                                                 OpTy->getNumElements());
+      Type *ShufTy =
+          VectorType::get(Type::getInt32Ty(Context), OpTy->getNumElements());
       Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
       V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
       break;
     }
     case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
       VectorType *RTy = dyn_cast<VectorType>(CurTy);
-      VectorType *OpTy =
-        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
       if (Record.size() < 4 || !RTy || !OpTy)
         return error("Invalid record");
       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
-      Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
-                                                 RTy->getNumElements());
+      Type *ShufTy =
+          VectorType::get(Type::getInt32Ty(Context), RTy->getNumElements());
       Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
       V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
       break;
     }
-    case bitc::CST_CODE_CE_CMP: {     // CE_CMP: [opty, opval, opval, pred]
+    case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
       if (Record.size() < 4)
         return error("Invalid record");
       Type *OpTy = getTypeByID(Record[0]);
       if (!OpTy)
         return error("Invalid record");
       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
 
       if (OpTy->isFPOrFPVectorTy())
         V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
       else
         V = ConstantExpr::getICmp(Record[3], Op0, Op1);
       break;
     }
     // This maintains backward compatibility, pre-asm dialect keywords.
     // FIXME: Remove with the 4.0 release.
     case bitc::CST_CODE_INLINEASM_OLD: {
       if (Record.size() < 2)
         return error("Invalid record");
       std::string AsmStr, ConstrStr;
       bool HasSideEffects = Record[0] & 1;
       bool IsAlignStack = Record[0] >> 1;
       unsigned AsmStrSize = Record[1];
-      if (2+AsmStrSize >= Record.size())
+      if (2 + AsmStrSize >= Record.size())
         return error("Invalid record");
-      unsigned ConstStrSize = Record[2+AsmStrSize];
-      if (3+AsmStrSize+ConstStrSize > Record.size())
+      unsigned ConstStrSize = Record[2 + AsmStrSize];
+      if (3 + AsmStrSize + ConstStrSize > Record.size())
         return error("Invalid record");
 
       for (unsigned i = 0; i != AsmStrSize; ++i)
-        AsmStr += (char)Record[2+i];
+        AsmStr += (char)Record[2 + i];
       for (unsigned i = 0; i != ConstStrSize; ++i)
-        ConstrStr += (char)Record[3+AsmStrSize+i];
+        ConstrStr += (char)Record[3 + AsmStrSize + i];
       PointerType *PTy = cast<PointerType>(CurTy);
       UpgradeInlineAsmString(&AsmStr);
-      V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
-                         AsmStr, ConstrStr, HasSideEffects, IsAlignStack);
+      V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), AsmStr,
+                         ConstrStr, HasSideEffects, IsAlignStack);
       break;
     }
     // This version adds support for the asm dialect keywords (e.g.,
     // inteldialect).
     case bitc::CST_CODE_INLINEASM: {
       if (Record.size() < 2)
         return error("Invalid record");
       std::string AsmStr, ConstrStr;
       bool HasSideEffects = Record[0] & 1;
       bool IsAlignStack = (Record[0] >> 1) & 1;
       unsigned AsmDialect = Record[0] >> 2;
       unsigned AsmStrSize = Record[1];
-      if (2+AsmStrSize >= Record.size())
+      if (2 + AsmStrSize >= Record.size())
         return error("Invalid record");
-      unsigned ConstStrSize = Record[2+AsmStrSize];
-      if (3+AsmStrSize+ConstStrSize > Record.size())
+      unsigned ConstStrSize = Record[2 + AsmStrSize];
+      if (3 + AsmStrSize + ConstStrSize > Record.size())
         return error("Invalid record");
 
       for (unsigned i = 0; i != AsmStrSize; ++i)
-        AsmStr += (char)Record[2+i];
+        AsmStr += (char)Record[2 + i];
       for (unsigned i = 0; i != ConstStrSize; ++i)
-        ConstrStr += (char)Record[3+AsmStrSize+i];
+        ConstrStr += (char)Record[3 + AsmStrSize + i];
       PointerType *PTy = cast<PointerType>(CurTy);
       UpgradeInlineAsmString(&AsmStr);
-      V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
-                         AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
+      V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), AsmStr,
+                         ConstrStr, HasSideEffects, IsAlignStack,
                          InlineAsm::AsmDialect(AsmDialect));
       break;
     }
-    case bitc::CST_CODE_BLOCKADDRESS:{
+    case bitc::CST_CODE_BLOCKADDRESS: {
       if (Record.size() < 3)
         return error("Invalid record");
       Type *FnTy = getTypeByID(Record[0]);
       if (!FnTy)
         return error("Invalid record");
-      Function *Fn =
-        dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
+      Function *Fn = dyn_cast_or_null<Function>(
+          ValueList.getConstantFwdRef(Record[1], FnTy));
       if (!Fn)
         return error("Invalid record");
 
       // If the function is already parsed we can insert the block address right
       // away.
       BasicBlock *BB;
       unsigned BBID = Record[2];
       if (!BBID)
while (true) {
 
     // Read a use list record.
     Record.clear();
     bool IsBB = false;
     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
     if (!MaybeRecord)
       return MaybeRecord.takeError();
     switch (MaybeRecord.get()) {
-    default:  // Default behavior: unknown type.
+    default: // Default behavior: unknown type.
       break;
     case bitc::USELIST_CODE_BB:
       IsBB = true;
       LLVM_FALLTHROUGH;
     case bitc::USELIST_CODE_DEFAULT: {
       unsigned RecordLength = Record.size();
       if (RecordLength < 3)
         // Records should have at least an ID and two indexes.

 Error BitcodeReader::rememberAndSkipFunctionBodies() {
   if (Error JumpFailed = Stream.JumpToBit(NextUnreadBit))
     return JumpFailed;
 
   if (Stream.AtEndOfStream())
     return error("Could not find function in stream");
 
   if (!SeenFirstFunctionBody)
-    return error("Trying to materialize functions before seeing function blocks");
+    return error(
+        "Trying to materialize functions before seeing function blocks");
 
   // An old bitcode file with the symbol table at the end would have
   // finished the parse greedily.
   assert(SeenValueSymbolTable);
 
   SmallVector<uint64_t, 64> Record;
 
   while (true) {
while (true) {
     switch (Entry.Kind) {
     case BitstreamEntry::Error:
       return error("Malformed block");
     case BitstreamEntry::EndBlock:
       return globalCleanup();
 
     case BitstreamEntry::SubBlock:
       switch (Entry.ID) {
-      default:  // Skip unknown content.
+      default: // Skip unknown content.
         if (Error Err = Stream.SkipBlock())
           return Err;
         break;
       case bitc::BLOCKINFO_BLOCK_ID:
         if (readBlockInfo())
           return error("Malformed block");
         break;
       case bitc::PARAMATTR_BLOCK_ID:
case BitstreamEntry::Record:
       break;
     }
 
     // Read a record.
     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
     if (!MaybeBitCode)
       return MaybeBitCode.takeError();
     switch (unsigned BitCode = MaybeBitCode.get()) {
-    default: break;  // Default behavior, ignore unknown content.
+    default:
+      break; // Default behavior, ignore unknown content.
     case bitc::MODULE_CODE_VERSION: {
       Expected<unsigned> VersionOrErr = parseVersionRecord(Record);
       if (!VersionOrErr)
         return VersionOrErr.takeError();
       UseRelativeIDs = *VersionOrErr >= 1;
       break;
     }
-    case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
+    case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       TheModule->setTargetTriple(S);
       break;
     }
-    case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strchr x N]
+    case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       TheModule->setDataLayout(S);
       break;
     }
-    case bitc::MODULE_CODE_ASM: {  // ASM: [strchr x N]
+    case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       TheModule->setModuleInlineAsm(S);
       break;
     }
-    case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strchr x N]
+    case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
       // FIXME: Remove in 4.0.
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       // Ignore value.
       break;
     }
-    case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strchr x N]
+    case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       SectionTable.push_back(S);
       break;
     }
-    case bitc::MODULE_CODE_GCNAME: {  // SECTIONNAME: [strchr x N]
+    case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N]
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       GCTable.push_back(S);
       break;
     }
     case bitc::MODULE_CODE_COMDAT:
       if (Error Err = parseComdatRecord(Record))
while (true) {
     switch (Entry.Kind) {
     case BitstreamEntry::Error:
       return error("Malformed block");
     case BitstreamEntry::EndBlock:
       goto OutOfRecordLoop;
 
     case BitstreamEntry::SubBlock:
       switch (Entry.ID) {
-      default:  // Skip unknown content.
+      default: // Skip unknown content.
         if (Error Err = Stream.SkipBlock())
           return Err;
         break;
       case bitc::CONSTANTS_BLOCK_ID:
         if (Error Err = parseConstants())
           return Err;
         NextValueNo = ValueList.size();
         break;
while (true) {
     Record.clear();
     Instruction *I = nullptr;
     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
     if (!MaybeBitCode)
       return MaybeBitCode.takeError();
     switch (unsigned BitCode = MaybeBitCode.get()) {
     default: // Default behavior: reject
       return error("Invalid value");
-    case bitc::FUNC_CODE_DECLAREBLOCKS: {   // DECLAREBLOCKS: [nblocks]
+    case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
       if (Record.size() < 1 || Record[0] == 0)
         return error("Invalid record");
       // Create all the basic blocks for the function.
       FunctionBBs.resize(Record[0]);
 
       // See if anything took the address of blocks in this function.
       auto BBFRI = BasicBlockFwdRefs.find(F);
       if (BBFRI == BasicBlockFwdRefs.end()) {
case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
         // Erase from the table.
         BasicBlockFwdRefs.erase(BBFRI);
       }
 
       CurBB = FunctionBBs[0];
       continue;
     }
 
-    case bitc::FUNC_CODE_DEBUG_LOC_AGAIN:  // DEBUG_LOC_AGAIN
+    case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN
       // This record indicates that the last instruction is at the same
       // location as the previous instruction with a location.
       I = getLastInstruction();
 
       if (!I)
         return error("Invalid record");
       I->setDebugLoc(LastLoc);
       I = nullptr;
       continue;
 
-    case bitc::FUNC_CODE_DEBUG_LOC: {      // DEBUG_LOC: [line, col, scope, ia]
+    case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
       I = getLastInstruction();
       if (!I || Record.size() < 4)
         return error("Invalid record");
 
       unsigned Line = Record[0], Col = Record[1];
       unsigned ScopeID = Record[2], IAID = Record[3];
       bool isImplicitCode = Record.size() == 5 && Record[4];
 
case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
         if (!IA)
           return error("Invalid record");
       }
       LastLoc = DebugLoc::get(Line, Col, Scope, IA, isImplicitCode);
       I->setDebugLoc(LastLoc);
       I = nullptr;
       continue;
     }
-    case bitc::FUNC_CODE_INST_UNOP: {    // UNOP: [opval, ty, opcode]
+    case bitc::FUNC_CODE_INST_UNOP: { // UNOP: [opval, ty, opcode]
       unsigned OpNum = 0;
       Value *LHS;
       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
-          OpNum+1 > Record.size())
+          OpNum + 1 > Record.size())
         return error("Invalid record");
 
       int Opc = getDecodedUnaryOpcode(Record[OpNum++], LHS->getType());
       if (Opc == -1)
         return error("Invalid record");
       I = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
       InstructionList.push_back(I);
       if (OpNum < Record.size()) {
         if (isa<FPMathOperator>(I)) {
           FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
           if (FMF.any())
             I->setFastMathFlags(FMF);
         }
       }
       break;
     }
-    case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opval, ty, opval, opcode]
+    case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
       unsigned OpNum = 0;
       Value *LHS, *RHS;
       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
           popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
-          OpNum+1 > Record.size())
+          OpNum + 1 > Record.size())
         return error("Invalid record");
 
       int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
       if (Opc == -1)
         return error("Invalid record");
       I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
       InstructionList.push_back(I);
       if (OpNum < Record.size()) {
-        if (Opc == Instruction::Add ||
-            Opc == Instruction::Sub ||
-            Opc == Instruction::Mul ||
-            Opc == Instruction::Shl) {
+        if (Opc == Instruction::Add || Opc == Instruction::Sub ||
+            Opc == Instruction::Mul || Opc == Instruction::Shl) {
           if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
             cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
           if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
             cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
-        } else if (Opc == Instruction::SDiv ||
-                   Opc == Instruction::UDiv ||
-                   Opc == Instruction::LShr ||
-                   Opc == Instruction::AShr) {
+        } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
+                   Opc == Instruction::LShr || Opc == Instruction::AShr) {
           if (Record[OpNum] & (1 << bitc::PEO_EXACT))
             cast<BinaryOperator>(I)->setIsExact(true);
         } else if (isa<FPMathOperator>(I)) {
           FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
           if (FMF.any())
             I->setFastMathFlags(FMF);
         }
-
       }
       break;
     }
-    case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opval, opty, destty, castopc]
+    case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
       unsigned OpNum = 0;
       Value *Op;
       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
-          OpNum+2 != Record.size())
+          OpNum + 2 != Record.size())
         return error("Invalid record");
 
       Type *ResTy = getTypeByID(Record[OpNum]);
       int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
       if (Opc == -1 || !ResTy)
         return error("Invalid record");
       Instruction *Temp = nullptr;
       if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands]
 
       Value *BasePtr;
       if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
         return error("Invalid record");
 
       if (!Ty)
         Ty = cast<PointerType>(BasePtr->getType()->getScalarType())
                  ->getElementType();
-      else if (Ty !=
-               cast<PointerType>(BasePtr->getType()->getScalarType())
+      else if (Ty != cast<PointerType>(BasePtr->getType()->getScalarType())
                          ->getElementType())
         return error(
             "Explicit gep type does not match pointee type of pointer operand");
 
-      SmallVector<Value*, 16> GEPIdx;
+      SmallVector<Value *, 16> GEPIdx;
       while (OpNum != Record.size()) {
         Value *Op;
         if (getValueTypePair(Record, OpNum, NextValueNo, Op))
           return error("Invalid record");
         GEPIdx.push_back(Op);
       }
 
       I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);
 
       InstructionList.push_back(I);
       if (InBounds)
         cast<GetElementPtrInst>(I)->setIsInBounds(true);
       break;
     }
 
     case bitc::FUNC_CODE_INST_EXTRACTVAL: {
-                                       // EXTRACTVAL: [opty, opval, n x indices]
       unsigned OpNum = 0;
       Value *Agg;
       if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
         return error("Invalid record");
 
       unsigned RecSize = Record.size();
       if (OpNum == RecSize)
         return error("EXTRACTVAL: Invalid instruction with 0 indices");
case bitc::FUNC_CODE_INST_EXTRACTVAL: {
       }
 
       I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
       InstructionList.push_back(I);
       break;
     }
 
     case bitc::FUNC_CODE_INST_INSERTVAL: {
-                           // INSERTVAL: [opty, opval, opty, opval, n x indices]
       unsigned OpNum = 0;
       Value *Agg;
       if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
         return error("Invalid record");
       Value *Val;
       if (getValueTypePair(Record, OpNum, NextValueNo, Val))
         return error("Invalid record");
 
case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
           popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
         return error("Invalid record");
 
       I = SelectInst::Create(Cond, TrueVal, FalseVal);
       InstructionList.push_back(I);
       break;
     }
 
-    case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
+    case bitc::FUNC_CODE_INST_VSELECT: { // VSELECT:
+                                         // [ty,opval,opval,predty,pred]
       // new form of select
       // handles select i1 or select [N x i1]
       unsigned OpNum = 0;
       Value *TrueVal, *FalseVal, *Cond;
       if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
           popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
           getValueTypePair(Record, OpNum, NextValueNo, Cond))
         return error("Invalid record");
 
       // select condition can be either i1 or [N x i1]
-      if (VectorType* vector_type =
-          dyn_cast<VectorType>(Cond->getType())) {
+      if (VectorType *vector_type = dyn_cast<VectorType>(Cond->getType())) {
         // expect <n x i1>
         if (vector_type->getElementType() != Type::getInt1Ty(Context))
           return error("Invalid type for value");
       } else {
         // expect i1
         if (Cond->getType() != Type::getInt1Ty(Context))
           return error("Invalid type for value");
       }
case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
                    cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
           getValueTypePair(Record, OpNum, NextValueNo, Idx))
         return error("Invalid record");
       I = InsertElementInst::Create(Vec, Elt, Idx);
       InstructionList.push_back(I);
       break;
     }
 
-    case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
+    case bitc::FUNC_CODE_INST_SHUFFLEVEC: { // SHUFFLEVEC:
+                                            // [opval,ty,opval,opval]
       unsigned OpNum = 0;
       Value *Vec1, *Vec2, *Mask;
       if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
           popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
         return error("Invalid record");
 
       if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
         return error("Invalid record");
       if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())
         return error("Invalid type for value");
       I = new ShuffleVectorInst(Vec1, Vec2, Mask);
       InstructionList.push_back(I);
       break;
     }
 
-    case bitc::FUNC_CODE_INST_CMP:   // CMP: [opty, opval, opval, pred]
+    case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred]
                                    // Old form of ICmp/FCmp returning bool
-      // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
-      // both legal on vectors but had different behaviour.
+                                   // Existed to differentiate between icmp/fcmp
+                                   // and vicmp/vfcmp which were both legal on
+                                   // vectors but had different behaviour.
     case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
       // FCmp/ICmp returning bool or vector of bool
 
       unsigned OpNum = 0;
       Value *LHS, *RHS;
       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
           popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
         return error("Invalid record");
 
       unsigned PredVal = Record[OpNum];
       bool IsFP = LHS->getType()->isFPOrFPVectorTy();
       FastMathFlags FMF;
-      if (IsFP && Record.size() > OpNum+1)
+      if (IsFP && Record.size() > OpNum + 1)
         FMF = getDecodedFastMathFlags(Record[++OpNum]);
 
-      if (OpNum+1 != Record.size())
+      if (OpNum + 1 != Record.size())
         return error("Invalid record");
 
       if (LHS->getType()->isFPOrFPVectorTy())
         I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS);
       else
         I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS);
 
       if (FMF.any())
         I->setFastMathFlags(FMF);
       InstructionList.push_back(I);
       break;
     }
 
     case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
-      {
-        unsigned Size = Record.size();
-        if (Size == 0) {
-          I = ReturnInst::Create(Context);
-          InstructionList.push_back(I);
-          break;
-        }
 
-        unsigned OpNum = 0;
-        Value *Op = nullptr;
-        if (getValueTypePair(Record, OpNum, NextValueNo, Op))
-          return error("Invalid record");
-        if (OpNum != Record.size())
-          return error("Invalid record");
 
-        I = ReturnInst::Create(Context, Op);
-        InstructionList.push_back(I);
-        break;
-      }
     case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
       if (Record.size() != 1 && Record.size() != 3)
         return error("Invalid record");
       BasicBlock *TrueDest = getBasicBlock(Record[0]);
       if (!TrueDest)
         return error("Invalid record");
 
       if (Record.size() == 1) {
         I = BranchInst::Create(TrueDest);
         InstructionList.push_back(I);
-      }
-      else {
+      } else {
         BasicBlock *FalseDest = getBasicBlock(Record[1]);
-        Value *Cond = getValue(Record, 2, NextValueNo,
-                               Type::getInt1Ty(Context));
+        Value *Cond =
+            getValue(Record, 2, NextValueNo, Type::getInt1Ty(Context));
         if (!FalseDest || !Cond)
           return error("Invalid record");
         I = BranchInst::Create(TrueDest, FalseDest, Cond);
         InstructionList.push_back(I);
       }
       break;
     }
     case bitc::FUNC_CODE_INST_CLEANUPRET: { // CLEANUPRET: [val] or [val,bb#]
case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
 
         unsigned NumCases = Record[4];
 
         SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
         InstructionList.push_back(SI);
 
         unsigned CurIdx = 5;
         for (unsigned i = 0; i != NumCases; ++i) {
-          SmallVector<ConstantInt*, 1> CaseVals;
+          SmallVector<ConstantInt *, 1> CaseVals;
           unsigned NumItems = Record[CurIdx++];
           for (unsigned ci = 0; ci != NumItems; ++ci) {
             bool isSingleNumber = Record[CurIdx++];
 
             APInt Low;
             unsigned ActiveWords = 1;
             if (ValueBitWidth > 64)
               ActiveWords = Record[CurIdx++];
             Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
                                 ValueBitWidth);
             CurIdx += ActiveWords;
 
             if (!isSingleNumber) {
               ActiveWords = 1;
               if (ValueBitWidth > 64)
                 ActiveWords = Record[CurIdx++];
               APInt High = readWideAPInt(
                   makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth);
               CurIdx += ActiveWords;
 
               // FIXME: It is not clear whether values in the range should be
               // compared as signed or unsigned values. The partially
               // implemented changes that used this format in the past used
               // unsigned comparisons.
-              for ( ; Low.ule(High); ++Low)
+              for (; Low.ule(High); ++Low)
                 CaseVals.push_back(ConstantInt::get(Context, Low));
             } else
               CaseVals.push_back(ConstantInt::get(Context, Low));
           }
           BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
-          for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
-                 cve = CaseVals.end(); cvi != cve; ++cvi)
+          for (SmallVector<ConstantInt *, 1>::iterator cvi = CaseVals.begin(),
+                                                       cve = CaseVals.end();
+               cvi != cve; ++cvi)
             SI->addCase(*cvi, DestBB);
         }
         I = SI;
         break;
       }
 
       // Old SwitchInst format without case ranges.
 
       if (Record.size() < 3 || (Record.size() & 1) == 0)
         return error("Invalid record");
       Type *OpTy = getTypeByID(Record[0]);
       Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
       BasicBlock *Default = getBasicBlock(Record[2]);
       if (!OpTy || !Cond || !Default)
         return error("Invalid record");
-      unsigned NumCases = (Record.size()-3)/2;
+      unsigned NumCases = (Record.size() - 3) / 2;
       SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
       InstructionList.push_back(SI);
       for (unsigned i = 0, e = NumCases; i != e; ++i) {
-        ConstantInt *CaseVal =
-          dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
-        BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
+        ConstantInt *CaseVal = dyn_cast_or_null<ConstantInt>(
+            getFnValueByID(Record[3 + i * 2], OpTy));
+        BasicBlock *DestBB = getBasicBlock(Record[1 + 3 + i * 2]);
         if (!CaseVal || !DestBB) {
           delete SI;
           return error("Invalid record");
         }
         SI->addCase(CaseVal, DestBB);
       }
       I = SI;
       break;
     }
     case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
       if (Record.size() < 2)
         return error("Invalid record");
       Type *OpTy = getTypeByID(Record[0]);
       Value *Address = getValue(Record, 1, NextValueNo, OpTy);
       if (!OpTy || !Address)
         return error("Invalid record");
-      unsigned NumDests = Record.size()-2;
+      unsigned NumDests = Record.size() - 2;
       IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
       InstructionList.push_back(IBI);
       for (unsigned i = 0, e = NumDests; i != e; ++i) {
-        if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
+        if (BasicBlock *DestBB = getBasicBlock(Record[2 + i])) {
           IBI->addDestination(DestBB);
         } else {
           delete IBI;
           return error("Invalid record");
         }
       }
       I = IBI;
       break;
case bitc::FUNC_CODE_INST_INVOKE: {
         if (!FTy)
           return error("Callee is not of pointer to function type");
       } else if (CalleeTy->getElementType() != FTy)
         return error("Explicit invoke type does not match pointee type of "
                      "callee operand");
       if (Record.size() < FTy->getNumParams() + OpNum)
         return error("Insufficient operands to call");
 
-      SmallVector<Value*, 16> Ops;
+      SmallVector<Value *, 16> Ops;
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
-        Ops.push_back(getValue(Record, OpNum, NextValueNo,
-                               FTy->getParamType(i)));
+        Ops.push_back(
+            getValue(Record, OpNum, NextValueNo, FTy->getParamType(i)));
         if (!Ops.back())
           return error("Invalid record");
       }
 
       if (!FTy->isVarArg()) {
         if (Record.size() != OpNum)
           return error("Invalid record");
       } else {
case bitc::FUNC_CODE_INST_CALLBR: {
         if (!FTy)
           return error("Callee is not of pointer to function type");
       } else if (OpTy->getElementType() != FTy)
         return error("Explicit call type does not match pointee type of "
                      "callee operand");
       if (Record.size() < FTy->getNumParams() + OpNum)
         return error("Insufficient operands to call");
 
-      SmallVector<Value*, 16> Args;
+      SmallVector<Value *, 16> Args;
       // Read the fixed params.
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
         if (FTy->getParamType(i)->isLabelTy())
           Args.push_back(getBasicBlock(Record[OpNum]));
         else
-          Args.push_back(getValue(Record, OpNum, NextValueNo,
-                                  FTy->getParamType(i)));
+          Args.push_back(
+              getValue(Record, OpNum, NextValueNo, FTy->getParamType(i)));
         if (!Args.back())
           return error("Invalid record");
       }
 
       // Read type/value pairs for varargs params.
       if (!FTy->isVarArg()) {
         if (OpNum != Record.size())
           return error("Invalid record");
case bitc::FUNC_CODE_INST_CALLBR: {
       cast<CallBrInst>(I)->setAttributes(PAL);
       break;
     }
     case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
       I = new UnreachableInst(Context);
       InstructionList.push_back(I);
       break;
     case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
-      if (Record.size() < 1 || ((Record.size()-1)&1))
+      if (Record.size() < 1 || ((Record.size() - 1) & 1))
         return error("Invalid record");
       Type *Ty = getTypeByID(Record[0]);
       if (!Ty)
         return error("Invalid record");
 
-      PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
+      PHINode *PN = PHINode::Create(Ty, (Record.size() - 1) / 2);
       InstructionList.push_back(PN);
 
-      for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
+      for (unsigned i = 0, e = Record.size() - 1; i != e; i += 2) {
         Value *V;
         // With the new function encoding, it is possible that operands have
         // negative IDs (for forward references).  Use a signed VBR
         // representation to keep the encoding small.
         if (UseRelativeIDs)
-          V = getValueSigned(Record, 1+i, NextValueNo, Ty);
+          V = getValueSigned(Record, 1 + i, NextValueNo, Ty);
         else
-          V = getValue(Record, 1+i, NextValueNo, Ty);
-        BasicBlock *BB = getBasicBlock(Record[2+i]);
+          V = getValue(Record, 1 + i, NextValueNo, Ty);
+        BasicBlock *BB = getBasicBlock(Record[2 + i]);
         if (!V || !BB)
           return error("Invalid record");
         PN->addIncoming(V, BB);
       }
       I = PN;
       break;
     }
 
case bitc::FUNC_CODE_INST_LANDINGPAD_OLD: {
       }
 
       bool IsCleanup = !!Record[Idx++];
       unsigned NumClauses = Record[Idx++];
       LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses);
       LP->setCleanup(IsCleanup);
       for (unsigned J = 0; J != NumClauses; ++J) {
         LandingPadInst::ClauseType CT =
-          LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
+            LandingPadInst::ClauseType(Record[Idx++]);
+        (void)CT;
         Value *Val;
 
         if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
           delete LP;
           return error("Invalid record");
         }
 
-        assert((CT != LandingPadInst::Catch ||
-                !isa<ArrayType>(Val->getType())) &&
-               "Catch clause has a invalid type!");
-        assert((CT != LandingPadInst::Filter ||
-                isa<ArrayType>(Val->getType())) &&
-               "Filter clause has invalid type!");
+        assert(
+            (CT != LandingPadInst::Catch || !isa<ArrayType>(Val->getType())) &&
+        assert(
+            (CT != LandingPadInst::Filter || isa<ArrayType>(Val->getType())) &&
         LP->addClause(cast<Constant>(Val));
       }
 
       I = LP;
       InstructionList.push_back(I);
       break;
     }
 
     case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
       if (Record.size() != 4)
         return error("Invalid record");
       uint64_t AlignRecord = Record[3];
       const uint64_t InAllocaMask = uint64_t(1) << 5;
       const uint64_t ExplicitTypeMask = uint64_t(1) << 6;
       const uint64_t SwiftErrorMask = uint64_t(1) << 7;
-      const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask |
-                                SwiftErrorMask;
+      const uint64_t FlagMask =
+          InAllocaMask | ExplicitTypeMask | SwiftErrorMask;
       bool InAlloca = AlignRecord & InAllocaMask;
       bool SwiftError = AlignRecord & SwiftErrorMask;
       Type *Ty = getTypeByID(Record[0]);
       if ((AlignRecord & ExplicitTypeMask) == 0) {
         auto *PTy = dyn_cast_or_null<PointerType>(Ty);
         if (!PTy)
           return error("Old-style alloca with a non-pointer type");
         Ty = PTy->getElementType();
case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
         return Err;
       I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
 
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_LOADATOMIC: {
-       // LOADATOMIC: [opty, op, align, vol, ordering, ssid]
       unsigned OpNum = 0;
       Value *Op;
       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
           (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
         return error("Invalid record");
 
       Type *Ty = nullptr;
       if (OpNum + 5 == Record.size())
case bitc::FUNC_CODE_INST_LOADATOMIC: {
       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
         return Err;
       I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align, Ordering, SSID);
 
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_STORE:
-    case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol]
+    case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align,
+                                           // vol]
       unsigned OpNum = 0;
       Value *Val, *Ptr;
       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
           (BitCode == bitc::FUNC_CODE_INST_STORE
                ? getValueTypePair(Record, OpNum, NextValueNo, Val)
                : popValue(Record, OpNum, NextValueNo,
                           cast<PointerType>(Ptr->getType())->getElementType(),
                           Val)) ||
           OpNum + 2 != Record.size())
         return error("Invalid record");
 
       if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
         return Err;
       unsigned Align;
       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
         return Err;
-      I = new StoreInst(Val, Ptr, Record[OpNum+1], Align);
+      I = new StoreInst(Val, Ptr, Record[OpNum + 1], Align);
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_STOREATOMIC:
     case bitc::FUNC_CODE_INST_STOREATOMIC_OLD: {
       // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, ssid]
       unsigned OpNum = 0;
       Value *Val, *Ptr;
case bitc::FUNC_CODE_INST_STOREATOMIC_OLD: {
         return error("Invalid record");
       SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
       if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
         return error("Invalid record");
 
       unsigned Align;
       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
         return Err;
-      I = new StoreInst(Val, Ptr, Record[OpNum+1], Align, Ordering, SSID);
+      I = new StoreInst(Val, Ptr, Record[OpNum + 1], Align, Ordering, SSID);
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_CMPXCHG_OLD:
     case bitc::FUNC_CODE_INST_CMPXCHG: {
       // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, ssid,
       //          failureordering?, isweak?]
       unsigned OpNum = 0;
case bitc::FUNC_CODE_INST_CMPXCHG: {
 
       if (Record.size() < 8) {
         // Before weak cmpxchgs existed, the instruction simply returned the
         // value loaded from memory, so bitcode files from that era will be
         // expecting the first component of a modern cmpxchg.
         CurBB->getInstList().push_back(I);
         I = ExtractValueInst::Create(I, 0);
       } else {
-        cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
+        cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum + 4]);
       }
 
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_ATOMICRMW: {
       // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, ssid]
       unsigned OpNum = 0;
       Value *Ptr, *Val;
       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
           !isa<PointerType>(Ptr->getType()) ||
           popValue(Record, OpNum, NextValueNo,
-                    cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
-          OpNum+4 != Record.size())
+          OpNum + 4 != Record.size())
         return error("Invalid record");
       AtomicRMWInst::BinOp Operation = getDecodedRMWOperation(Record[OpNum]);
       if (Operation < AtomicRMWInst::FIRST_BINOP ||
           Operation > AtomicRMWInst::LAST_BINOP)
         return error("Invalid record");
       AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
       if (Ordering == AtomicOrdering::NotAtomic ||
           Ordering == AtomicOrdering::Unordered)
         return error("Invalid record");
       SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
       I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SSID);
-      cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
+      cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum + 1]);
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, ssid]
       if (2 != Record.size())
         return error("Invalid record");
       AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
       if (Ordering == AtomicOrdering::NotAtomic ||
case bitc::FUNC_CODE_INST_CALL: {
         if (!FTy)
           return error("Callee is not of pointer to function type");
       } else if (OpTy->getElementType() != FTy)
         return error("Explicit call type does not match pointee type of "
                      "callee operand");
       if (Record.size() < FTy->getNumParams() + OpNum)
         return error("Insufficient operands to call");
 
-      SmallVector<Value*, 16> Args;
+      SmallVector<Value *, 16> Args;
       // Read the fixed params.
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
         if (FTy->getParamType(i)->isLabelTy())
           Args.push_back(getBasicBlock(Record[OpNum]));
         else
-          Args.push_back(getValue(Record, OpNum, NextValueNo,
-                                  FTy->getParamType(i)));
+          Args.push_back(
+              getValue(Record, OpNum, NextValueNo, FTy->getParamType(i)));
         if (!Args.back())
           return error("Invalid record");
       }
 
       // Read type/value pairs for varargs params.
       if (!FTy->isVarArg()) {
         if (OpNum != Record.size())
           return error("Invalid record");
OutOfRecordLoop:
 
   if (!OperandBundles.empty())
     return error("Operand bundles found with no consumer");
 
   // Check the function list for unresolved values.
   if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
     if (!A->getParent()) {
       // We found at least one unresolved value.  Nuke them all to avoid leaks.
-      for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
+      for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e;
+           ++i) {
         if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {
           A->replaceAllUsesWith(UndefValue::get(A->getType()));
           delete A;
         }
       }
       return error("Never resolved value found in function");
     }
   }
 
   // Unexpected unresolved metadata about to be dropped.
   if (MDLoader->hasFwdRefs())
     return error("Invalid function metadata: outgoing forward refs");
 
   // Trim the value list down to the size it was before we parsed this function.
   ValueList.shrinkTo(ModuleValueListSize);
   MDLoader->shrinkTo(ModuleMDLoaderSize);
-  std::vector<BasicBlock*>().swap(FunctionBBs);
+  std::vector<BasicBlock *>().swap(FunctionBBs);
   return Error::success();
 }
 
 /// Find the function body in the bitcode stream
 Error BitcodeReader::findFunctionInStream(
     Function *F,
     DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
   while (DeferredFunctionInfoIterator->second == 0) {

 //===----------------------------------------------------------------------===//
 
 Error BitcodeReader::materialize(GlobalValue *GV) {
   Function *F = dyn_cast<Function>(GV);
   // If it's not a function or is already material, ignore the request.
   if (!F || !F->isMaterializable())
     return Error::success();
 
-  DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
+  DenseMap<Function *, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
   assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
   // If its position is recorded as 0, its body is somewhere in the stream
   // but we haven't seen it yet.
   if (DFII->second == 0)
     if (Error Err = findFunctionInStream(F, DFII))
       return Err;
 
   // Materialize metadata before parsing any function bodies.
if (PrintSummaryGUIDs)
     dbgs() << "GUID " << ValueGUID << "(" << OriginalNameID << ") is "
            << ValueName << "\n";
 
   // UseStrtab is false for legacy summary formats and value names are
   // created on stack. In that case we save the name in a string saver in
   // the index so that the value name can be recorded.
   ValueIdToValueInfoMap[ValueID] = std::make_pair(
       TheIndex.getOrInsertValueInfo(
-          ValueGUID,
-          UseStrtab ? ValueName : TheIndex.saveString(ValueName)),
+          ValueGUID, UseStrtab ? ValueName : TheIndex.saveString(ValueName)),
       OriginalNameID);
 }
 
 // Specialized value symbol table parser used when reading module index
 // blocks where we don't actually create global values. The parsed information
 // is saved in the bitcode reader for use when later parsing summaries.
 Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable(
     uint64_t Offset,
case BitstreamEntry::SubBlock:
       case bitc::MODULE_STRTAB_BLOCK_ID:
         if (Error Err = parseModuleStringTable())
           return Err;
         break;
       }
       continue;
 
     case BitstreamEntry::Record: {
-        Record.clear();
-        Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
-        if (!MaybeBitCode)
-          return MaybeBitCode.takeError();
-        switch (MaybeBitCode.get()) {
-        default:
-          break; // Default behavior, ignore unknown content.
-        case bitc::MODULE_CODE_VERSION: {
-          if (Error Err = parseVersionRecord(Record).takeError())
-            return Err;
-          break;
-        }
-        /// MODULE_CODE_SOURCE_FILENAME: [namechar x N]
-        case bitc::MODULE_CODE_SOURCE_FILENAME: {
-          SmallString<128> ValueName;
-          if (convertToString(Record, 0, ValueName))
-            return error("Invalid record");
-          SourceFileName = ValueName.c_str();
-          break;
-        }
-        /// MODULE_CODE_HASH: [5*i32]
-        case bitc::MODULE_CODE_HASH: {
-          if (Record.size() != 5)
-            return error("Invalid hash length " + Twine(Record.size()).str());
-          auto &Hash = getThisModule()->second.second;
-          int Pos = 0;
-          for (auto &Val : Record) {
-            assert(!(Val >> 32) && "Unexpected high bits set");
-            Hash[Pos++] = Val;
-          }
-          break;
-        }
-        /// MODULE_CODE_VSTOFFSET: [offset]
-        case bitc::MODULE_CODE_VSTOFFSET:
-          if (Record.size() < 1)
-            return error("Invalid record");
-          // Note that we subtract 1 here because the offset is relative to one
-          // word before the start of the identification or module block, which
-          // was historically always the start of the regular bitcode header.
-          VSTOffset = Record[0] - 1;
-          break;
-        // v1 GLOBALVAR: [pointer type, isconst,     initid,       linkage, ...]
-        // v1 FUNCTION:  [type,         callingconv, isproto,      linkage, ...]
-        // v1 ALIAS:     [alias type,   addrspace,   aliasee val#, linkage, ...]
-        // v2: [strtab offset, strtab size, v1]
-        case bitc::MODULE_CODE_GLOBALVAR:
-        case bitc::MODULE_CODE_FUNCTION:
-        case bitc::MODULE_CODE_ALIAS: {
-          StringRef Name;
-          ArrayRef<uint64_t> GVRecord;
-          std::tie(Name, GVRecord) = readNameFromStrtab(Record);
-          if (GVRecord.size() <= 3)
-            return error("Invalid record");
-          uint64_t RawLinkage = GVRecord[3];
-          GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
-          if (!UseStrtab) {
-            ValueIdToLinkageMap[ValueId++] = Linkage;
-            break;
-          }
 
-          setValueGUID(ValueId++, Name, Linkage, SourceFileName);
-          break;
-        }
-        }
-      }
       continue;
     }
   }
 }
 
 std::vector<ValueInfo>
 ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t> Record) {
   std::vector<ValueInfo> Ret;
while (true) {
     // information used for ThinLTO renaming and importing.
     Record.clear();
     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
     if (!MaybeBitCode)
       return MaybeBitCode.takeError();
     switch (unsigned BitCode = MaybeBitCode.get()) {
     default: // Default behavior: ignore.
       break;
-    case bitc::FS_FLAGS: {  // [flags]
+    case bitc::FS_FLAGS: { // [flags]
       uint64_t Flags = Record[0];
       // Scan flags.
       assert(Flags <= 0x1f && "Unexpected bits in flag");
 
       // 1 bit: WithGlobalValueDeadStripping flag.
       // Set on combined index only.
       if (Flags & 0x1)
         TheIndex.setWithGlobalValueDeadStripping();
case bitc::FS_ALIAS: {
       // The module path string ref set in the summary must be owned by the
       // index's module string table. Since we don't have a module path
       // string table section in the per-module index, we create a single
       // module path string table entry with an empty (0) ID to take
       // ownership.
       AS->setModulePath(getThisModule()->first());
 
       auto AliaseeVI = getValueInfoFromValueId(AliaseeID).first;
-      auto AliaseeInModule = TheIndex.findSummaryInModule(AliaseeVI, ModulePath);
+      auto AliaseeInModule =
+          TheIndex.findSummaryInModule(AliaseeVI, ModulePath);
       if (!AliaseeInModule)
         return error("Alias expects aliasee summary to be parsed");
       AS->setAliasee(AliaseeVI, AliaseeInModule);
 
       auto GUID = getValueInfoFromValueId(ValueID);
       AS->setOriginalName(GUID.second);
       TheIndex.addGlobalValueSummary(GUID.first, std::move(AS));
       break;
case bitc::FS_COMBINED_ALIAS: {
       uint64_t RawFlags = Record[2];
       unsigned AliaseeValueId = Record[3];
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       auto AS = llvm::make_unique<AliasSummary>(Flags);
       LastSeenSummary = AS.get();
       AS->setModulePath(ModuleIdMap[ModuleId]);
 
       auto AliaseeVI = getValueInfoFromValueId(AliaseeValueId).first;
-      auto AliaseeInModule = TheIndex.findSummaryInModule(AliaseeVI, AS->modulePath());
+      auto AliaseeInModule =
+          TheIndex.findSummaryInModule(AliaseeVI, AS->modulePath());
       AS->setAliasee(AliaseeVI, AliaseeInModule);
 
       ValueInfo VI = getValueInfoFromValueId(ValueID).first;
       LastSeenGUID = VI.getGUID();
       TheIndex.addGlobalValueSummary(VI, std::move(AS));
       break;
     }
     // FS_COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]
case bitc::FS_TYPE_TESTS:
       assert(PendingTypeTests.empty());
       PendingTypeTests.insert(PendingTypeTests.end(), Record.begin(),
                               Record.end());
       break;
 
     case bitc::FS_TYPE_TEST_ASSUME_VCALLS:
       assert(PendingTypeTestAssumeVCalls.empty());
       for (unsigned I = 0; I != Record.size(); I += 2)
-        PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I+1]});
+        PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I + 1]});
       break;
 
     case bitc::FS_TYPE_CHECKED_LOAD_VCALLS:
       assert(PendingTypeCheckedLoadVCalls.empty());
       for (unsigned I = 0; I != Record.size(); I += 2)
-        PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I+1]});
+        PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I + 1]});
       break;
 
     case bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL:
       PendingTypeTestAssumeConstVCalls.push_back(
           {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
       break;
 
     case bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL:

 }
 
 namespace {
 
 // FIXME: This class is only here to support the transition to llvm::Error. It
 // will be removed once this transition is complete. Clients should prefer to
 // deal with the Error value directly, rather than converting to error_code.
 class BitcodeErrorCategoryType : public std::error_category {
-  const char *name() const noexcept override {
-    return "llvm.bitcode";
-  }
+  const char *name() const noexcept override { return "llvm.bitcode"; }
 
   std::string message(int IE) const override {
     BitcodeError E = static_cast<BitcodeError>(IE);
     switch (E) {
     case BitcodeError::CorruptedBitcode:
       return "Corrupted bitcode";
     }
     llvm_unreachable("Unknown error type!");

llvm/lib/IR/Type.cpp

 bool FunctionType::isValidArgumentType(Type *ArgTy) {
   return ArgTy->isFirstClassType();
 }
 
 //===----------------------------------------------------------------------===//
 //                       StructType Implementation
 //===----------------------------------------------------------------------===//
 
+StructType *StructType::getIfExists(LLVMContext &Context, StringRef Name) {
+  auto I = Context.pImpl->NamedStructTypes.find(Name);
+  if (I == Context.pImpl->NamedStructTypes.end())
+    return nullptr;
+  return I->getValue();
+}
+
 // Primitive Constructors.
 
+
 StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
                             bool isPacked) {
   LLVMContextImpl *pImpl = Context.pImpl;
   const AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked);
 
   StructType *ST;
   // Since we only want to allocate a fresh struct type in case none is found
   // and we don't want to perform two lookups (one for checking if existent and

llvm/unittests/Bitcode/BitReaderTest.cpp

TEST(BitReaderTest, MaterializeFunctionsForBlockAddrInFunctionAfter) {
 
   // Materialize @after, pulling in @func.
   EXPECT_FALSE(M->getFunction("after")->materialize());
   EXPECT_FALSE(M->getFunction("func")->empty());
   EXPECT_TRUE(M->getFunction("other")->empty());
   EXPECT_FALSE(verifyModule(*M, &dbgs()));
 }
 
+TEST(BitReaderTest, UseExistingNameStructType) {
+  // Make a module using a struct type, then write that.
+  LLVMContext C1;
+  StructType *T1 = StructType::create(C1, "Correct");
+  T1->setBody(Type::getInt32Ty(C1));
+  std::unique_ptr<Module> M1(new Module("M1", C1));
+  M1->getOrInsertFunction("F1", T1);
+  SmallString<1024> Memory;
+  raw_svector_ostream OS(Memory);
+  WriteBitcodeToFile(*M1, OS);
+
+  // Define that struct type in a new context. Read the module into that
+  // context. At this point, the context contains the StructType the module
+  // uses.
+  LLVMContext C2;
+  StructType *T2 = StructType::create(C2, T1->getName());
+  T2->setBody(Type::getInt32Ty(C2));
+  auto Careful = parseBitcodeFile(MemoryBufferRef(Memory.str(), "test"), C2);
+  EXPECT_TRUE((bool)Careful);
+  std::unique_ptr<Module> M2(Careful.get().release());
+
+  // Then one single test: was the already-present struct type used?
+  Function *F2 = M2->getFunction("F1");
+  EXPECT_NE(F2, nullptr);
+  EXPECT_EQ(cast<StructType>(F2->getReturnType())->getName(), T1->getName());
+
+  // Define a different StructType of the same name. Reading the bitcode into
+  // THAT context should fail.
+  LLVMContext C3;
+  StructType *T3 = StructType::create(C3, T1->getName());
+  T3->setBody(Type::getFloatTy(C3));
+  Careful = parseBitcodeFile(MemoryBufferRef(Memory.str(), "test"), C3);
+  EXPECT_FALSE((bool)Careful);
+  handleAllErrors(Careful.takeError(), [&](const ErrorInfoBase &DE) {});
+}
+
+TEST(BitReaderTest, ResolveForwardStructReferences) {
+  // This test is intended to resemble reading a subclass and a superclass from
+  // separate .bc files into the same LLVMContext. Subclasses and superclasses
+  // often contain functions (or methods if you will) with the same signature.
+  // This test approximates that using two functions with the same FunctionType.
+
+  // Make a context using two struct types that reference each other. One of the
+  // types necessarily has to contain a forward reference when written to the
+  // .bc files.
+
+  LLVMContext C1;
+  StructType *T1A = StructType::create(C1, "Struct1");
+  StructType *T2A = StructType::create(C1, "Struct2");
+  T1A->setBody(T2A->getPointerTo());
+  T2A->setBody(T1A->getPointerTo());
+
+  // Make two modules, each containing one function with the same function type.
+
+  std::unique_ptr<Module> M1A(new Module("M1", C1));
+  std::unique_ptr<Module> M2A(new Module("M2", C1));
+  M1A->getOrInsertFunction("F1", Type::getVoidTy(C1), T1A->getPointerTo(),
+                           T2A->getPointerTo());
+  M2A->getOrInsertFunction("F2", Type::getVoidTy(C1), T1A->getPointerTo(),
+                           T2A->getPointerTo());
+  EXPECT_EQ(M1A->getFunction("F1")->getFunctionType(),
+            M2A->getFunction("F2")->getFunctionType());
+
+  // Write both modules to separate .bc files, then read the .bc files into the
+  // same new context.
+
+  SmallString<1024> BC1;
+  raw_svector_ostream OS1(BC1);
+  WriteBitcodeToFile(*M1A, OS1);
+  SmallString<1024> BC2;
+  raw_svector_ostream OS2(BC2);
+  WriteBitcodeToFile(*M2A, OS2);
+
+  LLVMContext C2;
+  auto Careful = parseBitcodeFile(MemoryBufferRef(BC1.str(), "test"), C2);
+  EXPECT_TRUE((bool)Careful);
+  std::unique_ptr<Module> M1B(Careful.get().release());
+  Careful = parseBitcodeFile(MemoryBufferRef(BC2.str(), "test"), C2);
+  EXPECT_TRUE((bool)Careful);
+  std::unique_ptr<Module> M2B(Careful.get().release());
+
+  // The two functions should still have the same signature.
+
+  EXPECT_EQ(M1B->getFunction("F1")->getFunctionType(),
+            M2B->getFunction("F2")->getFunctionType());
+
+  // I wish I could EXPECT_THAT(BC1->containsForwardTypeReference()) but that
+  // seems entirely unreasonable.
+}
+
+TEST(BitReaderTest, CreateUnnamedStructTypes) {
+  // This test checks that two unnamed named struct types aren't inappropriately
+  // merged. I love it when I write a test just to be safe, and it passes the
+  // first time I run it.
+
+  LLVMContext C1;
+  StructType *T1 = StructType::create(C1);
+  StructType *T2 = StructType::create(C1);
+  T1->setBody(T2->getPointerTo());
+  // T2 intentionally opaque
+
+  std::unique_ptr<Module> M(new Module("M", C1));
+  M->getOrInsertFunction("F", Type::getVoidTy(C1), T1->getPointerTo(),
+                         T2->getPointerTo());
+
+  SmallString<1024> BC;
+  raw_svector_ostream OS(BC);
+  WriteBitcodeToFile(*M, OS);
+
+  LLVMContext C2;
+  StructType *T3 = StructType::create(C2);
+  auto Careful = parseBitcodeFile(MemoryBufferRef(BC.str(), "test"), C2);
+  EXPECT_TRUE((bool)Careful);
+
+  // There's no reason to believe that T1 or T2 matches T3, and T1 and T2
+  // definitely do not match each other. Verify all of that.
+
+  Function *F = Careful.get().release()->getFunction("F");
+  EXPECT_NE(nullptr, F);
+  FunctionType *FT = F->getFunctionType();
+  EXPECT_EQ(2U, FT->getNumParams());
+  EXPECT_NE(FT->getParamType(0), FT->getParamType(1));
+  EXPECT_NE(T3, FT->getParamType(0));
+  EXPECT_NE(T3, FT->getParamType(1));
+}
+
 } // end namespace