Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 2006 insertions, 2006 deletions

diff --git a/contrib/libs/llvm12/lib/AsmParser/LLParser.cpp b/contrib/libs/llvm12/lib/AsmParser/LLParser.cpp
index 2a3fb8fb66..eec0f69d97 100644
--- a/contrib/libs/llvm12/lib/AsmParser/LLParser.cpp
+++ b/contrib/libs/llvm12/lib/AsmParser/LLParser.cpp
@@ -65,20 +65,20 @@ bool LLParser::Run(bool UpgradeDebugInfo,
   Lex.Lex();
 
   if (Context.shouldDiscardValueNames())
-    return error(
+    return error( 
         Lex.getLoc(),
         "Can't read textual IR with a Context that discards named Values");
 
   if (M) {
-    if (parseTargetDefinitions())
+    if (parseTargetDefinitions()) 
       return true;
 
     if (auto LayoutOverride = DataLayoutCallback(M->getTargetTriple()))
       M->setDataLayout(*LayoutOverride);
   }
 
-  return parseTopLevelEntities() || validateEndOfModule(UpgradeDebugInfo) ||
-         validateEndOfIndex();
+  return parseTopLevelEntities() || validateEndOfModule(UpgradeDebugInfo) || 
+         validateEndOfIndex(); 
 }
 
 bool LLParser::parseStandaloneConstantValue(Constant *&C,
@@ -87,10 +87,10 @@ bool LLParser::parseStandaloneConstantValue(Constant *&C,
   Lex.Lex();
 
   Type *Ty = nullptr;
-  if (parseType(Ty) || parseConstantValue(Ty, C))
+  if (parseType(Ty) || parseConstantValue(Ty, C)) 
     return true;
   if (Lex.getKind() != lltok::Eof)
-    return error(Lex.getLoc(), "expected end of string");
+    return error(Lex.getLoc(), "expected end of string"); 
   return false;
 }
 
@@ -102,7 +102,7 @@ bool LLParser::parseTypeAtBeginning(Type *&Ty, unsigned &Read,
   Read = 0;
   SMLoc Start = Lex.getLoc();
   Ty = nullptr;
-  if (parseType(Ty))
+  if (parseType(Ty)) 
     return true;
   SMLoc End = Lex.getLoc();
   Read = End.getPointer() - Start.getPointer();
@@ -123,9 +123,9 @@ void LLParser::restoreParsingState(const SlotMapping *Slots) {
         std::make_pair(I.first, std::make_pair(I.second, LocTy())));
 }
 
-/// validateEndOfModule - Do final validity and sanity checks at the end of the
+/// validateEndOfModule - Do final validity and sanity checks at the end of the 
 /// module.
-bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) {
+bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) { 
   if (!M)
     return false;
   // Handle any function attribute group forward references.
@@ -190,39 +190,39 @@ bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) {
   // If there are entries in ForwardRefBlockAddresses at this point, the
   // function was never defined.
   if (!ForwardRefBlockAddresses.empty())
-    return error(ForwardRefBlockAddresses.begin()->first.Loc,
+    return error(ForwardRefBlockAddresses.begin()->first.Loc, 
                  "expected function name in blockaddress");
 
   for (const auto &NT : NumberedTypes)
     if (NT.second.second.isValid())
-      return error(NT.second.second,
+      return error(NT.second.second, 
                    "use of undefined type '%" + Twine(NT.first) + "'");
 
   for (StringMap<std::pair<Type*, LocTy> >::iterator I =
        NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
     if (I->second.second.isValid())
-      return error(I->second.second,
+      return error(I->second.second, 
                    "use of undefined type named '" + I->getKey() + "'");
 
   if (!ForwardRefComdats.empty())
-    return error(ForwardRefComdats.begin()->second,
+    return error(ForwardRefComdats.begin()->second, 
                  "use of undefined comdat '$" +
                      ForwardRefComdats.begin()->first + "'");
 
   if (!ForwardRefVals.empty())
-    return error(ForwardRefVals.begin()->second.second,
+    return error(ForwardRefVals.begin()->second.second, 
                  "use of undefined value '@" + ForwardRefVals.begin()->first +
-                     "'");
+                     "'"); 
 
   if (!ForwardRefValIDs.empty())
-    return error(ForwardRefValIDs.begin()->second.second,
+    return error(ForwardRefValIDs.begin()->second.second, 
                  "use of undefined value '@" +
-                     Twine(ForwardRefValIDs.begin()->first) + "'");
+                     Twine(ForwardRefValIDs.begin()->first) + "'"); 
 
   if (!ForwardRefMDNodes.empty())
-    return error(ForwardRefMDNodes.begin()->second.second,
+    return error(ForwardRefMDNodes.begin()->second.second, 
                  "use of undefined metadata '!" +
-                     Twine(ForwardRefMDNodes.begin()->first) + "'");
+                     Twine(ForwardRefMDNodes.begin()->first) + "'"); 
 
   // Resolve metadata cycles.
   for (auto &N : NumberedMetadata) {
@@ -275,22 +275,22 @@ bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) {
 }
 
 /// Do final validity and sanity checks at the end of the index.
-bool LLParser::validateEndOfIndex() {
+bool LLParser::validateEndOfIndex() { 
   if (!Index)
     return false;
 
   if (!ForwardRefValueInfos.empty())
-    return error(ForwardRefValueInfos.begin()->second.front().second,
+    return error(ForwardRefValueInfos.begin()->second.front().second, 
                  "use of undefined summary '^" +
                      Twine(ForwardRefValueInfos.begin()->first) + "'");
 
   if (!ForwardRefAliasees.empty())
-    return error(ForwardRefAliasees.begin()->second.front().second,
+    return error(ForwardRefAliasees.begin()->second.front().second, 
                  "use of undefined summary '^" +
                      Twine(ForwardRefAliasees.begin()->first) + "'");
 
   if (!ForwardRefTypeIds.empty())
-    return error(ForwardRefTypeIds.begin()->second.front().second,
+    return error(ForwardRefTypeIds.begin()->second.front().second, 
                  "use of undefined type id summary '^" +
                      Twine(ForwardRefTypeIds.begin()->first) + "'");
 
@@ -301,15 +301,15 @@ bool LLParser::validateEndOfIndex() {
 // Top-Level Entities
 //===----------------------------------------------------------------------===//
 
-bool LLParser::parseTargetDefinitions() {
+bool LLParser::parseTargetDefinitions() { 
   while (true) {
     switch (Lex.getKind()) {
     case lltok::kw_target:
-      if (parseTargetDefinition())
+      if (parseTargetDefinition()) 
         return true;
       break;
     case lltok::kw_source_filename:
-      if (parseSourceFileName())
+      if (parseSourceFileName()) 
         return true;
       break;
     default:
@@ -318,7 +318,7 @@ bool LLParser::parseTargetDefinitions() {
   }
 }
 
-bool LLParser::parseTopLevelEntities() {
+bool LLParser::parseTopLevelEntities() { 
   // If there is no Module, then parse just the summary index entries.
   if (!M) {
     while (true) {
@@ -326,11 +326,11 @@ bool LLParser::parseTopLevelEntities() {
       case lltok::Eof:
         return false;
       case lltok::SummaryID:
-        if (parseSummaryEntry())
+        if (parseSummaryEntry()) 
           return true;
         break;
       case lltok::kw_source_filename:
-        if (parseSourceFileName())
+        if (parseSourceFileName()) 
           return true;
         break;
       default:
@@ -341,64 +341,64 @@ bool LLParser::parseTopLevelEntities() {
   }
   while (true) {
     switch (Lex.getKind()) {
-    default:
-      return tokError("expected top-level entity");
+    default: 
+      return tokError("expected top-level entity"); 
     case lltok::Eof: return false;
-    case lltok::kw_declare:
-      if (parseDeclare())
-        return true;
-      break;
-    case lltok::kw_define:
-      if (parseDefine())
-        return true;
-      break;
-    case lltok::kw_module:
-      if (parseModuleAsm())
-        return true;
-      break;
-    case lltok::kw_deplibs:
-      if (parseDepLibs())
-        return true;
-      break;
-    case lltok::LocalVarID:
-      if (parseUnnamedType())
-        return true;
-      break;
-    case lltok::LocalVar:
-      if (parseNamedType())
-        return true;
-      break;
-    case lltok::GlobalID:
-      if (parseUnnamedGlobal())
-        return true;
-      break;
-    case lltok::GlobalVar:
-      if (parseNamedGlobal())
-        return true;
-      break;
+    case lltok::kw_declare: 
+      if (parseDeclare()) 
+        return true; 
+      break; 
+    case lltok::kw_define: 
+      if (parseDefine()) 
+        return true; 
+      break; 
+    case lltok::kw_module: 
+      if (parseModuleAsm()) 
+        return true; 
+      break; 
+    case lltok::kw_deplibs: 
+      if (parseDepLibs()) 
+        return true; 
+      break; 
+    case lltok::LocalVarID: 
+      if (parseUnnamedType()) 
+        return true; 
+      break; 
+    case lltok::LocalVar: 
+      if (parseNamedType()) 
+        return true; 
+      break; 
+    case lltok::GlobalID: 
+      if (parseUnnamedGlobal()) 
+        return true; 
+      break; 
+    case lltok::GlobalVar: 
+      if (parseNamedGlobal()) 
+        return true; 
+      break; 
     case lltok::ComdatVar:  if (parseComdat()) return true; break;
-    case lltok::exclaim:
-      if (parseStandaloneMetadata())
-        return true;
-      break;
+    case lltok::exclaim: 
+      if (parseStandaloneMetadata()) 
+        return true; 
+      break; 
     case lltok::SummaryID:
-      if (parseSummaryEntry())
-        return true;
-      break;
-    case lltok::MetadataVar:
-      if (parseNamedMetadata())
-        return true;
-      break;
-    case lltok::kw_attributes:
-      if (parseUnnamedAttrGrp())
-        return true;
-      break;
-    case lltok::kw_uselistorder:
-      if (parseUseListOrder())
+      if (parseSummaryEntry()) 
         return true;
       break;
+    case lltok::MetadataVar: 
+      if (parseNamedMetadata()) 
+        return true; 
+      break; 
+    case lltok::kw_attributes: 
+      if (parseUnnamedAttrGrp()) 
+        return true; 
+      break; 
+    case lltok::kw_uselistorder: 
+      if (parseUseListOrder()) 
+        return true; 
+      break; 
     case lltok::kw_uselistorder_bb:
-      if (parseUseListOrderBB())
+      if (parseUseListOrderBB()) 
         return true;
       break;
     }
@@ -407,14 +407,14 @@ bool LLParser::parseTopLevelEntities() {
 
 /// toplevelentity
 ///   ::= 'module' 'asm' STRINGCONSTANT
-bool LLParser::parseModuleAsm() {
+bool LLParser::parseModuleAsm() { 
   assert(Lex.getKind() == lltok::kw_module);
   Lex.Lex();
 
   std::string AsmStr;
-  if (parseToken(lltok::kw_asm, "expected 'module asm'") ||
-      parseStringConstant(AsmStr))
-    return true;
+  if (parseToken(lltok::kw_asm, "expected 'module asm'") || 
+      parseStringConstant(AsmStr)) 
+    return true; 
 
   M->appendModuleInlineAsm(AsmStr);
   return false;
@@ -423,23 +423,23 @@ bool LLParser::parseModuleAsm() {
 /// toplevelentity
 ///   ::= 'target' 'triple' '=' STRINGCONSTANT
 ///   ::= 'target' 'datalayout' '=' STRINGCONSTANT
-bool LLParser::parseTargetDefinition() {
+bool LLParser::parseTargetDefinition() { 
   assert(Lex.getKind() == lltok::kw_target);
   std::string Str;
   switch (Lex.Lex()) {
-  default:
-    return tokError("unknown target property");
+  default: 
+    return tokError("unknown target property"); 
   case lltok::kw_triple:
     Lex.Lex();
-    if (parseToken(lltok::equal, "expected '=' after target triple") ||
-        parseStringConstant(Str))
+    if (parseToken(lltok::equal, "expected '=' after target triple") || 
+        parseStringConstant(Str)) 
       return true;
     M->setTargetTriple(Str);
     return false;
   case lltok::kw_datalayout:
     Lex.Lex();
-    if (parseToken(lltok::equal, "expected '=' after target datalayout") ||
-        parseStringConstant(Str))
+    if (parseToken(lltok::equal, "expected '=' after target datalayout") || 
+        parseStringConstant(Str)) 
       return true;
     M->setDataLayout(Str);
     return false;
@@ -448,11 +448,11 @@ bool LLParser::parseTargetDefinition() {
 
 /// toplevelentity
 ///   ::= 'source_filename' '=' STRINGCONSTANT
-bool LLParser::parseSourceFileName() {
+bool LLParser::parseSourceFileName() { 
   assert(Lex.getKind() == lltok::kw_source_filename);
   Lex.Lex();
-  if (parseToken(lltok::equal, "expected '=' after source_filename") ||
-      parseStringConstant(SourceFileName))
+  if (parseToken(lltok::equal, "expected '=' after source_filename") || 
+      parseStringConstant(SourceFileName)) 
     return true;
   if (M)
     M->setSourceFileName(SourceFileName);
@@ -463,11 +463,11 @@ bool LLParser::parseSourceFileName() {
 ///   ::= 'deplibs' '=' '[' ']'
 ///   ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
 /// FIXME: Remove in 4.0. Currently parse, but ignore.
-bool LLParser::parseDepLibs() {
+bool LLParser::parseDepLibs() { 
   assert(Lex.getKind() == lltok::kw_deplibs);
   Lex.Lex();
-  if (parseToken(lltok::equal, "expected '=' after deplibs") ||
-      parseToken(lltok::lsquare, "expected '=' after deplibs"))
+  if (parseToken(lltok::equal, "expected '=' after deplibs") || 
+      parseToken(lltok::lsquare, "expected '=' after deplibs")) 
     return true;
 
   if (EatIfPresent(lltok::rsquare))
@@ -475,32 +475,32 @@ bool LLParser::parseDepLibs() {
 
   do {
     std::string Str;
-    if (parseStringConstant(Str))
-      return true;
+    if (parseStringConstant(Str)) 
+      return true; 
   } while (EatIfPresent(lltok::comma));
 
-  return parseToken(lltok::rsquare, "expected ']' at end of list");
+  return parseToken(lltok::rsquare, "expected ']' at end of list"); 
 }
 
-/// parseUnnamedType:
+/// parseUnnamedType: 
 ///   ::= LocalVarID '=' 'type' type
-bool LLParser::parseUnnamedType() {
+bool LLParser::parseUnnamedType() { 
   LocTy TypeLoc = Lex.getLoc();
   unsigned TypeID = Lex.getUIntVal();
   Lex.Lex(); // eat LocalVarID;
 
-  if (parseToken(lltok::equal, "expected '=' after name") ||
-      parseToken(lltok::kw_type, "expected 'type' after '='"))
+  if (parseToken(lltok::equal, "expected '=' after name") || 
+      parseToken(lltok::kw_type, "expected 'type' after '='")) 
     return true;
 
   Type *Result = nullptr;
-  if (parseStructDefinition(TypeLoc, "", NumberedTypes[TypeID], Result))
-    return true;
+  if (parseStructDefinition(TypeLoc, "", NumberedTypes[TypeID], Result)) 
+    return true; 
 
   if (!isa<StructType>(Result)) {
     std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
     if (Entry.first)
-      return error(TypeLoc, "non-struct types may not be recursive");
+      return error(TypeLoc, "non-struct types may not be recursive"); 
     Entry.first = Result;
     Entry.second = SMLoc();
   }
@@ -510,23 +510,23 @@ bool LLParser::parseUnnamedType() {
 
 /// toplevelentity
 ///   ::= LocalVar '=' 'type' type
-bool LLParser::parseNamedType() {
+bool LLParser::parseNamedType() { 
   std::string Name = Lex.getStrVal();
   LocTy NameLoc = Lex.getLoc();
   Lex.Lex();  // eat LocalVar.
 
-  if (parseToken(lltok::equal, "expected '=' after name") ||
-      parseToken(lltok::kw_type, "expected 'type' after name"))
+  if (parseToken(lltok::equal, "expected '=' after name") || 
+      parseToken(lltok::kw_type, "expected 'type' after name")) 
     return true;
 
   Type *Result = nullptr;
-  if (parseStructDefinition(NameLoc, Name, NamedTypes[Name], Result))
-    return true;
+  if (parseStructDefinition(NameLoc, Name, NamedTypes[Name], Result)) 
+    return true; 
 
   if (!isa<StructType>(Result)) {
     std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
     if (Entry.first)
-      return error(NameLoc, "non-struct types may not be recursive");
+      return error(NameLoc, "non-struct types may not be recursive"); 
     Entry.first = Result;
     Entry.second = SMLoc();
   }
@@ -536,7 +536,7 @@ bool LLParser::parseNamedType() {
 
 /// toplevelentity
 ///   ::= 'declare' FunctionHeader
-bool LLParser::parseDeclare() {
+bool LLParser::parseDeclare() { 
   assert(Lex.getKind() == lltok::kw_declare);
   Lex.Lex();
 
@@ -544,13 +544,13 @@ bool LLParser::parseDeclare() {
   while (Lex.getKind() == lltok::MetadataVar) {
     unsigned MDK;
     MDNode *N;
-    if (parseMetadataAttachment(MDK, N))
+    if (parseMetadataAttachment(MDK, N)) 
       return true;
     MDs.push_back({MDK, N});
   }
 
   Function *F;
-  if (parseFunctionHeader(F, false))
+  if (parseFunctionHeader(F, false)) 
     return true;
   for (auto &MD : MDs)
     F->addMetadata(MD.first, *MD.second);
@@ -559,32 +559,32 @@ bool LLParser::parseDeclare() {
 
 /// toplevelentity
 ///   ::= 'define' FunctionHeader (!dbg !56)* '{' ...
-bool LLParser::parseDefine() {
+bool LLParser::parseDefine() { 
   assert(Lex.getKind() == lltok::kw_define);
   Lex.Lex();
 
   Function *F;
-  return parseFunctionHeader(F, true) || parseOptionalFunctionMetadata(*F) ||
-         parseFunctionBody(*F);
+  return parseFunctionHeader(F, true) || parseOptionalFunctionMetadata(*F) || 
+         parseFunctionBody(*F); 
 }
 
-/// parseGlobalType
+/// parseGlobalType 
 ///   ::= 'constant'
 ///   ::= 'global'
-bool LLParser::parseGlobalType(bool &IsConstant) {
+bool LLParser::parseGlobalType(bool &IsConstant) { 
   if (Lex.getKind() == lltok::kw_constant)
     IsConstant = true;
   else if (Lex.getKind() == lltok::kw_global)
     IsConstant = false;
   else {
     IsConstant = false;
-    return tokError("expected 'global' or 'constant'");
+    return tokError("expected 'global' or 'constant'"); 
   }
   Lex.Lex();
   return false;
 }
 
-bool LLParser::parseOptionalUnnamedAddr(
+bool LLParser::parseOptionalUnnamedAddr( 
     GlobalVariable::UnnamedAddr &UnnamedAddr) {
   if (EatIfPresent(lltok::kw_unnamed_addr))
     UnnamedAddr = GlobalValue::UnnamedAddr::Global;
@@ -595,17 +595,17 @@ bool LLParser::parseOptionalUnnamedAddr(
   return false;
 }
 
-/// parseUnnamedGlobal:
+/// parseUnnamedGlobal: 
 ///   OptionalVisibility (ALIAS | IFUNC) ...
 ///   OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
 ///   OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 ///   GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
-///   GlobalID '=' OptionalLinkage OptionalPreemptionSpecifier
-///   OptionalVisibility
+///   GlobalID '=' OptionalLinkage OptionalPreemptionSpecifier 
+///   OptionalVisibility 
 ///                OptionalDLLStorageClass
 ///                                                     ...   -> global variable
-bool LLParser::parseUnnamedGlobal() {
+bool LLParser::parseUnnamedGlobal() { 
   unsigned VarID = NumberedVals.size();
   std::string Name;
   LocTy NameLoc = Lex.getLoc();
@@ -613,11 +613,11 @@ bool LLParser::parseUnnamedGlobal() {
   // Handle the GlobalID form.
   if (Lex.getKind() == lltok::GlobalID) {
     if (Lex.getUIntVal() != VarID)
-      return error(Lex.getLoc(),
-                   "variable expected to be numbered '%" + Twine(VarID) + "'");
+      return error(Lex.getLoc(), 
+                   "variable expected to be numbered '%" + Twine(VarID) + "'"); 
     Lex.Lex(); // eat GlobalID;
 
-    if (parseToken(lltok::equal, "expected '=' after name"))
+    if (parseToken(lltok::equal, "expected '=' after name")) 
       return true;
   }
 
@@ -626,25 +626,25 @@ bool LLParser::parseUnnamedGlobal() {
   bool DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
-  if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+  if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass, 
                            DSOLocal) ||
-      parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
+      parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr)) 
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
-    return parseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
+    return parseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility, 
                        DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
                              DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 }
 
-/// parseNamedGlobal:
+/// parseNamedGlobal: 
 ///   GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
 ///   GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
 ///                 OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
-bool LLParser::parseNamedGlobal() {
+bool LLParser::parseNamedGlobal() { 
   assert(Lex.getKind() == lltok::GlobalVar);
   LocTy NameLoc = Lex.getLoc();
   std::string Name = Lex.getStrVal();
@@ -655,14 +655,14 @@ bool LLParser::parseNamedGlobal() {
   bool DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
-  if (parseToken(lltok::equal, "expected '=' in global variable") ||
-      parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+  if (parseToken(lltok::equal, "expected '=' in global variable") || 
+      parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass, 
                            DSOLocal) ||
-      parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
+      parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr)) 
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
-    return parseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
+    return parseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility, 
                        DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
@@ -675,16 +675,16 @@ bool LLParser::parseComdat() {
   LocTy NameLoc = Lex.getLoc();
   Lex.Lex();
 
-  if (parseToken(lltok::equal, "expected '=' here"))
+  if (parseToken(lltok::equal, "expected '=' here")) 
     return true;
 
-  if (parseToken(lltok::kw_comdat, "expected comdat keyword"))
-    return tokError("expected comdat type");
+  if (parseToken(lltok::kw_comdat, "expected comdat keyword")) 
+    return tokError("expected comdat type"); 
 
   Comdat::SelectionKind SK;
   switch (Lex.getKind()) {
   default:
-    return tokError("unknown selection kind");
+    return tokError("unknown selection kind"); 
   case lltok::kw_any:
     SK = Comdat::Any;
     break;
@@ -707,7 +707,7 @@ bool LLParser::parseComdat() {
   Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
   Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
   if (I != ComdatSymTab.end() && !ForwardRefComdats.erase(Name))
-    return error(NameLoc, "redefinition of comdat '$" + Name + "'");
+    return error(NameLoc, "redefinition of comdat '$" + Name + "'"); 
 
   Comdat *C;
   if (I != ComdatSymTab.end())
@@ -721,21 +721,21 @@ bool LLParser::parseComdat() {
 
 // MDString:
 //   ::= '!' STRINGCONSTANT
-bool LLParser::parseMDString(MDString *&Result) {
+bool LLParser::parseMDString(MDString *&Result) { 
   std::string Str;
-  if (parseStringConstant(Str))
-    return true;
+  if (parseStringConstant(Str)) 
+    return true; 
   Result = MDString::get(Context, Str);
   return false;
 }
 
 // MDNode:
 //   ::= '!' MDNodeNumber
-bool LLParser::parseMDNodeID(MDNode *&Result) {
+bool LLParser::parseMDNodeID(MDNode *&Result) { 
   // !{ ..., !42, ... }
   LocTy IDLoc = Lex.getLoc();
   unsigned MID = 0;
-  if (parseUInt32(MID))
+  if (parseUInt32(MID)) 
     return true;
 
   // If not a forward reference, just return it now.
@@ -753,60 +753,60 @@ bool LLParser::parseMDNodeID(MDNode *&Result) {
   return false;
 }
 
-/// parseNamedMetadata:
+/// parseNamedMetadata: 
 ///   !foo = !{ !1, !2 }
-bool LLParser::parseNamedMetadata() {
+bool LLParser::parseNamedMetadata() { 
   assert(Lex.getKind() == lltok::MetadataVar);
   std::string Name = Lex.getStrVal();
   Lex.Lex();
 
-  if (parseToken(lltok::equal, "expected '=' here") ||
-      parseToken(lltok::exclaim, "Expected '!' here") ||
-      parseToken(lltok::lbrace, "Expected '{' here"))
+  if (parseToken(lltok::equal, "expected '=' here") || 
+      parseToken(lltok::exclaim, "Expected '!' here") || 
+      parseToken(lltok::lbrace, "Expected '{' here")) 
     return true;
 
   NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
   if (Lex.getKind() != lltok::rbrace)
     do {
       MDNode *N = nullptr;
-      // parse DIExpressions inline as a special case. They are still MDNodes,
+      // parse DIExpressions inline as a special case. They are still MDNodes, 
       // so they can still appear in named metadata. Remove this logic if they
       // become plain Metadata.
       if (Lex.getKind() == lltok::MetadataVar &&
           Lex.getStrVal() == "DIExpression") {
-        if (parseDIExpression(N, /*IsDistinct=*/false))
+        if (parseDIExpression(N, /*IsDistinct=*/false)) 
           return true;
-      } else if (parseToken(lltok::exclaim, "Expected '!' here") ||
-                 parseMDNodeID(N)) {
+      } else if (parseToken(lltok::exclaim, "Expected '!' here") || 
+                 parseMDNodeID(N)) { 
         return true;
       }
       NMD->addOperand(N);
     } while (EatIfPresent(lltok::comma));
 
-  return parseToken(lltok::rbrace, "expected end of metadata node");
+  return parseToken(lltok::rbrace, "expected end of metadata node"); 
 }
 
-/// parseStandaloneMetadata:
+/// parseStandaloneMetadata: 
 ///   !42 = !{...}
-bool LLParser::parseStandaloneMetadata() {
+bool LLParser::parseStandaloneMetadata() { 
   assert(Lex.getKind() == lltok::exclaim);
   Lex.Lex();
   unsigned MetadataID = 0;
 
   MDNode *Init;
-  if (parseUInt32(MetadataID) || parseToken(lltok::equal, "expected '=' here"))
+  if (parseUInt32(MetadataID) || parseToken(lltok::equal, "expected '=' here")) 
     return true;
 
   // Detect common error, from old metadata syntax.
   if (Lex.getKind() == lltok::Type)
-    return tokError("unexpected type in metadata definition");
+    return tokError("unexpected type in metadata definition"); 
 
   bool IsDistinct = EatIfPresent(lltok::kw_distinct);
   if (Lex.getKind() == lltok::MetadataVar) {
-    if (parseSpecializedMDNode(Init, IsDistinct))
+    if (parseSpecializedMDNode(Init, IsDistinct)) 
       return true;
-  } else if (parseToken(lltok::exclaim, "Expected '!' here") ||
-             parseMDTuple(Init, IsDistinct))
+  } else if (parseToken(lltok::exclaim, "Expected '!' here") || 
+             parseMDTuple(Init, IsDistinct)) 
     return true;
 
   // See if this was forward referenced, if so, handle it.
@@ -818,7 +818,7 @@ bool LLParser::parseStandaloneMetadata() {
     assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
   } else {
     if (NumberedMetadata.count(MetadataID))
-      return tokError("Metadata id is already used");
+      return tokError("Metadata id is already used"); 
     NumberedMetadata[MetadataID].reset(Init);
   }
 
@@ -826,25 +826,25 @@ bool LLParser::parseStandaloneMetadata() {
 }
 
 // Skips a single module summary entry.
-bool LLParser::skipModuleSummaryEntry() {
+bool LLParser::skipModuleSummaryEntry() { 
   // Each module summary entry consists of a tag for the entry
-  // type, followed by a colon, then the fields which may be surrounded by
-  // nested sets of parentheses. The "tag:" looks like a Label. Once parsing
-  // support is in place we will look for the tokens corresponding to the
-  // expected tags.
+  // type, followed by a colon, then the fields which may be surrounded by 
+  // nested sets of parentheses. The "tag:" looks like a Label. Once parsing 
+  // support is in place we will look for the tokens corresponding to the 
+  // expected tags. 
   if (Lex.getKind() != lltok::kw_gv && Lex.getKind() != lltok::kw_module &&
-      Lex.getKind() != lltok::kw_typeid && Lex.getKind() != lltok::kw_flags &&
-      Lex.getKind() != lltok::kw_blockcount)
-    return tokError(
-        "Expected 'gv', 'module', 'typeid', 'flags' or 'blockcount' at the "
-        "start of summary entry");
-  if (Lex.getKind() == lltok::kw_flags)
-    return parseSummaryIndexFlags();
-  if (Lex.getKind() == lltok::kw_blockcount)
-    return parseBlockCount();
+      Lex.getKind() != lltok::kw_typeid && Lex.getKind() != lltok::kw_flags && 
+      Lex.getKind() != lltok::kw_blockcount) 
+    return tokError( 
+        "Expected 'gv', 'module', 'typeid', 'flags' or 'blockcount' at the " 
+        "start of summary entry"); 
+  if (Lex.getKind() == lltok::kw_flags) 
+    return parseSummaryIndexFlags(); 
+  if (Lex.getKind() == lltok::kw_blockcount) 
+    return parseBlockCount(); 
   Lex.Lex();
-  if (parseToken(lltok::colon, "expected ':' at start of summary entry") ||
-      parseToken(lltok::lparen, "expected '(' at start of summary entry"))
+  if (parseToken(lltok::colon, "expected ':' at start of summary entry") || 
+      parseToken(lltok::lparen, "expected '(' at start of summary entry")) 
     return true;
   // Now walk through the parenthesized entry, until the number of open
   // parentheses goes back down to 0 (the first '(' was parsed above).
@@ -858,7 +858,7 @@ bool LLParser::skipModuleSummaryEntry() {
       NumOpenParen--;
       break;
     case lltok::Eof:
-      return tokError("found end of file while parsing summary entry");
+      return tokError("found end of file while parsing summary entry"); 
     default:
       // Skip everything in between parentheses.
       break;
@@ -870,7 +870,7 @@ bool LLParser::skipModuleSummaryEntry() {
 
 /// SummaryEntry
 ///   ::= SummaryID '=' GVEntry | ModuleEntry | TypeIdEntry
-bool LLParser::parseSummaryEntry() {
+bool LLParser::parseSummaryEntry() { 
   assert(Lex.getKind() == lltok::SummaryID);
   unsigned SummaryID = Lex.getUIntVal();
 
@@ -879,35 +879,35 @@ bool LLParser::parseSummaryEntry() {
   Lex.setIgnoreColonInIdentifiers(true);
 
   Lex.Lex();
-  if (parseToken(lltok::equal, "expected '=' here"))
+  if (parseToken(lltok::equal, "expected '=' here")) 
     return true;
 
   // If we don't have an index object, skip the summary entry.
   if (!Index)
-    return skipModuleSummaryEntry();
+    return skipModuleSummaryEntry(); 
 
   bool result = false;
   switch (Lex.getKind()) {
   case lltok::kw_gv:
-    result = parseGVEntry(SummaryID);
+    result = parseGVEntry(SummaryID); 
     break;
   case lltok::kw_module:
-    result = parseModuleEntry(SummaryID);
+    result = parseModuleEntry(SummaryID); 
     break;
   case lltok::kw_typeid:
-    result = parseTypeIdEntry(SummaryID);
+    result = parseTypeIdEntry(SummaryID); 
     break;
   case lltok::kw_typeidCompatibleVTable:
-    result = parseTypeIdCompatibleVtableEntry(SummaryID);
+    result = parseTypeIdCompatibleVtableEntry(SummaryID); 
     break;
   case lltok::kw_flags:
-    result = parseSummaryIndexFlags();
+    result = parseSummaryIndexFlags(); 
     break;
   case lltok::kw_blockcount:
-    result = parseBlockCount();
+    result = parseBlockCount(); 
     break;
   default:
-    result = error(Lex.getLoc(), "unexpected summary kind");
+    result = error(Lex.getLoc(), "unexpected summary kind"); 
     break;
   }
   Lex.setIgnoreColonInIdentifiers(false);
@@ -957,16 +957,16 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   GlobalValue::LinkageTypes Linkage = (GlobalValue::LinkageTypes) L;
 
   if(IsAlias && !GlobalAlias::isValidLinkage(Linkage))
-    return error(NameLoc, "invalid linkage type for alias");
+    return error(NameLoc, "invalid linkage type for alias"); 
 
   if (!isValidVisibilityForLinkage(Visibility, L))
-    return error(NameLoc,
+    return error(NameLoc, 
                  "symbol with local linkage must have default visibility");
 
   Type *Ty;
   LocTy ExplicitTypeLoc = Lex.getLoc();
-  if (parseType(Ty) ||
-      parseToken(lltok::comma, "expected comma after alias or ifunc's type"))
+  if (parseType(Ty) || 
+      parseToken(lltok::comma, "expected comma after alias or ifunc's type")) 
     return true;
 
   Constant *Aliasee;
@@ -975,31 +975,31 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
       Lex.getKind() != lltok::kw_getelementptr &&
       Lex.getKind() != lltok::kw_addrspacecast &&
       Lex.getKind() != lltok::kw_inttoptr) {
-    if (parseGlobalTypeAndValue(Aliasee))
+    if (parseGlobalTypeAndValue(Aliasee)) 
       return true;
   } else {
     // The bitcast dest type is not present, it is implied by the dest type.
     ValID ID;
-    if (parseValID(ID))
+    if (parseValID(ID)) 
       return true;
     if (ID.Kind != ValID::t_Constant)
-      return error(AliaseeLoc, "invalid aliasee");
+      return error(AliaseeLoc, "invalid aliasee"); 
     Aliasee = ID.ConstantVal;
   }
 
   Type *AliaseeType = Aliasee->getType();
   auto *PTy = dyn_cast<PointerType>(AliaseeType);
   if (!PTy)
-    return error(AliaseeLoc, "An alias or ifunc must have pointer type");
+    return error(AliaseeLoc, "An alias or ifunc must have pointer type"); 
   unsigned AddrSpace = PTy->getAddressSpace();
 
   if (IsAlias && Ty != PTy->getElementType())
-    return error(ExplicitTypeLoc,
-                 "explicit pointee type doesn't match operand's pointee type");
+    return error(ExplicitTypeLoc, 
+                 "explicit pointee type doesn't match operand's pointee type"); 
 
   if (!IsAlias && !PTy->getElementType()->isFunctionTy())
-    return error(ExplicitTypeLoc,
-                 "explicit pointee type should be a function type");
+    return error(ExplicitTypeLoc, 
+                 "explicit pointee type should be a function type"); 
 
   GlobalValue *GVal = nullptr;
 
@@ -1009,7 +1009,7 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
     GVal = M->getNamedValue(Name);
     if (GVal) {
       if (!ForwardRefVals.erase(Name))
-        return error(NameLoc, "redefinition of global '@" + Name + "'");
+        return error(NameLoc, "redefinition of global '@" + Name + "'"); 
     }
   } else {
     auto I = ForwardRefValIDs.find(NumberedVals.size());
@@ -1043,10 +1043,10 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
     if (Lex.getKind() == lltok::kw_partition) {
       Lex.Lex();
       GA->setPartition(Lex.getStrVal());
-      if (parseToken(lltok::StringConstant, "expected partition string"))
+      if (parseToken(lltok::StringConstant, "expected partition string")) 
         return true;
     } else {
-      return tokError("unknown alias or ifunc property!");
+      return tokError("unknown alias or ifunc property!"); 
     }
   }
 
@@ -1056,7 +1056,7 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   if (GVal) {
     // Verify that types agree.
     if (GVal->getType() != GA->getType())
-      return error(
+      return error( 
           ExplicitTypeLoc,
           "forward reference and definition of alias have different types");
 
@@ -1079,7 +1079,7 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   return false;
 }
 
-/// parseGlobal
+/// parseGlobal 
 ///   ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
 ///       OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
@@ -1092,13 +1092,13 @@ bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.
 ///
-bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
+bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc, 
                            unsigned Linkage, bool HasLinkage,
                            unsigned Visibility, unsigned DLLStorageClass,
                            bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
                            GlobalVariable::UnnamedAddr UnnamedAddr) {
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
-    return error(NameLoc,
+    return error(NameLoc, 
                  "symbol with local linkage must have default visibility");
 
   unsigned AddrSpace;
@@ -1107,11 +1107,11 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
   LocTy TyLoc;
 
   Type *Ty = nullptr;
-  if (parseOptionalAddrSpace(AddrSpace) ||
-      parseOptionalToken(lltok::kw_externally_initialized,
+  if (parseOptionalAddrSpace(AddrSpace) || 
+      parseOptionalToken(lltok::kw_externally_initialized, 
                          IsExternallyInitialized,
                          &IsExternallyInitializedLoc) ||
-      parseGlobalType(IsConstant) || parseType(Ty, TyLoc))
+      parseGlobalType(IsConstant) || parseType(Ty, TyLoc)) 
     return true;
 
   // If the linkage is specified and is external, then no initializer is
@@ -1120,12 +1120,12 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
   if (!HasLinkage ||
       !GlobalValue::isValidDeclarationLinkage(
           (GlobalValue::LinkageTypes)Linkage)) {
-    if (parseGlobalValue(Ty, Init))
+    if (parseGlobalValue(Ty, Init)) 
       return true;
   }
 
   if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
-    return error(TyLoc, "invalid type for global variable");
+    return error(TyLoc, "invalid type for global variable"); 
 
   GlobalValue *GVal = nullptr;
 
@@ -1134,7 +1134,7 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
     GVal = M->getNamedValue(Name);
     if (GVal) {
       if (!ForwardRefVals.erase(Name))
-        return error(NameLoc, "redefinition of global '@" + Name + "'");
+        return error(NameLoc, "redefinition of global '@" + Name + "'"); 
     }
   } else {
     auto I = ForwardRefValIDs.find(NumberedVals.size());
@@ -1151,9 +1151,9 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
                             AddrSpace);
   } else {
     if (GVal->getValueType() != Ty)
-      return error(
-          TyLoc,
-          "forward reference and definition of global have different types");
+      return error( 
+          TyLoc, 
+          "forward reference and definition of global have different types"); 
 
     GV = cast<GlobalVariable>(GVal);
 
@@ -1176,27 +1176,27 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
   GV->setThreadLocalMode(TLM);
   GV->setUnnamedAddr(UnnamedAddr);
 
-  // parse attributes on the global.
+  // parse attributes on the global. 
   while (Lex.getKind() == lltok::comma) {
     Lex.Lex();
 
     if (Lex.getKind() == lltok::kw_section) {
       Lex.Lex();
       GV->setSection(Lex.getStrVal());
-      if (parseToken(lltok::StringConstant, "expected global section string"))
+      if (parseToken(lltok::StringConstant, "expected global section string")) 
         return true;
     } else if (Lex.getKind() == lltok::kw_partition) {
       Lex.Lex();
       GV->setPartition(Lex.getStrVal());
-      if (parseToken(lltok::StringConstant, "expected partition string"))
+      if (parseToken(lltok::StringConstant, "expected partition string")) 
         return true;
     } else if (Lex.getKind() == lltok::kw_align) {
       MaybeAlign Alignment;
-      if (parseOptionalAlignment(Alignment))
-        return true;
+      if (parseOptionalAlignment(Alignment)) 
+        return true; 
       GV->setAlignment(Alignment);
     } else if (Lex.getKind() == lltok::MetadataVar) {
-      if (parseGlobalObjectMetadataAttachment(*GV))
+      if (parseGlobalObjectMetadataAttachment(*GV)) 
         return true;
     } else {
       Comdat *C;
@@ -1205,14 +1205,14 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
       if (C)
         GV->setComdat(C);
       else
-        return tokError("unknown global variable property!");
+        return tokError("unknown global variable property!"); 
     }
   }
 
   AttrBuilder Attrs;
   LocTy BuiltinLoc;
   std::vector<unsigned> FwdRefAttrGrps;
-  if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc))
+  if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc)) 
     return true;
   if (Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
     GV->setAttributes(AttributeSet::get(Context, Attrs));
@@ -1222,37 +1222,37 @@ bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
   return false;
 }
 
-/// parseUnnamedAttrGrp
+/// parseUnnamedAttrGrp 
 ///   ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
-bool LLParser::parseUnnamedAttrGrp() {
+bool LLParser::parseUnnamedAttrGrp() { 
   assert(Lex.getKind() == lltok::kw_attributes);
   LocTy AttrGrpLoc = Lex.getLoc();
   Lex.Lex();
 
   if (Lex.getKind() != lltok::AttrGrpID)
-    return tokError("expected attribute group id");
+    return tokError("expected attribute group id"); 
 
   unsigned VarID = Lex.getUIntVal();
   std::vector<unsigned> unused;
   LocTy BuiltinLoc;
   Lex.Lex();
 
-  if (parseToken(lltok::equal, "expected '=' here") ||
-      parseToken(lltok::lbrace, "expected '{' here") ||
-      parseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true,
+  if (parseToken(lltok::equal, "expected '=' here") || 
+      parseToken(lltok::lbrace, "expected '{' here") || 
+      parseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true, 
                                  BuiltinLoc) ||
-      parseToken(lltok::rbrace, "expected end of attribute group"))
+      parseToken(lltok::rbrace, "expected end of attribute group")) 
     return true;
 
   if (!NumberedAttrBuilders[VarID].hasAttributes())
-    return error(AttrGrpLoc, "attribute group has no attributes");
+    return error(AttrGrpLoc, "attribute group has no attributes"); 
 
   return false;
 }
 
-/// parseFnAttributeValuePairs
+/// parseFnAttributeValuePairs 
 ///   ::= <attr> | <attr> '=' <value>
-bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
+bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B, 
                                           std::vector<unsigned> &FwdRefAttrGrps,
                                           bool inAttrGrp, LocTy &BuiltinLoc) {
   bool HaveError = false;
@@ -1266,7 +1266,7 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     switch (Token) {
     default:
       if (!inAttrGrp) return HaveError;
-      return error(Lex.getLoc(), "unterminated attribute group");
+      return error(Lex.getLoc(), "unterminated attribute group"); 
     case lltok::rbrace:
       // Finished.
       return false;
@@ -1276,9 +1276,9 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
       //
       //   define void @foo() #1 { ... }
       if (inAttrGrp)
-        HaveError |= error(
-            Lex.getLoc(),
-            "cannot have an attribute group reference in an attribute group");
+        HaveError |= error( 
+            Lex.getLoc(), 
+            "cannot have an attribute group reference in an attribute group"); 
 
       unsigned AttrGrpNum = Lex.getUIntVal();
       if (inAttrGrp) break;
@@ -1289,7 +1289,7 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     }
     // Target-dependent attributes:
     case lltok::StringConstant: {
-      if (parseStringAttribute(B))
+      if (parseStringAttribute(B)) 
         return true;
       continue;
     }
@@ -1303,11 +1303,11 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
       if (inAttrGrp) {
         Lex.Lex();
         uint32_t Value = 0;
-        if (parseToken(lltok::equal, "expected '=' here") || parseUInt32(Value))
+        if (parseToken(lltok::equal, "expected '=' here") || parseUInt32(Value)) 
           return true;
         Alignment = Align(Value);
       } else {
-        if (parseOptionalAlignment(Alignment))
+        if (parseOptionalAlignment(Alignment)) 
           return true;
       }
       B.addAlignmentAttr(Alignment);
@@ -1317,11 +1317,11 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
       unsigned Alignment;
       if (inAttrGrp) {
         Lex.Lex();
-        if (parseToken(lltok::equal, "expected '=' here") ||
-            parseUInt32(Alignment))
+        if (parseToken(lltok::equal, "expected '=' here") || 
+            parseUInt32(Alignment)) 
           return true;
       } else {
-        if (parseOptionalStackAlignment(Alignment))
+        if (parseOptionalStackAlignment(Alignment)) 
           return true;
       }
       B.addStackAlignmentAttr(Alignment);
@@ -1340,7 +1340,7 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     case lltok::kw_argmemonly: B.addAttribute(Attribute::ArgMemOnly); break;
     case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;
     case lltok::kw_cold: B.addAttribute(Attribute::Cold); break;
-    case lltok::kw_hot: B.addAttribute(Attribute::Hot); break;
+    case lltok::kw_hot: B.addAttribute(Attribute::Hot); break; 
     case lltok::kw_convergent: B.addAttribute(Attribute::Convergent); break;
     case lltok::kw_inaccessiblememonly:
       B.addAttribute(Attribute::InaccessibleMemOnly); break;
@@ -1349,14 +1349,14 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
     case lltok::kw_jumptable: B.addAttribute(Attribute::JumpTable); break;
     case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
-    case lltok::kw_mustprogress:
-      B.addAttribute(Attribute::MustProgress);
-      break;
+    case lltok::kw_mustprogress: 
+      B.addAttribute(Attribute::MustProgress); 
+      break; 
     case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
     case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
-    case lltok::kw_nocallback:
-      B.addAttribute(Attribute::NoCallback);
-      break;
+    case lltok::kw_nocallback: 
+      B.addAttribute(Attribute::NoCallback); 
+      break; 
     case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
     case lltok::kw_nofree: B.addAttribute(Attribute::NoFree); break;
     case lltok::kw_noimplicitfloat:
@@ -1368,7 +1368,7 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
     case lltok::kw_nosync: B.addAttribute(Attribute::NoSync); break;
     case lltok::kw_nocf_check: B.addAttribute(Attribute::NoCfCheck); break;
-    case lltok::kw_noprofile: B.addAttribute(Attribute::NoProfile); break;
+    case lltok::kw_noprofile: B.addAttribute(Attribute::NoProfile); break; 
     case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break;
     case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
     case lltok::kw_null_pointer_is_valid:
@@ -1408,18 +1408,18 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
     case lltok::kw_preallocated: {
       Type *Ty;
-      if (parsePreallocated(Ty))
+      if (parsePreallocated(Ty)) 
         return true;
       B.addPreallocatedAttr(Ty);
       break;
     }
 
-    // error handling.
+    // error handling. 
     case lltok::kw_inreg:
     case lltok::kw_signext:
     case lltok::kw_zeroext:
       HaveError |=
-          error(Lex.getLoc(), "invalid use of attribute on a function");
+          error(Lex.getLoc(), "invalid use of attribute on a function"); 
       break;
     case lltok::kw_byval:
     case lltok::kw_dereferenceable:
@@ -1435,14 +1435,14 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
     case lltok::kw_swifterror:
     case lltok::kw_swiftself:
     case lltok::kw_immarg:
-    case lltok::kw_byref:
+    case lltok::kw_byref: 
       HaveError |=
-          error(Lex.getLoc(),
-                "invalid use of parameter-only attribute on a function");
+          error(Lex.getLoc(), 
+                "invalid use of parameter-only attribute on a function"); 
       break;
     }
 
-    // parsePreallocated() consumes token
+    // parsePreallocated() consumes token 
     if (Token != lltok::kw_preallocated)
       Lex.Lex();
   }
@@ -1478,22 +1478,22 @@ Value *LLParser::checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
       return Val;
   }
   if (Ty->isLabelTy())
-    error(Loc, "'" + Name + "' is not a basic block");
+    error(Loc, "'" + Name + "' is not a basic block"); 
   else
-    error(Loc, "'" + Name + "' defined with type '" +
+    error(Loc, "'" + Name + "' defined with type '" + 
                    getTypeString(Val->getType()) + "' but expected '" +
                    getTypeString(SuggestedTy) + "'");
   return nullptr;
 }
 
-/// getGlobalVal - Get a value with the specified name or ID, creating a
+/// getGlobalVal - Get a value with the specified name or ID, creating a 
 /// forward reference record if needed.  This can return null if the value
 /// exists but does not have the right type.
-GlobalValue *LLParser::getGlobalVal(const std::string &Name, Type *Ty,
+GlobalValue *LLParser::getGlobalVal(const std::string &Name, Type *Ty, 
                                     LocTy Loc, bool IsCall) {
   PointerType *PTy = dyn_cast<PointerType>(Ty);
   if (!PTy) {
-    error(Loc, "global variable reference must have pointer type");
+    error(Loc, "global variable reference must have pointer type"); 
     return nullptr;
   }
 
@@ -1520,11 +1520,11 @@ GlobalValue *LLParser::getGlobalVal(const std::string &Name, Type *Ty,
   return FwdVal;
 }
 
-GlobalValue *LLParser::getGlobalVal(unsigned ID, Type *Ty, LocTy Loc,
+GlobalValue *LLParser::getGlobalVal(unsigned ID, Type *Ty, LocTy Loc, 
                                     bool IsCall) {
   PointerType *PTy = dyn_cast<PointerType>(Ty);
   if (!PTy) {
-    error(Loc, "global variable reference must have pointer type");
+    error(Loc, "global variable reference must have pointer type"); 
     return nullptr;
   }
 
@@ -1570,56 +1570,56 @@ Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
 // Helper Routines.
 //===----------------------------------------------------------------------===//
 
-/// parseToken - If the current token has the specified kind, eat it and return
+/// parseToken - If the current token has the specified kind, eat it and return 
 /// success.  Otherwise, emit the specified error and return failure.
-bool LLParser::parseToken(lltok::Kind T, const char *ErrMsg) {
+bool LLParser::parseToken(lltok::Kind T, const char *ErrMsg) { 
   if (Lex.getKind() != T)
-    return tokError(ErrMsg);
+    return tokError(ErrMsg); 
   Lex.Lex();
   return false;
 }
 
-/// parseStringConstant
+/// parseStringConstant 
 ///   ::= StringConstant
-bool LLParser::parseStringConstant(std::string &Result) {
+bool LLParser::parseStringConstant(std::string &Result) { 
   if (Lex.getKind() != lltok::StringConstant)
-    return tokError("expected string constant");
+    return tokError("expected string constant"); 
   Result = Lex.getStrVal();
   Lex.Lex();
   return false;
 }
 
-/// parseUInt32
+/// parseUInt32 
 ///   ::= uint32
-bool LLParser::parseUInt32(uint32_t &Val) {
+bool LLParser::parseUInt32(uint32_t &Val) { 
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
-    return tokError("expected integer");
+    return tokError("expected integer"); 
   uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
   if (Val64 != unsigned(Val64))
-    return tokError("expected 32-bit integer (too large)");
+    return tokError("expected 32-bit integer (too large)"); 
   Val = Val64;
   Lex.Lex();
   return false;
 }
 
-/// parseUInt64
+/// parseUInt64 
 ///   ::= uint64
-bool LLParser::parseUInt64(uint64_t &Val) {
+bool LLParser::parseUInt64(uint64_t &Val) { 
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
-    return tokError("expected integer");
+    return tokError("expected integer"); 
   Val = Lex.getAPSIntVal().getLimitedValue();
   Lex.Lex();
   return false;
 }
 
-/// parseTLSModel
+/// parseTLSModel 
 ///   := 'localdynamic'
 ///   := 'initialexec'
 ///   := 'localexec'
-bool LLParser::parseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
+bool LLParser::parseTLSModel(GlobalVariable::ThreadLocalMode &TLM) { 
   switch (Lex.getKind()) {
     default:
-      return tokError("expected localdynamic, initialexec or localexec");
+      return tokError("expected localdynamic, initialexec or localexec"); 
     case lltok::kw_localdynamic:
       TLM = GlobalVariable::LocalDynamicTLSModel;
       break;
@@ -1635,11 +1635,11 @@ bool LLParser::parseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
   return false;
 }
 
-/// parseOptionalThreadLocal
+/// parseOptionalThreadLocal 
 ///   := /*empty*/
 ///   := 'thread_local'
 ///   := 'thread_local' '(' tlsmodel ')'
-bool LLParser::parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
+bool LLParser::parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) { 
   TLM = GlobalVariable::NotThreadLocal;
   if (!EatIfPresent(lltok::kw_thread_local))
     return false;
@@ -1647,40 +1647,40 @@ bool LLParser::parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
   TLM = GlobalVariable::GeneralDynamicTLSModel;
   if (Lex.getKind() == lltok::lparen) {
     Lex.Lex();
-    return parseTLSModel(TLM) ||
-           parseToken(lltok::rparen, "expected ')' after thread local model");
+    return parseTLSModel(TLM) || 
+           parseToken(lltok::rparen, "expected ')' after thread local model"); 
   }
   return false;
 }
 
-/// parseOptionalAddrSpace
+/// parseOptionalAddrSpace 
 ///   := /*empty*/
 ///   := 'addrspace' '(' uint32 ')'
-bool LLParser::parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS) {
+bool LLParser::parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS) { 
   AddrSpace = DefaultAS;
   if (!EatIfPresent(lltok::kw_addrspace))
     return false;
-  return parseToken(lltok::lparen, "expected '(' in address space") ||
-         parseUInt32(AddrSpace) ||
-         parseToken(lltok::rparen, "expected ')' in address space");
+  return parseToken(lltok::lparen, "expected '(' in address space") || 
+         parseUInt32(AddrSpace) || 
+         parseToken(lltok::rparen, "expected ')' in address space"); 
 }
 
-/// parseStringAttribute
+/// parseStringAttribute 
 ///   := StringConstant
 ///   := StringConstant '=' StringConstant
-bool LLParser::parseStringAttribute(AttrBuilder &B) {
+bool LLParser::parseStringAttribute(AttrBuilder &B) { 
   std::string Attr = Lex.getStrVal();
   Lex.Lex();
   std::string Val;
-  if (EatIfPresent(lltok::equal) && parseStringConstant(Val))
+  if (EatIfPresent(lltok::equal) && parseStringConstant(Val)) 
     return true;
   B.addAttribute(Attr, Val);
   return false;
 }
 
-/// parseOptionalParamAttrs - parse a potentially empty list of parameter
-/// attributes.
-bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
+/// parseOptionalParamAttrs - parse a potentially empty list of parameter 
+/// attributes. 
+bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) { 
   bool HaveError = false;
 
   B.clear();
@@ -1691,59 +1691,59 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
     default:  // End of attributes.
       return HaveError;
     case lltok::StringConstant: {
-      if (parseStringAttribute(B))
+      if (parseStringAttribute(B)) 
         return true;
       continue;
     }
     case lltok::kw_align: {
       MaybeAlign Alignment;
-      if (parseOptionalAlignment(Alignment, true))
+      if (parseOptionalAlignment(Alignment, true)) 
         return true;
       B.addAlignmentAttr(Alignment);
       continue;
     }
     case lltok::kw_byval: {
       Type *Ty;
-      if (parseRequiredTypeAttr(Ty, lltok::kw_byval))
+      if (parseRequiredTypeAttr(Ty, lltok::kw_byval)) 
         return true;
       B.addByValAttr(Ty);
       continue;
     }
-    case lltok::kw_sret: {
-      Type *Ty;
-      if (parseRequiredTypeAttr(Ty, lltok::kw_sret))
-        return true;
-      B.addStructRetAttr(Ty);
-      continue;
-    }
+    case lltok::kw_sret: { 
+      Type *Ty; 
+      if (parseRequiredTypeAttr(Ty, lltok::kw_sret)) 
+        return true; 
+      B.addStructRetAttr(Ty); 
+      continue; 
+    } 
     case lltok::kw_preallocated: {
       Type *Ty;
-      if (parsePreallocated(Ty))
+      if (parsePreallocated(Ty)) 
         return true;
       B.addPreallocatedAttr(Ty);
       continue;
     }
     case lltok::kw_dereferenceable: {
       uint64_t Bytes;
-      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
+      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes)) 
         return true;
       B.addDereferenceableAttr(Bytes);
       continue;
     }
     case lltok::kw_dereferenceable_or_null: {
       uint64_t Bytes;
-      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
+      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes)) 
         return true;
       B.addDereferenceableOrNullAttr(Bytes);
       continue;
     }
-    case lltok::kw_byref: {
-      Type *Ty;
-      if (parseByRef(Ty))
-        return true;
-      B.addByRefAttr(Ty);
-      continue;
-    }
+    case lltok::kw_byref: { 
+      Type *Ty; 
+      if (parseByRef(Ty)) 
+        return true; 
+      B.addByRefAttr(Ty); 
+      continue; 
+    } 
     case lltok::kw_inalloca:        B.addAttribute(Attribute::InAlloca); break;
     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
     case lltok::kw_nest:            B.addAttribute(Attribute::Nest); break;
@@ -1771,7 +1771,7 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
     case lltok::kw_inlinehint:
     case lltok::kw_jumptable:
     case lltok::kw_minsize:
-    case lltok::kw_mustprogress:
+    case lltok::kw_mustprogress: 
     case lltok::kw_naked:
     case lltok::kw_nobuiltin:
     case lltok::kw_noduplicate:
@@ -1779,7 +1779,7 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
     case lltok::kw_noinline:
     case lltok::kw_nonlazybind:
     case lltok::kw_nomerge:
-    case lltok::kw_noprofile:
+    case lltok::kw_noprofile: 
     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
     case lltok::kw_nocf_check:
@@ -1801,8 +1801,8 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
     case lltok::kw_shadowcallstack:
     case lltok::kw_strictfp:
     case lltok::kw_uwtable:
-      HaveError |=
-          error(Lex.getLoc(), "invalid use of function-only attribute");
+      HaveError |= 
+          error(Lex.getLoc(), "invalid use of function-only attribute"); 
       break;
     }
 
@@ -1810,9 +1810,9 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
   }
 }
 
-/// parseOptionalReturnAttrs - parse a potentially empty list of return
-/// attributes.
-bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
+/// parseOptionalReturnAttrs - parse a potentially empty list of return 
+/// attributes. 
+bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) { 
   bool HaveError = false;
 
   B.clear();
@@ -1823,27 +1823,27 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
     default:  // End of attributes.
       return HaveError;
     case lltok::StringConstant: {
-      if (parseStringAttribute(B))
+      if (parseStringAttribute(B)) 
         return true;
       continue;
     }
     case lltok::kw_dereferenceable: {
       uint64_t Bytes;
-      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
+      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes)) 
         return true;
       B.addDereferenceableAttr(Bytes);
       continue;
     }
     case lltok::kw_dereferenceable_or_null: {
       uint64_t Bytes;
-      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
+      if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes)) 
         return true;
       B.addDereferenceableOrNullAttr(Bytes);
       continue;
     }
     case lltok::kw_align: {
       MaybeAlign Alignment;
-      if (parseOptionalAlignment(Alignment))
+      if (parseOptionalAlignment(Alignment)) 
         return true;
       B.addAlignmentAttr(Alignment);
       continue;
@@ -1857,7 +1857,7 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
     case lltok::kw_signext:         B.addAttribute(Attribute::SExt); break;
     case lltok::kw_zeroext:         B.addAttribute(Attribute::ZExt); break;
 
-    // error handling.
+    // error handling. 
     case lltok::kw_byval:
     case lltok::kw_inalloca:
     case lltok::kw_nest:
@@ -1867,9 +1867,9 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
     case lltok::kw_swifterror:
     case lltok::kw_swiftself:
     case lltok::kw_immarg:
-    case lltok::kw_byref:
-      HaveError |=
-          error(Lex.getLoc(), "invalid use of parameter-only attribute");
+    case lltok::kw_byref: 
+      HaveError |= 
+          error(Lex.getLoc(), "invalid use of parameter-only attribute"); 
       break;
 
     case lltok::kw_alignstack:
@@ -1880,7 +1880,7 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
     case lltok::kw_inlinehint:
     case lltok::kw_jumptable:
     case lltok::kw_minsize:
-    case lltok::kw_mustprogress:
+    case lltok::kw_mustprogress: 
     case lltok::kw_naked:
     case lltok::kw_nobuiltin:
     case lltok::kw_noduplicate:
@@ -1888,7 +1888,7 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
     case lltok::kw_noinline:
     case lltok::kw_nonlazybind:
     case lltok::kw_nomerge:
-    case lltok::kw_noprofile:
+    case lltok::kw_noprofile: 
     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
     case lltok::kw_nocf_check:
@@ -1910,17 +1910,17 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
     case lltok::kw_shadowcallstack:
     case lltok::kw_strictfp:
     case lltok::kw_uwtable:
-      HaveError |=
-          error(Lex.getLoc(), "invalid use of function-only attribute");
+      HaveError |= 
+          error(Lex.getLoc(), "invalid use of function-only attribute"); 
       break;
     case lltok::kw_readnone:
     case lltok::kw_readonly:
-      HaveError |=
-          error(Lex.getLoc(), "invalid use of attribute on return type");
+      HaveError |= 
+          error(Lex.getLoc(), "invalid use of attribute on return type"); 
       break;
     case lltok::kw_preallocated:
       HaveError |=
-          error(Lex.getLoc(),
+          error(Lex.getLoc(), 
                 "invalid use of parameter-only/call site-only attribute");
       break;
     }
@@ -1960,7 +1960,7 @@ static unsigned parseOptionalLinkageAux(lltok::Kind Kind, bool &HasLinkage) {
   }
 }
 
-/// parseOptionalLinkage
+/// parseOptionalLinkage 
 ///   ::= /*empty*/
 ///   ::= 'private'
 ///   ::= 'internal'
@@ -1973,24 +1973,24 @@ static unsigned parseOptionalLinkageAux(lltok::Kind Kind, bool &HasLinkage) {
 ///   ::= 'common'
 ///   ::= 'extern_weak'
 ///   ::= 'external'
-bool LLParser::parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
+bool LLParser::parseOptionalLinkage(unsigned &Res, bool &HasLinkage, 
                                     unsigned &Visibility,
-                                    unsigned &DLLStorageClass, bool &DSOLocal) {
+                                    unsigned &DLLStorageClass, bool &DSOLocal) { 
   Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
   if (HasLinkage)
     Lex.Lex();
-  parseOptionalDSOLocal(DSOLocal);
-  parseOptionalVisibility(Visibility);
-  parseOptionalDLLStorageClass(DLLStorageClass);
+  parseOptionalDSOLocal(DSOLocal); 
+  parseOptionalVisibility(Visibility); 
+  parseOptionalDLLStorageClass(DLLStorageClass); 
 
   if (DSOLocal && DLLStorageClass == GlobalValue::DLLImportStorageClass) {
-    return error(Lex.getLoc(), "dso_location and DLL-StorageClass mismatch");
+    return error(Lex.getLoc(), "dso_location and DLL-StorageClass mismatch"); 
   }
 
   return false;
 }
 
-void LLParser::parseOptionalDSOLocal(bool &DSOLocal) {
+void LLParser::parseOptionalDSOLocal(bool &DSOLocal) { 
   switch (Lex.getKind()) {
   default:
     DSOLocal = false;
@@ -2006,13 +2006,13 @@ void LLParser::parseOptionalDSOLocal(bool &DSOLocal) {
   }
 }
 
-/// parseOptionalVisibility
+/// parseOptionalVisibility 
 ///   ::= /*empty*/
 ///   ::= 'default'
 ///   ::= 'hidden'
 ///   ::= 'protected'
 ///
-void LLParser::parseOptionalVisibility(unsigned &Res) {
+void LLParser::parseOptionalVisibility(unsigned &Res) { 
   switch (Lex.getKind()) {
   default:
     Res = GlobalValue::DefaultVisibility;
@@ -2030,12 +2030,12 @@ void LLParser::parseOptionalVisibility(unsigned &Res) {
   Lex.Lex();
 }
 
-/// parseOptionalDLLStorageClass
+/// parseOptionalDLLStorageClass 
 ///   ::= /*empty*/
 ///   ::= 'dllimport'
 ///   ::= 'dllexport'
 ///
-void LLParser::parseOptionalDLLStorageClass(unsigned &Res) {
+void LLParser::parseOptionalDLLStorageClass(unsigned &Res) { 
   switch (Lex.getKind()) {
   default:
     Res = GlobalValue::DefaultStorageClass;
@@ -2050,7 +2050,7 @@ void LLParser::parseOptionalDLLStorageClass(unsigned &Res) {
   Lex.Lex();
 }
 
-/// parseOptionalCallingConv
+/// parseOptionalCallingConv 
 ///   ::= /*empty*/
 ///   ::= 'ccc'
 ///   ::= 'fastcc'
@@ -2096,7 +2096,7 @@ void LLParser::parseOptionalDLLStorageClass(unsigned &Res) {
 ///   ::= 'tailcc'
 ///   ::= 'cc' UINT
 ///
-bool LLParser::parseOptionalCallingConv(unsigned &CC) {
+bool LLParser::parseOptionalCallingConv(unsigned &CC) { 
   switch (Lex.getKind()) {
   default:                       CC = CallingConv::C; return false;
   case lltok::kw_ccc:            CC = CallingConv::C; break;
@@ -2136,7 +2136,7 @@ bool LLParser::parseOptionalCallingConv(unsigned &CC) {
   case lltok::kw_hhvm_ccc:       CC = CallingConv::HHVM_C; break;
   case lltok::kw_cxx_fast_tlscc: CC = CallingConv::CXX_FAST_TLS; break;
   case lltok::kw_amdgpu_vs:      CC = CallingConv::AMDGPU_VS; break;
-  case lltok::kw_amdgpu_gfx:     CC = CallingConv::AMDGPU_Gfx; break;
+  case lltok::kw_amdgpu_gfx:     CC = CallingConv::AMDGPU_Gfx; break; 
   case lltok::kw_amdgpu_ls:      CC = CallingConv::AMDGPU_LS; break;
   case lltok::kw_amdgpu_hs:      CC = CallingConv::AMDGPU_HS; break;
   case lltok::kw_amdgpu_es:      CC = CallingConv::AMDGPU_ES; break;
@@ -2147,7 +2147,7 @@ bool LLParser::parseOptionalCallingConv(unsigned &CC) {
   case lltok::kw_tailcc:         CC = CallingConv::Tail; break;
   case lltok::kw_cc: {
       Lex.Lex();
-      return parseUInt32(CC);
+      return parseUInt32(CC); 
     }
   }
 
@@ -2155,28 +2155,28 @@ bool LLParser::parseOptionalCallingConv(unsigned &CC) {
   return false;
 }
 
-/// parseMetadataAttachment
+/// parseMetadataAttachment 
 ///   ::= !dbg !42
-bool LLParser::parseMetadataAttachment(unsigned &Kind, MDNode *&MD) {
+bool LLParser::parseMetadataAttachment(unsigned &Kind, MDNode *&MD) { 
   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata attachment");
 
   std::string Name = Lex.getStrVal();
   Kind = M->getMDKindID(Name);
   Lex.Lex();
 
-  return parseMDNode(MD);
+  return parseMDNode(MD); 
 }
 
-/// parseInstructionMetadata
+/// parseInstructionMetadata 
 ///   ::= !dbg !42 (',' !dbg !57)*
-bool LLParser::parseInstructionMetadata(Instruction &Inst) {
+bool LLParser::parseInstructionMetadata(Instruction &Inst) { 
   do {
     if (Lex.getKind() != lltok::MetadataVar)
-      return tokError("expected metadata after comma");
+      return tokError("expected metadata after comma"); 
 
     unsigned MDK;
     MDNode *N;
-    if (parseMetadataAttachment(MDK, N))
+    if (parseMetadataAttachment(MDK, N)) 
       return true;
 
     Inst.setMetadata(MDK, N);
@@ -2188,31 +2188,31 @@ bool LLParser::parseInstructionMetadata(Instruction &Inst) {
   return false;
 }
 
-/// parseGlobalObjectMetadataAttachment
+/// parseGlobalObjectMetadataAttachment 
 ///   ::= !dbg !57
-bool LLParser::parseGlobalObjectMetadataAttachment(GlobalObject &GO) {
+bool LLParser::parseGlobalObjectMetadataAttachment(GlobalObject &GO) { 
   unsigned MDK;
   MDNode *N;
-  if (parseMetadataAttachment(MDK, N))
+  if (parseMetadataAttachment(MDK, N)) 
     return true;
 
   GO.addMetadata(MDK, *N);
   return false;
 }
 
-/// parseOptionalFunctionMetadata
+/// parseOptionalFunctionMetadata 
 ///   ::= (!dbg !57)*
-bool LLParser::parseOptionalFunctionMetadata(Function &F) {
+bool LLParser::parseOptionalFunctionMetadata(Function &F) { 
   while (Lex.getKind() == lltok::MetadataVar)
-    if (parseGlobalObjectMetadataAttachment(F))
+    if (parseGlobalObjectMetadataAttachment(F)) 
       return true;
   return false;
 }
 
-/// parseOptionalAlignment
+/// parseOptionalAlignment 
 ///   ::= /* empty */
 ///   ::= 'align' 4
-bool LLParser::parseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) {
+bool LLParser::parseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) { 
   Alignment = None;
   if (!EatIfPresent(lltok::kw_align))
     return false;
@@ -2226,26 +2226,26 @@ bool LLParser::parseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) {
       HaveParens = true;
   }
 
-  if (parseUInt32(Value))
+  if (parseUInt32(Value)) 
     return true;
 
   if (HaveParens && !EatIfPresent(lltok::rparen))
-    return error(ParenLoc, "expected ')'");
+    return error(ParenLoc, "expected ')'"); 
 
   if (!isPowerOf2_32(Value))
-    return error(AlignLoc, "alignment is not a power of two");
+    return error(AlignLoc, "alignment is not a power of two"); 
   if (Value > Value::MaximumAlignment)
-    return error(AlignLoc, "huge alignments are not supported yet");
+    return error(AlignLoc, "huge alignments are not supported yet"); 
   Alignment = Align(Value);
   return false;
 }
 
-/// parseOptionalDerefAttrBytes
+/// parseOptionalDerefAttrBytes 
 ///   ::= /* empty */
 ///   ::= AttrKind '(' 4 ')'
 ///
 /// where AttrKind is either 'dereferenceable' or 'dereferenceable_or_null'.
-bool LLParser::parseOptionalDerefAttrBytes(lltok::Kind AttrKind,
+bool LLParser::parseOptionalDerefAttrBytes(lltok::Kind AttrKind, 
                                            uint64_t &Bytes) {
   assert((AttrKind == lltok::kw_dereferenceable ||
           AttrKind == lltok::kw_dereferenceable_or_null) &&
@@ -2256,25 +2256,25 @@ bool LLParser::parseOptionalDerefAttrBytes(lltok::Kind AttrKind,
     return false;
   LocTy ParenLoc = Lex.getLoc();
   if (!EatIfPresent(lltok::lparen))
-    return error(ParenLoc, "expected '('");
+    return error(ParenLoc, "expected '('"); 
   LocTy DerefLoc = Lex.getLoc();
-  if (parseUInt64(Bytes))
-    return true;
+  if (parseUInt64(Bytes)) 
+    return true; 
   ParenLoc = Lex.getLoc();
   if (!EatIfPresent(lltok::rparen))
-    return error(ParenLoc, "expected ')'");
+    return error(ParenLoc, "expected ')'"); 
   if (!Bytes)
-    return error(DerefLoc, "dereferenceable bytes must be non-zero");
+    return error(DerefLoc, "dereferenceable bytes must be non-zero"); 
   return false;
 }
 
-/// parseOptionalCommaAlign
+/// parseOptionalCommaAlign 
 ///   ::=
 ///   ::= ',' align 4
 ///
 /// This returns with AteExtraComma set to true if it ate an excess comma at the
 /// end.
-bool LLParser::parseOptionalCommaAlign(MaybeAlign &Alignment,
+bool LLParser::parseOptionalCommaAlign(MaybeAlign &Alignment, 
                                        bool &AteExtraComma) {
   AteExtraComma = false;
   while (EatIfPresent(lltok::comma)) {
@@ -2285,22 +2285,22 @@ bool LLParser::parseOptionalCommaAlign(MaybeAlign &Alignment,
     }
 
     if (Lex.getKind() != lltok::kw_align)
-      return error(Lex.getLoc(), "expected metadata or 'align'");
+      return error(Lex.getLoc(), "expected metadata or 'align'"); 
 
-    if (parseOptionalAlignment(Alignment))
-      return true;
+    if (parseOptionalAlignment(Alignment)) 
+      return true; 
   }
 
   return false;
 }
 
-/// parseOptionalCommaAddrSpace
+/// parseOptionalCommaAddrSpace 
 ///   ::=
 ///   ::= ',' addrspace(1)
 ///
 /// This returns with AteExtraComma set to true if it ate an excess comma at the
 /// end.
-bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
+bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc, 
                                            bool &AteExtraComma) {
   AteExtraComma = false;
   while (EatIfPresent(lltok::comma)) {
@@ -2312,9 +2312,9 @@ bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
 
     Loc = Lex.getLoc();
     if (Lex.getKind() != lltok::kw_addrspace)
-      return error(Lex.getLoc(), "expected metadata or 'addrspace'");
+      return error(Lex.getLoc(), "expected metadata or 'addrspace'"); 
 
-    if (parseOptionalAddrSpace(AddrSpace))
+    if (parseOptionalAddrSpace(AddrSpace)) 
       return true;
   }
 
@@ -2327,18 +2327,18 @@ bool LLParser::parseAllocSizeArguments(unsigned &BaseSizeArg,
 
   auto StartParen = Lex.getLoc();
   if (!EatIfPresent(lltok::lparen))
-    return error(StartParen, "expected '('");
+    return error(StartParen, "expected '('"); 
 
-  if (parseUInt32(BaseSizeArg))
+  if (parseUInt32(BaseSizeArg)) 
     return true;
 
   if (EatIfPresent(lltok::comma)) {
     auto HowManyAt = Lex.getLoc();
     unsigned HowMany;
-    if (parseUInt32(HowMany))
+    if (parseUInt32(HowMany)) 
       return true;
     if (HowMany == BaseSizeArg)
-      return error(HowManyAt,
+      return error(HowManyAt, 
                    "'allocsize' indices can't refer to the same parameter");
     HowManyArg = HowMany;
   } else
@@ -2346,42 +2346,42 @@ bool LLParser::parseAllocSizeArguments(unsigned &BaseSizeArg,
 
   auto EndParen = Lex.getLoc();
   if (!EatIfPresent(lltok::rparen))
-    return error(EndParen, "expected ')'");
+    return error(EndParen, "expected ')'"); 
   return false;
 }
 
-/// parseScopeAndOrdering
+/// parseScopeAndOrdering 
 ///   if isAtomic: ::= SyncScope? AtomicOrdering
 ///   else: ::=
 ///
 /// This sets Scope and Ordering to the parsed values.
-bool LLParser::parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,
+bool LLParser::parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID, 
                                      AtomicOrdering &Ordering) {
-  if (!IsAtomic)
+  if (!IsAtomic) 
     return false;
 
-  return parseScope(SSID) || parseOrdering(Ordering);
+  return parseScope(SSID) || parseOrdering(Ordering); 
 }
 
-/// parseScope
+/// parseScope 
 ///   ::= syncscope("singlethread" | "<target scope>")?
 ///
 /// This sets synchronization scope ID to the ID of the parsed value.
-bool LLParser::parseScope(SyncScope::ID &SSID) {
+bool LLParser::parseScope(SyncScope::ID &SSID) { 
   SSID = SyncScope::System;
   if (EatIfPresent(lltok::kw_syncscope)) {
     auto StartParenAt = Lex.getLoc();
     if (!EatIfPresent(lltok::lparen))
-      return error(StartParenAt, "Expected '(' in syncscope");
+      return error(StartParenAt, "Expected '(' in syncscope"); 
 
     std::string SSN;
     auto SSNAt = Lex.getLoc();
-    if (parseStringConstant(SSN))
-      return error(SSNAt, "Expected synchronization scope name");
+    if (parseStringConstant(SSN)) 
+      return error(SSNAt, "Expected synchronization scope name"); 
 
     auto EndParenAt = Lex.getLoc();
     if (!EatIfPresent(lltok::rparen))
-      return error(EndParenAt, "Expected ')' in syncscope");
+      return error(EndParenAt, "Expected ')' in syncscope"); 
 
     SSID = Context.getOrInsertSyncScopeID(SSN);
   }
@@ -2389,14 +2389,14 @@ bool LLParser::parseScope(SyncScope::ID &SSID) {
   return false;
 }
 
-/// parseOrdering
+/// parseOrdering 
 ///   ::= AtomicOrdering
 ///
 /// This sets Ordering to the parsed value.
-bool LLParser::parseOrdering(AtomicOrdering &Ordering) {
+bool LLParser::parseOrdering(AtomicOrdering &Ordering) { 
   switch (Lex.getKind()) {
-  default:
-    return tokError("Expected ordering on atomic instruction");
+  default: 
+    return tokError("Expected ordering on atomic instruction"); 
   case lltok::kw_unordered: Ordering = AtomicOrdering::Unordered; break;
   case lltok::kw_monotonic: Ordering = AtomicOrdering::Monotonic; break;
   // Not specified yet:
@@ -2412,53 +2412,53 @@ bool LLParser::parseOrdering(AtomicOrdering &Ordering) {
   return false;
 }
 
-/// parseOptionalStackAlignment
+/// parseOptionalStackAlignment 
 ///   ::= /* empty */
 ///   ::= 'alignstack' '(' 4 ')'
-bool LLParser::parseOptionalStackAlignment(unsigned &Alignment) {
+bool LLParser::parseOptionalStackAlignment(unsigned &Alignment) { 
   Alignment = 0;
   if (!EatIfPresent(lltok::kw_alignstack))
     return false;
   LocTy ParenLoc = Lex.getLoc();
   if (!EatIfPresent(lltok::lparen))
-    return error(ParenLoc, "expected '('");
+    return error(ParenLoc, "expected '('"); 
   LocTy AlignLoc = Lex.getLoc();
-  if (parseUInt32(Alignment))
-    return true;
+  if (parseUInt32(Alignment)) 
+    return true; 
   ParenLoc = Lex.getLoc();
   if (!EatIfPresent(lltok::rparen))
-    return error(ParenLoc, "expected ')'");
+    return error(ParenLoc, "expected ')'"); 
   if (!isPowerOf2_32(Alignment))
-    return error(AlignLoc, "stack alignment is not a power of two");
+    return error(AlignLoc, "stack alignment is not a power of two"); 
   return false;
 }
 
-/// parseIndexList - This parses the index list for an insert/extractvalue
+/// parseIndexList - This parses the index list for an insert/extractvalue 
 /// instruction.  This sets AteExtraComma in the case where we eat an extra
 /// comma at the end of the line and find that it is followed by metadata.
 /// Clients that don't allow metadata can call the version of this function that
 /// only takes one argument.
 ///
-/// parseIndexList
+/// parseIndexList 
 ///    ::=  (',' uint32)+
 ///
-bool LLParser::parseIndexList(SmallVectorImpl<unsigned> &Indices,
+bool LLParser::parseIndexList(SmallVectorImpl<unsigned> &Indices, 
                               bool &AteExtraComma) {
   AteExtraComma = false;
 
   if (Lex.getKind() != lltok::comma)
-    return tokError("expected ',' as start of index list");
+    return tokError("expected ',' as start of index list"); 
 
   while (EatIfPresent(lltok::comma)) {
     if (Lex.getKind() == lltok::MetadataVar) {
-      if (Indices.empty())
-        return tokError("expected index");
+      if (Indices.empty()) 
+        return tokError("expected index"); 
       AteExtraComma = true;
       return false;
     }
     unsigned Idx = 0;
-    if (parseUInt32(Idx))
-      return true;
+    if (parseUInt32(Idx)) 
+      return true; 
     Indices.push_back(Idx);
   }
 
@@ -2469,12 +2469,12 @@ bool LLParser::parseIndexList(SmallVectorImpl<unsigned> &Indices,
 // Type Parsing.
 //===----------------------------------------------------------------------===//
 
-/// parseType - parse a type.
-bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
+/// parseType - parse a type. 
+bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) { 
   SMLoc TypeLoc = Lex.getLoc();
   switch (Lex.getKind()) {
   default:
-    return tokError(Msg);
+    return tokError(Msg); 
   case lltok::Type:
     // Type ::= 'float' | 'void' (etc)
     Result = Lex.getTyVal();
@@ -2482,23 +2482,23 @@ bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
     break;
   case lltok::lbrace:
     // Type ::= StructType
-    if (parseAnonStructType(Result, false))
+    if (parseAnonStructType(Result, false)) 
       return true;
     break;
   case lltok::lsquare:
     // Type ::= '[' ... ']'
     Lex.Lex(); // eat the lsquare.
-    if (parseArrayVectorType(Result, false))
+    if (parseArrayVectorType(Result, false)) 
       return true;
     break;
   case lltok::less: // Either vector or packed struct.
     // Type ::= '<' ... '>'
     Lex.Lex();
     if (Lex.getKind() == lltok::lbrace) {
-      if (parseAnonStructType(Result, true) ||
-          parseToken(lltok::greater, "expected '>' at end of packed struct"))
+      if (parseAnonStructType(Result, true) || 
+          parseToken(lltok::greater, "expected '>' at end of packed struct")) 
         return true;
-    } else if (parseArrayVectorType(Result, true))
+    } else if (parseArrayVectorType(Result, true)) 
       return true;
     break;
   case lltok::LocalVar: {
@@ -2532,23 +2532,23 @@ bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
   }
   }
 
-  // parse the type suffixes.
+  // parse the type suffixes. 
   while (true) {
     switch (Lex.getKind()) {
     // End of type.
     default:
       if (!AllowVoid && Result->isVoidTy())
-        return error(TypeLoc, "void type only allowed for function results");
+        return error(TypeLoc, "void type only allowed for function results"); 
       return false;
 
     // Type ::= Type '*'
     case lltok::star:
       if (Result->isLabelTy())
-        return tokError("basic block pointers are invalid");
+        return tokError("basic block pointers are invalid"); 
       if (Result->isVoidTy())
-        return tokError("pointers to void are invalid - use i8* instead");
+        return tokError("pointers to void are invalid - use i8* instead"); 
       if (!PointerType::isValidElementType(Result))
-        return tokError("pointer to this type is invalid");
+        return tokError("pointer to this type is invalid"); 
       Result = PointerType::getUnqual(Result);
       Lex.Lex();
       break;
@@ -2556,14 +2556,14 @@ bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
     // Type ::= Type 'addrspace' '(' uint32 ')' '*'
     case lltok::kw_addrspace: {
       if (Result->isLabelTy())
-        return tokError("basic block pointers are invalid");
+        return tokError("basic block pointers are invalid"); 
       if (Result->isVoidTy())
-        return tokError("pointers to void are invalid; use i8* instead");
+        return tokError("pointers to void are invalid; use i8* instead"); 
       if (!PointerType::isValidElementType(Result))
-        return tokError("pointer to this type is invalid");
+        return tokError("pointer to this type is invalid"); 
       unsigned AddrSpace;
-      if (parseOptionalAddrSpace(AddrSpace) ||
-          parseToken(lltok::star, "expected '*' in address space"))
+      if (parseOptionalAddrSpace(AddrSpace) || 
+          parseToken(lltok::star, "expected '*' in address space")) 
         return true;
 
       Result = PointerType::get(Result, AddrSpace);
@@ -2572,55 +2572,55 @@ bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
 
     /// Types '(' ArgTypeListI ')' OptFuncAttrs
     case lltok::lparen:
-      if (parseFunctionType(Result))
+      if (parseFunctionType(Result)) 
         return true;
       break;
     }
   }
 }
 
-/// parseParameterList
+/// parseParameterList 
 ///    ::= '(' ')'
 ///    ::= '(' Arg (',' Arg)* ')'
 ///  Arg
 ///    ::= Type OptionalAttributes Value OptionalAttributes
-bool LLParser::parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
+bool LLParser::parseParameterList(SmallVectorImpl<ParamInfo> &ArgList, 
                                   PerFunctionState &PFS, bool IsMustTailCall,
                                   bool InVarArgsFunc) {
-  if (parseToken(lltok::lparen, "expected '(' in call"))
+  if (parseToken(lltok::lparen, "expected '(' in call")) 
     return true;
 
   while (Lex.getKind() != lltok::rparen) {
     // If this isn't the first argument, we need a comma.
     if (!ArgList.empty() &&
-        parseToken(lltok::comma, "expected ',' in argument list"))
+        parseToken(lltok::comma, "expected ',' in argument list")) 
       return true;
 
-    // parse an ellipsis if this is a musttail call in a variadic function.
+    // parse an ellipsis if this is a musttail call in a variadic function. 
     if (Lex.getKind() == lltok::dotdotdot) {
       const char *Msg = "unexpected ellipsis in argument list for ";
       if (!IsMustTailCall)
-        return tokError(Twine(Msg) + "non-musttail call");
+        return tokError(Twine(Msg) + "non-musttail call"); 
       if (!InVarArgsFunc)
-        return tokError(Twine(Msg) + "musttail call in non-varargs function");
+        return tokError(Twine(Msg) + "musttail call in non-varargs function"); 
       Lex.Lex();  // Lex the '...', it is purely for readability.
-      return parseToken(lltok::rparen, "expected ')' at end of argument list");
+      return parseToken(lltok::rparen, "expected ')' at end of argument list"); 
     }
 
-    // parse the argument.
+    // parse the argument. 
     LocTy ArgLoc;
     Type *ArgTy = nullptr;
     AttrBuilder ArgAttrs;
     Value *V;
-    if (parseType(ArgTy, ArgLoc))
+    if (parseType(ArgTy, ArgLoc)) 
       return true;
 
     if (ArgTy->isMetadataTy()) {
-      if (parseMetadataAsValue(V, PFS))
+      if (parseMetadataAsValue(V, PFS)) 
         return true;
     } else {
       // Otherwise, handle normal operands.
-      if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS))
+      if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS)) 
         return true;
     }
     ArgList.push_back(ParamInfo(
@@ -2628,41 +2628,41 @@ bool LLParser::parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
   }
 
   if (IsMustTailCall && InVarArgsFunc)
-    return tokError("expected '...' at end of argument list for musttail call "
+    return tokError("expected '...' at end of argument list for musttail call " 
                     "in varargs function");
 
   Lex.Lex();  // Lex the ')'.
   return false;
 }
 
-/// parseRequiredTypeAttr
-///   ::= attrname(<ty>)
-bool LLParser::parseRequiredTypeAttr(Type *&Result, lltok::Kind AttrName) {
+/// parseRequiredTypeAttr 
+///   ::= attrname(<ty>) 
+bool LLParser::parseRequiredTypeAttr(Type *&Result, lltok::Kind AttrName) { 
   Result = nullptr;
-  if (!EatIfPresent(AttrName))
+  if (!EatIfPresent(AttrName)) 
     return true;
   if (!EatIfPresent(lltok::lparen))
-    return error(Lex.getLoc(), "expected '('");
-  if (parseType(Result))
+    return error(Lex.getLoc(), "expected '('"); 
+  if (parseType(Result)) 
     return true;
   if (!EatIfPresent(lltok::rparen))
-    return error(Lex.getLoc(), "expected ')'");
+    return error(Lex.getLoc(), "expected ')'"); 
   return false;
 }
 
-/// parsePreallocated
+/// parsePreallocated 
 ///   ::= preallocated(<ty>)
-bool LLParser::parsePreallocated(Type *&Result) {
-  return parseRequiredTypeAttr(Result, lltok::kw_preallocated);
-}
-
-/// parseByRef
-///   ::= byref(<type>)
-bool LLParser::parseByRef(Type *&Result) {
-  return parseRequiredTypeAttr(Result, lltok::kw_byref);
+bool LLParser::parsePreallocated(Type *&Result) { 
+  return parseRequiredTypeAttr(Result, lltok::kw_preallocated); 
 }
 
-/// parseOptionalOperandBundles
+/// parseByRef 
+///   ::= byref(<type>) 
+bool LLParser::parseByRef(Type *&Result) { 
+  return parseRequiredTypeAttr(Result, lltok::kw_byref); 
+} 
+ 
+/// parseOptionalOperandBundles 
 ///    ::= /*empty*/
 ///    ::= '[' OperandBundle [, OperandBundle ]* ']'
 ///
@@ -2671,7 +2671,7 @@ bool LLParser::parseByRef(Type *&Result) {
 ///    ::= bundle-tag '(' Type Value [, Type Value ]* ')'
 ///
 /// bundle-tag ::= String Constant
-bool LLParser::parseOptionalOperandBundles(
+bool LLParser::parseOptionalOperandBundles( 
     SmallVectorImpl<OperandBundleDef> &BundleList, PerFunctionState &PFS) {
   LocTy BeginLoc = Lex.getLoc();
   if (!EatIfPresent(lltok::lsquare))
@@ -2680,26 +2680,26 @@ bool LLParser::parseOptionalOperandBundles(
   while (Lex.getKind() != lltok::rsquare) {
     // If this isn't the first operand bundle, we need a comma.
     if (!BundleList.empty() &&
-        parseToken(lltok::comma, "expected ',' in input list"))
+        parseToken(lltok::comma, "expected ',' in input list")) 
       return true;
 
     std::string Tag;
-    if (parseStringConstant(Tag))
+    if (parseStringConstant(Tag)) 
       return true;
 
-    if (parseToken(lltok::lparen, "expected '(' in operand bundle"))
+    if (parseToken(lltok::lparen, "expected '(' in operand bundle")) 
       return true;
 
     std::vector<Value *> Inputs;
     while (Lex.getKind() != lltok::rparen) {
       // If this isn't the first input, we need a comma.
       if (!Inputs.empty() &&
-          parseToken(lltok::comma, "expected ',' in input list"))
+          parseToken(lltok::comma, "expected ',' in input list")) 
         return true;
 
       Type *Ty = nullptr;
       Value *Input = nullptr;
-      if (parseType(Ty) || parseValue(Ty, Input, PFS))
+      if (parseType(Ty) || parseValue(Ty, Input, PFS)) 
         return true;
       Inputs.push_back(Input);
     }
@@ -2710,13 +2710,13 @@ bool LLParser::parseOptionalOperandBundles(
   }
 
   if (BundleList.empty())
-    return error(BeginLoc, "operand bundle set must not be empty");
+    return error(BeginLoc, "operand bundle set must not be empty"); 
 
   Lex.Lex(); // Lex the ']'.
   return false;
 }
 
-/// parseArgumentList - parse the argument list for a function type or function
+/// parseArgumentList - parse the argument list for a function type or function 
 /// prototype.
 ///   ::= '(' ArgTypeListI ')'
 /// ArgTypeListI
@@ -2725,17 +2725,17 @@ bool LLParser::parseOptionalOperandBundles(
 ///   ::= ArgTypeList ',' '...'
 ///   ::= ArgType (',' ArgType)*
 ///
-bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
-                                 bool &IsVarArg) {
+bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, 
+                                 bool &IsVarArg) { 
   unsigned CurValID = 0;
-  IsVarArg = false;
+  IsVarArg = false; 
   assert(Lex.getKind() == lltok::lparen);
   Lex.Lex(); // eat the (.
 
   if (Lex.getKind() == lltok::rparen) {
     // empty
   } else if (Lex.getKind() == lltok::dotdotdot) {
-    IsVarArg = true;
+    IsVarArg = true; 
     Lex.Lex();
   } else {
     LocTy TypeLoc = Lex.getLoc();
@@ -2743,25 +2743,25 @@ bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
     AttrBuilder Attrs;
     std::string Name;
 
-    if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
-      return true;
+    if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs)) 
+      return true; 
 
     if (ArgTy->isVoidTy())
-      return error(TypeLoc, "argument can not have void type");
+      return error(TypeLoc, "argument can not have void type"); 
 
     if (Lex.getKind() == lltok::LocalVar) {
       Name = Lex.getStrVal();
       Lex.Lex();
     } else if (Lex.getKind() == lltok::LocalVarID) {
       if (Lex.getUIntVal() != CurValID)
-        return error(TypeLoc, "argument expected to be numbered '%" +
+        return error(TypeLoc, "argument expected to be numbered '%" + 
                                   Twine(CurValID) + "'");
       ++CurValID;
       Lex.Lex();
     }
 
     if (!FunctionType::isValidArgumentType(ArgTy))
-      return error(TypeLoc, "invalid type for function argument");
+      return error(TypeLoc, "invalid type for function argument"); 
 
     ArgList.emplace_back(TypeLoc, ArgTy,
                          AttributeSet::get(ArgTy->getContext(), Attrs),
@@ -2770,17 +2770,17 @@ bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
     while (EatIfPresent(lltok::comma)) {
       // Handle ... at end of arg list.
       if (EatIfPresent(lltok::dotdotdot)) {
-        IsVarArg = true;
+        IsVarArg = true; 
         break;
       }
 
       // Otherwise must be an argument type.
       TypeLoc = Lex.getLoc();
-      if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
-        return true;
+      if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs)) 
+        return true; 
 
       if (ArgTy->isVoidTy())
-        return error(TypeLoc, "argument can not have void type");
+        return error(TypeLoc, "argument can not have void type"); 
 
       if (Lex.getKind() == lltok::LocalVar) {
         Name = Lex.getStrVal();
@@ -2788,7 +2788,7 @@ bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
       } else {
         if (Lex.getKind() == lltok::LocalVarID) {
           if (Lex.getUIntVal() != CurValID)
-            return error(TypeLoc, "argument expected to be numbered '%" +
+            return error(TypeLoc, "argument expected to be numbered '%" + 
                                       Twine(CurValID) + "'");
           Lex.Lex();
         }
@@ -2797,7 +2797,7 @@ bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
       }
 
       if (!ArgTy->isFirstClassType())
-        return error(TypeLoc, "invalid type for function argument");
+        return error(TypeLoc, "invalid type for function argument"); 
 
       ArgList.emplace_back(TypeLoc, ArgTy,
                            AttributeSet::get(ArgTy->getContext(), Attrs),
@@ -2805,28 +2805,28 @@ bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
     }
   }
 
-  return parseToken(lltok::rparen, "expected ')' at end of argument list");
+  return parseToken(lltok::rparen, "expected ')' at end of argument list"); 
 }
 
-/// parseFunctionType
+/// parseFunctionType 
 ///  ::= Type ArgumentList OptionalAttrs
-bool LLParser::parseFunctionType(Type *&Result) {
+bool LLParser::parseFunctionType(Type *&Result) { 
   assert(Lex.getKind() == lltok::lparen);
 
   if (!FunctionType::isValidReturnType(Result))
-    return tokError("invalid function return type");
+    return tokError("invalid function return type"); 
 
   SmallVector<ArgInfo, 8> ArgList;
-  bool IsVarArg;
-  if (parseArgumentList(ArgList, IsVarArg))
+  bool IsVarArg; 
+  if (parseArgumentList(ArgList, IsVarArg)) 
     return true;
 
   // Reject names on the arguments lists.
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
     if (!ArgList[i].Name.empty())
-      return error(ArgList[i].Loc, "argument name invalid in function type");
+      return error(ArgList[i].Loc, "argument name invalid in function type"); 
     if (ArgList[i].Attrs.hasAttributes())
-      return error(ArgList[i].Loc,
+      return error(ArgList[i].Loc, 
                    "argument attributes invalid in function type");
   }
 
@@ -2834,28 +2834,28 @@ bool LLParser::parseFunctionType(Type *&Result) {
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
     ArgListTy.push_back(ArgList[i].Ty);
 
-  Result = FunctionType::get(Result, ArgListTy, IsVarArg);
+  Result = FunctionType::get(Result, ArgListTy, IsVarArg); 
   return false;
 }
 
-/// parseAnonStructType - parse an anonymous struct type, which is inlined into
+/// parseAnonStructType - parse an anonymous struct type, which is inlined into 
 /// other structs.
-bool LLParser::parseAnonStructType(Type *&Result, bool Packed) {
+bool LLParser::parseAnonStructType(Type *&Result, bool Packed) { 
   SmallVector<Type*, 8> Elts;
-  if (parseStructBody(Elts))
-    return true;
+  if (parseStructBody(Elts)) 
+    return true; 
 
   Result = StructType::get(Context, Elts, Packed);
   return false;
 }
 
-/// parseStructDefinition - parse a struct in a 'type' definition.
-bool LLParser::parseStructDefinition(SMLoc TypeLoc, StringRef Name,
-                                     std::pair<Type *, LocTy> &Entry,
+/// parseStructDefinition - parse a struct in a 'type' definition. 
+bool LLParser::parseStructDefinition(SMLoc TypeLoc, StringRef Name, 
+                                     std::pair<Type *, LocTy> &Entry, 
                                      Type *&ResultTy) {
   // If the type was already defined, diagnose the redefinition.
   if (Entry.first && !Entry.second.isValid())
-    return error(TypeLoc, "redefinition of type");
+    return error(TypeLoc, "redefinition of type"); 
 
   // If we have opaque, just return without filling in the definition for the
   // struct.  This counts as a definition as far as the .ll file goes.
@@ -2878,12 +2878,12 @@ bool LLParser::parseStructDefinition(SMLoc TypeLoc, StringRef Name,
   // forward referenced and not allowed to be recursive.
   if (Lex.getKind() != lltok::lbrace) {
     if (Entry.first)
-      return error(TypeLoc, "forward references to non-struct type");
+      return error(TypeLoc, "forward references to non-struct type"); 
 
     ResultTy = nullptr;
     if (isPacked)
-      return parseArrayVectorType(ResultTy, true);
-    return parseType(ResultTy);
+      return parseArrayVectorType(ResultTy, true); 
+    return parseType(ResultTy); 
   }
 
   // This type is being defined, so clear the location to indicate this.
@@ -2896,8 +2896,8 @@ bool LLParser::parseStructDefinition(SMLoc TypeLoc, StringRef Name,
   StructType *STy = cast<StructType>(Entry.first);
 
   SmallVector<Type*, 8> Body;
-  if (parseStructBody(Body) ||
-      (isPacked && parseToken(lltok::greater, "expected '>' in packed struct")))
+  if (parseStructBody(Body) || 
+      (isPacked && parseToken(lltok::greater, "expected '>' in packed struct"))) 
     return true;
 
   STy->setBody(Body, isPacked);
@@ -2905,13 +2905,13 @@ bool LLParser::parseStructDefinition(SMLoc TypeLoc, StringRef Name,
   return false;
 }
 
-/// parseStructType: Handles packed and unpacked types.  </> parsed elsewhere.
+/// parseStructType: Handles packed and unpacked types.  </> parsed elsewhere. 
 ///   StructType
 ///     ::= '{' '}'
 ///     ::= '{' Type (',' Type)* '}'
 ///     ::= '<' '{' '}' '>'
 ///     ::= '<' '{' Type (',' Type)* '}' '>'
-bool LLParser::parseStructBody(SmallVectorImpl<Type *> &Body) {
+bool LLParser::parseStructBody(SmallVectorImpl<Type *> &Body) { 
   assert(Lex.getKind() == lltok::lbrace);
   Lex.Lex(); // Consume the '{'
 
@@ -2921,39 +2921,39 @@ bool LLParser::parseStructBody(SmallVectorImpl<Type *> &Body) {
 
   LocTy EltTyLoc = Lex.getLoc();
   Type *Ty = nullptr;
-  if (parseType(Ty))
-    return true;
+  if (parseType(Ty)) 
+    return true; 
   Body.push_back(Ty);
 
   if (!StructType::isValidElementType(Ty))
-    return error(EltTyLoc, "invalid element type for struct");
+    return error(EltTyLoc, "invalid element type for struct"); 
 
   while (EatIfPresent(lltok::comma)) {
     EltTyLoc = Lex.getLoc();
-    if (parseType(Ty))
-      return true;
+    if (parseType(Ty)) 
+      return true; 
 
     if (!StructType::isValidElementType(Ty))
-      return error(EltTyLoc, "invalid element type for struct");
+      return error(EltTyLoc, "invalid element type for struct"); 
 
     Body.push_back(Ty);
   }
 
-  return parseToken(lltok::rbrace, "expected '}' at end of struct");
+  return parseToken(lltok::rbrace, "expected '}' at end of struct"); 
 }
 
-/// parseArrayVectorType - parse an array or vector type, assuming the first
+/// parseArrayVectorType - parse an array or vector type, assuming the first 
 /// token has already been consumed.
 ///   Type
 ///     ::= '[' APSINTVAL 'x' Types ']'
 ///     ::= '<' APSINTVAL 'x' Types '>'
 ///     ::= '<' 'vscale' 'x' APSINTVAL 'x' Types '>'
-bool LLParser::parseArrayVectorType(Type *&Result, bool IsVector) {
+bool LLParser::parseArrayVectorType(Type *&Result, bool IsVector) { 
   bool Scalable = false;
 
-  if (IsVector && Lex.getKind() == lltok::kw_vscale) {
+  if (IsVector && Lex.getKind() == lltok::kw_vscale) { 
     Lex.Lex(); // consume the 'vscale'
-    if (parseToken(lltok::kw_x, "expected 'x' after vscale"))
+    if (parseToken(lltok::kw_x, "expected 'x' after vscale")) 
       return true;
 
     Scalable = true;
@@ -2961,35 +2961,35 @@ bool LLParser::parseArrayVectorType(Type *&Result, bool IsVector) {
 
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
       Lex.getAPSIntVal().getBitWidth() > 64)
-    return tokError("expected number in address space");
+    return tokError("expected number in address space"); 
 
   LocTy SizeLoc = Lex.getLoc();
   uint64_t Size = Lex.getAPSIntVal().getZExtValue();
   Lex.Lex();
 
-  if (parseToken(lltok::kw_x, "expected 'x' after element count"))
-    return true;
+  if (parseToken(lltok::kw_x, "expected 'x' after element count")) 
+    return true; 
 
   LocTy TypeLoc = Lex.getLoc();
   Type *EltTy = nullptr;
-  if (parseType(EltTy))
-    return true;
+  if (parseType(EltTy)) 
+    return true; 
 
-  if (parseToken(IsVector ? lltok::greater : lltok::rsquare,
+  if (parseToken(IsVector ? lltok::greater : lltok::rsquare, 
                  "expected end of sequential type"))
     return true;
 
-  if (IsVector) {
+  if (IsVector) { 
     if (Size == 0)
-      return error(SizeLoc, "zero element vector is illegal");
+      return error(SizeLoc, "zero element vector is illegal"); 
     if ((unsigned)Size != Size)
-      return error(SizeLoc, "size too large for vector");
+      return error(SizeLoc, "size too large for vector"); 
     if (!VectorType::isValidElementType(EltTy))
-      return error(TypeLoc, "invalid vector element type");
+      return error(TypeLoc, "invalid vector element type"); 
     Result = VectorType::get(EltTy, unsigned(Size), Scalable);
   } else {
     if (!ArrayType::isValidElementType(EltTy))
-      return error(TypeLoc, "invalid array element type");
+      return error(TypeLoc, "invalid array element type"); 
     Result = ArrayType::get(EltTy, Size);
   }
   return false;
@@ -3029,22 +3029,22 @@ LLParser::PerFunctionState::~PerFunctionState() {
   }
 }
 
-bool LLParser::PerFunctionState::finishFunction() {
+bool LLParser::PerFunctionState::finishFunction() { 
   if (!ForwardRefVals.empty())
-    return P.error(ForwardRefVals.begin()->second.second,
+    return P.error(ForwardRefVals.begin()->second.second, 
                    "use of undefined value '%" + ForwardRefVals.begin()->first +
-                       "'");
+                       "'"); 
   if (!ForwardRefValIDs.empty())
-    return P.error(ForwardRefValIDs.begin()->second.second,
+    return P.error(ForwardRefValIDs.begin()->second.second, 
                    "use of undefined value '%" +
-                       Twine(ForwardRefValIDs.begin()->first) + "'");
+                       Twine(ForwardRefValIDs.begin()->first) + "'"); 
   return false;
 }
 
-/// getVal - Get a value with the specified name or ID, creating a
+/// getVal - Get a value with the specified name or ID, creating a 
 /// forward reference record if needed.  This can return null if the value
 /// exists but does not have the right type.
-Value *LLParser::PerFunctionState::getVal(const std::string &Name, Type *Ty,
+Value *LLParser::PerFunctionState::getVal(const std::string &Name, Type *Ty, 
                                           LocTy Loc, bool IsCall) {
   // Look this name up in the normal function symbol table.
   Value *Val = F.getValueSymbolTable()->lookup(Name);
@@ -3063,7 +3063,7 @@ Value *LLParser::PerFunctionState::getVal(const std::string &Name, Type *Ty,
 
   // Don't make placeholders with invalid type.
   if (!Ty->isFirstClassType()) {
-    P.error(Loc, "invalid use of a non-first-class type");
+    P.error(Loc, "invalid use of a non-first-class type"); 
     return nullptr;
   }
 
@@ -3079,7 +3079,7 @@ Value *LLParser::PerFunctionState::getVal(const std::string &Name, Type *Ty,
   return FwdVal;
 }
 
-Value *LLParser::PerFunctionState::getVal(unsigned ID, Type *Ty, LocTy Loc,
+Value *LLParser::PerFunctionState::getVal(unsigned ID, Type *Ty, LocTy Loc, 
                                           bool IsCall) {
   // Look this name up in the normal function symbol table.
   Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
@@ -3097,7 +3097,7 @@ Value *LLParser::PerFunctionState::getVal(unsigned ID, Type *Ty, LocTy Loc,
     return P.checkValidVariableType(Loc, "%" + Twine(ID), Ty, Val, IsCall);
 
   if (!Ty->isFirstClassType()) {
-    P.error(Loc, "invalid use of a non-first-class type");
+    P.error(Loc, "invalid use of a non-first-class type"); 
     return nullptr;
   }
 
@@ -3113,15 +3113,15 @@ Value *LLParser::PerFunctionState::getVal(unsigned ID, Type *Ty, LocTy Loc,
   return FwdVal;
 }
 
-/// setInstName - After an instruction is parsed and inserted into its
+/// setInstName - After an instruction is parsed and inserted into its 
 /// basic block, this installs its name.
-bool LLParser::PerFunctionState::setInstName(int NameID,
+bool LLParser::PerFunctionState::setInstName(int NameID, 
                                              const std::string &NameStr,
                                              LocTy NameLoc, Instruction *Inst) {
   // If this instruction has void type, it cannot have a name or ID specified.
   if (Inst->getType()->isVoidTy()) {
     if (NameID != -1 || !NameStr.empty())
-      return P.error(NameLoc, "instructions returning void cannot have a name");
+      return P.error(NameLoc, "instructions returning void cannot have a name"); 
     return false;
   }
 
@@ -3133,16 +3133,16 @@ bool LLParser::PerFunctionState::setInstName(int NameID,
       NameID = NumberedVals.size();
 
     if (unsigned(NameID) != NumberedVals.size())
-      return P.error(NameLoc, "instruction expected to be numbered '%" +
-                                  Twine(NumberedVals.size()) + "'");
+      return P.error(NameLoc, "instruction expected to be numbered '%" + 
+                                  Twine(NumberedVals.size()) + "'"); 
 
     auto FI = ForwardRefValIDs.find(NameID);
     if (FI != ForwardRefValIDs.end()) {
       Value *Sentinel = FI->second.first;
       if (Sentinel->getType() != Inst->getType())
-        return P.error(NameLoc, "instruction forward referenced with type '" +
-                                    getTypeString(FI->second.first->getType()) +
-                                    "'");
+        return P.error(NameLoc, "instruction forward referenced with type '" + 
+                                    getTypeString(FI->second.first->getType()) + 
+                                    "'"); 
 
       Sentinel->replaceAllUsesWith(Inst);
       Sentinel->deleteValue();
@@ -3158,9 +3158,9 @@ bool LLParser::PerFunctionState::setInstName(int NameID,
   if (FI != ForwardRefVals.end()) {
     Value *Sentinel = FI->second.first;
     if (Sentinel->getType() != Inst->getType())
-      return P.error(NameLoc, "instruction forward referenced with type '" +
-                                  getTypeString(FI->second.first->getType()) +
-                                  "'");
+      return P.error(NameLoc, "instruction forward referenced with type '" + 
+                                  getTypeString(FI->second.first->getType()) + 
+                                  "'"); 
 
     Sentinel->replaceAllUsesWith(Inst);
     Sentinel->deleteValue();
@@ -3171,46 +3171,46 @@ bool LLParser::PerFunctionState::setInstName(int NameID,
   Inst->setName(NameStr);
 
   if (Inst->getName() != NameStr)
-    return P.error(NameLoc, "multiple definition of local value named '" +
-                                NameStr + "'");
+    return P.error(NameLoc, "multiple definition of local value named '" + 
+                                NameStr + "'"); 
   return false;
 }
 
-/// getBB - Get a basic block with the specified name or ID, creating a
+/// getBB - Get a basic block with the specified name or ID, creating a 
 /// forward reference record if needed.
-BasicBlock *LLParser::PerFunctionState::getBB(const std::string &Name,
+BasicBlock *LLParser::PerFunctionState::getBB(const std::string &Name, 
                                               LocTy Loc) {
   return dyn_cast_or_null<BasicBlock>(
-      getVal(Name, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
+      getVal(Name, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false)); 
 }
 
-BasicBlock *LLParser::PerFunctionState::getBB(unsigned ID, LocTy Loc) {
+BasicBlock *LLParser::PerFunctionState::getBB(unsigned ID, LocTy Loc) { 
   return dyn_cast_or_null<BasicBlock>(
-      getVal(ID, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
+      getVal(ID, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false)); 
 }
 
-/// defineBB - Define the specified basic block, which is either named or
+/// defineBB - Define the specified basic block, which is either named or 
 /// unnamed.  If there is an error, this returns null otherwise it returns
 /// the block being defined.
-BasicBlock *LLParser::PerFunctionState::defineBB(const std::string &Name,
+BasicBlock *LLParser::PerFunctionState::defineBB(const std::string &Name, 
                                                  int NameID, LocTy Loc) {
   BasicBlock *BB;
   if (Name.empty()) {
     if (NameID != -1 && unsigned(NameID) != NumberedVals.size()) {
-      P.error(Loc, "label expected to be numbered '" +
+      P.error(Loc, "label expected to be numbered '" + 
                        Twine(NumberedVals.size()) + "'");
       return nullptr;
     }
-    BB = getBB(NumberedVals.size(), Loc);
+    BB = getBB(NumberedVals.size(), Loc); 
     if (!BB) {
-      P.error(Loc, "unable to create block numbered '" +
+      P.error(Loc, "unable to create block numbered '" + 
                        Twine(NumberedVals.size()) + "'");
       return nullptr;
     }
   } else {
-    BB = getBB(Name, Loc);
+    BB = getBB(Name, Loc); 
     if (!BB) {
-      P.error(Loc, "unable to create block named '" + Name + "'");
+      P.error(Loc, "unable to create block named '" + Name + "'"); 
       return nullptr;
     }
   }
@@ -3235,17 +3235,17 @@ BasicBlock *LLParser::PerFunctionState::defineBB(const std::string &Name,
 // Constants.
 //===----------------------------------------------------------------------===//
 
-/// parseValID - parse an abstract value that doesn't necessarily have a
+/// parseValID - parse an abstract value that doesn't necessarily have a 
 /// type implied.  For example, if we parse "4" we don't know what integer type
 /// it has.  The value will later be combined with its type and checked for
 /// sanity.  PFS is used to convert function-local operands of metadata (since
 /// metadata operands are not just parsed here but also converted to values).
 /// PFS can be null when we are not parsing metadata values inside a function.
-bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
+bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) { 
   ID.Loc = Lex.getLoc();
   switch (Lex.getKind()) {
-  default:
-    return tokError("expected value token");
+  default: 
+    return tokError("expected value token"); 
   case lltok::GlobalID:  // @42
     ID.UIntVal = Lex.getUIntVal();
     ID.Kind = ValID::t_GlobalID;
@@ -3280,7 +3280,7 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     break;
   case lltok::kw_null: ID.Kind = ValID::t_Null; break;
   case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
-  case lltok::kw_poison: ID.Kind = ValID::t_Poison; break;
+  case lltok::kw_poison: ID.Kind = ValID::t_Poison; break; 
   case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
   case lltok::kw_none: ID.Kind = ValID::t_None; break;
 
@@ -3288,8 +3288,8 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     // ValID ::= '{' ConstVector '}'
     Lex.Lex();
     SmallVector<Constant*, 16> Elts;
-    if (parseGlobalValueVector(Elts) ||
-        parseToken(lltok::rbrace, "expected end of struct constant"))
+    if (parseGlobalValueVector(Elts) || 
+        parseToken(lltok::rbrace, "expected end of struct constant")) 
       return true;
 
     ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.size());
@@ -3307,10 +3307,10 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
 
     SmallVector<Constant*, 16> Elts;
     LocTy FirstEltLoc = Lex.getLoc();
-    if (parseGlobalValueVector(Elts) ||
+    if (parseGlobalValueVector(Elts) || 
         (isPackedStruct &&
-         parseToken(lltok::rbrace, "expected end of packed struct")) ||
-        parseToken(lltok::greater, "expected end of constant"))
+         parseToken(lltok::rbrace, "expected end of packed struct")) || 
+        parseToken(lltok::greater, "expected end of constant")) 
       return true;
 
     if (isPackedStruct) {
@@ -3323,21 +3323,21 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     }
 
     if (Elts.empty())
-      return error(ID.Loc, "constant vector must not be empty");
+      return error(ID.Loc, "constant vector must not be empty"); 
 
     if (!Elts[0]->getType()->isIntegerTy() &&
         !Elts[0]->getType()->isFloatingPointTy() &&
         !Elts[0]->getType()->isPointerTy())
-      return error(
-          FirstEltLoc,
-          "vector elements must have integer, pointer or floating point type");
+      return error( 
+          FirstEltLoc, 
+          "vector elements must have integer, pointer or floating point type"); 
 
     // Verify that all the vector elements have the same type.
     for (unsigned i = 1, e = Elts.size(); i != e; ++i)
       if (Elts[i]->getType() != Elts[0]->getType())
-        return error(FirstEltLoc, "vector element #" + Twine(i) +
-                                      " is not of type '" +
-                                      getTypeString(Elts[0]->getType()));
+        return error(FirstEltLoc, "vector element #" + Twine(i) + 
+                                      " is not of type '" + 
+                                      getTypeString(Elts[0]->getType())); 
 
     ID.ConstantVal = ConstantVector::get(Elts);
     ID.Kind = ValID::t_Constant;
@@ -3347,8 +3347,8 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     Lex.Lex();
     SmallVector<Constant*, 16> Elts;
     LocTy FirstEltLoc = Lex.getLoc();
-    if (parseGlobalValueVector(Elts) ||
-        parseToken(lltok::rsquare, "expected end of array constant"))
+    if (parseGlobalValueVector(Elts) || 
+        parseToken(lltok::rsquare, "expected end of array constant")) 
       return true;
 
     // Handle empty element.
@@ -3360,17 +3360,17 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     }
 
     if (!Elts[0]->getType()->isFirstClassType())
-      return error(FirstEltLoc, "invalid array element type: " +
-                                    getTypeString(Elts[0]->getType()));
+      return error(FirstEltLoc, "invalid array element type: " + 
+                                    getTypeString(Elts[0]->getType())); 
 
     ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
 
     // Verify all elements are correct type!
     for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
       if (Elts[i]->getType() != Elts[0]->getType())
-        return error(FirstEltLoc, "array element #" + Twine(i) +
-                                      " is not of type '" +
-                                      getTypeString(Elts[0]->getType()));
+        return error(FirstEltLoc, "array element #" + Twine(i) + 
+                                      " is not of type '" + 
+                                      getTypeString(Elts[0]->getType())); 
     }
 
     ID.ConstantVal = ConstantArray::get(ATy, Elts);
@@ -3381,8 +3381,8 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     Lex.Lex();
     ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
                                                   false);
-    if (parseToken(lltok::StringConstant, "expected string"))
-      return true;
+    if (parseToken(lltok::StringConstant, "expected string")) 
+      return true; 
     ID.Kind = ValID::t_Constant;
     return false;
 
@@ -3391,12 +3391,12 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     //             STRINGCONSTANT
     bool HasSideEffect, AlignStack, AsmDialect;
     Lex.Lex();
-    if (parseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
-        parseOptionalToken(lltok::kw_alignstack, AlignStack) ||
-        parseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
-        parseStringConstant(ID.StrVal) ||
-        parseToken(lltok::comma, "expected comma in inline asm expression") ||
-        parseToken(lltok::StringConstant, "expected constraint string"))
+    if (parseOptionalToken(lltok::kw_sideeffect, HasSideEffect) || 
+        parseOptionalToken(lltok::kw_alignstack, AlignStack) || 
+        parseOptionalToken(lltok::kw_inteldialect, AsmDialect) || 
+        parseStringConstant(ID.StrVal) || 
+        parseToken(lltok::comma, "expected comma in inline asm expression") || 
+        parseToken(lltok::StringConstant, "expected constraint string")) 
       return true;
     ID.StrVal2 = Lex.getStrVal();
     ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
@@ -3411,18 +3411,18 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
 
     ValID Fn, Label;
 
-    if (parseToken(lltok::lparen, "expected '(' in block address expression") ||
-        parseValID(Fn) ||
-        parseToken(lltok::comma,
-                   "expected comma in block address expression") ||
-        parseValID(Label) ||
-        parseToken(lltok::rparen, "expected ')' in block address expression"))
+    if (parseToken(lltok::lparen, "expected '(' in block address expression") || 
+        parseValID(Fn) || 
+        parseToken(lltok::comma, 
+                   "expected comma in block address expression") || 
+        parseValID(Label) || 
+        parseToken(lltok::rparen, "expected ')' in block address expression")) 
       return true;
 
     if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
-      return error(Fn.Loc, "expected function name in blockaddress");
+      return error(Fn.Loc, "expected function name in blockaddress"); 
     if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
-      return error(Label.Loc, "expected basic block name in blockaddress");
+      return error(Label.Loc, "expected basic block name in blockaddress"); 
 
     // Try to find the function (but skip it if it's forward-referenced).
     GlobalValue *GV = nullptr;
@@ -3436,10 +3436,10 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     if (GV) {
       // Confirm that it's actually a function with a definition.
       if (!isa<Function>(GV))
-        return error(Fn.Loc, "expected function name in blockaddress");
+        return error(Fn.Loc, "expected function name in blockaddress"); 
       F = cast<Function>(GV);
       if (F->isDeclaration())
-        return error(Fn.Loc, "cannot take blockaddress inside a declaration");
+        return error(Fn.Loc, "cannot take blockaddress inside a declaration"); 
     }
 
     if (!F) {
@@ -3463,19 +3463,19 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     BasicBlock *BB;
     if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
       if (Label.Kind == ValID::t_LocalID)
-        BB = BlockAddressPFS->getBB(Label.UIntVal, Label.Loc);
+        BB = BlockAddressPFS->getBB(Label.UIntVal, Label.Loc); 
       else
-        BB = BlockAddressPFS->getBB(Label.StrVal, Label.Loc);
+        BB = BlockAddressPFS->getBB(Label.StrVal, Label.Loc); 
       if (!BB)
-        return error(Label.Loc, "referenced value is not a basic block");
+        return error(Label.Loc, "referenced value is not a basic block"); 
     } else {
       if (Label.Kind == ValID::t_LocalID)
-        return error(Label.Loc, "cannot take address of numeric label after "
+        return error(Label.Loc, "cannot take address of numeric label after " 
                                 "the function is defined");
       BB = dyn_cast_or_null<BasicBlock>(
           F->getValueSymbolTable()->lookup(Label.StrVal));
       if (!BB)
-        return error(Label.Loc, "referenced value is not a basic block");
+        return error(Label.Loc, "referenced value is not a basic block"); 
     }
 
     ID.ConstantVal = BlockAddress::get(F, BB);
@@ -3483,39 +3483,39 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     return false;
   }
 
-  case lltok::kw_dso_local_equivalent: {
-    // ValID ::= 'dso_local_equivalent' @foo
-    Lex.Lex();
-
-    ValID Fn;
-
-    if (parseValID(Fn))
-      return true;
-
-    if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
-      return error(Fn.Loc,
-                   "expected global value name in dso_local_equivalent");
-
-    // Try to find the function (but skip it if it's forward-referenced).
-    GlobalValue *GV = nullptr;
-    if (Fn.Kind == ValID::t_GlobalID) {
-      if (Fn.UIntVal < NumberedVals.size())
-        GV = NumberedVals[Fn.UIntVal];
-    } else if (!ForwardRefVals.count(Fn.StrVal)) {
-      GV = M->getNamedValue(Fn.StrVal);
-    }
-
-    assert(GV && "Could not find a corresponding global variable");
-
-    if (!GV->getValueType()->isFunctionTy())
-      return error(Fn.Loc, "expected a function, alias to function, or ifunc "
-                           "in dso_local_equivalent");
-
-    ID.ConstantVal = DSOLocalEquivalent::get(GV);
-    ID.Kind = ValID::t_Constant;
-    return false;
-  }
-
+  case lltok::kw_dso_local_equivalent: { 
+    // ValID ::= 'dso_local_equivalent' @foo 
+    Lex.Lex(); 
+ 
+    ValID Fn; 
+ 
+    if (parseValID(Fn)) 
+      return true; 
+ 
+    if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName) 
+      return error(Fn.Loc, 
+                   "expected global value name in dso_local_equivalent"); 
+ 
+    // Try to find the function (but skip it if it's forward-referenced). 
+    GlobalValue *GV = nullptr; 
+    if (Fn.Kind == ValID::t_GlobalID) { 
+      if (Fn.UIntVal < NumberedVals.size()) 
+        GV = NumberedVals[Fn.UIntVal]; 
+    } else if (!ForwardRefVals.count(Fn.StrVal)) { 
+      GV = M->getNamedValue(Fn.StrVal); 
+    } 
+ 
+    assert(GV && "Could not find a corresponding global variable"); 
+ 
+    if (!GV->getValueType()->isFunctionTy()) 
+      return error(Fn.Loc, "expected a function, alias to function, or ifunc " 
+                           "in dso_local_equivalent"); 
+ 
+    ID.ConstantVal = DSOLocalEquivalent::get(GV); 
+    ID.Kind = ValID::t_Constant; 
+    return false; 
+  } 
+ 
   case lltok::kw_trunc:
   case lltok::kw_zext:
   case lltok::kw_sext:
@@ -3533,16 +3533,16 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     Type *DestTy = nullptr;
     Constant *SrcVal;
     Lex.Lex();
-    if (parseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
-        parseGlobalTypeAndValue(SrcVal) ||
-        parseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
-        parseType(DestTy) ||
-        parseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
+    if (parseToken(lltok::lparen, "expected '(' after constantexpr cast") || 
+        parseGlobalTypeAndValue(SrcVal) || 
+        parseToken(lltok::kw_to, "expected 'to' in constantexpr cast") || 
+        parseType(DestTy) || 
+        parseToken(lltok::rparen, "expected ')' at end of constantexpr cast")) 
       return true;
     if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
-      return error(ID.Loc, "invalid cast opcode for cast from '" +
-                               getTypeString(SrcVal->getType()) + "' to '" +
-                               getTypeString(DestTy) + "'");
+      return error(ID.Loc, "invalid cast opcode for cast from '" + 
+                               getTypeString(SrcVal->getType()) + "' to '" + 
+                               getTypeString(DestTy) + "'"); 
     ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
                                                  SrcVal, DestTy);
     ID.Kind = ValID::t_Constant;
@@ -3552,16 +3552,16 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     Lex.Lex();
     Constant *Val;
     SmallVector<unsigned, 4> Indices;
-    if (parseToken(lltok::lparen,
-                   "expected '(' in extractvalue constantexpr") ||
-        parseGlobalTypeAndValue(Val) || parseIndexList(Indices) ||
-        parseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
+    if (parseToken(lltok::lparen, 
+                   "expected '(' in extractvalue constantexpr") || 
+        parseGlobalTypeAndValue(Val) || parseIndexList(Indices) || 
+        parseToken(lltok::rparen, "expected ')' in extractvalue constantexpr")) 
       return true;
 
     if (!Val->getType()->isAggregateType())
-      return error(ID.Loc, "extractvalue operand must be aggregate type");
+      return error(ID.Loc, "extractvalue operand must be aggregate type"); 
     if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
-      return error(ID.Loc, "invalid indices for extractvalue");
+      return error(ID.Loc, "invalid indices for extractvalue"); 
     ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
     ID.Kind = ValID::t_Constant;
     return false;
@@ -3570,21 +3570,21 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     Lex.Lex();
     Constant *Val0, *Val1;
     SmallVector<unsigned, 4> Indices;
-    if (parseToken(lltok::lparen, "expected '(' in insertvalue constantexpr") ||
-        parseGlobalTypeAndValue(Val0) ||
-        parseToken(lltok::comma,
-                   "expected comma in insertvalue constantexpr") ||
-        parseGlobalTypeAndValue(Val1) || parseIndexList(Indices) ||
-        parseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
+    if (parseToken(lltok::lparen, "expected '(' in insertvalue constantexpr") || 
+        parseGlobalTypeAndValue(Val0) || 
+        parseToken(lltok::comma, 
+                   "expected comma in insertvalue constantexpr") || 
+        parseGlobalTypeAndValue(Val1) || parseIndexList(Indices) || 
+        parseToken(lltok::rparen, "expected ')' in insertvalue constantexpr")) 
       return true;
     if (!Val0->getType()->isAggregateType())
-      return error(ID.Loc, "insertvalue operand must be aggregate type");
+      return error(ID.Loc, "insertvalue operand must be aggregate type"); 
     Type *IndexedType =
         ExtractValueInst::getIndexedType(Val0->getType(), Indices);
     if (!IndexedType)
-      return error(ID.Loc, "invalid indices for insertvalue");
+      return error(ID.Loc, "invalid indices for insertvalue"); 
     if (IndexedType != Val1->getType())
-      return error(ID.Loc, "insertvalue operand and field disagree in type: '" +
+      return error(ID.Loc, "insertvalue operand and field disagree in type: '" + 
                                getTypeString(Val1->getType()) +
                                "' instead of '" + getTypeString(IndexedType) +
                                "'");
@@ -3597,28 +3597,28 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     unsigned PredVal, Opc = Lex.getUIntVal();
     Constant *Val0, *Val1;
     Lex.Lex();
-    if (parseCmpPredicate(PredVal, Opc) ||
-        parseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
-        parseGlobalTypeAndValue(Val0) ||
-        parseToken(lltok::comma, "expected comma in compare constantexpr") ||
-        parseGlobalTypeAndValue(Val1) ||
-        parseToken(lltok::rparen, "expected ')' in compare constantexpr"))
+    if (parseCmpPredicate(PredVal, Opc) || 
+        parseToken(lltok::lparen, "expected '(' in compare constantexpr") || 
+        parseGlobalTypeAndValue(Val0) || 
+        parseToken(lltok::comma, "expected comma in compare constantexpr") || 
+        parseGlobalTypeAndValue(Val1) || 
+        parseToken(lltok::rparen, "expected ')' in compare constantexpr")) 
       return true;
 
     if (Val0->getType() != Val1->getType())
-      return error(ID.Loc, "compare operands must have the same type");
+      return error(ID.Loc, "compare operands must have the same type"); 
 
     CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
 
     if (Opc == Instruction::FCmp) {
       if (!Val0->getType()->isFPOrFPVectorTy())
-        return error(ID.Loc, "fcmp requires floating point operands");
+        return error(ID.Loc, "fcmp requires floating point operands"); 
       ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
     } else {
       assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
       if (!Val0->getType()->isIntOrIntVectorTy() &&
           !Val0->getType()->isPtrOrPtrVectorTy())
-        return error(ID.Loc, "icmp requires pointer or integer operands");
+        return error(ID.Loc, "icmp requires pointer or integer operands"); 
       ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
     }
     ID.Kind = ValID::t_Constant;
@@ -3630,16 +3630,16 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     unsigned Opc = Lex.getUIntVal();
     Constant *Val;
     Lex.Lex();
-    if (parseToken(lltok::lparen, "expected '(' in unary constantexpr") ||
-        parseGlobalTypeAndValue(Val) ||
-        parseToken(lltok::rparen, "expected ')' in unary constantexpr"))
+    if (parseToken(lltok::lparen, "expected '(' in unary constantexpr") || 
+        parseGlobalTypeAndValue(Val) || 
+        parseToken(lltok::rparen, "expected ')' in unary constantexpr")) 
       return true;
 
     // Check that the type is valid for the operator.
     switch (Opc) {
     case Instruction::FNeg:
       if (!Val->getType()->isFPOrFPVectorTy())
-        return error(ID.Loc, "constexpr requires fp operands");
+        return error(ID.Loc, "constexpr requires fp operands"); 
       break;
     default: llvm_unreachable("Unknown unary operator!");
     }
@@ -3685,14 +3685,14 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
       if (EatIfPresent(lltok::kw_exact))
         Exact = true;
     }
-    if (parseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
-        parseGlobalTypeAndValue(Val0) ||
-        parseToken(lltok::comma, "expected comma in binary constantexpr") ||
-        parseGlobalTypeAndValue(Val1) ||
-        parseToken(lltok::rparen, "expected ')' in binary constantexpr"))
+    if (parseToken(lltok::lparen, "expected '(' in binary constantexpr") || 
+        parseGlobalTypeAndValue(Val0) || 
+        parseToken(lltok::comma, "expected comma in binary constantexpr") || 
+        parseGlobalTypeAndValue(Val1) || 
+        parseToken(lltok::rparen, "expected ')' in binary constantexpr")) 
       return true;
     if (Val0->getType() != Val1->getType())
-      return error(ID.Loc, "operands of constexpr must have same type");
+      return error(ID.Loc, "operands of constexpr must have same type"); 
     // Check that the type is valid for the operator.
     switch (Opc) {
     case Instruction::Add:
@@ -3706,7 +3706,7 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     case Instruction::AShr:
     case Instruction::LShr:
       if (!Val0->getType()->isIntOrIntVectorTy())
-        return error(ID.Loc, "constexpr requires integer operands");
+        return error(ID.Loc, "constexpr requires integer operands"); 
       break;
     case Instruction::FAdd:
     case Instruction::FSub:
@@ -3714,7 +3714,7 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     case Instruction::FDiv:
     case Instruction::FRem:
       if (!Val0->getType()->isFPOrFPVectorTy())
-        return error(ID.Loc, "constexpr requires fp operands");
+        return error(ID.Loc, "constexpr requires fp operands"); 
       break;
     default: llvm_unreachable("Unknown binary operator!");
     }
@@ -3735,16 +3735,16 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     unsigned Opc = Lex.getUIntVal();
     Constant *Val0, *Val1;
     Lex.Lex();
-    if (parseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
-        parseGlobalTypeAndValue(Val0) ||
-        parseToken(lltok::comma, "expected comma in logical constantexpr") ||
-        parseGlobalTypeAndValue(Val1) ||
-        parseToken(lltok::rparen, "expected ')' in logical constantexpr"))
+    if (parseToken(lltok::lparen, "expected '(' in logical constantexpr") || 
+        parseGlobalTypeAndValue(Val0) || 
+        parseToken(lltok::comma, "expected comma in logical constantexpr") || 
+        parseGlobalTypeAndValue(Val1) || 
+        parseToken(lltok::rparen, "expected ')' in logical constantexpr")) 
       return true;
     if (Val0->getType() != Val1->getType())
-      return error(ID.Loc, "operands of constexpr must have same type");
+      return error(ID.Loc, "operands of constexpr must have same type"); 
     if (!Val0->getType()->isIntOrIntVectorTy())
-      return error(ID.Loc,
+      return error(ID.Loc, 
                    "constexpr requires integer or integer vector operands");
     ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
     ID.Kind = ValID::t_Constant;
@@ -3765,31 +3765,31 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
     if (Opc == Instruction::GetElementPtr)
       InBounds = EatIfPresent(lltok::kw_inbounds);
 
-    if (parseToken(lltok::lparen, "expected '(' in constantexpr"))
+    if (parseToken(lltok::lparen, "expected '(' in constantexpr")) 
       return true;
 
     LocTy ExplicitTypeLoc = Lex.getLoc();
     if (Opc == Instruction::GetElementPtr) {
-      if (parseType(Ty) ||
-          parseToken(lltok::comma, "expected comma after getelementptr's type"))
+      if (parseType(Ty) || 
+          parseToken(lltok::comma, "expected comma after getelementptr's type")) 
         return true;
     }
 
     Optional<unsigned> InRangeOp;
-    if (parseGlobalValueVector(
+    if (parseGlobalValueVector( 
             Elts, Opc == Instruction::GetElementPtr ? &InRangeOp : nullptr) ||
-        parseToken(lltok::rparen, "expected ')' in constantexpr"))
+        parseToken(lltok::rparen, "expected ')' in constantexpr")) 
       return true;
 
     if (Opc == Instruction::GetElementPtr) {
       if (Elts.size() == 0 ||
           !Elts[0]->getType()->isPtrOrPtrVectorTy())
-        return error(ID.Loc, "base of getelementptr must be a pointer");
+        return error(ID.Loc, "base of getelementptr must be a pointer"); 
 
       Type *BaseType = Elts[0]->getType();
       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
       if (Ty != BasePointerType->getElementType())
-        return error(
+        return error( 
             ExplicitTypeLoc,
             "explicit pointee type doesn't match operand's pointee type");
 
@@ -3802,11 +3802,11 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
       for (Constant *Val : Indices) {
         Type *ValTy = Val->getType();
         if (!ValTy->isIntOrIntVectorTy())
-          return error(ID.Loc, "getelementptr index must be an integer");
+          return error(ID.Loc, "getelementptr index must be an integer"); 
         if (auto *ValVTy = dyn_cast<VectorType>(ValTy)) {
           unsigned ValNumEl = cast<FixedVectorType>(ValVTy)->getNumElements();
           if (GEPWidth && (ValNumEl != GEPWidth))
-            return error(
+            return error( 
                 ID.Loc,
                 "getelementptr vector index has a wrong number of elements");
           // GEPWidth may have been unknown because the base is a scalar,
@@ -3817,14 +3817,14 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
 
       SmallPtrSet<Type*, 4> Visited;
       if (!Indices.empty() && !Ty->isSized(&Visited))
-        return error(ID.Loc, "base element of getelementptr must be sized");
+        return error(ID.Loc, "base element of getelementptr must be sized"); 
 
       if (!GetElementPtrInst::getIndexedType(Ty, Indices))
-        return error(ID.Loc, "invalid getelementptr indices");
+        return error(ID.Loc, "invalid getelementptr indices"); 
 
       if (InRangeOp) {
         if (*InRangeOp == 0)
-          return error(ID.Loc,
+          return error(ID.Loc, 
                        "inrange keyword may not appear on pointer operand");
         --*InRangeOp;
       }
@@ -3833,31 +3833,31 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
                                                       InBounds, InRangeOp);
     } else if (Opc == Instruction::Select) {
       if (Elts.size() != 3)
-        return error(ID.Loc, "expected three operands to select");
+        return error(ID.Loc, "expected three operands to select"); 
       if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
                                                               Elts[2]))
-        return error(ID.Loc, Reason);
+        return error(ID.Loc, Reason); 
       ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
     } else if (Opc == Instruction::ShuffleVector) {
       if (Elts.size() != 3)
-        return error(ID.Loc, "expected three operands to shufflevector");
+        return error(ID.Loc, "expected three operands to shufflevector"); 
       if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
-        return error(ID.Loc, "invalid operands to shufflevector");
+        return error(ID.Loc, "invalid operands to shufflevector"); 
       SmallVector<int, 16> Mask;
       ShuffleVectorInst::getShuffleMask(cast<Constant>(Elts[2]), Mask);
       ID.ConstantVal = ConstantExpr::getShuffleVector(Elts[0], Elts[1], Mask);
     } else if (Opc == Instruction::ExtractElement) {
       if (Elts.size() != 2)
-        return error(ID.Loc, "expected two operands to extractelement");
+        return error(ID.Loc, "expected two operands to extractelement"); 
       if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
-        return error(ID.Loc, "invalid extractelement operands");
+        return error(ID.Loc, "invalid extractelement operands"); 
       ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
     } else {
       assert(Opc == Instruction::InsertElement && "Unknown opcode");
       if (Elts.size() != 3)
-        return error(ID.Loc, "expected three operands to insertelement");
+        return error(ID.Loc, "expected three operands to insertelement"); 
       if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
-        return error(ID.Loc, "invalid insertelement operands");
+        return error(ID.Loc, "invalid insertelement operands"); 
       ID.ConstantVal =
                  ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
     }
@@ -3871,21 +3871,21 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
   return false;
 }
 
-/// parseGlobalValue - parse a global value with the specified type.
-bool LLParser::parseGlobalValue(Type *Ty, Constant *&C) {
+/// parseGlobalValue - parse a global value with the specified type. 
+bool LLParser::parseGlobalValue(Type *Ty, Constant *&C) { 
   C = nullptr;
   ValID ID;
   Value *V = nullptr;
-  bool Parsed = parseValID(ID) ||
-                convertValIDToValue(Ty, ID, V, nullptr, /*IsCall=*/false);
+  bool Parsed = parseValID(ID) || 
+                convertValIDToValue(Ty, ID, V, nullptr, /*IsCall=*/false); 
   if (V && !(C = dyn_cast<Constant>(V)))
-    return error(ID.Loc, "global values must be constants");
+    return error(ID.Loc, "global values must be constants"); 
   return Parsed;
 }
 
-bool LLParser::parseGlobalTypeAndValue(Constant *&V) {
+bool LLParser::parseGlobalTypeAndValue(Constant *&V) { 
   Type *Ty = nullptr;
-  return parseType(Ty) || parseGlobalValue(Ty, V);
+  return parseType(Ty) || parseGlobalValue(Ty, V); 
 }
 
 bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
@@ -3897,24 +3897,24 @@ bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
 
   if (EatIfPresent(lltok::lparen)) {
     if (Lex.getKind() != lltok::ComdatVar)
-      return tokError("expected comdat variable");
+      return tokError("expected comdat variable"); 
     C = getComdat(Lex.getStrVal(), Lex.getLoc());
     Lex.Lex();
-    if (parseToken(lltok::rparen, "expected ')' after comdat var"))
+    if (parseToken(lltok::rparen, "expected ')' after comdat var")) 
       return true;
   } else {
     if (GlobalName.empty())
-      return tokError("comdat cannot be unnamed");
+      return tokError("comdat cannot be unnamed"); 
     C = getComdat(std::string(GlobalName), KwLoc);
   }
 
   return false;
 }
 
-/// parseGlobalValueVector
+/// parseGlobalValueVector 
 ///   ::= /*empty*/
 ///   ::= [inrange] TypeAndValue (',' [inrange] TypeAndValue)*
-bool LLParser::parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
+bool LLParser::parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts, 
                                       Optional<unsigned> *InRangeOp) {
   // Empty list.
   if (Lex.getKind() == lltok::rbrace ||
@@ -3928,17 +3928,17 @@ bool LLParser::parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
       *InRangeOp = Elts.size();
 
     Constant *C;
-    if (parseGlobalTypeAndValue(C))
-      return true;
+    if (parseGlobalTypeAndValue(C)) 
+      return true; 
     Elts.push_back(C);
   } while (EatIfPresent(lltok::comma));
 
   return false;
 }
 
-bool LLParser::parseMDTuple(MDNode *&MD, bool IsDistinct) {
+bool LLParser::parseMDTuple(MDNode *&MD, bool IsDistinct) { 
   SmallVector<Metadata *, 16> Elts;
-  if (parseMDNodeVector(Elts))
+  if (parseMDNodeVector(Elts)) 
     return true;
 
   MD = (IsDistinct ? MDTuple::getDistinct : MDTuple::get)(Context, Elts);
@@ -3949,20 +3949,20 @@ bool LLParser::parseMDTuple(MDNode *&MD, bool IsDistinct) {
 ///  ::= !{ ... }
 ///  ::= !7
 ///  ::= !DILocation(...)
-bool LLParser::parseMDNode(MDNode *&N) {
+bool LLParser::parseMDNode(MDNode *&N) { 
   if (Lex.getKind() == lltok::MetadataVar)
-    return parseSpecializedMDNode(N);
+    return parseSpecializedMDNode(N); 
 
-  return parseToken(lltok::exclaim, "expected '!' here") || parseMDNodeTail(N);
+  return parseToken(lltok::exclaim, "expected '!' here") || parseMDNodeTail(N); 
 }
 
-bool LLParser::parseMDNodeTail(MDNode *&N) {
+bool LLParser::parseMDNodeTail(MDNode *&N) { 
   // !{ ... }
   if (Lex.getKind() == lltok::lbrace)
-    return parseMDTuple(N);
+    return parseMDTuple(N); 
 
   // !42
-  return parseMDNodeID(N);
+  return parseMDNodeID(N); 
 }
 
 namespace {
@@ -4160,9 +4160,9 @@ struct MDSignedOrUnsignedField
 namespace llvm {
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDAPSIntField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDAPSIntField &Result) { 
   if (Lex.getKind() != lltok::APSInt)
-    return tokError("expected integer");
+    return tokError("expected integer"); 
 
   Result.assign(Lex.getAPSIntVal());
   Lex.Lex();
@@ -4170,14 +4170,14 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDAPSIntField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             MDUnsignedField &Result) {
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
-    return tokError("expected unsigned integer");
+    return tokError("expected unsigned integer"); 
 
   auto &U = Lex.getAPSIntVal();
   if (U.ugt(Result.Max))
-    return tokError("value for '" + Name + "' too large, limit is " +
+    return tokError("value for '" + Name + "' too large, limit is " + 
                     Twine(Result.Max));
   Result.assign(U.getZExtValue());
   assert(Result.Val <= Result.Max && "Expected value in range");
@@ -4186,25 +4186,25 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, LineField &Result) {
-  return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, LineField &Result) { 
+  return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 }
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, ColumnField &Result) {
-  return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, ColumnField &Result) { 
+  return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) { 
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::DwarfTag)
-    return tokError("expected DWARF tag");
+    return tokError("expected DWARF tag"); 
 
   unsigned Tag = dwarf::getTag(Lex.getStrVal());
   if (Tag == dwarf::DW_TAG_invalid)
-    return tokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'");
+    return tokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'"); 
   assert(Tag <= Result.Max && "Expected valid DWARF tag");
 
   Result.assign(Tag);
@@ -4213,18 +4213,18 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             DwarfMacinfoTypeField &Result) {
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::DwarfMacinfo)
-    return tokError("expected DWARF macinfo type");
+    return tokError("expected DWARF macinfo type"); 
 
   unsigned Macinfo = dwarf::getMacinfo(Lex.getStrVal());
   if (Macinfo == dwarf::DW_MACINFO_invalid)
-    return tokError("invalid DWARF macinfo type" + Twine(" '") +
-                    Lex.getStrVal() + "'");
+    return tokError("invalid DWARF macinfo type" + Twine(" '") + 
+                    Lex.getStrVal() + "'"); 
   assert(Macinfo <= Result.Max && "Expected valid DWARF macinfo type");
 
   Result.assign(Macinfo);
@@ -4233,17 +4233,17 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             DwarfVirtualityField &Result) {
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::DwarfVirtuality)
-    return tokError("expected DWARF virtuality code");
+    return tokError("expected DWARF virtuality code"); 
 
   unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
   if (Virtuality == dwarf::DW_VIRTUALITY_invalid)
-    return tokError("invalid DWARF virtuality code" + Twine(" '") +
+    return tokError("invalid DWARF virtuality code" + Twine(" '") + 
                     Lex.getStrVal() + "'");
   assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code");
   Result.assign(Virtuality);
@@ -4252,16 +4252,16 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) { 
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::DwarfLang)
-    return tokError("expected DWARF language");
+    return tokError("expected DWARF language"); 
 
   unsigned Lang = dwarf::getLanguage(Lex.getStrVal());
   if (!Lang)
-    return tokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() +
+    return tokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() + 
                     "'");
   assert(Lang <= Result.Max && "Expected valid DWARF language");
   Result.assign(Lang);
@@ -4270,17 +4270,17 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) { 
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::DwarfCC)
-    return tokError("expected DWARF calling convention");
+    return tokError("expected DWARF calling convention"); 
 
   unsigned CC = dwarf::getCallingConvention(Lex.getStrVal());
   if (!CC)
-    return tokError("invalid DWARF calling convention" + Twine(" '") +
-                    Lex.getStrVal() + "'");
+    return tokError("invalid DWARF calling convention" + Twine(" '") + 
+                    Lex.getStrVal() + "'"); 
   assert(CC <= Result.Max && "Expected valid DWARF calling convention");
   Result.assign(CC);
   Lex.Lex();
@@ -4288,17 +4288,17 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
-                            EmissionKindField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
+                            EmissionKindField &Result) { 
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::EmissionKind)
-    return tokError("expected emission kind");
+    return tokError("expected emission kind"); 
 
   auto Kind = DICompileUnit::getEmissionKind(Lex.getStrVal());
   if (!Kind)
-    return tokError("invalid emission kind" + Twine(" '") + Lex.getStrVal() +
+    return tokError("invalid emission kind" + Twine(" '") + Lex.getStrVal() + 
                     "'");
   assert(*Kind <= Result.Max && "Expected valid emission kind");
   Result.assign(*Kind);
@@ -4307,17 +4307,17 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             NameTableKindField &Result) {
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::NameTableKind)
-    return tokError("expected nameTable kind");
+    return tokError("expected nameTable kind"); 
 
   auto Kind = DICompileUnit::getNameTableKind(Lex.getStrVal());
   if (!Kind)
-    return tokError("invalid nameTable kind" + Twine(" '") + Lex.getStrVal() +
+    return tokError("invalid nameTable kind" + Twine(" '") + Lex.getStrVal() + 
                     "'");
   assert(((unsigned)*Kind) <= Result.Max && "Expected valid nameTable kind");
   Result.assign((unsigned)*Kind);
@@ -4326,17 +4326,17 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             DwarfAttEncodingField &Result) {
   if (Lex.getKind() == lltok::APSInt)
-    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+    return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); 
 
   if (Lex.getKind() != lltok::DwarfAttEncoding)
-    return tokError("expected DWARF type attribute encoding");
+    return tokError("expected DWARF type attribute encoding"); 
 
   unsigned Encoding = dwarf::getAttributeEncoding(Lex.getStrVal());
   if (!Encoding)
-    return tokError("invalid DWARF type attribute encoding" + Twine(" '") +
+    return tokError("invalid DWARF type attribute encoding" + Twine(" '") + 
                     Lex.getStrVal() + "'");
   assert(Encoding <= Result.Max && "Expected valid DWARF language");
   Result.assign(Encoding);
@@ -4349,29 +4349,29 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 ///  ::= DIFlagVector
 ///  ::= DIFlagVector '|' DIFlagFwdDecl '|' uint32 '|' DIFlagPublic
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) { 
 
-  // parser for a single flag.
+  // parser for a single flag. 
   auto parseFlag = [&](DINode::DIFlags &Val) {
     if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
       uint32_t TempVal = static_cast<uint32_t>(Val);
-      bool Res = parseUInt32(TempVal);
+      bool Res = parseUInt32(TempVal); 
       Val = static_cast<DINode::DIFlags>(TempVal);
       return Res;
     }
 
     if (Lex.getKind() != lltok::DIFlag)
-      return tokError("expected debug info flag");
+      return tokError("expected debug info flag"); 
 
     Val = DINode::getFlag(Lex.getStrVal());
     if (!Val)
-      return tokError(Twine("invalid debug info flag flag '") +
+      return tokError(Twine("invalid debug info flag flag '") + 
                       Lex.getStrVal() + "'");
     Lex.Lex();
     return false;
   };
 
-  // parse the flags and combine them together.
+  // parse the flags and combine them together. 
   DINode::DIFlags Combined = DINode::FlagZero;
   do {
     DINode::DIFlags Val;
@@ -4389,29 +4389,29 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
 ///  ::= DISPFlagVector
 ///  ::= DISPFlagVector '|' DISPFlag* '|' uint32
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, DISPFlagField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, DISPFlagField &Result) { 
 
-  // parser for a single flag.
+  // parser for a single flag. 
   auto parseFlag = [&](DISubprogram::DISPFlags &Val) {
     if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
       uint32_t TempVal = static_cast<uint32_t>(Val);
-      bool Res = parseUInt32(TempVal);
+      bool Res = parseUInt32(TempVal); 
       Val = static_cast<DISubprogram::DISPFlags>(TempVal);
       return Res;
     }
 
     if (Lex.getKind() != lltok::DISPFlag)
-      return tokError("expected debug info flag");
+      return tokError("expected debug info flag"); 
 
     Val = DISubprogram::getFlag(Lex.getStrVal());
     if (!Val)
-      return tokError(Twine("invalid subprogram debug info flag '") +
+      return tokError(Twine("invalid subprogram debug info flag '") + 
                       Lex.getStrVal() + "'");
     Lex.Lex();
     return false;
   };
 
-  // parse the flags and combine them together.
+  // parse the flags and combine them together. 
   DISubprogram::DISPFlags Combined = DISubprogram::SPFlagZero;
   do {
     DISubprogram::DISPFlags Val;
@@ -4425,16 +4425,16 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, DISPFlagField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDSignedField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDSignedField &Result) { 
   if (Lex.getKind() != lltok::APSInt)
-    return tokError("expected signed integer");
+    return tokError("expected signed integer"); 
 
   auto &S = Lex.getAPSIntVal();
   if (S < Result.Min)
-    return tokError("value for '" + Name + "' too small, limit is " +
+    return tokError("value for '" + Name + "' too small, limit is " + 
                     Twine(Result.Min));
   if (S > Result.Max)
-    return tokError("value for '" + Name + "' too large, limit is " +
+    return tokError("value for '" + Name + "' too large, limit is " + 
                     Twine(Result.Max));
   Result.assign(S.getExtValue());
   assert(Result.Val >= Result.Min && "Expected value in range");
@@ -4444,10 +4444,10 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDSignedField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) { 
   switch (Lex.getKind()) {
   default:
-    return tokError("expected 'true' or 'false'");
+    return tokError("expected 'true' or 'false'"); 
   case lltok::kw_true:
     Result.assign(true);
     break;
@@ -4460,17 +4460,17 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDField &Result) { 
   if (Lex.getKind() == lltok::kw_null) {
     if (!Result.AllowNull)
-      return tokError("'" + Name + "' cannot be null");
+      return tokError("'" + Name + "' cannot be null"); 
     Lex.Lex();
     Result.assign(nullptr);
     return false;
   }
 
   Metadata *MD;
-  if (parseMetadata(MD, nullptr))
+  if (parseMetadata(MD, nullptr)) 
     return true;
 
   Result.assign(MD);
@@ -4478,12 +4478,12 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDField &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             MDSignedOrMDField &Result) {
   // Try to parse a signed int.
   if (Lex.getKind() == lltok::APSInt) {
     MDSignedField Res = Result.A;
-    if (!parseMDField(Loc, Name, Res)) {
+    if (!parseMDField(Loc, Name, Res)) { 
       Result.assign(Res);
       return false;
     }
@@ -4492,7 +4492,7 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 
   // Otherwise, try to parse as an MDField.
   MDField Res = Result.B;
-  if (!parseMDField(Loc, Name, Res)) {
+  if (!parseMDField(Loc, Name, Res)) { 
     Result.assign(Res);
     return false;
   }
@@ -4501,23 +4501,23 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDStringField &Result) { 
   LocTy ValueLoc = Lex.getLoc();
   std::string S;
-  if (parseStringConstant(S))
+  if (parseStringConstant(S)) 
     return true;
 
   if (!Result.AllowEmpty && S.empty())
-    return error(ValueLoc, "'" + Name + "' cannot be empty");
+    return error(ValueLoc, "'" + Name + "' cannot be empty"); 
 
   Result.assign(S.empty() ? nullptr : MDString::get(Context, S));
   return false;
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) { 
   SmallVector<Metadata *, 4> MDs;
-  if (parseMDNodeVector(MDs))
+  if (parseMDNodeVector(MDs)) 
     return true;
 
   Result.assign(std::move(MDs));
@@ -4525,14 +4525,14 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
 }
 
 template <>
-bool LLParser::parseMDField(LocTy Loc, StringRef Name,
+bool LLParser::parseMDField(LocTy Loc, StringRef Name, 
                             ChecksumKindField &Result) {
   Optional<DIFile::ChecksumKind> CSKind =
       DIFile::getChecksumKind(Lex.getStrVal());
 
   if (Lex.getKind() != lltok::ChecksumKind || !CSKind)
-    return tokError("invalid checksum kind" + Twine(" '") + Lex.getStrVal() +
-                    "'");
+    return tokError("invalid checksum kind" + Twine(" '") + Lex.getStrVal() + 
+                    "'"); 
 
   Result.assign(*CSKind);
   Lex.Lex();
@@ -4542,12 +4542,12 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name,
 } // end namespace llvm
 
 template <class ParserTy>
-bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) {
+bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) { 
   do {
     if (Lex.getKind() != lltok::LabelStr)
-      return tokError("expected field label here");
+      return tokError("expected field label here"); 
 
-    if (ParseField())
+    if (ParseField()) 
       return true;
   } while (EatIfPresent(lltok::comma));
 
@@ -4555,70 +4555,70 @@ bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) {
 }
 
 template <class ParserTy>
-bool LLParser::parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc) {
+bool LLParser::parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc) { 
   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
   Lex.Lex();
 
-  if (parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::lparen, "expected '(' here")) 
     return true;
   if (Lex.getKind() != lltok::rparen)
-    if (parseMDFieldsImplBody(ParseField))
+    if (parseMDFieldsImplBody(ParseField)) 
       return true;
 
   ClosingLoc = Lex.getLoc();
-  return parseToken(lltok::rparen, "expected ')' here");
+  return parseToken(lltok::rparen, "expected ')' here"); 
 }
 
 template <class FieldTy>
-bool LLParser::parseMDField(StringRef Name, FieldTy &Result) {
+bool LLParser::parseMDField(StringRef Name, FieldTy &Result) { 
   if (Result.Seen)
-    return tokError("field '" + Name + "' cannot be specified more than once");
+    return tokError("field '" + Name + "' cannot be specified more than once"); 
 
   LocTy Loc = Lex.getLoc();
   Lex.Lex();
-  return parseMDField(Loc, Name, Result);
+  return parseMDField(Loc, Name, Result); 
 }
 
-bool LLParser::parseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
+bool LLParser::parseSpecializedMDNode(MDNode *&N, bool IsDistinct) { 
   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
 
 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
   if (Lex.getStrVal() == #CLASS)                                               \
-    return parse##CLASS(N, IsDistinct);
+    return parse##CLASS(N, IsDistinct); 
 #include "llvm/IR/Metadata.def"
 
-  return tokError("expected metadata type");
+  return tokError("expected metadata type"); 
 }
 
 #define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
 #define NOP_FIELD(NAME, TYPE, INIT)
 #define REQUIRE_FIELD(NAME, TYPE, INIT)                                        \
   if (!NAME.Seen)                                                              \
-    return error(ClosingLoc, "missing required field '" #NAME "'");
+    return error(ClosingLoc, "missing required field '" #NAME "'"); 
 #define PARSE_MD_FIELD(NAME, TYPE, DEFAULT)                                    \
   if (Lex.getStrVal() == #NAME)                                                \
-    return parseMDField(#NAME, NAME);
+    return parseMDField(#NAME, NAME); 
 #define PARSE_MD_FIELDS()                                                      \
   VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD)                                \
   do {                                                                         \
     LocTy ClosingLoc;                                                          \
-    if (parseMDFieldsImpl(                                                     \
-            [&]() -> bool {                                                    \
-              VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD)                  \
-              return tokError(Twine("invalid field '") + Lex.getStrVal() +     \
-                              "'");                                            \
-            },                                                                 \
-            ClosingLoc))                                                       \
+    if (parseMDFieldsImpl(                                                     \ 
+            [&]() -> bool {                                                    \ 
+              VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD)                  \ 
+              return tokError(Twine("invalid field '") + Lex.getStrVal() +     \ 
+                              "'");                                            \ 
+            },                                                                 \ 
+            ClosingLoc))                                                       \ 
       return true;                                                             \
     VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD)                                  \
   } while (false)
 #define GET_OR_DISTINCT(CLASS, ARGS)                                           \
   (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
 
-/// parseDILocationFields:
+/// parseDILocationFields: 
 ///   ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6,
 ///   isImplicitCode: true)
-bool LLParser::parseDILocation(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDILocation(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(column, ColumnField, );                                             \
@@ -4634,9 +4634,9 @@ bool LLParser::parseDILocation(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseGenericDINode:
+/// parseGenericDINode: 
 ///   ::= !GenericDINode(tag: 15, header: "...", operands: {...})
-bool LLParser::parseGenericDINode(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseGenericDINode(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(header, MDStringField, );                                           \
@@ -4649,11 +4649,11 @@ bool LLParser::parseGenericDINode(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDISubrange:
+/// parseDISubrange: 
 ///   ::= !DISubrange(count: 30, lowerBound: 2)
 ///   ::= !DISubrange(count: !node, lowerBound: 2)
 ///   ::= !DISubrange(lowerBound: !node1, upperBound: !node2, stride: !node3)
-bool LLParser::parseDISubrange(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDISubrange(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(count, MDSignedOrMDField, (-1, -1, INT64_MAX, false));              \
   OPTIONAL(lowerBound, MDSignedOrMDField, );                                   \
@@ -4691,42 +4691,42 @@ bool LLParser::parseDISubrange(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIGenericSubrange:
-///   ::= !DIGenericSubrange(lowerBound: !node1, upperBound: !node2, stride:
-///   !node3)
-bool LLParser::parseDIGenericSubrange(MDNode *&Result, bool IsDistinct) {
-#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
-  OPTIONAL(count, MDSignedOrMDField, );                                        \
-  OPTIONAL(lowerBound, MDSignedOrMDField, );                                   \
-  OPTIONAL(upperBound, MDSignedOrMDField, );                                   \
-  OPTIONAL(stride, MDSignedOrMDField, );
-  PARSE_MD_FIELDS();
-#undef VISIT_MD_FIELDS
-
-  auto ConvToMetadata = [&](MDSignedOrMDField Bound) -> Metadata * {
-    if (Bound.isMDSignedField())
-      return DIExpression::get(
-          Context, {dwarf::DW_OP_consts,
-                    static_cast<uint64_t>(Bound.getMDSignedValue())});
-    if (Bound.isMDField())
-      return Bound.getMDFieldValue();
-    return nullptr;
-  };
-
-  Metadata *Count = ConvToMetadata(count);
-  Metadata *LowerBound = ConvToMetadata(lowerBound);
-  Metadata *UpperBound = ConvToMetadata(upperBound);
-  Metadata *Stride = ConvToMetadata(stride);
-
-  Result = GET_OR_DISTINCT(DIGenericSubrange,
-                           (Context, Count, LowerBound, UpperBound, Stride));
-
-  return false;
-}
-
-/// parseDIEnumerator:
+/// parseDIGenericSubrange: 
+///   ::= !DIGenericSubrange(lowerBound: !node1, upperBound: !node2, stride: 
+///   !node3) 
+bool LLParser::parseDIGenericSubrange(MDNode *&Result, bool IsDistinct) { 
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \ 
+  OPTIONAL(count, MDSignedOrMDField, );                                        \ 
+  OPTIONAL(lowerBound, MDSignedOrMDField, );                                   \ 
+  OPTIONAL(upperBound, MDSignedOrMDField, );                                   \ 
+  OPTIONAL(stride, MDSignedOrMDField, ); 
+  PARSE_MD_FIELDS(); 
+#undef VISIT_MD_FIELDS 
+ 
+  auto ConvToMetadata = [&](MDSignedOrMDField Bound) -> Metadata * { 
+    if (Bound.isMDSignedField()) 
+      return DIExpression::get( 
+          Context, {dwarf::DW_OP_consts, 
+                    static_cast<uint64_t>(Bound.getMDSignedValue())}); 
+    if (Bound.isMDField()) 
+      return Bound.getMDFieldValue(); 
+    return nullptr; 
+  }; 
+ 
+  Metadata *Count = ConvToMetadata(count); 
+  Metadata *LowerBound = ConvToMetadata(lowerBound); 
+  Metadata *UpperBound = ConvToMetadata(upperBound); 
+  Metadata *Stride = ConvToMetadata(stride); 
+ 
+  Result = GET_OR_DISTINCT(DIGenericSubrange, 
+                           (Context, Count, LowerBound, UpperBound, Stride)); 
+ 
+  return false; 
+} 
+ 
+/// parseDIEnumerator: 
 ///   ::= !DIEnumerator(value: 30, isUnsigned: true, name: "SomeKind")
-bool LLParser::parseDIEnumerator(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIEnumerator(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(name, MDStringField, );                                             \
   REQUIRED(value, MDAPSIntField, );                                            \
@@ -4735,7 +4735,7 @@ bool LLParser::parseDIEnumerator(MDNode *&Result, bool IsDistinct) {
 #undef VISIT_MD_FIELDS
 
   if (isUnsigned.Val && value.Val.isNegative())
-    return tokError("unsigned enumerator with negative value");
+    return tokError("unsigned enumerator with negative value"); 
 
   APSInt Value(value.Val);
   // Add a leading zero so that unsigned values with the msb set are not
@@ -4749,10 +4749,10 @@ bool LLParser::parseDIEnumerator(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIBasicType:
+/// parseDIBasicType: 
 ///   ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32,
 ///                    encoding: DW_ATE_encoding, flags: 0)
-bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type));                     \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4768,33 +4768,33 @@ bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIStringType:
-///   ::= !DIStringType(name: "character(4)", size: 32, align: 32)
-bool LLParser::parseDIStringType(MDNode *&Result, bool IsDistinct) {
-#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
-  OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_string_type));                   \
-  OPTIONAL(name, MDStringField, );                                             \
-  OPTIONAL(stringLength, MDField, );                                           \
-  OPTIONAL(stringLengthExpression, MDField, );                                 \
-  OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
-  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \
-  OPTIONAL(encoding, DwarfAttEncodingField, );
-  PARSE_MD_FIELDS();
-#undef VISIT_MD_FIELDS
-
-  Result = GET_OR_DISTINCT(DIStringType,
-                           (Context, tag.Val, name.Val, stringLength.Val,
-                            stringLengthExpression.Val, size.Val, align.Val,
-                            encoding.Val));
-  return false;
-}
-
-/// parseDIDerivedType:
+/// parseDIStringType: 
+///   ::= !DIStringType(name: "character(4)", size: 32, align: 32) 
+bool LLParser::parseDIStringType(MDNode *&Result, bool IsDistinct) { 
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \ 
+  OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_string_type));                   \ 
+  OPTIONAL(name, MDStringField, );                                             \ 
+  OPTIONAL(stringLength, MDField, );                                           \ 
+  OPTIONAL(stringLengthExpression, MDField, );                                 \ 
+  OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \ 
+  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \ 
+  OPTIONAL(encoding, DwarfAttEncodingField, ); 
+  PARSE_MD_FIELDS(); 
+#undef VISIT_MD_FIELDS 
+ 
+  Result = GET_OR_DISTINCT(DIStringType, 
+                           (Context, tag.Val, name.Val, stringLength.Val, 
+                            stringLengthExpression.Val, size.Val, align.Val, 
+                            encoding.Val)); 
+  return false; 
+} 
+ 
+/// parseDIDerivedType: 
 ///   ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
 ///                      line: 7, scope: !1, baseType: !2, size: 32,
 ///                      align: 32, offset: 0, flags: 0, extraData: !3,
 ///                      dwarfAddressSpace: 3)
-bool LLParser::parseDIDerivedType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIDerivedType(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4823,7 +4823,7 @@ bool LLParser::parseDIDerivedType(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-bool LLParser::parseDICompositeType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDICompositeType(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4841,28 +4841,28 @@ bool LLParser::parseDICompositeType(MDNode *&Result, bool IsDistinct) {
   OPTIONAL(templateParams, MDField, );                                         \
   OPTIONAL(identifier, MDStringField, );                                       \
   OPTIONAL(discriminator, MDField, );                                          \
-  OPTIONAL(dataLocation, MDField, );                                           \
-  OPTIONAL(associated, MDField, );                                             \
-  OPTIONAL(allocated, MDField, );                                              \
-  OPTIONAL(rank, MDSignedOrMDField, );
+  OPTIONAL(dataLocation, MDField, );                                           \ 
+  OPTIONAL(associated, MDField, );                                             \ 
+  OPTIONAL(allocated, MDField, );                                              \ 
+  OPTIONAL(rank, MDSignedOrMDField, ); 
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Metadata *Rank = nullptr;
-  if (rank.isMDSignedField())
-    Rank = ConstantAsMetadata::get(ConstantInt::getSigned(
-        Type::getInt64Ty(Context), rank.getMDSignedValue()));
-  else if (rank.isMDField())
-    Rank = rank.getMDFieldValue();
-
+  Metadata *Rank = nullptr; 
+  if (rank.isMDSignedField()) 
+    Rank = ConstantAsMetadata::get(ConstantInt::getSigned( 
+        Type::getInt64Ty(Context), rank.getMDSignedValue())); 
+  else if (rank.isMDField()) 
+    Rank = rank.getMDFieldValue(); 
+ 
   // If this has an identifier try to build an ODR type.
   if (identifier.Val)
     if (auto *CT = DICompositeType::buildODRType(
             Context, *identifier.Val, tag.Val, name.Val, file.Val, line.Val,
             scope.Val, baseType.Val, size.Val, align.Val, offset.Val, flags.Val,
             elements.Val, runtimeLang.Val, vtableHolder.Val, templateParams.Val,
-            discriminator.Val, dataLocation.Val, associated.Val, allocated.Val,
-            Rank)) {
+            discriminator.Val, dataLocation.Val, associated.Val, allocated.Val, 
+            Rank)) { 
       Result = CT;
       return false;
     }
@@ -4874,12 +4874,12 @@ bool LLParser::parseDICompositeType(MDNode *&Result, bool IsDistinct) {
       (Context, tag.Val, name.Val, file.Val, line.Val, scope.Val, baseType.Val,
        size.Val, align.Val, offset.Val, flags.Val, elements.Val,
        runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val,
-       discriminator.Val, dataLocation.Val, associated.Val, allocated.Val,
-       Rank));
+       discriminator.Val, dataLocation.Val, associated.Val, allocated.Val, 
+       Rank)); 
   return false;
 }
 
-bool LLParser::parseDISubroutineType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDISubroutineType(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(flags, DIFlagField, );                                              \
   OPTIONAL(cc, DwarfCCField, );                                                \
@@ -4892,12 +4892,12 @@ bool LLParser::parseDISubroutineType(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIFileType:
+/// parseDIFileType: 
 ///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir",
 ///                   checksumkind: CSK_MD5,
 ///                   checksum: "000102030405060708090a0b0c0d0e0f",
 ///                   source: "source file contents")
-bool LLParser::parseDIFile(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIFile(MDNode *&Result, bool IsDistinct) { 
   // The default constructed value for checksumkind is required, but will never
   // be used, as the parser checks if the field was actually Seen before using
   // the Val.
@@ -4924,14 +4924,14 @@ bool LLParser::parseDIFile(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDICompileUnit:
+/// parseDICompileUnit: 
 ///   ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
 ///                      isOptimized: true, flags: "-O2", runtimeVersion: 1,
 ///                      splitDebugFilename: "abc.debug",
 ///                      emissionKind: FullDebug, enums: !1, retainedTypes: !2,
 ///                      globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd,
 ///                      sysroot: "/", sdk: "MacOSX.sdk")
-bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) { 
   if (!IsDistinct)
     return Lex.Error("missing 'distinct', required for !DICompileUnit");
 
@@ -4968,7 +4968,7 @@ bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDISubprogram:
+/// parseDISubprogram: 
 ///   ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
 ///                     file: !1, line: 7, type: !2, isLocal: false,
 ///                     isDefinition: true, scopeLine: 8, containingType: !3,
@@ -4976,7 +4976,7 @@ bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) {
 ///                     virtualIndex: 10, thisAdjustment: 4, flags: 11,
 ///                     spFlags: 10, isOptimized: false, templateParams: !4,
 ///                     declaration: !5, retainedNodes: !6, thrownTypes: !7)
-bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) { 
   auto Loc = Lex.getLoc();
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(scope, MDField, );                                                  \
@@ -5022,9 +5022,9 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDILexicalBlock:
+/// parseDILexicalBlock: 
 ///   ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
-bool LLParser::parseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDILexicalBlock(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(file, MDField, );                                                   \
@@ -5038,9 +5038,9 @@ bool LLParser::parseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDILexicalBlockFile:
+/// parseDILexicalBlockFile: 
 ///   ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
-bool LLParser::parseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(file, MDField, );                                                   \
@@ -5053,9 +5053,9 @@ bool LLParser::parseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDICommonBlock:
+/// parseDICommonBlock: 
 ///   ::= !DICommonBlock(scope: !0, file: !2, name: "COMMON name", line: 9)
-bool LLParser::parseDICommonBlock(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDICommonBlock(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   OPTIONAL(declaration, MDField, );                                            \
@@ -5071,9 +5071,9 @@ bool LLParser::parseDICommonBlock(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDINamespace:
+/// parseDINamespace: 
 ///   ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
-bool LLParser::parseDINamespace(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDINamespace(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   OPTIONAL(name, MDStringField, );                                             \
@@ -5086,10 +5086,10 @@ bool LLParser::parseDINamespace(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIMacro:
-///   ::= !DIMacro(macinfo: type, line: 9, name: "SomeMacro", value:
-///   "SomeValue")
-bool LLParser::parseDIMacro(MDNode *&Result, bool IsDistinct) {
+/// parseDIMacro: 
+///   ::= !DIMacro(macinfo: type, line: 9, name: "SomeMacro", value: 
+///   "SomeValue") 
+bool LLParser::parseDIMacro(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(type, DwarfMacinfoTypeField, );                                     \
   OPTIONAL(line, LineField, );                                                 \
@@ -5103,9 +5103,9 @@ bool LLParser::parseDIMacro(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIMacroFile:
+/// parseDIMacroFile: 
 ///   ::= !DIMacroFile(line: 9, file: !2, nodes: !3)
-bool LLParser::parseDIMacroFile(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIMacroFile(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(type, DwarfMacinfoTypeField, (dwarf::DW_MACINFO_start_file));       \
   OPTIONAL(line, LineField, );                                                 \
@@ -5119,11 +5119,11 @@ bool LLParser::parseDIMacroFile(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIModule:
+/// parseDIModule: 
 ///   ::= !DIModule(scope: !0, name: "SomeModule", configMacros:
 ///   "-DNDEBUG", includePath: "/usr/include", apinotes: "module.apinotes",
-///   file: !1, line: 4, isDecl: false)
-bool LLParser::parseDIModule(MDNode *&Result, bool IsDistinct) {
+///   file: !1, line: 4, isDecl: false) 
+bool LLParser::parseDIModule(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   REQUIRED(name, MDStringField, );                                             \
@@ -5131,20 +5131,20 @@ bool LLParser::parseDIModule(MDNode *&Result, bool IsDistinct) {
   OPTIONAL(includePath, MDStringField, );                                      \
   OPTIONAL(apinotes, MDStringField, );                                         \
   OPTIONAL(file, MDField, );                                                   \
-  OPTIONAL(line, LineField, );                                                 \
-  OPTIONAL(isDecl, MDBoolField, );
+  OPTIONAL(line, LineField, );                                                 \ 
+  OPTIONAL(isDecl, MDBoolField, ); 
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DIModule, (Context, file.Val, scope.Val, name.Val,
                                       configMacros.Val, includePath.Val,
-                                      apinotes.Val, line.Val, isDecl.Val));
+                                      apinotes.Val, line.Val, isDecl.Val)); 
   return false;
 }
 
-/// parseDITemplateTypeParameter:
+/// parseDITemplateTypeParameter: 
 ///   ::= !DITemplateTypeParameter(name: "Ty", type: !1, defaulted: false)
-bool LLParser::parseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(name, MDStringField, );                                             \
   REQUIRED(type, MDField, );                                                   \
@@ -5157,11 +5157,11 @@ bool LLParser::parseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDITemplateValueParameter:
+/// parseDITemplateValueParameter: 
 ///   ::= !DITemplateValueParameter(tag: DW_TAG_template_value_parameter,
 ///                                 name: "V", type: !1, defaulted: false,
 ///                                 value: i32 7)
-bool LLParser::parseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter));      \
   OPTIONAL(name, MDStringField, );                                             \
@@ -5178,12 +5178,12 @@ bool LLParser::parseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIGlobalVariable:
+/// parseDIGlobalVariable: 
 ///   ::= !DIGlobalVariable(scope: !0, name: "foo", linkageName: "foo",
 ///                         file: !1, line: 7, type: !2, isLocal: false,
 ///                         isDefinition: true, templateParams: !3,
 ///                         declaration: !4, align: 8)
-bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(name, MDStringField, (/* AllowEmpty */ false));                     \
   OPTIONAL(scope, MDField, );                                                  \
@@ -5207,14 +5207,14 @@ bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDILocalVariable:
+/// parseDILocalVariable: 
 ///   ::= !DILocalVariable(arg: 7, scope: !0, name: "foo",
 ///                        file: !1, line: 7, type: !2, arg: 2, flags: 7,
 ///                        align: 8)
 ///   ::= !DILocalVariable(scope: !0, name: "foo",
 ///                        file: !1, line: 7, type: !2, arg: 2, flags: 7,
 ///                        align: 8)
-bool LLParser::parseDILocalVariable(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDILocalVariable(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(name, MDStringField, );                                             \
@@ -5233,9 +5233,9 @@ bool LLParser::parseDILocalVariable(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDILabel:
+/// parseDILabel: 
 ///   ::= !DILabel(scope: !0, name: "foo", file: !1, line: 7)
-bool LLParser::parseDILabel(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDILabel(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   REQUIRED(name, MDStringField, );                                             \
@@ -5249,13 +5249,13 @@ bool LLParser::parseDILabel(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIExpression:
+/// parseDIExpression: 
 ///   ::= !DIExpression(0, 7, -1)
-bool LLParser::parseDIExpression(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIExpression(MDNode *&Result, bool IsDistinct) { 
   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
   Lex.Lex();
 
-  if (parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   SmallVector<uint64_t, 8> Elements;
@@ -5267,7 +5267,7 @@ bool LLParser::parseDIExpression(MDNode *&Result, bool IsDistinct) {
           Elements.push_back(Op);
           continue;
         }
-        return tokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'");
+        return tokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'"); 
       }
 
       if (Lex.getKind() == lltok::DwarfAttEncoding) {
@@ -5276,30 +5276,30 @@ bool LLParser::parseDIExpression(MDNode *&Result, bool IsDistinct) {
           Elements.push_back(Op);
           continue;
         }
-        return tokError(Twine("invalid DWARF attribute encoding '") +
-                        Lex.getStrVal() + "'");
+        return tokError(Twine("invalid DWARF attribute encoding '") + 
+                        Lex.getStrVal() + "'"); 
       }
 
       if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
-        return tokError("expected unsigned integer");
+        return tokError("expected unsigned integer"); 
 
       auto &U = Lex.getAPSIntVal();
       if (U.ugt(UINT64_MAX))
-        return tokError("element too large, limit is " + Twine(UINT64_MAX));
+        return tokError("element too large, limit is " + Twine(UINT64_MAX)); 
       Elements.push_back(U.getZExtValue());
       Lex.Lex();
     } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   Result = GET_OR_DISTINCT(DIExpression, (Context, Elements));
   return false;
 }
 
-/// parseDIGlobalVariableExpression:
+/// parseDIGlobalVariableExpression: 
 ///   ::= !DIGlobalVariableExpression(var: !0, expr: !1)
-bool LLParser::parseDIGlobalVariableExpression(MDNode *&Result,
+bool LLParser::parseDIGlobalVariableExpression(MDNode *&Result, 
                                                bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(var, MDField, );                                                    \
@@ -5312,10 +5312,10 @@ bool LLParser::parseDIGlobalVariableExpression(MDNode *&Result,
   return false;
 }
 
-/// parseDIObjCProperty:
+/// parseDIObjCProperty: 
 ///   ::= !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
 ///                       getter: "getFoo", attributes: 7, type: !2)
-bool LLParser::parseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIObjCProperty(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(file, MDField, );                                                   \
@@ -5333,10 +5333,10 @@ bool LLParser::parseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
   return false;
 }
 
-/// parseDIImportedEntity:
+/// parseDIImportedEntity: 
 ///   ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
 ///                         line: 7, name: "foo")
-bool LLParser::parseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
+bool LLParser::parseDIImportedEntity(MDNode *&Result, bool IsDistinct) { 
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   REQUIRED(scope, MDField, );                                                  \
@@ -5358,45 +5358,45 @@ bool LLParser::parseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
 #undef REQUIRE_FIELD
 #undef DECLARE_FIELD
 
-/// parseMetadataAsValue
+/// parseMetadataAsValue 
 ///  ::= metadata i32 %local
 ///  ::= metadata i32 @global
 ///  ::= metadata i32 7
 ///  ::= metadata !0
 ///  ::= metadata !{...}
 ///  ::= metadata !"string"
-bool LLParser::parseMetadataAsValue(Value *&V, PerFunctionState &PFS) {
+bool LLParser::parseMetadataAsValue(Value *&V, PerFunctionState &PFS) { 
   // Note: the type 'metadata' has already been parsed.
   Metadata *MD;
-  if (parseMetadata(MD, &PFS))
+  if (parseMetadata(MD, &PFS)) 
     return true;
 
   V = MetadataAsValue::get(Context, MD);
   return false;
 }
 
-/// parseValueAsMetadata
+/// parseValueAsMetadata 
 ///  ::= i32 %local
 ///  ::= i32 @global
 ///  ::= i32 7
-bool LLParser::parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
+bool LLParser::parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg, 
                                     PerFunctionState *PFS) {
   Type *Ty;
   LocTy Loc;
-  if (parseType(Ty, TypeMsg, Loc))
+  if (parseType(Ty, TypeMsg, Loc)) 
     return true;
   if (Ty->isMetadataTy())
-    return error(Loc, "invalid metadata-value-metadata roundtrip");
+    return error(Loc, "invalid metadata-value-metadata roundtrip"); 
 
   Value *V;
-  if (parseValue(Ty, V, PFS))
+  if (parseValue(Ty, V, PFS)) 
     return true;
 
   MD = ValueAsMetadata::get(V);
   return false;
 }
 
-/// parseMetadata
+/// parseMetadata 
 ///  ::= i32 %local
 ///  ::= i32 @global
 ///  ::= i32 7
@@ -5404,10 +5404,10 @@ bool LLParser::parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
 ///  ::= !{...}
 ///  ::= !"string"
 ///  ::= !DILocation(...)
-bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
+bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) { 
   if (Lex.getKind() == lltok::MetadataVar) {
     MDNode *N;
-    if (parseSpecializedMDNode(N))
+    if (parseSpecializedMDNode(N)) 
       return true;
     MD = N;
     return false;
@@ -5416,7 +5416,7 @@ bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
   // ValueAsMetadata:
   // <type> <value>
   if (Lex.getKind() != lltok::exclaim)
-    return parseValueAsMetadata(MD, "expected metadata operand", PFS);
+    return parseValueAsMetadata(MD, "expected metadata operand", PFS); 
 
   // '!'.
   assert(Lex.getKind() == lltok::exclaim && "Expected '!' here");
@@ -5426,7 +5426,7 @@ bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
   //   ::= '!' STRINGCONSTANT
   if (Lex.getKind() == lltok::StringConstant) {
     MDString *S;
-    if (parseMDString(S))
+    if (parseMDString(S)) 
       return true;
     MD = S;
     return false;
@@ -5436,7 +5436,7 @@ bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
   // !{ ... }
   // !7
   MDNode *N;
-  if (parseMDNodeTail(N))
+  if (parseMDNodeTail(N)) 
     return true;
   MD = N;
   return false;
@@ -5446,52 +5446,52 @@ bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
 // Function Parsing.
 //===----------------------------------------------------------------------===//
 
-bool LLParser::convertValIDToValue(Type *Ty, ValID &ID, Value *&V,
+bool LLParser::convertValIDToValue(Type *Ty, ValID &ID, Value *&V, 
                                    PerFunctionState *PFS, bool IsCall) {
   if (Ty->isFunctionTy())
-    return error(ID.Loc, "functions are not values, refer to them as pointers");
+    return error(ID.Loc, "functions are not values, refer to them as pointers"); 
 
   switch (ID.Kind) {
   case ValID::t_LocalID:
-    if (!PFS)
-      return error(ID.Loc, "invalid use of function-local name");
-    V = PFS->getVal(ID.UIntVal, Ty, ID.Loc, IsCall);
+    if (!PFS) 
+      return error(ID.Loc, "invalid use of function-local name"); 
+    V = PFS->getVal(ID.UIntVal, Ty, ID.Loc, IsCall); 
     return V == nullptr;
   case ValID::t_LocalName:
-    if (!PFS)
-      return error(ID.Loc, "invalid use of function-local name");
-    V = PFS->getVal(ID.StrVal, Ty, ID.Loc, IsCall);
+    if (!PFS) 
+      return error(ID.Loc, "invalid use of function-local name"); 
+    V = PFS->getVal(ID.StrVal, Ty, ID.Loc, IsCall); 
     return V == nullptr;
   case ValID::t_InlineAsm: {
     if (!ID.FTy || !InlineAsm::Verify(ID.FTy, ID.StrVal2))
-      return error(ID.Loc, "invalid type for inline asm constraint string");
+      return error(ID.Loc, "invalid type for inline asm constraint string"); 
     V = InlineAsm::get(ID.FTy, ID.StrVal, ID.StrVal2, ID.UIntVal & 1,
                        (ID.UIntVal >> 1) & 1,
                        (InlineAsm::AsmDialect(ID.UIntVal >> 2)));
     return false;
   }
   case ValID::t_GlobalName:
-    V = getGlobalVal(ID.StrVal, Ty, ID.Loc, IsCall);
+    V = getGlobalVal(ID.StrVal, Ty, ID.Loc, IsCall); 
     return V == nullptr;
   case ValID::t_GlobalID:
-    V = getGlobalVal(ID.UIntVal, Ty, ID.Loc, IsCall);
+    V = getGlobalVal(ID.UIntVal, Ty, ID.Loc, IsCall); 
     return V == nullptr;
   case ValID::t_APSInt:
     if (!Ty->isIntegerTy())
-      return error(ID.Loc, "integer constant must have integer type");
+      return error(ID.Loc, "integer constant must have integer type"); 
     ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
     V = ConstantInt::get(Context, ID.APSIntVal);
     return false;
   case ValID::t_APFloat:
     if (!Ty->isFloatingPointTy() ||
         !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
-      return error(ID.Loc, "floating point constant invalid for type");
+      return error(ID.Loc, "floating point constant invalid for type"); 
 
     // The lexer has no type info, so builds all half, bfloat, float, and double
     // FP constants as double.  Fix this here.  Long double does not need this.
     if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
-      // Check for signaling before potentially converting and losing that info.
-      bool IsSNAN = ID.APFloatVal.isSignaling();
+      // Check for signaling before potentially converting and losing that info. 
+      bool IsSNAN = ID.APFloatVal.isSignaling(); 
       bool Ignored;
       if (Ty->isHalfTy())
         ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
@@ -5502,81 +5502,81 @@ bool LLParser::convertValIDToValue(Type *Ty, ValID &ID, Value *&V,
       else if (Ty->isFloatTy())
         ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
                               &Ignored);
-      if (IsSNAN) {
-        // The convert call above may quiet an SNaN, so manufacture another
-        // SNaN. The bitcast works because the payload (significand) parameter
-        // is truncated to fit.
-        APInt Payload = ID.APFloatVal.bitcastToAPInt();
-        ID.APFloatVal = APFloat::getSNaN(ID.APFloatVal.getSemantics(),
-                                         ID.APFloatVal.isNegative(), &Payload);
-      }
+      if (IsSNAN) { 
+        // The convert call above may quiet an SNaN, so manufacture another 
+        // SNaN. The bitcast works because the payload (significand) parameter 
+        // is truncated to fit. 
+        APInt Payload = ID.APFloatVal.bitcastToAPInt(); 
+        ID.APFloatVal = APFloat::getSNaN(ID.APFloatVal.getSemantics(), 
+                                         ID.APFloatVal.isNegative(), &Payload); 
+      } 
     }
     V = ConstantFP::get(Context, ID.APFloatVal);
 
     if (V->getType() != Ty)
-      return error(ID.Loc, "floating point constant does not have type '" +
-                               getTypeString(Ty) + "'");
+      return error(ID.Loc, "floating point constant does not have type '" + 
+                               getTypeString(Ty) + "'"); 
 
     return false;
   case ValID::t_Null:
     if (!Ty->isPointerTy())
-      return error(ID.Loc, "null must be a pointer type");
+      return error(ID.Loc, "null must be a pointer type"); 
     V = ConstantPointerNull::get(cast<PointerType>(Ty));
     return false;
   case ValID::t_Undef:
     // FIXME: LabelTy should not be a first-class type.
     if (!Ty->isFirstClassType() || Ty->isLabelTy())
-      return error(ID.Loc, "invalid type for undef constant");
+      return error(ID.Loc, "invalid type for undef constant"); 
     V = UndefValue::get(Ty);
     return false;
   case ValID::t_EmptyArray:
     if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
-      return error(ID.Loc, "invalid empty array initializer");
+      return error(ID.Loc, "invalid empty array initializer"); 
     V = UndefValue::get(Ty);
     return false;
   case ValID::t_Zero:
     // FIXME: LabelTy should not be a first-class type.
     if (!Ty->isFirstClassType() || Ty->isLabelTy())
-      return error(ID.Loc, "invalid type for null constant");
+      return error(ID.Loc, "invalid type for null constant"); 
     V = Constant::getNullValue(Ty);
     return false;
   case ValID::t_None:
     if (!Ty->isTokenTy())
-      return error(ID.Loc, "invalid type for none constant");
+      return error(ID.Loc, "invalid type for none constant"); 
     V = Constant::getNullValue(Ty);
     return false;
-  case ValID::t_Poison:
-    // FIXME: LabelTy should not be a first-class type.
-    if (!Ty->isFirstClassType() || Ty->isLabelTy())
-      return error(ID.Loc, "invalid type for poison constant");
-    V = PoisonValue::get(Ty);
-    return false;
+  case ValID::t_Poison: 
+    // FIXME: LabelTy should not be a first-class type. 
+    if (!Ty->isFirstClassType() || Ty->isLabelTy()) 
+      return error(ID.Loc, "invalid type for poison constant"); 
+    V = PoisonValue::get(Ty); 
+    return false; 
   case ValID::t_Constant:
     if (ID.ConstantVal->getType() != Ty)
-      return error(ID.Loc, "constant expression type mismatch");
+      return error(ID.Loc, "constant expression type mismatch"); 
     V = ID.ConstantVal;
     return false;
   case ValID::t_ConstantStruct:
   case ValID::t_PackedConstantStruct:
     if (StructType *ST = dyn_cast<StructType>(Ty)) {
       if (ST->getNumElements() != ID.UIntVal)
-        return error(ID.Loc,
+        return error(ID.Loc, 
                      "initializer with struct type has wrong # elements");
       if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
-        return error(ID.Loc, "packed'ness of initializer and type don't match");
+        return error(ID.Loc, "packed'ness of initializer and type don't match"); 
 
       // Verify that the elements are compatible with the structtype.
       for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
         if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
-          return error(
-              ID.Loc,
-              "element " + Twine(i) +
-                  " of struct initializer doesn't match struct element type");
+          return error( 
+              ID.Loc, 
+              "element " + Twine(i) + 
+                  " of struct initializer doesn't match struct element type"); 
 
       V = ConstantStruct::get(
           ST, makeArrayRef(ID.ConstantStructElts.get(), ID.UIntVal));
     } else
-      return error(ID.Loc, "constant expression type mismatch");
+      return error(ID.Loc, "constant expression type mismatch"); 
     return false;
   }
   llvm_unreachable("Invalid ValID");
@@ -5586,7 +5586,7 @@ bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
   C = nullptr;
   ValID ID;
   auto Loc = Lex.getLoc();
-  if (parseValID(ID, /*PFS=*/nullptr))
+  if (parseValID(ID, /*PFS=*/nullptr)) 
     return true;
   switch (ID.Kind) {
   case ValID::t_APSInt:
@@ -5596,7 +5596,7 @@ bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
   case ValID::t_ConstantStruct:
   case ValID::t_PackedConstantStruct: {
     Value *V;
-    if (convertValIDToValue(Ty, ID, V, /*PFS=*/nullptr, /*IsCall=*/false))
+    if (convertValIDToValue(Ty, ID, V, /*PFS=*/nullptr, /*IsCall=*/false)) 
       return true;
     assert(isa<Constant>(V) && "Expected a constant value");
     C = cast<Constant>(V);
@@ -5606,30 +5606,30 @@ bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
     C = Constant::getNullValue(Ty);
     return false;
   default:
-    return error(Loc, "expected a constant value");
+    return error(Loc, "expected a constant value"); 
   }
 }
 
-bool LLParser::parseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
+bool LLParser::parseValue(Type *Ty, Value *&V, PerFunctionState *PFS) { 
   V = nullptr;
   ValID ID;
-  return parseValID(ID, PFS) ||
-         convertValIDToValue(Ty, ID, V, PFS, /*IsCall=*/false);
+  return parseValID(ID, PFS) || 
+         convertValIDToValue(Ty, ID, V, PFS, /*IsCall=*/false); 
 }
 
-bool LLParser::parseTypeAndValue(Value *&V, PerFunctionState *PFS) {
+bool LLParser::parseTypeAndValue(Value *&V, PerFunctionState *PFS) { 
   Type *Ty = nullptr;
-  return parseType(Ty) || parseValue(Ty, V, PFS);
+  return parseType(Ty) || parseValue(Ty, V, PFS); 
 }
 
-bool LLParser::parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
+bool LLParser::parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc, 
                                       PerFunctionState &PFS) {
   Value *V;
   Loc = Lex.getLoc();
-  if (parseTypeAndValue(V, PFS))
-    return true;
+  if (parseTypeAndValue(V, PFS)) 
+    return true; 
   if (!isa<BasicBlock>(V))
-    return error(Loc, "expected a basic block");
+    return error(Loc, "expected a basic block"); 
   BB = cast<BasicBlock>(V);
   return false;
 }
@@ -5639,8 +5639,8 @@ bool LLParser::parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
 ///       OptionalCallingConv OptRetAttrs OptUnnamedAddr Type GlobalName
 ///       '(' ArgList ')' OptAddrSpace OptFuncAttrs OptSection OptionalAlign
 ///       OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
-bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
-  // parse the linkage.
+bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) { 
+  // parse the linkage. 
   LocTy LinkageLoc = Lex.getLoc();
   unsigned Linkage;
   unsigned Visibility;
@@ -5651,10 +5651,10 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
   bool HasLinkage;
   Type *RetType = nullptr;
   LocTy RetTypeLoc = Lex.getLoc();
-  if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+  if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass, 
                            DSOLocal) ||
-      parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
-      parseType(RetType, RetTypeLoc, true /*void allowed*/))
+      parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) || 
+      parseType(RetType, RetTypeLoc, true /*void allowed*/)) 
     return true;
 
   // Verify that the linkage is ok.
@@ -5662,8 +5662,8 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
   case GlobalValue::ExternalLinkage:
     break; // always ok.
   case GlobalValue::ExternalWeakLinkage:
-    if (IsDefine)
-      return error(LinkageLoc, "invalid linkage for function definition");
+    if (IsDefine) 
+      return error(LinkageLoc, "invalid linkage for function definition"); 
     break;
   case GlobalValue::PrivateLinkage:
   case GlobalValue::InternalLinkage:
@@ -5672,20 +5672,20 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
   case GlobalValue::LinkOnceODRLinkage:
   case GlobalValue::WeakAnyLinkage:
   case GlobalValue::WeakODRLinkage:
-    if (!IsDefine)
-      return error(LinkageLoc, "invalid linkage for function declaration");
+    if (!IsDefine) 
+      return error(LinkageLoc, "invalid linkage for function declaration"); 
     break;
   case GlobalValue::AppendingLinkage:
   case GlobalValue::CommonLinkage:
-    return error(LinkageLoc, "invalid function linkage type");
+    return error(LinkageLoc, "invalid function linkage type"); 
   }
 
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
-    return error(LinkageLoc,
+    return error(LinkageLoc, 
                  "symbol with local linkage must have default visibility");
 
   if (!FunctionType::isValidReturnType(RetType))
-    return error(RetTypeLoc, "invalid function return type");
+    return error(RetTypeLoc, "invalid function return type"); 
 
   LocTy NameLoc = Lex.getLoc();
 
@@ -5696,19 +5696,19 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
     unsigned NameID = Lex.getUIntVal();
 
     if (NameID != NumberedVals.size())
-      return tokError("function expected to be numbered '%" +
+      return tokError("function expected to be numbered '%" + 
                       Twine(NumberedVals.size()) + "'");
   } else {
-    return tokError("expected function name");
+    return tokError("expected function name"); 
   }
 
   Lex.Lex();
 
   if (Lex.getKind() != lltok::lparen)
-    return tokError("expected '(' in function argument list");
+    return tokError("expected '(' in function argument list"); 
 
   SmallVector<ArgInfo, 8> ArgList;
-  bool IsVarArg;
+  bool IsVarArg; 
   AttrBuilder FuncAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
   LocTy BuiltinLoc;
@@ -5723,24 +5723,24 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
   Constant *PersonalityFn = nullptr;
   Comdat *C;
 
-  if (parseArgumentList(ArgList, IsVarArg) ||
-      parseOptionalUnnamedAddr(UnnamedAddr) ||
-      parseOptionalProgramAddrSpace(AddrSpace) ||
-      parseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
+  if (parseArgumentList(ArgList, IsVarArg) || 
+      parseOptionalUnnamedAddr(UnnamedAddr) || 
+      parseOptionalProgramAddrSpace(AddrSpace) || 
+      parseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false, 
                                  BuiltinLoc) ||
-      (EatIfPresent(lltok::kw_section) && parseStringConstant(Section)) ||
-      (EatIfPresent(lltok::kw_partition) && parseStringConstant(Partition)) ||
+      (EatIfPresent(lltok::kw_section) && parseStringConstant(Section)) || 
+      (EatIfPresent(lltok::kw_partition) && parseStringConstant(Partition)) || 
       parseOptionalComdat(FunctionName, C) ||
-      parseOptionalAlignment(Alignment) ||
-      (EatIfPresent(lltok::kw_gc) && parseStringConstant(GC)) ||
-      (EatIfPresent(lltok::kw_prefix) && parseGlobalTypeAndValue(Prefix)) ||
-      (EatIfPresent(lltok::kw_prologue) && parseGlobalTypeAndValue(Prologue)) ||
+      parseOptionalAlignment(Alignment) || 
+      (EatIfPresent(lltok::kw_gc) && parseStringConstant(GC)) || 
+      (EatIfPresent(lltok::kw_prefix) && parseGlobalTypeAndValue(Prefix)) || 
+      (EatIfPresent(lltok::kw_prologue) && parseGlobalTypeAndValue(Prologue)) || 
       (EatIfPresent(lltok::kw_personality) &&
-       parseGlobalTypeAndValue(PersonalityFn)))
+       parseGlobalTypeAndValue(PersonalityFn))) 
     return true;
 
   if (FuncAttrs.contains(Attribute::Builtin))
-    return error(BuiltinLoc, "'builtin' attribute not valid on function");
+    return error(BuiltinLoc, "'builtin' attribute not valid on function"); 
 
   // If the alignment was parsed as an attribute, move to the alignment field.
   if (FuncAttrs.hasAlignmentAttr()) {
@@ -5763,9 +5763,9 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
                          AttributeSet::get(Context, RetAttrs), Attrs);
 
   if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
-    return error(RetTypeLoc, "functions with 'sret' argument must return void");
+    return error(RetTypeLoc, "functions with 'sret' argument must return void"); 
 
-  FunctionType *FT = FunctionType::get(RetType, ParamTypeList, IsVarArg);
+  FunctionType *FT = FunctionType::get(RetType, ParamTypeList, IsVarArg); 
   PointerType *PFT = PointerType::get(FT, AddrSpace);
 
   Fn = nullptr;
@@ -5776,24 +5776,24 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
     if (FRVI != ForwardRefVals.end()) {
       Fn = M->getFunction(FunctionName);
       if (!Fn)
-        return error(FRVI->second.second, "invalid forward reference to "
-                                          "function as global value!");
+        return error(FRVI->second.second, "invalid forward reference to " 
+                                          "function as global value!"); 
       if (Fn->getType() != PFT)
-        return error(FRVI->second.second,
-                     "invalid forward reference to "
-                     "function '" +
-                         FunctionName +
-                         "' with wrong type: "
-                         "expected '" +
-                         getTypeString(PFT) + "' but was '" +
-                         getTypeString(Fn->getType()) + "'");
+        return error(FRVI->second.second, 
+                     "invalid forward reference to " 
+                     "function '" + 
+                         FunctionName + 
+                         "' with wrong type: " 
+                         "expected '" + 
+                         getTypeString(PFT) + "' but was '" + 
+                         getTypeString(Fn->getType()) + "'"); 
       ForwardRefVals.erase(FRVI);
     } else if ((Fn = M->getFunction(FunctionName))) {
       // Reject redefinitions.
-      return error(NameLoc,
-                   "invalid redefinition of function '" + FunctionName + "'");
+      return error(NameLoc, 
+                   "invalid redefinition of function '" + FunctionName + "'"); 
     } else if (M->getNamedValue(FunctionName)) {
-      return error(NameLoc, "redefinition of function '@" + FunctionName + "'");
+      return error(NameLoc, "redefinition of function '@" + FunctionName + "'"); 
     }
 
   } else {
@@ -5803,12 +5803,12 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
     if (I != ForwardRefValIDs.end()) {
       Fn = cast<Function>(I->second.first);
       if (Fn->getType() != PFT)
-        return error(NameLoc, "type of definition and forward reference of '@" +
-                                  Twine(NumberedVals.size()) +
-                                  "' disagree: "
-                                  "expected '" +
-                                  getTypeString(PFT) + "' but was '" +
-                                  getTypeString(Fn->getType()) + "'");
+        return error(NameLoc, "type of definition and forward reference of '@" + 
+                                  Twine(NumberedVals.size()) + 
+                                  "' disagree: " 
+                                  "expected '" + 
+                                  getTypeString(PFT) + "' but was '" + 
+                                  getTypeString(Fn->getType()) + "'"); 
       ForwardRefValIDs.erase(I);
     }
   }
@@ -5851,11 +5851,11 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
     ArgIt->setName(ArgList[i].Name);
 
     if (ArgIt->getName() != ArgList[i].Name)
-      return error(ArgList[i].Loc,
-                   "redefinition of argument '%" + ArgList[i].Name + "'");
+      return error(ArgList[i].Loc, 
+                   "redefinition of argument '%" + ArgList[i].Name + "'"); 
   }
 
-  if (IsDefine)
+  if (IsDefine) 
     return false;
 
   // Check the declaration has no block address forward references.
@@ -5869,7 +5869,7 @@ bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
   }
   auto Blocks = ForwardRefBlockAddresses.find(ID);
   if (Blocks != ForwardRefBlockAddresses.end())
-    return error(Blocks->first.Loc,
+    return error(Blocks->first.Loc, 
                  "cannot take blockaddress inside a declaration");
   return false;
 }
@@ -5896,11 +5896,11 @@ bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
            "Expected local id or name");
     BasicBlock *BB;
     if (BBID.Kind == ValID::t_LocalName)
-      BB = getBB(BBID.StrVal, BBID.Loc);
+      BB = getBB(BBID.StrVal, BBID.Loc); 
     else
-      BB = getBB(BBID.UIntVal, BBID.Loc);
+      BB = getBB(BBID.UIntVal, BBID.Loc); 
     if (!BB)
-      return P.error(BBID.Loc, "referenced value is not a basic block");
+      return P.error(BBID.Loc, "referenced value is not a basic block"); 
 
     GV->replaceAllUsesWith(BlockAddress::get(&F, BB));
     GV->eraseFromParent();
@@ -5910,11 +5910,11 @@ bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
   return false;
 }
 
-/// parseFunctionBody
+/// parseFunctionBody 
 ///   ::= '{' BasicBlock+ UseListOrderDirective* '}'
-bool LLParser::parseFunctionBody(Function &Fn) {
+bool LLParser::parseFunctionBody(Function &Fn) { 
   if (Lex.getKind() != lltok::lbrace)
-    return tokError("expected '{' in function body");
+    return tokError("expected '{' in function body"); 
   Lex.Lex();  // eat the {.
 
   int FunctionNumber = -1;
@@ -5930,27 +5930,27 @@ bool LLParser::parseFunctionBody(Function &Fn) {
 
   // We need at least one basic block.
   if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_uselistorder)
-    return tokError("function body requires at least one basic block");
+    return tokError("function body requires at least one basic block"); 
 
   while (Lex.getKind() != lltok::rbrace &&
          Lex.getKind() != lltok::kw_uselistorder)
-    if (parseBasicBlock(PFS))
-      return true;
+    if (parseBasicBlock(PFS)) 
+      return true; 
 
   while (Lex.getKind() != lltok::rbrace)
-    if (parseUseListOrder(&PFS))
+    if (parseUseListOrder(&PFS)) 
       return true;
 
   // Eat the }.
   Lex.Lex();
 
   // Verify function is ok.
-  return PFS.finishFunction();
+  return PFS.finishFunction(); 
 }
 
-/// parseBasicBlock
+/// parseBasicBlock 
 ///   ::= (LabelStr|LabelID)? Instruction*
-bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
+bool LLParser::parseBasicBlock(PerFunctionState &PFS) { 
   // If this basic block starts out with a name, remember it.
   std::string Name;
   int NameID = -1;
@@ -5963,13 +5963,13 @@ bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
     Lex.Lex();
   }
 
-  BasicBlock *BB = PFS.defineBB(Name, NameID, NameLoc);
+  BasicBlock *BB = PFS.defineBB(Name, NameID, NameLoc); 
   if (!BB)
     return true;
 
   std::string NameStr;
 
-  // parse the instructions in this block until we get a terminator.
+  // parse the instructions in this block until we get a terminator. 
   Instruction *Inst;
   do {
     // This instruction may have three possibilities for a name: a) none
@@ -5981,18 +5981,18 @@ bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
     if (Lex.getKind() == lltok::LocalVarID) {
       NameID = Lex.getUIntVal();
       Lex.Lex();
-      if (parseToken(lltok::equal, "expected '=' after instruction id"))
+      if (parseToken(lltok::equal, "expected '=' after instruction id")) 
         return true;
     } else if (Lex.getKind() == lltok::LocalVar) {
       NameStr = Lex.getStrVal();
       Lex.Lex();
-      if (parseToken(lltok::equal, "expected '=' after instruction name"))
+      if (parseToken(lltok::equal, "expected '=' after instruction name")) 
         return true;
     }
 
-    switch (parseInstruction(Inst, BB, PFS)) {
-    default:
-      llvm_unreachable("Unknown parseInstruction result!");
+    switch (parseInstruction(Inst, BB, PFS)) { 
+    default: 
+      llvm_unreachable("Unknown parseInstruction result!"); 
     case InstError: return true;
     case InstNormal:
       BB->getInstList().push_back(Inst);
@@ -6000,7 +6000,7 @@ bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
       // With a normal result, we check to see if the instruction is followed by
       // a comma and metadata.
       if (EatIfPresent(lltok::comma))
-        if (parseInstructionMetadata(*Inst))
+        if (parseInstructionMetadata(*Inst)) 
           return true;
       break;
     case InstExtraComma:
@@ -6008,14 +6008,14 @@ bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
 
       // If the instruction parser ate an extra comma at the end of it, it
       // *must* be followed by metadata.
-      if (parseInstructionMetadata(*Inst))
+      if (parseInstructionMetadata(*Inst)) 
         return true;
       break;
     }
 
     // Set the name on the instruction.
-    if (PFS.setInstName(NameID, NameStr, NameLoc, Inst))
-      return true;
+    if (PFS.setInstName(NameID, NameStr, NameLoc, Inst)) 
+      return true; 
   } while (!Inst->isTerminator());
 
   return false;
@@ -6025,50 +6025,50 @@ bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
 // Instruction Parsing.
 //===----------------------------------------------------------------------===//
 
-/// parseInstruction - parse one of the many different instructions.
+/// parseInstruction - parse one of the many different instructions. 
 ///
-int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
+int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB, 
                                PerFunctionState &PFS) {
   lltok::Kind Token = Lex.getKind();
   if (Token == lltok::Eof)
-    return tokError("found end of file when expecting more instructions");
+    return tokError("found end of file when expecting more instructions"); 
   LocTy Loc = Lex.getLoc();
   unsigned KeywordVal = Lex.getUIntVal();
   Lex.Lex();  // Eat the keyword.
 
   switch (Token) {
-  default:
-    return error(Loc, "expected instruction opcode");
+  default: 
+    return error(Loc, "expected instruction opcode"); 
   // Terminator Instructions.
   case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
-  case lltok::kw_ret:
-    return parseRet(Inst, BB, PFS);
-  case lltok::kw_br:
-    return parseBr(Inst, PFS);
-  case lltok::kw_switch:
-    return parseSwitch(Inst, PFS);
-  case lltok::kw_indirectbr:
-    return parseIndirectBr(Inst, PFS);
-  case lltok::kw_invoke:
-    return parseInvoke(Inst, PFS);
-  case lltok::kw_resume:
-    return parseResume(Inst, PFS);
-  case lltok::kw_cleanupret:
-    return parseCleanupRet(Inst, PFS);
-  case lltok::kw_catchret:
-    return parseCatchRet(Inst, PFS);
-  case lltok::kw_catchswitch:
-    return parseCatchSwitch(Inst, PFS);
-  case lltok::kw_catchpad:
-    return parseCatchPad(Inst, PFS);
-  case lltok::kw_cleanuppad:
-    return parseCleanupPad(Inst, PFS);
-  case lltok::kw_callbr:
-    return parseCallBr(Inst, PFS);
+  case lltok::kw_ret: 
+    return parseRet(Inst, BB, PFS); 
+  case lltok::kw_br: 
+    return parseBr(Inst, PFS); 
+  case lltok::kw_switch: 
+    return parseSwitch(Inst, PFS); 
+  case lltok::kw_indirectbr: 
+    return parseIndirectBr(Inst, PFS); 
+  case lltok::kw_invoke: 
+    return parseInvoke(Inst, PFS); 
+  case lltok::kw_resume: 
+    return parseResume(Inst, PFS); 
+  case lltok::kw_cleanupret: 
+    return parseCleanupRet(Inst, PFS); 
+  case lltok::kw_catchret: 
+    return parseCatchRet(Inst, PFS); 
+  case lltok::kw_catchswitch: 
+    return parseCatchSwitch(Inst, PFS); 
+  case lltok::kw_catchpad: 
+    return parseCatchPad(Inst, PFS); 
+  case lltok::kw_cleanuppad: 
+    return parseCleanupPad(Inst, PFS); 
+  case lltok::kw_callbr: 
+    return parseCallBr(Inst, PFS); 
   // Unary Operators.
   case lltok::kw_fneg: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
-    int Res = parseUnaryOp(Inst, PFS, KeywordVal, /*IsFP*/ true);
+    int Res = parseUnaryOp(Inst, PFS, KeywordVal, /*IsFP*/ true); 
     if (Res != 0)
       return Res;
     if (FMF.any())
@@ -6084,8 +6084,8 @@ int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
     bool NSW = EatIfPresent(lltok::kw_nsw);
     if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
 
-    if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false))
-      return true;
+    if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false)) 
+      return true; 
 
     if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
     if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
@@ -6097,7 +6097,7 @@ int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
   case lltok::kw_fdiv:
   case lltok::kw_frem: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
-    int Res = parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ true);
+    int Res = parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ true); 
     if (Res != 0)
       return Res;
     if (FMF.any())
@@ -6111,25 +6111,25 @@ int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
   case lltok::kw_ashr: {
     bool Exact = EatIfPresent(lltok::kw_exact);
 
-    if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false))
-      return true;
+    if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false)) 
+      return true; 
     if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
     return false;
   }
 
   case lltok::kw_urem:
-  case lltok::kw_srem:
-    return parseArithmetic(Inst, PFS, KeywordVal,
-                           /*IsFP*/ false);
+  case lltok::kw_srem: 
+    return parseArithmetic(Inst, PFS, KeywordVal, 
+                           /*IsFP*/ false); 
   case lltok::kw_and:
   case lltok::kw_or:
-  case lltok::kw_xor:
-    return parseLogical(Inst, PFS, KeywordVal);
-  case lltok::kw_icmp:
-    return parseCompare(Inst, PFS, KeywordVal);
+  case lltok::kw_xor: 
+    return parseLogical(Inst, PFS, KeywordVal); 
+  case lltok::kw_icmp: 
+    return parseCompare(Inst, PFS, KeywordVal); 
   case lltok::kw_fcmp: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
-    int Res = parseCompare(Inst, PFS, KeywordVal);
+    int Res = parseCompare(Inst, PFS, KeywordVal); 
     if (Res != 0)
       return Res;
     if (FMF.any())
@@ -6150,84 +6150,84 @@ int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
   case lltok::kw_fptoui:
   case lltok::kw_fptosi:
   case lltok::kw_inttoptr:
-  case lltok::kw_ptrtoint:
-    return parseCast(Inst, PFS, KeywordVal);
+  case lltok::kw_ptrtoint: 
+    return parseCast(Inst, PFS, KeywordVal); 
   // Other.
   case lltok::kw_select: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
-    int Res = parseSelect(Inst, PFS);
+    int Res = parseSelect(Inst, PFS); 
     if (Res != 0)
       return Res;
     if (FMF.any()) {
       if (!isa<FPMathOperator>(Inst))
-        return error(Loc, "fast-math-flags specified for select without "
+        return error(Loc, "fast-math-flags specified for select without " 
                           "floating-point scalar or vector return type");
       Inst->setFastMathFlags(FMF);
     }
     return 0;
   }
-  case lltok::kw_va_arg:
-    return parseVAArg(Inst, PFS);
-  case lltok::kw_extractelement:
-    return parseExtractElement(Inst, PFS);
-  case lltok::kw_insertelement:
-    return parseInsertElement(Inst, PFS);
-  case lltok::kw_shufflevector:
-    return parseShuffleVector(Inst, PFS);
+  case lltok::kw_va_arg: 
+    return parseVAArg(Inst, PFS); 
+  case lltok::kw_extractelement: 
+    return parseExtractElement(Inst, PFS); 
+  case lltok::kw_insertelement: 
+    return parseInsertElement(Inst, PFS); 
+  case lltok::kw_shufflevector: 
+    return parseShuffleVector(Inst, PFS); 
   case lltok::kw_phi: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
-    int Res = parsePHI(Inst, PFS);
+    int Res = parsePHI(Inst, PFS); 
     if (Res != 0)
       return Res;
     if (FMF.any()) {
       if (!isa<FPMathOperator>(Inst))
-        return error(Loc, "fast-math-flags specified for phi without "
+        return error(Loc, "fast-math-flags specified for phi without " 
                           "floating-point scalar or vector return type");
       Inst->setFastMathFlags(FMF);
     }
     return 0;
   }
-  case lltok::kw_landingpad:
-    return parseLandingPad(Inst, PFS);
-  case lltok::kw_freeze:
-    return parseFreeze(Inst, PFS);
+  case lltok::kw_landingpad: 
+    return parseLandingPad(Inst, PFS); 
+  case lltok::kw_freeze: 
+    return parseFreeze(Inst, PFS); 
   // Call.
-  case lltok::kw_call:
-    return parseCall(Inst, PFS, CallInst::TCK_None);
-  case lltok::kw_tail:
-    return parseCall(Inst, PFS, CallInst::TCK_Tail);
-  case lltok::kw_musttail:
-    return parseCall(Inst, PFS, CallInst::TCK_MustTail);
-  case lltok::kw_notail:
-    return parseCall(Inst, PFS, CallInst::TCK_NoTail);
+  case lltok::kw_call: 
+    return parseCall(Inst, PFS, CallInst::TCK_None); 
+  case lltok::kw_tail: 
+    return parseCall(Inst, PFS, CallInst::TCK_Tail); 
+  case lltok::kw_musttail: 
+    return parseCall(Inst, PFS, CallInst::TCK_MustTail); 
+  case lltok::kw_notail: 
+    return parseCall(Inst, PFS, CallInst::TCK_NoTail); 
   // Memory.
-  case lltok::kw_alloca:
-    return parseAlloc(Inst, PFS);
-  case lltok::kw_load:
-    return parseLoad(Inst, PFS);
-  case lltok::kw_store:
-    return parseStore(Inst, PFS);
-  case lltok::kw_cmpxchg:
-    return parseCmpXchg(Inst, PFS);
-  case lltok::kw_atomicrmw:
-    return parseAtomicRMW(Inst, PFS);
-  case lltok::kw_fence:
-    return parseFence(Inst, PFS);
-  case lltok::kw_getelementptr:
-    return parseGetElementPtr(Inst, PFS);
-  case lltok::kw_extractvalue:
-    return parseExtractValue(Inst, PFS);
-  case lltok::kw_insertvalue:
-    return parseInsertValue(Inst, PFS);
-  }
-}
-
-/// parseCmpPredicate - parse an integer or fp predicate, based on Kind.
-bool LLParser::parseCmpPredicate(unsigned &P, unsigned Opc) {
+  case lltok::kw_alloca: 
+    return parseAlloc(Inst, PFS); 
+  case lltok::kw_load: 
+    return parseLoad(Inst, PFS); 
+  case lltok::kw_store: 
+    return parseStore(Inst, PFS); 
+  case lltok::kw_cmpxchg: 
+    return parseCmpXchg(Inst, PFS); 
+  case lltok::kw_atomicrmw: 
+    return parseAtomicRMW(Inst, PFS); 
+  case lltok::kw_fence: 
+    return parseFence(Inst, PFS); 
+  case lltok::kw_getelementptr: 
+    return parseGetElementPtr(Inst, PFS); 
+  case lltok::kw_extractvalue: 
+    return parseExtractValue(Inst, PFS); 
+  case lltok::kw_insertvalue: 
+    return parseInsertValue(Inst, PFS); 
+  }
+}
+
+/// parseCmpPredicate - parse an integer or fp predicate, based on Kind. 
+bool LLParser::parseCmpPredicate(unsigned &P, unsigned Opc) { 
   if (Opc == Instruction::FCmp) {
     switch (Lex.getKind()) {
-    default:
-      return tokError("expected fcmp predicate (e.g. 'oeq')");
+    default: 
+      return tokError("expected fcmp predicate (e.g. 'oeq')"); 
     case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
     case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
     case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
@@ -6247,8 +6247,8 @@ bool LLParser::parseCmpPredicate(unsigned &P, unsigned Opc) {
     }
   } else {
     switch (Lex.getKind()) {
-    default:
-      return tokError("expected icmp predicate (e.g. 'eq')");
+    default: 
+      return tokError("expected icmp predicate (e.g. 'eq')"); 
     case lltok::kw_eq:  P = CmpInst::ICMP_EQ; break;
     case lltok::kw_ne:  P = CmpInst::ICMP_NE; break;
     case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
@@ -6269,48 +6269,48 @@ bool LLParser::parseCmpPredicate(unsigned &P, unsigned Opc) {
 // Terminator Instructions.
 //===----------------------------------------------------------------------===//
 
-/// parseRet - parse a return instruction.
+/// parseRet - parse a return instruction. 
 ///   ::= 'ret' void (',' !dbg, !1)*
 ///   ::= 'ret' TypeAndValue (',' !dbg, !1)*
-bool LLParser::parseRet(Instruction *&Inst, BasicBlock *BB,
+bool LLParser::parseRet(Instruction *&Inst, BasicBlock *BB, 
                         PerFunctionState &PFS) {
   SMLoc TypeLoc = Lex.getLoc();
   Type *Ty = nullptr;
-  if (parseType(Ty, true /*void allowed*/))
-    return true;
+  if (parseType(Ty, true /*void allowed*/)) 
+    return true; 
 
   Type *ResType = PFS.getFunction().getReturnType();
 
   if (Ty->isVoidTy()) {
     if (!ResType->isVoidTy())
-      return error(TypeLoc, "value doesn't match function result type '" +
-                                getTypeString(ResType) + "'");
+      return error(TypeLoc, "value doesn't match function result type '" + 
+                                getTypeString(ResType) + "'"); 
 
     Inst = ReturnInst::Create(Context);
     return false;
   }
 
   Value *RV;
-  if (parseValue(Ty, RV, PFS))
-    return true;
+  if (parseValue(Ty, RV, PFS)) 
+    return true; 
 
   if (ResType != RV->getType())
-    return error(TypeLoc, "value doesn't match function result type '" +
-                              getTypeString(ResType) + "'");
+    return error(TypeLoc, "value doesn't match function result type '" + 
+                              getTypeString(ResType) + "'"); 
 
   Inst = ReturnInst::Create(Context, RV);
   return false;
 }
 
-/// parseBr
+/// parseBr 
 ///   ::= 'br' TypeAndValue
 ///   ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
-bool LLParser::parseBr(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseBr(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy Loc, Loc2;
   Value *Op0;
   BasicBlock *Op1, *Op2;
-  if (parseTypeAndValue(Op0, Loc, PFS))
-    return true;
+  if (parseTypeAndValue(Op0, Loc, PFS)) 
+    return true; 
 
   if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
     Inst = BranchInst::Create(BB);
@@ -6318,52 +6318,52 @@ bool LLParser::parseBr(Instruction *&Inst, PerFunctionState &PFS) {
   }
 
   if (Op0->getType() != Type::getInt1Ty(Context))
-    return error(Loc, "branch condition must have 'i1' type");
+    return error(Loc, "branch condition must have 'i1' type"); 
 
-  if (parseToken(lltok::comma, "expected ',' after branch condition") ||
-      parseTypeAndBasicBlock(Op1, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after true destination") ||
-      parseTypeAndBasicBlock(Op2, Loc2, PFS))
+  if (parseToken(lltok::comma, "expected ',' after branch condition") || 
+      parseTypeAndBasicBlock(Op1, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after true destination") || 
+      parseTypeAndBasicBlock(Op2, Loc2, PFS)) 
     return true;
 
   Inst = BranchInst::Create(Op1, Op2, Op0);
   return false;
 }
 
-/// parseSwitch
+/// parseSwitch 
 ///  Instruction
 ///    ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
 ///  JumpTable
 ///    ::= (TypeAndValue ',' TypeAndValue)*
-bool LLParser::parseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseSwitch(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy CondLoc, BBLoc;
   Value *Cond;
   BasicBlock *DefaultBB;
-  if (parseTypeAndValue(Cond, CondLoc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after switch condition") ||
-      parseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
-      parseToken(lltok::lsquare, "expected '[' with switch table"))
+  if (parseTypeAndValue(Cond, CondLoc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after switch condition") || 
+      parseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) || 
+      parseToken(lltok::lsquare, "expected '[' with switch table")) 
     return true;
 
   if (!Cond->getType()->isIntegerTy())
-    return error(CondLoc, "switch condition must have integer type");
+    return error(CondLoc, "switch condition must have integer type"); 
 
-  // parse the jump table pairs.
+  // parse the jump table pairs. 
   SmallPtrSet<Value*, 32> SeenCases;
   SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
   while (Lex.getKind() != lltok::rsquare) {
     Value *Constant;
     BasicBlock *DestBB;
 
-    if (parseTypeAndValue(Constant, CondLoc, PFS) ||
-        parseToken(lltok::comma, "expected ',' after case value") ||
-        parseTypeAndBasicBlock(DestBB, PFS))
+    if (parseTypeAndValue(Constant, CondLoc, PFS) || 
+        parseToken(lltok::comma, "expected ',' after case value") || 
+        parseTypeAndBasicBlock(DestBB, PFS)) 
       return true;
 
     if (!SeenCases.insert(Constant).second)
-      return error(CondLoc, "duplicate case value in switch");
+      return error(CondLoc, "duplicate case value in switch"); 
     if (!isa<ConstantInt>(Constant))
-      return error(CondLoc, "case value is not a constant integer");
+      return error(CondLoc, "case value is not a constant integer"); 
 
     Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
   }
@@ -6377,37 +6377,37 @@ bool LLParser::parseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-/// parseIndirectBr
+/// parseIndirectBr 
 ///  Instruction
 ///    ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
-bool LLParser::parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy AddrLoc;
   Value *Address;
-  if (parseTypeAndValue(Address, AddrLoc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after indirectbr address") ||
-      parseToken(lltok::lsquare, "expected '[' with indirectbr"))
+  if (parseTypeAndValue(Address, AddrLoc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after indirectbr address") || 
+      parseToken(lltok::lsquare, "expected '[' with indirectbr")) 
     return true;
 
   if (!Address->getType()->isPointerTy())
-    return error(AddrLoc, "indirectbr address must have pointer type");
+    return error(AddrLoc, "indirectbr address must have pointer type"); 
 
-  // parse the destination list.
+  // parse the destination list. 
   SmallVector<BasicBlock*, 16> DestList;
 
   if (Lex.getKind() != lltok::rsquare) {
     BasicBlock *DestBB;
-    if (parseTypeAndBasicBlock(DestBB, PFS))
+    if (parseTypeAndBasicBlock(DestBB, PFS)) 
       return true;
     DestList.push_back(DestBB);
 
     while (EatIfPresent(lltok::comma)) {
-      if (parseTypeAndBasicBlock(DestBB, PFS))
+      if (parseTypeAndBasicBlock(DestBB, PFS)) 
         return true;
       DestList.push_back(DestBB);
     }
   }
 
-  if (parseToken(lltok::rsquare, "expected ']' at end of block list"))
+  if (parseToken(lltok::rsquare, "expected ']' at end of block list")) 
     return true;
 
   IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
@@ -6417,10 +6417,10 @@ bool LLParser::parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-/// parseInvoke
+/// parseInvoke 
 ///   ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
 ///       OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
-bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy CallLoc = Lex.getLoc();
   AttrBuilder RetAttrs, FnAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
@@ -6434,17 +6434,17 @@ bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
   SmallVector<OperandBundleDef, 2> BundleList;
 
   BasicBlock *NormalBB, *UnwindBB;
-  if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
-      parseOptionalProgramAddrSpace(InvokeAddrSpace) ||
-      parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
-      parseValID(CalleeID) || parseParameterList(ArgList, PFS) ||
-      parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
+  if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) || 
+      parseOptionalProgramAddrSpace(InvokeAddrSpace) || 
+      parseType(RetType, RetTypeLoc, true /*void allowed*/) || 
+      parseValID(CalleeID) || parseParameterList(ArgList, PFS) || 
+      parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, 
                                  NoBuiltinLoc) ||
-      parseOptionalOperandBundles(BundleList, PFS) ||
-      parseToken(lltok::kw_to, "expected 'to' in invoke") ||
-      parseTypeAndBasicBlock(NormalBB, PFS) ||
-      parseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
-      parseTypeAndBasicBlock(UnwindBB, PFS))
+      parseOptionalOperandBundles(BundleList, PFS) || 
+      parseToken(lltok::kw_to, "expected 'to' in invoke") || 
+      parseTypeAndBasicBlock(NormalBB, PFS) || 
+      parseToken(lltok::kw_unwind, "expected 'unwind' in invoke") || 
+      parseTypeAndBasicBlock(UnwindBB, PFS)) 
     return true;
 
   // If RetType is a non-function pointer type, then this is the short syntax
@@ -6458,7 +6458,7 @@ bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
       ParamTypes.push_back(ArgList[i].V->getType());
 
     if (!FunctionType::isValidReturnType(RetType))
-      return error(RetTypeLoc, "Invalid result type for LLVM function");
+      return error(RetTypeLoc, "Invalid result type for LLVM function"); 
 
     Ty = FunctionType::get(RetType, ParamTypes, false);
   }
@@ -6467,7 +6467,7 @@ bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
 
   // Look up the callee.
   Value *Callee;
-  if (convertValIDToValue(PointerType::get(Ty, InvokeAddrSpace), CalleeID,
+  if (convertValIDToValue(PointerType::get(Ty, InvokeAddrSpace), CalleeID, 
                           Callee, &PFS, /*IsCall=*/true))
     return true;
 
@@ -6484,21 +6484,21 @@ bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
     if (I != E) {
       ExpectedTy = *I++;
     } else if (!Ty->isVarArg()) {
-      return error(ArgList[i].Loc, "too many arguments specified");
+      return error(ArgList[i].Loc, "too many arguments specified"); 
     }
 
     if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
-      return error(ArgList[i].Loc, "argument is not of expected type '" +
-                                       getTypeString(ExpectedTy) + "'");
+      return error(ArgList[i].Loc, "argument is not of expected type '" + 
+                                       getTypeString(ExpectedTy) + "'"); 
     Args.push_back(ArgList[i].V);
     ArgAttrs.push_back(ArgList[i].Attrs);
   }
 
   if (I != E)
-    return error(CallLoc, "not enough parameters specified for call");
+    return error(CallLoc, "not enough parameters specified for call"); 
 
   if (FnAttrs.hasAlignmentAttr())
-    return error(CallLoc, "invoke instructions may not have an alignment");
+    return error(CallLoc, "invoke instructions may not have an alignment"); 
 
   // Finish off the Attribute and check them
   AttributeList PAL =
@@ -6514,11 +6514,11 @@ bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-/// parseResume
+/// parseResume 
 ///   ::= 'resume' TypeAndValue
-bool LLParser::parseResume(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseResume(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Exn; LocTy ExnLoc;
-  if (parseTypeAndValue(Exn, ExnLoc, PFS))
+  if (parseTypeAndValue(Exn, ExnLoc, PFS)) 
     return true;
 
   ResumeInst *RI = ResumeInst::Create(Exn);
@@ -6526,29 +6526,29 @@ bool LLParser::parseResume(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-bool LLParser::parseExceptionArgs(SmallVectorImpl<Value *> &Args,
+bool LLParser::parseExceptionArgs(SmallVectorImpl<Value *> &Args, 
                                   PerFunctionState &PFS) {
-  if (parseToken(lltok::lsquare, "expected '[' in catchpad/cleanuppad"))
+  if (parseToken(lltok::lsquare, "expected '[' in catchpad/cleanuppad")) 
     return true;
 
   while (Lex.getKind() != lltok::rsquare) {
     // If this isn't the first argument, we need a comma.
     if (!Args.empty() &&
-        parseToken(lltok::comma, "expected ',' in argument list"))
+        parseToken(lltok::comma, "expected ',' in argument list")) 
       return true;
 
-    // parse the argument.
+    // parse the argument. 
     LocTy ArgLoc;
     Type *ArgTy = nullptr;
-    if (parseType(ArgTy, ArgLoc))
+    if (parseType(ArgTy, ArgLoc)) 
       return true;
 
     Value *V;
     if (ArgTy->isMetadataTy()) {
-      if (parseMetadataAsValue(V, PFS))
+      if (parseMetadataAsValue(V, PFS)) 
         return true;
     } else {
-      if (parseValue(ArgTy, V, PFS))
+      if (parseValue(ArgTy, V, PFS)) 
         return true;
     }
     Args.push_back(V);
@@ -6558,27 +6558,27 @@ bool LLParser::parseExceptionArgs(SmallVectorImpl<Value *> &Args,
   return false;
 }
 
-/// parseCleanupRet
+/// parseCleanupRet 
 ///   ::= 'cleanupret' from Value unwind ('to' 'caller' | TypeAndValue)
-bool LLParser::parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *CleanupPad = nullptr;
 
-  if (parseToken(lltok::kw_from, "expected 'from' after cleanupret"))
+  if (parseToken(lltok::kw_from, "expected 'from' after cleanupret")) 
     return true;
 
-  if (parseValue(Type::getTokenTy(Context), CleanupPad, PFS))
+  if (parseValue(Type::getTokenTy(Context), CleanupPad, PFS)) 
     return true;
 
-  if (parseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret"))
+  if (parseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret")) 
     return true;
 
   BasicBlock *UnwindBB = nullptr;
   if (Lex.getKind() == lltok::kw_to) {
     Lex.Lex();
-    if (parseToken(lltok::kw_caller, "expected 'caller' in cleanupret"))
+    if (parseToken(lltok::kw_caller, "expected 'caller' in cleanupret")) 
       return true;
   } else {
-    if (parseTypeAndBasicBlock(UnwindBB, PFS)) {
+    if (parseTypeAndBasicBlock(UnwindBB, PFS)) { 
       return true;
     }
   }
@@ -6587,64 +6587,64 @@ bool LLParser::parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-/// parseCatchRet
+/// parseCatchRet 
 ///   ::= 'catchret' from Parent Value 'to' TypeAndValue
-bool LLParser::parseCatchRet(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseCatchRet(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *CatchPad = nullptr;
 
-  if (parseToken(lltok::kw_from, "expected 'from' after catchret"))
+  if (parseToken(lltok::kw_from, "expected 'from' after catchret")) 
     return true;
 
-  if (parseValue(Type::getTokenTy(Context), CatchPad, PFS))
+  if (parseValue(Type::getTokenTy(Context), CatchPad, PFS)) 
     return true;
 
   BasicBlock *BB;
-  if (parseToken(lltok::kw_to, "expected 'to' in catchret") ||
-      parseTypeAndBasicBlock(BB, PFS))
-    return true;
+  if (parseToken(lltok::kw_to, "expected 'to' in catchret") || 
+      parseTypeAndBasicBlock(BB, PFS)) 
+    return true; 
 
   Inst = CatchReturnInst::Create(CatchPad, BB);
   return false;
 }
 
-/// parseCatchSwitch
+/// parseCatchSwitch 
 ///   ::= 'catchswitch' within Parent
-bool LLParser::parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *ParentPad;
 
-  if (parseToken(lltok::kw_within, "expected 'within' after catchswitch"))
+  if (parseToken(lltok::kw_within, "expected 'within' after catchswitch")) 
     return true;
 
   if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
       Lex.getKind() != lltok::LocalVarID)
-    return tokError("expected scope value for catchswitch");
+    return tokError("expected scope value for catchswitch"); 
 
-  if (parseValue(Type::getTokenTy(Context), ParentPad, PFS))
+  if (parseValue(Type::getTokenTy(Context), ParentPad, PFS)) 
     return true;
 
-  if (parseToken(lltok::lsquare, "expected '[' with catchswitch labels"))
+  if (parseToken(lltok::lsquare, "expected '[' with catchswitch labels")) 
     return true;
 
   SmallVector<BasicBlock *, 32> Table;
   do {
     BasicBlock *DestBB;
-    if (parseTypeAndBasicBlock(DestBB, PFS))
+    if (parseTypeAndBasicBlock(DestBB, PFS)) 
       return true;
     Table.push_back(DestBB);
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rsquare, "expected ']' after catchswitch labels"))
+  if (parseToken(lltok::rsquare, "expected ']' after catchswitch labels")) 
     return true;
 
-  if (parseToken(lltok::kw_unwind, "expected 'unwind' after catchswitch scope"))
+  if (parseToken(lltok::kw_unwind, "expected 'unwind' after catchswitch scope")) 
     return true;
 
   BasicBlock *UnwindBB = nullptr;
   if (EatIfPresent(lltok::kw_to)) {
-    if (parseToken(lltok::kw_caller, "expected 'caller' in catchswitch"))
+    if (parseToken(lltok::kw_caller, "expected 'caller' in catchswitch")) 
       return true;
   } else {
-    if (parseTypeAndBasicBlock(UnwindBB, PFS))
+    if (parseTypeAndBasicBlock(UnwindBB, PFS)) 
       return true;
   }
 
@@ -6656,45 +6656,45 @@ bool LLParser::parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-/// parseCatchPad
+/// parseCatchPad 
 ///   ::= 'catchpad' ParamList 'to' TypeAndValue 'unwind' TypeAndValue
-bool LLParser::parseCatchPad(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseCatchPad(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *CatchSwitch = nullptr;
 
-  if (parseToken(lltok::kw_within, "expected 'within' after catchpad"))
+  if (parseToken(lltok::kw_within, "expected 'within' after catchpad")) 
     return true;
 
   if (Lex.getKind() != lltok::LocalVar && Lex.getKind() != lltok::LocalVarID)
-    return tokError("expected scope value for catchpad");
+    return tokError("expected scope value for catchpad"); 
 
-  if (parseValue(Type::getTokenTy(Context), CatchSwitch, PFS))
+  if (parseValue(Type::getTokenTy(Context), CatchSwitch, PFS)) 
     return true;
 
   SmallVector<Value *, 8> Args;
-  if (parseExceptionArgs(Args, PFS))
+  if (parseExceptionArgs(Args, PFS)) 
     return true;
 
   Inst = CatchPadInst::Create(CatchSwitch, Args);
   return false;
 }
 
-/// parseCleanupPad
+/// parseCleanupPad 
 ///   ::= 'cleanuppad' within Parent ParamList
-bool LLParser::parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *ParentPad = nullptr;
 
-  if (parseToken(lltok::kw_within, "expected 'within' after cleanuppad"))
+  if (parseToken(lltok::kw_within, "expected 'within' after cleanuppad")) 
     return true;
 
   if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
       Lex.getKind() != lltok::LocalVarID)
-    return tokError("expected scope value for cleanuppad");
+    return tokError("expected scope value for cleanuppad"); 
 
-  if (parseValue(Type::getTokenTy(Context), ParentPad, PFS))
+  if (parseValue(Type::getTokenTy(Context), ParentPad, PFS)) 
     return true;
 
   SmallVector<Value *, 8> Args;
-  if (parseExceptionArgs(Args, PFS))
+  if (parseExceptionArgs(Args, PFS)) 
     return true;
 
   Inst = CleanupPadInst::Create(ParentPad, Args);
@@ -6705,32 +6705,32 @@ bool LLParser::parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) {
 // Unary Operators.
 //===----------------------------------------------------------------------===//
 
-/// parseUnaryOp
+/// parseUnaryOp 
 ///  ::= UnaryOp TypeAndValue ',' Value
 ///
 /// If IsFP is false, then any integer operand is allowed, if it is true, any fp
 /// operand is allowed.
-bool LLParser::parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
+bool LLParser::parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, 
                             unsigned Opc, bool IsFP) {
   LocTy Loc; Value *LHS;
-  if (parseTypeAndValue(LHS, Loc, PFS))
+  if (parseTypeAndValue(LHS, Loc, PFS)) 
     return true;
 
   bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy()
                     : LHS->getType()->isIntOrIntVectorTy();
 
   if (!Valid)
-    return error(Loc, "invalid operand type for instruction");
+    return error(Loc, "invalid operand type for instruction"); 
 
   Inst = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
   return false;
 }
 
-/// parseCallBr
+/// parseCallBr 
 ///   ::= 'callbr' OptionalCallingConv OptionalAttrs Type Value ParamList
 ///       OptionalAttrs OptionalOperandBundles 'to' TypeAndValue
 ///       '[' LabelList ']'
-bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy CallLoc = Lex.getLoc();
   AttrBuilder RetAttrs, FnAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
@@ -6743,34 +6743,34 @@ bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
   SmallVector<OperandBundleDef, 2> BundleList;
 
   BasicBlock *DefaultDest;
-  if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
-      parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
-      parseValID(CalleeID) || parseParameterList(ArgList, PFS) ||
-      parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
+  if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) || 
+      parseType(RetType, RetTypeLoc, true /*void allowed*/) || 
+      parseValID(CalleeID) || parseParameterList(ArgList, PFS) || 
+      parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, 
                                  NoBuiltinLoc) ||
-      parseOptionalOperandBundles(BundleList, PFS) ||
-      parseToken(lltok::kw_to, "expected 'to' in callbr") ||
-      parseTypeAndBasicBlock(DefaultDest, PFS) ||
-      parseToken(lltok::lsquare, "expected '[' in callbr"))
+      parseOptionalOperandBundles(BundleList, PFS) || 
+      parseToken(lltok::kw_to, "expected 'to' in callbr") || 
+      parseTypeAndBasicBlock(DefaultDest, PFS) || 
+      parseToken(lltok::lsquare, "expected '[' in callbr")) 
     return true;
 
-  // parse the destination list.
+  // parse the destination list. 
   SmallVector<BasicBlock *, 16> IndirectDests;
 
   if (Lex.getKind() != lltok::rsquare) {
     BasicBlock *DestBB;
-    if (parseTypeAndBasicBlock(DestBB, PFS))
+    if (parseTypeAndBasicBlock(DestBB, PFS)) 
       return true;
     IndirectDests.push_back(DestBB);
 
     while (EatIfPresent(lltok::comma)) {
-      if (parseTypeAndBasicBlock(DestBB, PFS))
+      if (parseTypeAndBasicBlock(DestBB, PFS)) 
         return true;
       IndirectDests.push_back(DestBB);
     }
   }
 
-  if (parseToken(lltok::rsquare, "expected ']' at end of block list"))
+  if (parseToken(lltok::rsquare, "expected ']' at end of block list")) 
     return true;
 
   // If RetType is a non-function pointer type, then this is the short syntax
@@ -6784,7 +6784,7 @@ bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
       ParamTypes.push_back(ArgList[i].V->getType());
 
     if (!FunctionType::isValidReturnType(RetType))
-      return error(RetTypeLoc, "Invalid result type for LLVM function");
+      return error(RetTypeLoc, "Invalid result type for LLVM function"); 
 
     Ty = FunctionType::get(RetType, ParamTypes, false);
   }
@@ -6793,7 +6793,7 @@ bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
 
   // Look up the callee.
   Value *Callee;
-  if (convertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS,
+  if (convertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS, 
                           /*IsCall=*/true))
     return true;
 
@@ -6810,21 +6810,21 @@ bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
     if (I != E) {
       ExpectedTy = *I++;
     } else if (!Ty->isVarArg()) {
-      return error(ArgList[i].Loc, "too many arguments specified");
+      return error(ArgList[i].Loc, "too many arguments specified"); 
     }
 
     if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
-      return error(ArgList[i].Loc, "argument is not of expected type '" +
+      return error(ArgList[i].Loc, "argument is not of expected type '" + 
                                        getTypeString(ExpectedTy) + "'");
     Args.push_back(ArgList[i].V);
     ArgAttrs.push_back(ArgList[i].Attrs);
   }
 
   if (I != E)
-    return error(CallLoc, "not enough parameters specified for call");
+    return error(CallLoc, "not enough parameters specified for call"); 
 
   if (FnAttrs.hasAlignmentAttr())
-    return error(CallLoc, "callbr instructions may not have an alignment");
+    return error(CallLoc, "callbr instructions may not have an alignment"); 
 
   // Finish off the Attribute and check them
   AttributeList PAL =
@@ -6845,70 +6845,70 @@ bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
 // Binary Operators.
 //===----------------------------------------------------------------------===//
 
-/// parseArithmetic
+/// parseArithmetic 
 ///  ::= ArithmeticOps TypeAndValue ',' Value
 ///
 /// If IsFP is false, then any integer operand is allowed, if it is true, any fp
 /// operand is allowed.
-bool LLParser::parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
+bool LLParser::parseArithmetic(Instruction *&Inst, PerFunctionState &PFS, 
                                unsigned Opc, bool IsFP) {
   LocTy Loc; Value *LHS, *RHS;
-  if (parseTypeAndValue(LHS, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' in arithmetic operation") ||
-      parseValue(LHS->getType(), RHS, PFS))
+  if (parseTypeAndValue(LHS, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' in arithmetic operation") || 
+      parseValue(LHS->getType(), RHS, PFS)) 
     return true;
 
   bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy()
                     : LHS->getType()->isIntOrIntVectorTy();
 
   if (!Valid)
-    return error(Loc, "invalid operand type for instruction");
+    return error(Loc, "invalid operand type for instruction"); 
 
   Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
   return false;
 }
 
-/// parseLogical
+/// parseLogical 
 ///  ::= ArithmeticOps TypeAndValue ',' Value {
-bool LLParser::parseLogical(Instruction *&Inst, PerFunctionState &PFS,
+bool LLParser::parseLogical(Instruction *&Inst, PerFunctionState &PFS, 
                             unsigned Opc) {
   LocTy Loc; Value *LHS, *RHS;
-  if (parseTypeAndValue(LHS, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' in logical operation") ||
-      parseValue(LHS->getType(), RHS, PFS))
+  if (parseTypeAndValue(LHS, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' in logical operation") || 
+      parseValue(LHS->getType(), RHS, PFS)) 
     return true;
 
   if (!LHS->getType()->isIntOrIntVectorTy())
-    return error(Loc,
-                 "instruction requires integer or integer vector operands");
+    return error(Loc, 
+                 "instruction requires integer or integer vector operands"); 
 
   Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
   return false;
 }
 
-/// parseCompare
+/// parseCompare 
 ///  ::= 'icmp' IPredicates TypeAndValue ',' Value
 ///  ::= 'fcmp' FPredicates TypeAndValue ',' Value
-bool LLParser::parseCompare(Instruction *&Inst, PerFunctionState &PFS,
+bool LLParser::parseCompare(Instruction *&Inst, PerFunctionState &PFS, 
                             unsigned Opc) {
-  // parse the integer/fp comparison predicate.
+  // parse the integer/fp comparison predicate. 
   LocTy Loc;
   unsigned Pred;
   Value *LHS, *RHS;
-  if (parseCmpPredicate(Pred, Opc) || parseTypeAndValue(LHS, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after compare value") ||
-      parseValue(LHS->getType(), RHS, PFS))
+  if (parseCmpPredicate(Pred, Opc) || parseTypeAndValue(LHS, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after compare value") || 
+      parseValue(LHS->getType(), RHS, PFS)) 
     return true;
 
   if (Opc == Instruction::FCmp) {
     if (!LHS->getType()->isFPOrFPVectorTy())
-      return error(Loc, "fcmp requires floating point operands");
+      return error(Loc, "fcmp requires floating point operands"); 
     Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
   } else {
     assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
     if (!LHS->getType()->isIntOrIntVectorTy() &&
         !LHS->getType()->isPtrOrPtrVectorTy())
-      return error(Loc, "icmp requires integer operands");
+      return error(Loc, "icmp requires integer operands"); 
     Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
   }
   return false;
@@ -6918,132 +6918,132 @@ bool LLParser::parseCompare(Instruction *&Inst, PerFunctionState &PFS,
 // Other Instructions.
 //===----------------------------------------------------------------------===//
 
-/// parseCast
+/// parseCast 
 ///   ::= CastOpc TypeAndValue 'to' Type
-bool LLParser::parseCast(Instruction *&Inst, PerFunctionState &PFS,
+bool LLParser::parseCast(Instruction *&Inst, PerFunctionState &PFS, 
                          unsigned Opc) {
   LocTy Loc;
   Value *Op;
   Type *DestTy = nullptr;
-  if (parseTypeAndValue(Op, Loc, PFS) ||
-      parseToken(lltok::kw_to, "expected 'to' after cast value") ||
-      parseType(DestTy))
+  if (parseTypeAndValue(Op, Loc, PFS) || 
+      parseToken(lltok::kw_to, "expected 'to' after cast value") || 
+      parseType(DestTy)) 
     return true;
 
   if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
     CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
-    return error(Loc, "invalid cast opcode for cast from '" +
-                          getTypeString(Op->getType()) + "' to '" +
-                          getTypeString(DestTy) + "'");
+    return error(Loc, "invalid cast opcode for cast from '" + 
+                          getTypeString(Op->getType()) + "' to '" + 
+                          getTypeString(DestTy) + "'"); 
   }
   Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
   return false;
 }
 
-/// parseSelect
+/// parseSelect 
 ///   ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
-bool LLParser::parseSelect(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseSelect(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy Loc;
   Value *Op0, *Op1, *Op2;
-  if (parseTypeAndValue(Op0, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after select condition") ||
-      parseTypeAndValue(Op1, PFS) ||
-      parseToken(lltok::comma, "expected ',' after select value") ||
-      parseTypeAndValue(Op2, PFS))
+  if (parseTypeAndValue(Op0, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after select condition") || 
+      parseTypeAndValue(Op1, PFS) || 
+      parseToken(lltok::comma, "expected ',' after select value") || 
+      parseTypeAndValue(Op2, PFS)) 
     return true;
 
   if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
-    return error(Loc, Reason);
+    return error(Loc, Reason); 
 
   Inst = SelectInst::Create(Op0, Op1, Op2);
   return false;
 }
 
-/// parseVAArg
+/// parseVAArg 
 ///   ::= 'va_arg' TypeAndValue ',' Type
-bool LLParser::parseVAArg(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseVAArg(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Op;
   Type *EltTy = nullptr;
   LocTy TypeLoc;
-  if (parseTypeAndValue(Op, PFS) ||
-      parseToken(lltok::comma, "expected ',' after vaarg operand") ||
-      parseType(EltTy, TypeLoc))
+  if (parseTypeAndValue(Op, PFS) || 
+      parseToken(lltok::comma, "expected ',' after vaarg operand") || 
+      parseType(EltTy, TypeLoc)) 
     return true;
 
   if (!EltTy->isFirstClassType())
-    return error(TypeLoc, "va_arg requires operand with first class type");
+    return error(TypeLoc, "va_arg requires operand with first class type"); 
 
   Inst = new VAArgInst(Op, EltTy);
   return false;
 }
 
-/// parseExtractElement
+/// parseExtractElement 
 ///   ::= 'extractelement' TypeAndValue ',' TypeAndValue
-bool LLParser::parseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseExtractElement(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy Loc;
   Value *Op0, *Op1;
-  if (parseTypeAndValue(Op0, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after extract value") ||
-      parseTypeAndValue(Op1, PFS))
+  if (parseTypeAndValue(Op0, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after extract value") || 
+      parseTypeAndValue(Op1, PFS)) 
     return true;
 
   if (!ExtractElementInst::isValidOperands(Op0, Op1))
-    return error(Loc, "invalid extractelement operands");
+    return error(Loc, "invalid extractelement operands"); 
 
   Inst = ExtractElementInst::Create(Op0, Op1);
   return false;
 }
 
-/// parseInsertElement
+/// parseInsertElement 
 ///   ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
-bool LLParser::parseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseInsertElement(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy Loc;
   Value *Op0, *Op1, *Op2;
-  if (parseTypeAndValue(Op0, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after insertelement value") ||
-      parseTypeAndValue(Op1, PFS) ||
-      parseToken(lltok::comma, "expected ',' after insertelement value") ||
-      parseTypeAndValue(Op2, PFS))
+  if (parseTypeAndValue(Op0, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after insertelement value") || 
+      parseTypeAndValue(Op1, PFS) || 
+      parseToken(lltok::comma, "expected ',' after insertelement value") || 
+      parseTypeAndValue(Op2, PFS)) 
     return true;
 
   if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
-    return error(Loc, "invalid insertelement operands");
+    return error(Loc, "invalid insertelement operands"); 
 
   Inst = InsertElementInst::Create(Op0, Op1, Op2);
   return false;
 }
 
-/// parseShuffleVector
+/// parseShuffleVector 
 ///   ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
-bool LLParser::parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy Loc;
   Value *Op0, *Op1, *Op2;
-  if (parseTypeAndValue(Op0, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after shuffle mask") ||
-      parseTypeAndValue(Op1, PFS) ||
-      parseToken(lltok::comma, "expected ',' after shuffle value") ||
-      parseTypeAndValue(Op2, PFS))
+  if (parseTypeAndValue(Op0, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after shuffle mask") || 
+      parseTypeAndValue(Op1, PFS) || 
+      parseToken(lltok::comma, "expected ',' after shuffle value") || 
+      parseTypeAndValue(Op2, PFS)) 
     return true;
 
   if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
-    return error(Loc, "invalid shufflevector operands");
+    return error(Loc, "invalid shufflevector operands"); 
 
   Inst = new ShuffleVectorInst(Op0, Op1, Op2);
   return false;
 }
 
-/// parsePHI
+/// parsePHI 
 ///   ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
-int LLParser::parsePHI(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parsePHI(Instruction *&Inst, PerFunctionState &PFS) { 
   Type *Ty = nullptr;  LocTy TypeLoc;
   Value *Op0, *Op1;
 
-  if (parseType(Ty, TypeLoc) ||
-      parseToken(lltok::lsquare, "expected '[' in phi value list") ||
-      parseValue(Ty, Op0, PFS) ||
-      parseToken(lltok::comma, "expected ',' after insertelement value") ||
-      parseValue(Type::getLabelTy(Context), Op1, PFS) ||
-      parseToken(lltok::rsquare, "expected ']' in phi value list"))
+  if (parseType(Ty, TypeLoc) || 
+      parseToken(lltok::lsquare, "expected '[' in phi value list") || 
+      parseValue(Ty, Op0, PFS) || 
+      parseToken(lltok::comma, "expected ',' after insertelement value") || 
+      parseValue(Type::getLabelTy(Context), Op1, PFS) || 
+      parseToken(lltok::rsquare, "expected ']' in phi value list")) 
     return true;
 
   bool AteExtraComma = false;
@@ -7060,16 +7060,16 @@ int LLParser::parsePHI(Instruction *&Inst, PerFunctionState &PFS) {
       break;
     }
 
-    if (parseToken(lltok::lsquare, "expected '[' in phi value list") ||
-        parseValue(Ty, Op0, PFS) ||
-        parseToken(lltok::comma, "expected ',' after insertelement value") ||
-        parseValue(Type::getLabelTy(Context), Op1, PFS) ||
-        parseToken(lltok::rsquare, "expected ']' in phi value list"))
+    if (parseToken(lltok::lsquare, "expected '[' in phi value list") || 
+        parseValue(Ty, Op0, PFS) || 
+        parseToken(lltok::comma, "expected ',' after insertelement value") || 
+        parseValue(Type::getLabelTy(Context), Op1, PFS) || 
+        parseToken(lltok::rsquare, "expected ']' in phi value list")) 
       return true;
   }
 
   if (!Ty->isFirstClassType())
-    return error(TypeLoc, "phi node must have first class type");
+    return error(TypeLoc, "phi node must have first class type"); 
 
   PHINode *PN = PHINode::Create(Ty, PHIVals.size());
   for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
@@ -7078,16 +7078,16 @@ int LLParser::parsePHI(Instruction *&Inst, PerFunctionState &PFS) {
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseLandingPad
+/// parseLandingPad 
 ///   ::= 'landingpad' Type 'personality' TypeAndValue 'cleanup'? Clause+
 /// Clause
 ///   ::= 'catch' TypeAndValue
 ///   ::= 'filter'
 ///   ::= 'filter' TypeAndValue ( ',' TypeAndValue )*
-bool LLParser::parseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseLandingPad(Instruction *&Inst, PerFunctionState &PFS) { 
   Type *Ty = nullptr; LocTy TyLoc;
 
-  if (parseType(Ty, TyLoc))
+  if (parseType(Ty, TyLoc)) 
     return true;
 
   std::unique_ptr<LandingPadInst> LP(LandingPadInst::Create(Ty, 0));
@@ -7100,26 +7100,26 @@ bool LLParser::parseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
     else if (EatIfPresent(lltok::kw_filter))
       CT = LandingPadInst::Filter;
     else
-      return tokError("expected 'catch' or 'filter' clause type");
+      return tokError("expected 'catch' or 'filter' clause type"); 
 
     Value *V;
     LocTy VLoc;
-    if (parseTypeAndValue(V, VLoc, PFS))
+    if (parseTypeAndValue(V, VLoc, PFS)) 
       return true;
 
     // A 'catch' type expects a non-array constant. A filter clause expects an
     // array constant.
     if (CT == LandingPadInst::Catch) {
       if (isa<ArrayType>(V->getType()))
-        error(VLoc, "'catch' clause has an invalid type");
+        error(VLoc, "'catch' clause has an invalid type"); 
     } else {
       if (!isa<ArrayType>(V->getType()))
-        error(VLoc, "'filter' clause has an invalid type");
+        error(VLoc, "'filter' clause has an invalid type"); 
     }
 
     Constant *CV = dyn_cast<Constant>(V);
     if (!CV)
-      return error(VLoc, "clause argument must be a constant");
+      return error(VLoc, "clause argument must be a constant"); 
     LP->addClause(CV);
   }
 
@@ -7127,19 +7127,19 @@ bool LLParser::parseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
   return false;
 }
 
-/// parseFreeze
+/// parseFreeze 
 ///   ::= 'freeze' Type Value
-bool LLParser::parseFreeze(Instruction *&Inst, PerFunctionState &PFS) {
+bool LLParser::parseFreeze(Instruction *&Inst, PerFunctionState &PFS) { 
   LocTy Loc;
   Value *Op;
-  if (parseTypeAndValue(Op, Loc, PFS))
+  if (parseTypeAndValue(Op, Loc, PFS)) 
     return true;
 
   Inst = new FreezeInst(Op);
   return false;
 }
 
-/// parseCall
+/// parseCall 
 ///   ::= 'call' OptionalFastMathFlags OptionalCallingConv
 ///           OptionalAttrs Type Value ParameterList OptionalAttrs
 ///   ::= 'tail' 'call' OptionalFastMathFlags OptionalCallingConv
@@ -7148,7 +7148,7 @@ bool LLParser::parseFreeze(Instruction *&Inst, PerFunctionState &PFS) {
 ///           OptionalAttrs Type Value ParameterList OptionalAttrs
 ///   ::= 'notail' 'call'  OptionalFastMathFlags OptionalCallingConv
 ///           OptionalAttrs Type Value ParameterList OptionalAttrs
-bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
+bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS, 
                          CallInst::TailCallKind TCK) {
   AttrBuilder RetAttrs, FnAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
@@ -7163,20 +7163,20 @@ bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
   LocTy CallLoc = Lex.getLoc();
 
   if (TCK != CallInst::TCK_None &&
-      parseToken(lltok::kw_call,
+      parseToken(lltok::kw_call, 
                  "expected 'tail call', 'musttail call', or 'notail call'"))
     return true;
 
   FastMathFlags FMF = EatFastMathFlagsIfPresent();
 
-  if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
-      parseOptionalProgramAddrSpace(CallAddrSpace) ||
-      parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
-      parseValID(CalleeID) ||
-      parseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
+  if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) || 
+      parseOptionalProgramAddrSpace(CallAddrSpace) || 
+      parseType(RetType, RetTypeLoc, true /*void allowed*/) || 
+      parseValID(CalleeID) || 
+      parseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail, 
                          PFS.getFunction().isVarArg()) ||
-      parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, BuiltinLoc) ||
-      parseOptionalOperandBundles(BundleList, PFS))
+      parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, BuiltinLoc) || 
+      parseOptionalOperandBundles(BundleList, PFS)) 
     return true;
 
   // If RetType is a non-function pointer type, then this is the short syntax
@@ -7190,7 +7190,7 @@ bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
       ParamTypes.push_back(ArgList[i].V->getType());
 
     if (!FunctionType::isValidReturnType(RetType))
-      return error(RetTypeLoc, "Invalid result type for LLVM function");
+      return error(RetTypeLoc, "Invalid result type for LLVM function"); 
 
     Ty = FunctionType::get(RetType, ParamTypes, false);
   }
@@ -7199,7 +7199,7 @@ bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
 
   // Look up the callee.
   Value *Callee;
-  if (convertValIDToValue(PointerType::get(Ty, CallAddrSpace), CalleeID, Callee,
+  if (convertValIDToValue(PointerType::get(Ty, CallAddrSpace), CalleeID, Callee, 
                           &PFS, /*IsCall=*/true))
     return true;
 
@@ -7217,21 +7217,21 @@ bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
     if (I != E) {
       ExpectedTy = *I++;
     } else if (!Ty->isVarArg()) {
-      return error(ArgList[i].Loc, "too many arguments specified");
+      return error(ArgList[i].Loc, "too many arguments specified"); 
     }
 
     if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
-      return error(ArgList[i].Loc, "argument is not of expected type '" +
-                                       getTypeString(ExpectedTy) + "'");
+      return error(ArgList[i].Loc, "argument is not of expected type '" + 
+                                       getTypeString(ExpectedTy) + "'"); 
     Args.push_back(ArgList[i].V);
     Attrs.push_back(ArgList[i].Attrs);
   }
 
   if (I != E)
-    return error(CallLoc, "not enough parameters specified for call");
+    return error(CallLoc, "not enough parameters specified for call"); 
 
   if (FnAttrs.hasAlignmentAttr())
-    return error(CallLoc, "call instructions may not have an alignment");
+    return error(CallLoc, "call instructions may not have an alignment"); 
 
   // Finish off the Attribute and check them
   AttributeList PAL =
@@ -7244,8 +7244,8 @@ bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
   if (FMF.any()) {
     if (!isa<FPMathOperator>(CI)) {
       CI->deleteValue();
-      return error(CallLoc, "fast-math-flags specified for call without "
-                            "floating-point scalar or vector return type");
+      return error(CallLoc, "fast-math-flags specified for call without " 
+                            "floating-point scalar or vector return type"); 
     }
     CI->setFastMathFlags(FMF);
   }
@@ -7259,10 +7259,10 @@ bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
 // Memory Instructions.
 //===----------------------------------------------------------------------===//
 
-/// parseAlloc
+/// parseAlloc 
 ///   ::= 'alloca' 'inalloca'? 'swifterror'? Type (',' TypeAndValue)?
 ///       (',' 'align' i32)? (',', 'addrspace(n))?
-int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Size = nullptr;
   LocTy SizeLoc, TyLoc, ASLoc;
   MaybeAlign Alignment;
@@ -7272,37 +7272,37 @@ int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
   bool IsInAlloca = EatIfPresent(lltok::kw_inalloca);
   bool IsSwiftError = EatIfPresent(lltok::kw_swifterror);
 
-  if (parseType(Ty, TyLoc))
-    return true;
+  if (parseType(Ty, TyLoc)) 
+    return true; 
 
   if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
-    return error(TyLoc, "invalid type for alloca");
+    return error(TyLoc, "invalid type for alloca"); 
 
   bool AteExtraComma = false;
   if (EatIfPresent(lltok::comma)) {
     if (Lex.getKind() == lltok::kw_align) {
-      if (parseOptionalAlignment(Alignment))
+      if (parseOptionalAlignment(Alignment)) 
         return true;
-      if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma))
+      if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma)) 
         return true;
     } else if (Lex.getKind() == lltok::kw_addrspace) {
       ASLoc = Lex.getLoc();
-      if (parseOptionalAddrSpace(AddrSpace))
+      if (parseOptionalAddrSpace(AddrSpace)) 
         return true;
     } else if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
     } else {
-      if (parseTypeAndValue(Size, SizeLoc, PFS))
+      if (parseTypeAndValue(Size, SizeLoc, PFS)) 
         return true;
       if (EatIfPresent(lltok::comma)) {
         if (Lex.getKind() == lltok::kw_align) {
-          if (parseOptionalAlignment(Alignment))
+          if (parseOptionalAlignment(Alignment)) 
             return true;
-          if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma))
+          if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma)) 
             return true;
         } else if (Lex.getKind() == lltok::kw_addrspace) {
           ASLoc = Lex.getLoc();
-          if (parseOptionalAddrSpace(AddrSpace))
+          if (parseOptionalAddrSpace(AddrSpace)) 
             return true;
         } else if (Lex.getKind() == lltok::MetadataVar) {
           AteExtraComma = true;
@@ -7312,11 +7312,11 @@ int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
   }
 
   if (Size && !Size->getType()->isIntegerTy())
-    return error(SizeLoc, "element count must have integer type");
+    return error(SizeLoc, "element count must have integer type"); 
 
   SmallPtrSet<Type *, 4> Visited;
   if (!Alignment && !Ty->isSized(&Visited))
-    return error(TyLoc, "Cannot allocate unsized type");
+    return error(TyLoc, "Cannot allocate unsized type"); 
   if (!Alignment)
     Alignment = M->getDataLayout().getPrefTypeAlign(Ty);
   AllocaInst *AI = new AllocaInst(Ty, AddrSpace, Size, *Alignment);
@@ -7326,11 +7326,11 @@ int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseLoad
+/// parseLoad 
 ///   ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)?
 ///   ::= 'load' 'atomic' 'volatile'? TypeAndValue
 ///       'singlethread'? AtomicOrdering (',' 'align' i32)?
-int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Val; LocTy Loc;
   MaybeAlign Alignment;
   bool AteExtraComma = false;
@@ -7351,39 +7351,39 @@ int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) {
 
   Type *Ty;
   LocTy ExplicitTypeLoc = Lex.getLoc();
-  if (parseType(Ty) ||
-      parseToken(lltok::comma, "expected comma after load's type") ||
-      parseTypeAndValue(Val, Loc, PFS) ||
-      parseScopeAndOrdering(isAtomic, SSID, Ordering) ||
-      parseOptionalCommaAlign(Alignment, AteExtraComma))
+  if (parseType(Ty) || 
+      parseToken(lltok::comma, "expected comma after load's type") || 
+      parseTypeAndValue(Val, Loc, PFS) || 
+      parseScopeAndOrdering(isAtomic, SSID, Ordering) || 
+      parseOptionalCommaAlign(Alignment, AteExtraComma)) 
     return true;
 
   if (!Val->getType()->isPointerTy() || !Ty->isFirstClassType())
-    return error(Loc, "load operand must be a pointer to a first class type");
+    return error(Loc, "load operand must be a pointer to a first class type"); 
   if (isAtomic && !Alignment)
-    return error(Loc, "atomic load must have explicit non-zero alignment");
+    return error(Loc, "atomic load must have explicit non-zero alignment"); 
   if (Ordering == AtomicOrdering::Release ||
       Ordering == AtomicOrdering::AcquireRelease)
-    return error(Loc, "atomic load cannot use Release ordering");
+    return error(Loc, "atomic load cannot use Release ordering"); 
 
   if (Ty != cast<PointerType>(Val->getType())->getElementType())
-    return error(ExplicitTypeLoc,
+    return error(ExplicitTypeLoc, 
                  "explicit pointee type doesn't match operand's pointee type");
   SmallPtrSet<Type *, 4> Visited;
   if (!Alignment && !Ty->isSized(&Visited))
-    return error(ExplicitTypeLoc, "loading unsized types is not allowed");
+    return error(ExplicitTypeLoc, "loading unsized types is not allowed"); 
   if (!Alignment)
     Alignment = M->getDataLayout().getABITypeAlign(Ty);
   Inst = new LoadInst(Ty, Val, "", isVolatile, *Alignment, Ordering, SSID);
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseStore
+/// parseStore 
 
 ///   ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)?
 ///   ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue
 ///       'singlethread'? AtomicOrdering (',' 'align' i32)?
-int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Val, *Ptr; LocTy Loc, PtrLoc;
   MaybeAlign Alignment;
   bool AteExtraComma = false;
@@ -7402,27 +7402,27 @@ int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) {
     Lex.Lex();
   }
 
-  if (parseTypeAndValue(Val, Loc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after store operand") ||
-      parseTypeAndValue(Ptr, PtrLoc, PFS) ||
-      parseScopeAndOrdering(isAtomic, SSID, Ordering) ||
-      parseOptionalCommaAlign(Alignment, AteExtraComma))
+  if (parseTypeAndValue(Val, Loc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after store operand") || 
+      parseTypeAndValue(Ptr, PtrLoc, PFS) || 
+      parseScopeAndOrdering(isAtomic, SSID, Ordering) || 
+      parseOptionalCommaAlign(Alignment, AteExtraComma)) 
     return true;
 
   if (!Ptr->getType()->isPointerTy())
-    return error(PtrLoc, "store operand must be a pointer");
+    return error(PtrLoc, "store operand must be a pointer"); 
   if (!Val->getType()->isFirstClassType())
-    return error(Loc, "store operand must be a first class value");
+    return error(Loc, "store operand must be a first class value"); 
   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
-    return error(Loc, "stored value and pointer type do not match");
+    return error(Loc, "stored value and pointer type do not match"); 
   if (isAtomic && !Alignment)
-    return error(Loc, "atomic store must have explicit non-zero alignment");
+    return error(Loc, "atomic store must have explicit non-zero alignment"); 
   if (Ordering == AtomicOrdering::Acquire ||
       Ordering == AtomicOrdering::AcquireRelease)
-    return error(Loc, "atomic store cannot use Acquire ordering");
+    return error(Loc, "atomic store cannot use Acquire ordering"); 
   SmallPtrSet<Type *, 4> Visited;
   if (!Alignment && !Val->getType()->isSized(&Visited))
-    return error(Loc, "storing unsized types is not allowed");
+    return error(Loc, "storing unsized types is not allowed"); 
   if (!Alignment)
     Alignment = M->getDataLayout().getABITypeAlign(Val->getType());
 
@@ -7430,10 +7430,10 @@ int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) {
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseCmpXchg
+/// parseCmpXchg 
 ///   ::= 'cmpxchg' 'weak'? 'volatile'? TypeAndValue ',' TypeAndValue ','
 ///       TypeAndValue 'singlethread'? AtomicOrdering AtomicOrdering
-int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc;
   bool AteExtraComma = false;
   AtomicOrdering SuccessOrdering = AtomicOrdering::NotAtomic;
@@ -7448,33 +7448,33 @@ int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
   if (EatIfPresent(lltok::kw_volatile))
     isVolatile = true;
 
-  if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after cmpxchg address") ||
-      parseTypeAndValue(Cmp, CmpLoc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") ||
-      parseTypeAndValue(New, NewLoc, PFS) ||
-      parseScopeAndOrdering(true /*Always atomic*/, SSID, SuccessOrdering) ||
-      parseOrdering(FailureOrdering))
+  if (parseTypeAndValue(Ptr, PtrLoc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after cmpxchg address") || 
+      parseTypeAndValue(Cmp, CmpLoc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") || 
+      parseTypeAndValue(New, NewLoc, PFS) || 
+      parseScopeAndOrdering(true /*Always atomic*/, SSID, SuccessOrdering) || 
+      parseOrdering(FailureOrdering)) 
     return true;
 
   if (SuccessOrdering == AtomicOrdering::Unordered ||
       FailureOrdering == AtomicOrdering::Unordered)
-    return tokError("cmpxchg cannot be unordered");
+    return tokError("cmpxchg cannot be unordered"); 
   if (isStrongerThan(FailureOrdering, SuccessOrdering))
-    return tokError("cmpxchg failure argument shall be no stronger than the "
+    return tokError("cmpxchg failure argument shall be no stronger than the " 
                     "success argument");
   if (FailureOrdering == AtomicOrdering::Release ||
       FailureOrdering == AtomicOrdering::AcquireRelease)
-    return tokError(
+    return tokError( 
         "cmpxchg failure ordering cannot include release semantics");
   if (!Ptr->getType()->isPointerTy())
-    return error(PtrLoc, "cmpxchg operand must be a pointer");
+    return error(PtrLoc, "cmpxchg operand must be a pointer"); 
   if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
-    return error(CmpLoc, "compare value and pointer type do not match");
+    return error(CmpLoc, "compare value and pointer type do not match"); 
   if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType())
-    return error(NewLoc, "new value and pointer type do not match");
+    return error(NewLoc, "new value and pointer type do not match"); 
   if (!New->getType()->isFirstClassType())
-    return error(NewLoc, "cmpxchg operand must be a first class value");
+    return error(NewLoc, "cmpxchg operand must be a first class value"); 
 
   Align Alignment(
       PFS.getFunction().getParent()->getDataLayout().getTypeStoreSize(
@@ -7488,10 +7488,10 @@ int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseAtomicRMW
+/// parseAtomicRMW 
 ///   ::= 'atomicrmw' 'volatile'? BinOp TypeAndValue ',' TypeAndValue
 ///       'singlethread'? AtomicOrdering
-int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Ptr, *Val; LocTy PtrLoc, ValLoc;
   bool AteExtraComma = false;
   AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
@@ -7504,8 +7504,8 @@ int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
     isVolatile = true;
 
   switch (Lex.getKind()) {
-  default:
-    return tokError("expected binary operation in atomicrmw");
+  default: 
+    return tokError("expected binary operation in atomicrmw"); 
   case lltok::kw_xchg: Operation = AtomicRMWInst::Xchg; break;
   case lltok::kw_add: Operation = AtomicRMWInst::Add; break;
   case lltok::kw_sub: Operation = AtomicRMWInst::Sub; break;
@@ -7528,43 +7528,43 @@ int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
   }
   Lex.Lex();  // Eat the operation.
 
-  if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
-      parseToken(lltok::comma, "expected ',' after atomicrmw address") ||
-      parseTypeAndValue(Val, ValLoc, PFS) ||
-      parseScopeAndOrdering(true /*Always atomic*/, SSID, Ordering))
+  if (parseTypeAndValue(Ptr, PtrLoc, PFS) || 
+      parseToken(lltok::comma, "expected ',' after atomicrmw address") || 
+      parseTypeAndValue(Val, ValLoc, PFS) || 
+      parseScopeAndOrdering(true /*Always atomic*/, SSID, Ordering)) 
     return true;
 
   if (Ordering == AtomicOrdering::Unordered)
-    return tokError("atomicrmw cannot be unordered");
+    return tokError("atomicrmw cannot be unordered"); 
   if (!Ptr->getType()->isPointerTy())
-    return error(PtrLoc, "atomicrmw operand must be a pointer");
+    return error(PtrLoc, "atomicrmw operand must be a pointer"); 
   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
-    return error(ValLoc, "atomicrmw value and pointer type do not match");
+    return error(ValLoc, "atomicrmw value and pointer type do not match"); 
 
   if (Operation == AtomicRMWInst::Xchg) {
     if (!Val->getType()->isIntegerTy() &&
         !Val->getType()->isFloatingPointTy()) {
-      return error(ValLoc,
-                   "atomicrmw " + AtomicRMWInst::getOperationName(Operation) +
-                       " operand must be an integer or floating point type");
+      return error(ValLoc, 
+                   "atomicrmw " + AtomicRMWInst::getOperationName(Operation) + 
+                       " operand must be an integer or floating point type"); 
     }
   } else if (IsFP) {
     if (!Val->getType()->isFloatingPointTy()) {
-      return error(ValLoc, "atomicrmw " +
-                               AtomicRMWInst::getOperationName(Operation) +
-                               " operand must be a floating point type");
+      return error(ValLoc, "atomicrmw " + 
+                               AtomicRMWInst::getOperationName(Operation) + 
+                               " operand must be a floating point type"); 
     }
   } else {
     if (!Val->getType()->isIntegerTy()) {
-      return error(ValLoc, "atomicrmw " +
-                               AtomicRMWInst::getOperationName(Operation) +
-                               " operand must be an integer");
+      return error(ValLoc, "atomicrmw " + 
+                               AtomicRMWInst::getOperationName(Operation) + 
+                               " operand must be an integer"); 
     }
   }
 
   unsigned Size = Val->getType()->getPrimitiveSizeInBits();
   if (Size < 8 || (Size & (Size - 1)))
-    return error(ValLoc, "atomicrmw operand must be power-of-two byte-sized"
+    return error(ValLoc, "atomicrmw operand must be power-of-two byte-sized" 
                          " integer");
   Align Alignment(
       PFS.getFunction().getParent()->getDataLayout().getTypeStoreSize(
@@ -7576,26 +7576,26 @@ int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseFence
+/// parseFence 
 ///   ::= 'fence' 'singlethread'? AtomicOrdering
-int LLParser::parseFence(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseFence(Instruction *&Inst, PerFunctionState &PFS) { 
   AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
   SyncScope::ID SSID = SyncScope::System;
-  if (parseScopeAndOrdering(true /*Always atomic*/, SSID, Ordering))
+  if (parseScopeAndOrdering(true /*Always atomic*/, SSID, Ordering)) 
     return true;
 
   if (Ordering == AtomicOrdering::Unordered)
-    return tokError("fence cannot be unordered");
+    return tokError("fence cannot be unordered"); 
   if (Ordering == AtomicOrdering::Monotonic)
-    return tokError("fence cannot be monotonic");
+    return tokError("fence cannot be monotonic"); 
 
   Inst = new FenceInst(Context, Ordering, SSID);
   return InstNormal;
 }
 
-/// parseGetElementPtr
+/// parseGetElementPtr 
 ///   ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
-int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Ptr = nullptr;
   Value *Val = nullptr;
   LocTy Loc, EltLoc;
@@ -7604,18 +7604,18 @@ int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
 
   Type *Ty = nullptr;
   LocTy ExplicitTypeLoc = Lex.getLoc();
-  if (parseType(Ty) ||
-      parseToken(lltok::comma, "expected comma after getelementptr's type") ||
-      parseTypeAndValue(Ptr, Loc, PFS))
+  if (parseType(Ty) || 
+      parseToken(lltok::comma, "expected comma after getelementptr's type") || 
+      parseTypeAndValue(Ptr, Loc, PFS)) 
     return true;
 
   Type *BaseType = Ptr->getType();
   PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());
   if (!BasePointerType)
-    return error(Loc, "base of getelementptr must be a pointer");
+    return error(Loc, "base of getelementptr must be a pointer"); 
 
   if (Ty != BasePointerType->getElementType())
-    return error(ExplicitTypeLoc,
+    return error(ExplicitTypeLoc, 
                  "explicit pointee type doesn't match operand's pointee type");
 
   SmallVector<Value*, 16> Indices;
@@ -7624,24 +7624,24 @@ int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
   // All vector parameters should have the same vector width.
   ElementCount GEPWidth = BaseType->isVectorTy()
                               ? cast<VectorType>(BaseType)->getElementCount()
-                              : ElementCount::getFixed(0);
+                              : ElementCount::getFixed(0); 
 
   while (EatIfPresent(lltok::comma)) {
     if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
       break;
     }
-    if (parseTypeAndValue(Val, EltLoc, PFS))
-      return true;
+    if (parseTypeAndValue(Val, EltLoc, PFS)) 
+      return true; 
     if (!Val->getType()->isIntOrIntVectorTy())
-      return error(EltLoc, "getelementptr index must be an integer");
+      return error(EltLoc, "getelementptr index must be an integer"); 
 
     if (auto *ValVTy = dyn_cast<VectorType>(Val->getType())) {
       ElementCount ValNumEl = ValVTy->getElementCount();
-      if (GEPWidth != ElementCount::getFixed(0) && GEPWidth != ValNumEl)
-        return error(
-            EltLoc,
-            "getelementptr vector index has a wrong number of elements");
+      if (GEPWidth != ElementCount::getFixed(0) && GEPWidth != ValNumEl) 
+        return error( 
+            EltLoc, 
+            "getelementptr vector index has a wrong number of elements"); 
       GEPWidth = ValNumEl;
     }
     Indices.push_back(Val);
@@ -7649,55 +7649,55 @@ int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
 
   SmallPtrSet<Type*, 4> Visited;
   if (!Indices.empty() && !Ty->isSized(&Visited))
-    return error(Loc, "base element of getelementptr must be sized");
+    return error(Loc, "base element of getelementptr must be sized"); 
 
   if (!GetElementPtrInst::getIndexedType(Ty, Indices))
-    return error(Loc, "invalid getelementptr indices");
+    return error(Loc, "invalid getelementptr indices"); 
   Inst = GetElementPtrInst::Create(Ty, Ptr, Indices);
   if (InBounds)
     cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseExtractValue
+/// parseExtractValue 
 ///   ::= 'extractvalue' TypeAndValue (',' uint32)+
-int LLParser::parseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Val; LocTy Loc;
   SmallVector<unsigned, 4> Indices;
   bool AteExtraComma;
-  if (parseTypeAndValue(Val, Loc, PFS) ||
-      parseIndexList(Indices, AteExtraComma))
+  if (parseTypeAndValue(Val, Loc, PFS) || 
+      parseIndexList(Indices, AteExtraComma)) 
     return true;
 
   if (!Val->getType()->isAggregateType())
-    return error(Loc, "extractvalue operand must be aggregate type");
+    return error(Loc, "extractvalue operand must be aggregate type"); 
 
   if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
-    return error(Loc, "invalid indices for extractvalue");
+    return error(Loc, "invalid indices for extractvalue"); 
   Inst = ExtractValueInst::Create(Val, Indices);
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
-/// parseInsertValue
+/// parseInsertValue 
 ///   ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
-int LLParser::parseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
+int LLParser::parseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { 
   Value *Val0, *Val1; LocTy Loc0, Loc1;
   SmallVector<unsigned, 4> Indices;
   bool AteExtraComma;
-  if (parseTypeAndValue(Val0, Loc0, PFS) ||
-      parseToken(lltok::comma, "expected comma after insertvalue operand") ||
-      parseTypeAndValue(Val1, Loc1, PFS) ||
-      parseIndexList(Indices, AteExtraComma))
+  if (parseTypeAndValue(Val0, Loc0, PFS) || 
+      parseToken(lltok::comma, "expected comma after insertvalue operand") || 
+      parseTypeAndValue(Val1, Loc1, PFS) || 
+      parseIndexList(Indices, AteExtraComma)) 
     return true;
 
   if (!Val0->getType()->isAggregateType())
-    return error(Loc0, "insertvalue operand must be aggregate type");
+    return error(Loc0, "insertvalue operand must be aggregate type"); 
 
   Type *IndexedType = ExtractValueInst::getIndexedType(Val0->getType(), Indices);
   if (!IndexedType)
-    return error(Loc0, "invalid indices for insertvalue");
+    return error(Loc0, "invalid indices for insertvalue"); 
   if (IndexedType != Val1->getType())
-    return error(Loc1, "insertvalue operand and field disagree in type: '" +
+    return error(Loc1, "insertvalue operand and field disagree in type: '" + 
                            getTypeString(Val1->getType()) + "' instead of '" +
                            getTypeString(IndexedType) + "'");
   Inst = InsertValueInst::Create(Val0, Val1, Indices);
@@ -7708,12 +7708,12 @@ int LLParser::parseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
 // Embedded metadata.
 //===----------------------------------------------------------------------===//
 
-/// parseMDNodeVector
+/// parseMDNodeVector 
 ///   ::= { Element (',' Element)* }
 /// Element
 ///   ::= 'null' | TypeAndValue
-bool LLParser::parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) {
-  if (parseToken(lltok::lbrace, "expected '{' here"))
+bool LLParser::parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) { 
+  if (parseToken(lltok::lbrace, "expected '{' here")) 
     return true;
 
   // Check for an empty list.
@@ -7728,12 +7728,12 @@ bool LLParser::parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) {
     }
 
     Metadata *MD;
-    if (parseMetadata(MD, nullptr))
+    if (parseMetadata(MD, nullptr)) 
       return true;
     Elts.push_back(MD);
   } while (EatIfPresent(lltok::comma));
 
-  return parseToken(lltok::rbrace, "expected end of metadata node");
+  return parseToken(lltok::rbrace, "expected end of metadata node"); 
 }
 
 //===----------------------------------------------------------------------===//
@@ -7742,7 +7742,7 @@ bool LLParser::parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) {
 bool LLParser::sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes,
                                 SMLoc Loc) {
   if (V->use_empty())
-    return error(Loc, "value has no uses");
+    return error(Loc, "value has no uses"); 
 
   unsigned NumUses = 0;
   SmallDenseMap<const Use *, unsigned, 16> Order;
@@ -7752,9 +7752,9 @@ bool LLParser::sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes,
     Order[&U] = Indexes[NumUses - 1];
   }
   if (NumUses < 2)
-    return error(Loc, "value only has one use");
+    return error(Loc, "value only has one use"); 
   if (Order.size() != Indexes.size() || NumUses > Indexes.size())
-    return error(Loc,
+    return error(Loc, 
                  "wrong number of indexes, expected " + Twine(V->getNumUses()));
 
   V->sortUseList([&](const Use &L, const Use &R) {
@@ -7763,11 +7763,11 @@ bool LLParser::sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes,
   return false;
 }
 
-/// parseUseListOrderIndexes
+/// parseUseListOrderIndexes 
 ///   ::= '{' uint32 (',' uint32)+ '}'
-bool LLParser::parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes) {
+bool LLParser::parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes) { 
   SMLoc Loc = Lex.getLoc();
-  if (parseToken(lltok::lbrace, "expected '{' here"))
+  if (parseToken(lltok::lbrace, "expected '{' here")) 
     return true;
   if (Lex.getKind() == lltok::rbrace)
     return Lex.Error("expected non-empty list of uselistorder indexes");
@@ -7781,7 +7781,7 @@ bool LLParser::parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes) {
   assert(Indexes.empty() && "Expected empty order vector");
   do {
     unsigned Index;
-    if (parseUInt32(Index))
+    if (parseUInt32(Index)) 
       return true;
 
     // Update consistency checks.
@@ -7792,51 +7792,51 @@ bool LLParser::parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes) {
     Indexes.push_back(Index);
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rbrace, "expected '}' here"))
+  if (parseToken(lltok::rbrace, "expected '}' here")) 
     return true;
 
   if (Indexes.size() < 2)
-    return error(Loc, "expected >= 2 uselistorder indexes");
+    return error(Loc, "expected >= 2 uselistorder indexes"); 
   if (Offset != 0 || Max >= Indexes.size())
-    return error(Loc,
-                 "expected distinct uselistorder indexes in range [0, size)");
+    return error(Loc, 
+                 "expected distinct uselistorder indexes in range [0, size)"); 
   if (IsOrdered)
-    return error(Loc, "expected uselistorder indexes to change the order");
+    return error(Loc, "expected uselistorder indexes to change the order"); 
 
   return false;
 }
 
-/// parseUseListOrder
+/// parseUseListOrder 
 ///   ::= 'uselistorder' Type Value ',' UseListOrderIndexes
-bool LLParser::parseUseListOrder(PerFunctionState *PFS) {
+bool LLParser::parseUseListOrder(PerFunctionState *PFS) { 
   SMLoc Loc = Lex.getLoc();
-  if (parseToken(lltok::kw_uselistorder, "expected uselistorder directive"))
+  if (parseToken(lltok::kw_uselistorder, "expected uselistorder directive")) 
     return true;
 
   Value *V;
   SmallVector<unsigned, 16> Indexes;
-  if (parseTypeAndValue(V, PFS) ||
-      parseToken(lltok::comma, "expected comma in uselistorder directive") ||
-      parseUseListOrderIndexes(Indexes))
+  if (parseTypeAndValue(V, PFS) || 
+      parseToken(lltok::comma, "expected comma in uselistorder directive") || 
+      parseUseListOrderIndexes(Indexes)) 
     return true;
 
   return sortUseListOrder(V, Indexes, Loc);
 }
 
-/// parseUseListOrderBB
+/// parseUseListOrderBB 
 ///   ::= 'uselistorder_bb' @foo ',' %bar ',' UseListOrderIndexes
-bool LLParser::parseUseListOrderBB() {
+bool LLParser::parseUseListOrderBB() { 
   assert(Lex.getKind() == lltok::kw_uselistorder_bb);
   SMLoc Loc = Lex.getLoc();
   Lex.Lex();
 
   ValID Fn, Label;
   SmallVector<unsigned, 16> Indexes;
-  if (parseValID(Fn) ||
-      parseToken(lltok::comma, "expected comma in uselistorder_bb directive") ||
-      parseValID(Label) ||
-      parseToken(lltok::comma, "expected comma in uselistorder_bb directive") ||
-      parseUseListOrderIndexes(Indexes))
+  if (parseValID(Fn) || 
+      parseToken(lltok::comma, "expected comma in uselistorder_bb directive") || 
+      parseValID(Label) || 
+      parseToken(lltok::comma, "expected comma in uselistorder_bb directive") || 
+      parseUseListOrderIndexes(Indexes)) 
     return true;
 
   // Check the function.
@@ -7846,26 +7846,26 @@ bool LLParser::parseUseListOrderBB() {
   else if (Fn.Kind == ValID::t_GlobalID)
     GV = Fn.UIntVal < NumberedVals.size() ? NumberedVals[Fn.UIntVal] : nullptr;
   else
-    return error(Fn.Loc, "expected function name in uselistorder_bb");
+    return error(Fn.Loc, "expected function name in uselistorder_bb"); 
   if (!GV)
-    return error(Fn.Loc,
-                 "invalid function forward reference in uselistorder_bb");
+    return error(Fn.Loc, 
+                 "invalid function forward reference in uselistorder_bb"); 
   auto *F = dyn_cast<Function>(GV);
   if (!F)
-    return error(Fn.Loc, "expected function name in uselistorder_bb");
+    return error(Fn.Loc, "expected function name in uselistorder_bb"); 
   if (F->isDeclaration())
-    return error(Fn.Loc, "invalid declaration in uselistorder_bb");
+    return error(Fn.Loc, "invalid declaration in uselistorder_bb"); 
 
   // Check the basic block.
   if (Label.Kind == ValID::t_LocalID)
-    return error(Label.Loc, "invalid numeric label in uselistorder_bb");
+    return error(Label.Loc, "invalid numeric label in uselistorder_bb"); 
   if (Label.Kind != ValID::t_LocalName)
-    return error(Label.Loc, "expected basic block name in uselistorder_bb");
+    return error(Label.Loc, "expected basic block name in uselistorder_bb"); 
   Value *V = F->getValueSymbolTable()->lookup(Label.StrVal);
   if (!V)
-    return error(Label.Loc, "invalid basic block in uselistorder_bb");
+    return error(Label.Loc, "invalid basic block in uselistorder_bb"); 
   if (!isa<BasicBlock>(V))
-    return error(Label.Loc, "expected basic block in uselistorder_bb");
+    return error(Label.Loc, "expected basic block in uselistorder_bb"); 
 
   return sortUseListOrder(V, Indexes, Loc);
 }
@@ -7873,32 +7873,32 @@ bool LLParser::parseUseListOrderBB() {
 /// ModuleEntry
 ///   ::= 'module' ':' '(' 'path' ':' STRINGCONSTANT ',' 'hash' ':' Hash ')'
 /// Hash ::= '(' UInt32 ',' UInt32 ',' UInt32 ',' UInt32 ',' UInt32 ')'
-bool LLParser::parseModuleEntry(unsigned ID) {
+bool LLParser::parseModuleEntry(unsigned ID) { 
   assert(Lex.getKind() == lltok::kw_module);
   Lex.Lex();
 
   std::string Path;
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseToken(lltok::kw_path, "expected 'path' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseStringConstant(Path) ||
-      parseToken(lltok::comma, "expected ',' here") ||
-      parseToken(lltok::kw_hash, "expected 'hash' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseToken(lltok::kw_path, "expected 'path' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseStringConstant(Path) || 
+      parseToken(lltok::comma, "expected ',' here") || 
+      parseToken(lltok::kw_hash, "expected 'hash' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   ModuleHash Hash;
-  if (parseUInt32(Hash[0]) || parseToken(lltok::comma, "expected ',' here") ||
-      parseUInt32(Hash[1]) || parseToken(lltok::comma, "expected ',' here") ||
-      parseUInt32(Hash[2]) || parseToken(lltok::comma, "expected ',' here") ||
-      parseUInt32(Hash[3]) || parseToken(lltok::comma, "expected ',' here") ||
-      parseUInt32(Hash[4]))
+  if (parseUInt32(Hash[0]) || parseToken(lltok::comma, "expected ',' here") || 
+      parseUInt32(Hash[1]) || parseToken(lltok::comma, "expected ',' here") || 
+      parseUInt32(Hash[2]) || parseToken(lltok::comma, "expected ',' here") || 
+      parseUInt32(Hash[3]) || parseToken(lltok::comma, "expected ',' here") || 
+      parseUInt32(Hash[4])) 
     return true;
 
-  if (parseToken(lltok::rparen, "expected ')' here") ||
-      parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here") || 
+      parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   auto ModuleEntry = Index->addModule(Path, ID, Hash);
@@ -7909,21 +7909,21 @@ bool LLParser::parseModuleEntry(unsigned ID) {
 
 /// TypeIdEntry
 ///   ::= 'typeid' ':' '(' 'name' ':' STRINGCONSTANT ',' TypeIdSummary ')'
-bool LLParser::parseTypeIdEntry(unsigned ID) {
+bool LLParser::parseTypeIdEntry(unsigned ID) { 
   assert(Lex.getKind() == lltok::kw_typeid);
   Lex.Lex();
 
   std::string Name;
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseToken(lltok::kw_name, "expected 'name' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseStringConstant(Name))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseToken(lltok::kw_name, "expected 'name' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseStringConstant(Name)) 
     return true;
 
   TypeIdSummary &TIS = Index->getOrInsertTypeIdSummary(Name);
-  if (parseToken(lltok::comma, "expected ',' here") ||
-      parseTypeIdSummary(TIS) || parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::comma, "expected ',' here") || 
+      parseTypeIdSummary(TIS) || parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   // Check if this ID was forward referenced, and if so, update the
@@ -7943,20 +7943,20 @@ bool LLParser::parseTypeIdEntry(unsigned ID) {
 
 /// TypeIdSummary
 ///   ::= 'summary' ':' '(' TypeTestResolution [',' OptionalWpdResolutions]? ')'
-bool LLParser::parseTypeIdSummary(TypeIdSummary &TIS) {
-  if (parseToken(lltok::kw_summary, "expected 'summary' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseTypeTestResolution(TIS.TTRes))
+bool LLParser::parseTypeIdSummary(TypeIdSummary &TIS) { 
+  if (parseToken(lltok::kw_summary, "expected 'summary' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseTypeTestResolution(TIS.TTRes)) 
     return true;
 
   if (EatIfPresent(lltok::comma)) {
     // Expect optional wpdResolutions field
-    if (parseOptionalWpdResolutions(TIS.WPDRes))
+    if (parseOptionalWpdResolutions(TIS.WPDRes)) 
       return true;
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -7969,40 +7969,40 @@ static ValueInfo EmptyVI =
 ///   ::= 'typeidCompatibleVTable' ':' '(' 'name' ':' STRINGCONSTANT ','
 ///   TypeIdCompatibleVtableInfo
 ///   ')'
-bool LLParser::parseTypeIdCompatibleVtableEntry(unsigned ID) {
+bool LLParser::parseTypeIdCompatibleVtableEntry(unsigned ID) { 
   assert(Lex.getKind() == lltok::kw_typeidCompatibleVTable);
   Lex.Lex();
 
   std::string Name;
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseToken(lltok::kw_name, "expected 'name' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseStringConstant(Name))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseToken(lltok::kw_name, "expected 'name' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseStringConstant(Name)) 
     return true;
 
   TypeIdCompatibleVtableInfo &TI =
       Index->getOrInsertTypeIdCompatibleVtableSummary(Name);
-  if (parseToken(lltok::comma, "expected ',' here") ||
-      parseToken(lltok::kw_summary, "expected 'summary' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::comma, "expected ',' here") || 
+      parseToken(lltok::kw_summary, "expected 'summary' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   IdToIndexMapType IdToIndexMap;
-  // parse each call edge
+  // parse each call edge 
   do {
     uint64_t Offset;
-    if (parseToken(lltok::lparen, "expected '(' here") ||
-        parseToken(lltok::kw_offset, "expected 'offset' here") ||
-        parseToken(lltok::colon, "expected ':' here") || parseUInt64(Offset) ||
-        parseToken(lltok::comma, "expected ',' here"))
+    if (parseToken(lltok::lparen, "expected '(' here") || 
+        parseToken(lltok::kw_offset, "expected 'offset' here") || 
+        parseToken(lltok::colon, "expected ':' here") || parseUInt64(Offset) || 
+        parseToken(lltok::comma, "expected ',' here")) 
       return true;
 
     LocTy Loc = Lex.getLoc();
     unsigned GVId;
     ValueInfo VI;
-    if (parseGVReference(VI, GVId))
+    if (parseGVReference(VI, GVId)) 
       return true;
 
     // Keep track of the TypeIdCompatibleVtableInfo array index needing a
@@ -8012,23 +8012,23 @@ bool LLParser::parseTypeIdCompatibleVtableEntry(unsigned ID) {
       IdToIndexMap[GVId].push_back(std::make_pair(TI.size(), Loc));
     TI.push_back({Offset, VI});
 
-    if (parseToken(lltok::rparen, "expected ')' in call"))
+    if (parseToken(lltok::rparen, "expected ')' in call")) 
       return true;
   } while (EatIfPresent(lltok::comma));
 
   // Now that the TI vector is finalized, it is safe to save the locations
   // of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Infos = ForwardRefValueInfos[I.first];
+    auto &Infos = ForwardRefValueInfos[I.first]; 
     for (auto P : I.second) {
       assert(TI[P.first].VTableVI == EmptyVI &&
              "Forward referenced ValueInfo expected to be empty");
-      Infos.emplace_back(&TI[P.first].VTableVI, P.second);
+      Infos.emplace_back(&TI[P.first].VTableVI, P.second); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here") ||
-      parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here") || 
+      parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   // Check if this ID was forward referenced, and if so, update the
@@ -8052,12 +8052,12 @@ bool LLParser::parseTypeIdCompatibleVtableEntry(unsigned ID) {
 ///         'sizeM1BitWidth' ':' SizeM1BitWidth [',' 'alignLog2' ':' UInt64]?
 ///         [',' 'sizeM1' ':' UInt64]? [',' 'bitMask' ':' UInt8]?
 ///         [',' 'inlinesBits' ':' UInt64]? ')'
-bool LLParser::parseTypeTestResolution(TypeTestResolution &TTRes) {
-  if (parseToken(lltok::kw_typeTestRes, "expected 'typeTestRes' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseToken(lltok::kw_kind, "expected 'kind' here") ||
-      parseToken(lltok::colon, "expected ':' here"))
+bool LLParser::parseTypeTestResolution(TypeTestResolution &TTRes) { 
+  if (parseToken(lltok::kw_typeTestRes, "expected 'typeTestRes' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseToken(lltok::kw_kind, "expected 'kind' here") || 
+      parseToken(lltok::colon, "expected ':' here")) 
     return true;
 
   switch (Lex.getKind()) {
@@ -8080,34 +8080,34 @@ bool LLParser::parseTypeTestResolution(TypeTestResolution &TTRes) {
     TTRes.TheKind = TypeTestResolution::AllOnes;
     break;
   default:
-    return error(Lex.getLoc(), "unexpected TypeTestResolution kind");
+    return error(Lex.getLoc(), "unexpected TypeTestResolution kind"); 
   }
   Lex.Lex();
 
-  if (parseToken(lltok::comma, "expected ',' here") ||
-      parseToken(lltok::kw_sizeM1BitWidth, "expected 'sizeM1BitWidth' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseUInt32(TTRes.SizeM1BitWidth))
+  if (parseToken(lltok::comma, "expected ',' here") || 
+      parseToken(lltok::kw_sizeM1BitWidth, "expected 'sizeM1BitWidth' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseUInt32(TTRes.SizeM1BitWidth)) 
     return true;
 
-  // parse optional fields
+  // parse optional fields 
   while (EatIfPresent(lltok::comma)) {
     switch (Lex.getKind()) {
     case lltok::kw_alignLog2:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") ||
-          parseUInt64(TTRes.AlignLog2))
+      if (parseToken(lltok::colon, "expected ':'") || 
+          parseUInt64(TTRes.AlignLog2)) 
         return true;
       break;
     case lltok::kw_sizeM1:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseUInt64(TTRes.SizeM1))
+      if (parseToken(lltok::colon, "expected ':'") || parseUInt64(TTRes.SizeM1)) 
         return true;
       break;
     case lltok::kw_bitMask: {
       unsigned Val;
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseUInt32(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseUInt32(Val)) 
         return true;
       assert(Val <= 0xff);
       TTRes.BitMask = (uint8_t)Val;
@@ -8115,16 +8115,16 @@ bool LLParser::parseTypeTestResolution(TypeTestResolution &TTRes) {
     }
     case lltok::kw_inlineBits:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") ||
-          parseUInt64(TTRes.InlineBits))
+      if (parseToken(lltok::colon, "expected ':'") || 
+          parseUInt64(TTRes.InlineBits)) 
         return true;
       break;
     default:
-      return error(Lex.getLoc(), "expected optional TypeTestResolution field");
+      return error(Lex.getLoc(), "expected optional TypeTestResolution field"); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8133,26 +8133,26 @@ bool LLParser::parseTypeTestResolution(TypeTestResolution &TTRes) {
 /// OptionalWpdResolutions
 ///   ::= 'wpsResolutions' ':' '(' WpdResolution [',' WpdResolution]* ')'
 /// WpdResolution ::= '(' 'offset' ':' UInt64 ',' WpdRes ')'
-bool LLParser::parseOptionalWpdResolutions(
+bool LLParser::parseOptionalWpdResolutions( 
     std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap) {
-  if (parseToken(lltok::kw_wpdResolutions, "expected 'wpdResolutions' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::kw_wpdResolutions, "expected 'wpdResolutions' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   do {
     uint64_t Offset;
     WholeProgramDevirtResolution WPDRes;
-    if (parseToken(lltok::lparen, "expected '(' here") ||
-        parseToken(lltok::kw_offset, "expected 'offset' here") ||
-        parseToken(lltok::colon, "expected ':' here") || parseUInt64(Offset) ||
-        parseToken(lltok::comma, "expected ',' here") || parseWpdRes(WPDRes) ||
-        parseToken(lltok::rparen, "expected ')' here"))
+    if (parseToken(lltok::lparen, "expected '(' here") || 
+        parseToken(lltok::kw_offset, "expected 'offset' here") || 
+        parseToken(lltok::colon, "expected ':' here") || parseUInt64(Offset) || 
+        parseToken(lltok::comma, "expected ',' here") || parseWpdRes(WPDRes) || 
+        parseToken(lltok::rparen, "expected ')' here")) 
       return true;
     WPDResMap[Offset] = WPDRes;
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8166,12 +8166,12 @@ bool LLParser::parseOptionalWpdResolutions(
 ///         [',' OptionalResByArg]? ')'
 ///   ::= 'wpdRes' ':' '(' 'kind' ':' 'branchFunnel'
 ///         [',' OptionalResByArg]? ')'
-bool LLParser::parseWpdRes(WholeProgramDevirtResolution &WPDRes) {
-  if (parseToken(lltok::kw_wpdRes, "expected 'wpdRes' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseToken(lltok::kw_kind, "expected 'kind' here") ||
-      parseToken(lltok::colon, "expected ':' here"))
+bool LLParser::parseWpdRes(WholeProgramDevirtResolution &WPDRes) { 
+  if (parseToken(lltok::kw_wpdRes, "expected 'wpdRes' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseToken(lltok::kw_kind, "expected 'kind' here") || 
+      parseToken(lltok::colon, "expected ':' here")) 
     return true;
 
   switch (Lex.getKind()) {
@@ -8185,30 +8185,30 @@ bool LLParser::parseWpdRes(WholeProgramDevirtResolution &WPDRes) {
     WPDRes.TheKind = WholeProgramDevirtResolution::BranchFunnel;
     break;
   default:
-    return error(Lex.getLoc(), "unexpected WholeProgramDevirtResolution kind");
+    return error(Lex.getLoc(), "unexpected WholeProgramDevirtResolution kind"); 
   }
   Lex.Lex();
 
-  // parse optional fields
+  // parse optional fields 
   while (EatIfPresent(lltok::comma)) {
     switch (Lex.getKind()) {
     case lltok::kw_singleImplName:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':' here") ||
-          parseStringConstant(WPDRes.SingleImplName))
+      if (parseToken(lltok::colon, "expected ':' here") || 
+          parseStringConstant(WPDRes.SingleImplName)) 
         return true;
       break;
     case lltok::kw_resByArg:
-      if (parseOptionalResByArg(WPDRes.ResByArg))
+      if (parseOptionalResByArg(WPDRes.ResByArg)) 
         return true;
       break;
     default:
-      return error(Lex.getLoc(),
+      return error(Lex.getLoc(), 
                    "expected optional WholeProgramDevirtResolution field");
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8221,22 +8221,22 @@ bool LLParser::parseWpdRes(WholeProgramDevirtResolution &WPDRes) {
 ///                  'virtualConstProp' )
 ///                [',' 'info' ':' UInt64]? [',' 'byte' ':' UInt32]?
 ///                [',' 'bit' ':' UInt32]? ')'
-bool LLParser::parseOptionalResByArg(
+bool LLParser::parseOptionalResByArg( 
     std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
         &ResByArg) {
-  if (parseToken(lltok::kw_resByArg, "expected 'resByArg' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::kw_resByArg, "expected 'resByArg' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   do {
     std::vector<uint64_t> Args;
-    if (parseArgs(Args) || parseToken(lltok::comma, "expected ',' here") ||
-        parseToken(lltok::kw_byArg, "expected 'byArg here") ||
-        parseToken(lltok::colon, "expected ':' here") ||
-        parseToken(lltok::lparen, "expected '(' here") ||
-        parseToken(lltok::kw_kind, "expected 'kind' here") ||
-        parseToken(lltok::colon, "expected ':' here"))
+    if (parseArgs(Args) || parseToken(lltok::comma, "expected ',' here") || 
+        parseToken(lltok::kw_byArg, "expected 'byArg here") || 
+        parseToken(lltok::colon, "expected ':' here") || 
+        parseToken(lltok::lparen, "expected '(' here") || 
+        parseToken(lltok::kw_kind, "expected 'kind' here") || 
+        parseToken(lltok::colon, "expected ':' here")) 
       return true;
 
     WholeProgramDevirtResolution::ByArg ByArg;
@@ -8254,45 +8254,45 @@ bool LLParser::parseOptionalResByArg(
       ByArg.TheKind = WholeProgramDevirtResolution::ByArg::VirtualConstProp;
       break;
     default:
-      return error(Lex.getLoc(),
+      return error(Lex.getLoc(), 
                    "unexpected WholeProgramDevirtResolution::ByArg kind");
     }
     Lex.Lex();
 
-    // parse optional fields
+    // parse optional fields 
     while (EatIfPresent(lltok::comma)) {
       switch (Lex.getKind()) {
       case lltok::kw_info:
         Lex.Lex();
-        if (parseToken(lltok::colon, "expected ':' here") ||
-            parseUInt64(ByArg.Info))
+        if (parseToken(lltok::colon, "expected ':' here") || 
+            parseUInt64(ByArg.Info)) 
           return true;
         break;
       case lltok::kw_byte:
         Lex.Lex();
-        if (parseToken(lltok::colon, "expected ':' here") ||
-            parseUInt32(ByArg.Byte))
+        if (parseToken(lltok::colon, "expected ':' here") || 
+            parseUInt32(ByArg.Byte)) 
           return true;
         break;
       case lltok::kw_bit:
         Lex.Lex();
-        if (parseToken(lltok::colon, "expected ':' here") ||
-            parseUInt32(ByArg.Bit))
+        if (parseToken(lltok::colon, "expected ':' here") || 
+            parseUInt32(ByArg.Bit)) 
           return true;
         break;
       default:
-        return error(Lex.getLoc(),
+        return error(Lex.getLoc(), 
                      "expected optional whole program devirt field");
       }
     }
 
-    if (parseToken(lltok::rparen, "expected ')' here"))
+    if (parseToken(lltok::rparen, "expected ')' here")) 
       return true;
 
     ResByArg[Args] = ByArg;
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8300,20 +8300,20 @@ bool LLParser::parseOptionalResByArg(
 
 /// OptionalResByArg
 ///   ::= 'args' ':' '(' UInt64[, UInt64]* ')'
-bool LLParser::parseArgs(std::vector<uint64_t> &Args) {
-  if (parseToken(lltok::kw_args, "expected 'args' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+bool LLParser::parseArgs(std::vector<uint64_t> &Args) { 
+  if (parseToken(lltok::kw_args, "expected 'args' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   do {
     uint64_t Val;
-    if (parseUInt64(Val))
+    if (parseUInt64(Val)) 
       return true;
     Args.push_back(Val);
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8334,7 +8334,7 @@ static void resolveFwdRef(ValueInfo *Fwd, ValueInfo &Resolved) {
 
 /// Stores the given Name/GUID and associated summary into the Index.
 /// Also updates any forward references to the associated entry ID.
-void LLParser::addGlobalValueToIndex(
+void LLParser::addGlobalValueToIndex( 
     std::string Name, GlobalValue::GUID GUID, GlobalValue::LinkageTypes Linkage,
     unsigned ID, std::unique_ptr<GlobalValueSummary> Summary) {
   // First create the ValueInfo utilizing the Name or GUID.
@@ -8396,48 +8396,48 @@ void LLParser::addGlobalValueToIndex(
   }
 }
 
-/// parseSummaryIndexFlags
+/// parseSummaryIndexFlags 
 ///   ::= 'flags' ':' UInt64
-bool LLParser::parseSummaryIndexFlags() {
+bool LLParser::parseSummaryIndexFlags() { 
   assert(Lex.getKind() == lltok::kw_flags);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here"))
+  if (parseToken(lltok::colon, "expected ':' here")) 
     return true;
   uint64_t Flags;
-  if (parseUInt64(Flags))
+  if (parseUInt64(Flags)) 
     return true;
-  if (Index)
-    Index->setFlags(Flags);
+  if (Index) 
+    Index->setFlags(Flags); 
   return false;
 }
 
-/// parseBlockCount
+/// parseBlockCount 
 ///   ::= 'blockcount' ':' UInt64
-bool LLParser::parseBlockCount() {
+bool LLParser::parseBlockCount() { 
   assert(Lex.getKind() == lltok::kw_blockcount);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here"))
+  if (parseToken(lltok::colon, "expected ':' here")) 
     return true;
   uint64_t BlockCount;
-  if (parseUInt64(BlockCount))
+  if (parseUInt64(BlockCount)) 
     return true;
-  if (Index)
-    Index->setBlockCount(BlockCount);
+  if (Index) 
+    Index->setBlockCount(BlockCount); 
   return false;
 }
 
-/// parseGVEntry
+/// parseGVEntry 
 ///   ::= 'gv' ':' '(' ('name' ':' STRINGCONSTANT | 'guid' ':' UInt64)
 ///         [',' 'summaries' ':' Summary[',' Summary]* ]? ')'
 /// Summary ::= '(' (FunctionSummary | VariableSummary | AliasSummary) ')'
-bool LLParser::parseGVEntry(unsigned ID) {
+bool LLParser::parseGVEntry(unsigned ID) { 
   assert(Lex.getKind() == lltok::kw_gv);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   std::string Name;
@@ -8445,23 +8445,23 @@ bool LLParser::parseGVEntry(unsigned ID) {
   switch (Lex.getKind()) {
   case lltok::kw_name:
     Lex.Lex();
-    if (parseToken(lltok::colon, "expected ':' here") ||
-        parseStringConstant(Name))
+    if (parseToken(lltok::colon, "expected ':' here") || 
+        parseStringConstant(Name)) 
       return true;
     // Can't create GUID/ValueInfo until we have the linkage.
     break;
   case lltok::kw_guid:
     Lex.Lex();
-    if (parseToken(lltok::colon, "expected ':' here") || parseUInt64(GUID))
+    if (parseToken(lltok::colon, "expected ':' here") || parseUInt64(GUID)) 
       return true;
     break;
   default:
-    return error(Lex.getLoc(), "expected name or guid tag");
+    return error(Lex.getLoc(), "expected name or guid tag"); 
   }
 
   if (!EatIfPresent(lltok::comma)) {
     // No summaries. Wrap up.
-    if (parseToken(lltok::rparen, "expected ')' here"))
+    if (parseToken(lltok::rparen, "expected ')' here")) 
       return true;
     // This was created for a call to an external or indirect target.
     // A GUID with no summary came from a VALUE_GUID record, dummy GUID
@@ -8469,37 +8469,37 @@ bool LLParser::parseGVEntry(unsigned ID) {
     // an external definition. We pass ExternalLinkage since that is only
     // used when the GUID must be computed from Name, and in that case
     // the symbol must have external linkage.
-    addGlobalValueToIndex(Name, GUID, GlobalValue::ExternalLinkage, ID,
+    addGlobalValueToIndex(Name, GUID, GlobalValue::ExternalLinkage, ID, 
                           nullptr);
     return false;
   }
 
   // Have a list of summaries
-  if (parseToken(lltok::kw_summaries, "expected 'summaries' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::kw_summaries, "expected 'summaries' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
   do {
     switch (Lex.getKind()) {
     case lltok::kw_function:
-      if (parseFunctionSummary(Name, GUID, ID))
+      if (parseFunctionSummary(Name, GUID, ID)) 
         return true;
       break;
     case lltok::kw_variable:
-      if (parseVariableSummary(Name, GUID, ID))
+      if (parseVariableSummary(Name, GUID, ID)) 
         return true;
       break;
     case lltok::kw_alias:
-      if (parseAliasSummary(Name, GUID, ID))
+      if (parseAliasSummary(Name, GUID, ID)) 
         return true;
       break;
     default:
-      return error(Lex.getLoc(), "expected summary type");
+      return error(Lex.getLoc(), "expected summary type"); 
     }
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here") ||
-      parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here") || 
+      parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8510,7 +8510,7 @@ bool LLParser::parseGVEntry(unsigned ID) {
 ///         ',' 'insts' ':' UInt32 [',' OptionalFFlags]? [',' OptionalCalls]?
 ///         [',' OptionalTypeIdInfo]? [',' OptionalParamAccesses]?
 ///         [',' OptionalRefs]? ')'
-bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
+bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID, 
                                     unsigned ID) {
   assert(Lex.getKind() == lltok::kw_function);
   Lex.Lex();
@@ -8526,44 +8526,44 @@ bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
   std::vector<ValueInfo> Refs;
   // Default is all-zeros (conservative values).
   FunctionSummary::FFlags FFlags = {};
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseModuleReference(ModulePath) ||
-      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
-      parseToken(lltok::comma, "expected ',' here") ||
-      parseToken(lltok::kw_insts, "expected 'insts' here") ||
-      parseToken(lltok::colon, "expected ':' here") || parseUInt32(InstCount))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseModuleReference(ModulePath) || 
+      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) || 
+      parseToken(lltok::comma, "expected ',' here") || 
+      parseToken(lltok::kw_insts, "expected 'insts' here") || 
+      parseToken(lltok::colon, "expected ':' here") || parseUInt32(InstCount)) 
     return true;
 
-  // parse optional fields
+  // parse optional fields 
   while (EatIfPresent(lltok::comma)) {
     switch (Lex.getKind()) {
     case lltok::kw_funcFlags:
-      if (parseOptionalFFlags(FFlags))
+      if (parseOptionalFFlags(FFlags)) 
         return true;
       break;
     case lltok::kw_calls:
-      if (parseOptionalCalls(Calls))
+      if (parseOptionalCalls(Calls)) 
         return true;
       break;
     case lltok::kw_typeIdInfo:
-      if (parseOptionalTypeIdInfo(TypeIdInfo))
+      if (parseOptionalTypeIdInfo(TypeIdInfo)) 
         return true;
       break;
     case lltok::kw_refs:
-      if (parseOptionalRefs(Refs))
+      if (parseOptionalRefs(Refs)) 
         return true;
       break;
     case lltok::kw_params:
-      if (parseOptionalParamAccesses(ParamAccesses))
+      if (parseOptionalParamAccesses(ParamAccesses)) 
         return true;
       break;
     default:
-      return error(Lex.getLoc(), "expected optional function summary field");
+      return error(Lex.getLoc(), "expected optional function summary field"); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   auto FS = std::make_unique<FunctionSummary>(
@@ -8577,7 +8577,7 @@ bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
 
   FS->setModulePath(ModulePath);
 
-  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
+  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage, 
                         ID, std::move(FS));
 
   return false;
@@ -8586,7 +8586,7 @@ bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
 /// VariableSummary
 ///   ::= 'variable' ':' '(' 'module' ':' ModuleReference ',' GVFlags
 ///         [',' OptionalRefs]? ')'
-bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID,
+bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID, 
                                     unsigned ID) {
   assert(Lex.getKind() == lltok::kw_variable);
   Lex.Lex();
@@ -8601,31 +8601,31 @@ bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID,
                                         GlobalObject::VCallVisibilityPublic);
   std::vector<ValueInfo> Refs;
   VTableFuncList VTableFuncs;
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseModuleReference(ModulePath) ||
-      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
-      parseToken(lltok::comma, "expected ',' here") ||
-      parseGVarFlags(GVarFlags))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseModuleReference(ModulePath) || 
+      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) || 
+      parseToken(lltok::comma, "expected ',' here") || 
+      parseGVarFlags(GVarFlags)) 
     return true;
 
-  // parse optional fields
+  // parse optional fields 
   while (EatIfPresent(lltok::comma)) {
     switch (Lex.getKind()) {
     case lltok::kw_vTableFuncs:
-      if (parseOptionalVTableFuncs(VTableFuncs))
+      if (parseOptionalVTableFuncs(VTableFuncs)) 
         return true;
       break;
     case lltok::kw_refs:
-      if (parseOptionalRefs(Refs))
+      if (parseOptionalRefs(Refs)) 
         return true;
       break;
     default:
-      return error(Lex.getLoc(), "expected optional variable summary field");
+      return error(Lex.getLoc(), "expected optional variable summary field"); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   auto GS =
@@ -8634,7 +8634,7 @@ bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID,
   GS->setModulePath(ModulePath);
   GS->setVTableFuncs(std::move(VTableFuncs));
 
-  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
+  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage, 
                         ID, std::move(GS));
 
   return false;
@@ -8643,7 +8643,7 @@ bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID,
 /// AliasSummary
 ///   ::= 'alias' ':' '(' 'module' ':' ModuleReference ',' GVFlags ','
 ///         'aliasee' ':' GVReference ')'
-bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
+bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID, 
                                  unsigned ID) {
   assert(Lex.getKind() == lltok::kw_alias);
   LocTy Loc = Lex.getLoc();
@@ -8653,21 +8653,21 @@ bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
   GlobalValueSummary::GVFlags GVFlags = GlobalValueSummary::GVFlags(
       /*Linkage=*/GlobalValue::ExternalLinkage, /*NotEligibleToImport=*/false,
       /*Live=*/false, /*IsLocal=*/false, /*CanAutoHide=*/false);
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here") ||
-      parseModuleReference(ModulePath) ||
-      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
-      parseToken(lltok::comma, "expected ',' here") ||
-      parseToken(lltok::kw_aliasee, "expected 'aliasee' here") ||
-      parseToken(lltok::colon, "expected ':' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here") || 
+      parseModuleReference(ModulePath) || 
+      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) || 
+      parseToken(lltok::comma, "expected ',' here") || 
+      parseToken(lltok::kw_aliasee, "expected 'aliasee' here") || 
+      parseToken(lltok::colon, "expected ':' here")) 
     return true;
 
   ValueInfo AliaseeVI;
   unsigned GVId;
-  if (parseGVReference(AliaseeVI, GVId))
+  if (parseGVReference(AliaseeVI, GVId)) 
     return true;
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   auto AS = std::make_unique<AliasSummary>(GVFlags);
@@ -8676,14 +8676,14 @@ bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
 
   // Record forward reference if the aliasee is not parsed yet.
   if (AliaseeVI.getRef() == FwdVIRef) {
-    ForwardRefAliasees[GVId].emplace_back(AS.get(), Loc);
+    ForwardRefAliasees[GVId].emplace_back(AS.get(), Loc); 
   } else {
     auto Summary = Index->findSummaryInModule(AliaseeVI, ModulePath);
     assert(Summary && "Aliasee must be a definition");
     AS->setAliasee(AliaseeVI, Summary);
   }
 
-  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
+  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage, 
                         ID, std::move(AS));
 
   return false;
@@ -8691,9 +8691,9 @@ bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
 
 /// Flag
 ///   ::= [0|1]
-bool LLParser::parseFlag(unsigned &Val) {
+bool LLParser::parseFlag(unsigned &Val) { 
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
-    return tokError("expected integer");
+    return tokError("expected integer"); 
   Val = (unsigned)Lex.getAPSIntVal().getBoolValue();
   Lex.Lex();
   return false;
@@ -8706,12 +8706,12 @@ bool LLParser::parseFlag(unsigned &Val) {
 ///        [',' 'noInline' ':' Flag]? ')'
 ///        [',' 'alwaysInline' ':' Flag]? ')'
 
-bool LLParser::parseOptionalFFlags(FunctionSummary::FFlags &FFlags) {
+bool LLParser::parseOptionalFFlags(FunctionSummary::FFlags &FFlags) { 
   assert(Lex.getKind() == lltok::kw_funcFlags);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' in funcFlags") |
-      parseToken(lltok::lparen, "expected '(' in funcFlags"))
+  if (parseToken(lltok::colon, "expected ':' in funcFlags") | 
+      parseToken(lltok::lparen, "expected '(' in funcFlags")) 
     return true;
 
   do {
@@ -8719,46 +8719,46 @@ bool LLParser::parseOptionalFFlags(FunctionSummary::FFlags &FFlags) {
     switch (Lex.getKind()) {
     case lltok::kw_readNone:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val)) 
         return true;
       FFlags.ReadNone = Val;
       break;
     case lltok::kw_readOnly:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val)) 
         return true;
       FFlags.ReadOnly = Val;
       break;
     case lltok::kw_noRecurse:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val)) 
         return true;
       FFlags.NoRecurse = Val;
       break;
     case lltok::kw_returnDoesNotAlias:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val)) 
         return true;
       FFlags.ReturnDoesNotAlias = Val;
       break;
     case lltok::kw_noInline:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val)) 
         return true;
       FFlags.NoInline = Val;
       break;
     case lltok::kw_alwaysInline:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val)) 
         return true;
       FFlags.AlwaysInline = Val;
       break;
     default:
-      return error(Lex.getLoc(), "expected function flag type");
+      return error(Lex.getLoc(), "expected function flag type"); 
     }
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' in funcFlags"))
+  if (parseToken(lltok::rparen, "expected ')' in funcFlags")) 
     return true;
 
   return false;
@@ -8768,26 +8768,26 @@ bool LLParser::parseOptionalFFlags(FunctionSummary::FFlags &FFlags) {
 ///   := 'calls' ':' '(' Call [',' Call]* ')'
 /// Call ::= '(' 'callee' ':' GVReference
 ///            [( ',' 'hotness' ':' Hotness | ',' 'relbf' ':' UInt32 )]? ')'
-bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
+bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) { 
   assert(Lex.getKind() == lltok::kw_calls);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' in calls") |
-      parseToken(lltok::lparen, "expected '(' in calls"))
+  if (parseToken(lltok::colon, "expected ':' in calls") | 
+      parseToken(lltok::lparen, "expected '(' in calls")) 
     return true;
 
   IdToIndexMapType IdToIndexMap;
-  // parse each call edge
+  // parse each call edge 
   do {
     ValueInfo VI;
-    if (parseToken(lltok::lparen, "expected '(' in call") ||
-        parseToken(lltok::kw_callee, "expected 'callee' in call") ||
-        parseToken(lltok::colon, "expected ':'"))
+    if (parseToken(lltok::lparen, "expected '(' in call") || 
+        parseToken(lltok::kw_callee, "expected 'callee' in call") || 
+        parseToken(lltok::colon, "expected ':'")) 
       return true;
 
     LocTy Loc = Lex.getLoc();
     unsigned GVId;
-    if (parseGVReference(VI, GVId))
+    if (parseGVReference(VI, GVId)) 
       return true;
 
     CalleeInfo::HotnessType Hotness = CalleeInfo::HotnessType::Unknown;
@@ -8795,11 +8795,11 @@ bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
     if (EatIfPresent(lltok::comma)) {
       // Expect either hotness or relbf
       if (EatIfPresent(lltok::kw_hotness)) {
-        if (parseToken(lltok::colon, "expected ':'") || parseHotness(Hotness))
+        if (parseToken(lltok::colon, "expected ':'") || parseHotness(Hotness)) 
           return true;
       } else {
-        if (parseToken(lltok::kw_relbf, "expected relbf") ||
-            parseToken(lltok::colon, "expected ':'") || parseUInt32(RelBF))
+        if (parseToken(lltok::kw_relbf, "expected relbf") || 
+            parseToken(lltok::colon, "expected ':'") || parseUInt32(RelBF)) 
           return true;
       }
     }
@@ -8810,22 +8810,22 @@ bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
       IdToIndexMap[GVId].push_back(std::make_pair(Calls.size(), Loc));
     Calls.push_back(FunctionSummary::EdgeTy{VI, CalleeInfo(Hotness, RelBF)});
 
-    if (parseToken(lltok::rparen, "expected ')' in call"))
+    if (parseToken(lltok::rparen, "expected ')' in call")) 
       return true;
   } while (EatIfPresent(lltok::comma));
 
   // Now that the Calls vector is finalized, it is safe to save the locations
   // of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Infos = ForwardRefValueInfos[I.first];
+    auto &Infos = ForwardRefValueInfos[I.first]; 
     for (auto P : I.second) {
       assert(Calls[P.first].first.getRef() == FwdVIRef &&
              "Forward referenced ValueInfo expected to be empty");
-      Infos.emplace_back(&Calls[P.first].first, P.second);
+      Infos.emplace_back(&Calls[P.first].first, P.second); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' in calls"))
+  if (parseToken(lltok::rparen, "expected ')' in calls")) 
     return true;
 
   return false;
@@ -8833,7 +8833,7 @@ bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
 
 /// Hotness
 ///   := ('unknown'|'cold'|'none'|'hot'|'critical')
-bool LLParser::parseHotness(CalleeInfo::HotnessType &Hotness) {
+bool LLParser::parseHotness(CalleeInfo::HotnessType &Hotness) { 
   switch (Lex.getKind()) {
   case lltok::kw_unknown:
     Hotness = CalleeInfo::HotnessType::Unknown;
@@ -8851,7 +8851,7 @@ bool LLParser::parseHotness(CalleeInfo::HotnessType &Hotness) {
     Hotness = CalleeInfo::HotnessType::Critical;
     break;
   default:
-    return error(Lex.getLoc(), "invalid call edge hotness");
+    return error(Lex.getLoc(), "invalid call edge hotness"); 
   }
   Lex.Lex();
   return false;
@@ -8860,32 +8860,32 @@ bool LLParser::parseHotness(CalleeInfo::HotnessType &Hotness) {
 /// OptionalVTableFuncs
 ///   := 'vTableFuncs' ':' '(' VTableFunc [',' VTableFunc]* ')'
 /// VTableFunc ::= '(' 'virtFunc' ':' GVReference ',' 'offset' ':' UInt64 ')'
-bool LLParser::parseOptionalVTableFuncs(VTableFuncList &VTableFuncs) {
+bool LLParser::parseOptionalVTableFuncs(VTableFuncList &VTableFuncs) { 
   assert(Lex.getKind() == lltok::kw_vTableFuncs);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' in vTableFuncs") |
-      parseToken(lltok::lparen, "expected '(' in vTableFuncs"))
+  if (parseToken(lltok::colon, "expected ':' in vTableFuncs") | 
+      parseToken(lltok::lparen, "expected '(' in vTableFuncs")) 
     return true;
 
   IdToIndexMapType IdToIndexMap;
-  // parse each virtual function pair
+  // parse each virtual function pair 
   do {
     ValueInfo VI;
-    if (parseToken(lltok::lparen, "expected '(' in vTableFunc") ||
-        parseToken(lltok::kw_virtFunc, "expected 'callee' in vTableFunc") ||
-        parseToken(lltok::colon, "expected ':'"))
+    if (parseToken(lltok::lparen, "expected '(' in vTableFunc") || 
+        parseToken(lltok::kw_virtFunc, "expected 'callee' in vTableFunc") || 
+        parseToken(lltok::colon, "expected ':'")) 
       return true;
 
     LocTy Loc = Lex.getLoc();
     unsigned GVId;
-    if (parseGVReference(VI, GVId))
+    if (parseGVReference(VI, GVId)) 
       return true;
 
     uint64_t Offset;
-    if (parseToken(lltok::comma, "expected comma") ||
-        parseToken(lltok::kw_offset, "expected offset") ||
-        parseToken(lltok::colon, "expected ':'") || parseUInt64(Offset))
+    if (parseToken(lltok::comma, "expected comma") || 
+        parseToken(lltok::kw_offset, "expected offset") || 
+        parseToken(lltok::colon, "expected ':'") || parseUInt64(Offset)) 
       return true;
 
     // Keep track of the VTableFuncs array index needing a forward reference.
@@ -8895,53 +8895,53 @@ bool LLParser::parseOptionalVTableFuncs(VTableFuncList &VTableFuncs) {
       IdToIndexMap[GVId].push_back(std::make_pair(VTableFuncs.size(), Loc));
     VTableFuncs.push_back({VI, Offset});
 
-    if (parseToken(lltok::rparen, "expected ')' in vTableFunc"))
+    if (parseToken(lltok::rparen, "expected ')' in vTableFunc")) 
       return true;
   } while (EatIfPresent(lltok::comma));
 
   // Now that the VTableFuncs vector is finalized, it is safe to save the
   // locations of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Infos = ForwardRefValueInfos[I.first];
+    auto &Infos = ForwardRefValueInfos[I.first]; 
     for (auto P : I.second) {
       assert(VTableFuncs[P.first].FuncVI == EmptyVI &&
              "Forward referenced ValueInfo expected to be empty");
-      Infos.emplace_back(&VTableFuncs[P.first].FuncVI, P.second);
+      Infos.emplace_back(&VTableFuncs[P.first].FuncVI, P.second); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' in vTableFuncs"))
+  if (parseToken(lltok::rparen, "expected ')' in vTableFuncs")) 
     return true;
 
   return false;
 }
 
 /// ParamNo := 'param' ':' UInt64
-bool LLParser::parseParamNo(uint64_t &ParamNo) {
-  if (parseToken(lltok::kw_param, "expected 'param' here") ||
-      parseToken(lltok::colon, "expected ':' here") || parseUInt64(ParamNo))
+bool LLParser::parseParamNo(uint64_t &ParamNo) { 
+  if (parseToken(lltok::kw_param, "expected 'param' here") || 
+      parseToken(lltok::colon, "expected ':' here") || parseUInt64(ParamNo)) 
     return true;
   return false;
 }
 
 /// ParamAccessOffset := 'offset' ':' '[' APSINTVAL ',' APSINTVAL ']'
-bool LLParser::parseParamAccessOffset(ConstantRange &Range) {
+bool LLParser::parseParamAccessOffset(ConstantRange &Range) { 
   APSInt Lower;
   APSInt Upper;
   auto ParseAPSInt = [&](APSInt &Val) {
     if (Lex.getKind() != lltok::APSInt)
-      return tokError("expected integer");
+      return tokError("expected integer"); 
     Val = Lex.getAPSIntVal();
     Val = Val.extOrTrunc(FunctionSummary::ParamAccess::RangeWidth);
     Val.setIsSigned(true);
     Lex.Lex();
     return false;
   };
-  if (parseToken(lltok::kw_offset, "expected 'offset' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lsquare, "expected '[' here") || ParseAPSInt(Lower) ||
-      parseToken(lltok::comma, "expected ',' here") || ParseAPSInt(Upper) ||
-      parseToken(lltok::rsquare, "expected ']' here"))
+  if (parseToken(lltok::kw_offset, "expected 'offset' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lsquare, "expected '[' here") || ParseAPSInt(Lower) || 
+      parseToken(lltok::comma, "expected ',' here") || ParseAPSInt(Upper) || 
+      parseToken(lltok::rsquare, "expected ']' here")) 
     return true;
 
   ++Upper;
@@ -8955,29 +8955,29 @@ bool LLParser::parseParamAccessOffset(ConstantRange &Range) {
 
 /// ParamAccessCall
 ///   := '(' 'callee' ':' GVReference ',' ParamNo ',' ParamAccessOffset ')'
-bool LLParser::parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
-                                    IdLocListType &IdLocList) {
-  if (parseToken(lltok::lparen, "expected '(' here") ||
-      parseToken(lltok::kw_callee, "expected 'callee' here") ||
-      parseToken(lltok::colon, "expected ':' here"))
+bool LLParser::parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call, 
+                                    IdLocListType &IdLocList) { 
+  if (parseToken(lltok::lparen, "expected '(' here") || 
+      parseToken(lltok::kw_callee, "expected 'callee' here") || 
+      parseToken(lltok::colon, "expected ':' here")) 
     return true;
 
   unsigned GVId;
   ValueInfo VI;
-  LocTy Loc = Lex.getLoc();
-  if (parseGVReference(VI, GVId))
+  LocTy Loc = Lex.getLoc(); 
+  if (parseGVReference(VI, GVId)) 
     return true;
 
-  Call.Callee = VI;
-  IdLocList.emplace_back(GVId, Loc);
+  Call.Callee = VI; 
+  IdLocList.emplace_back(GVId, Loc); 
 
-  if (parseToken(lltok::comma, "expected ',' here") ||
-      parseParamNo(Call.ParamNo) ||
-      parseToken(lltok::comma, "expected ',' here") ||
-      parseParamAccessOffset(Call.Offsets))
+  if (parseToken(lltok::comma, "expected ',' here") || 
+      parseParamNo(Call.ParamNo) || 
+      parseToken(lltok::comma, "expected ',' here") || 
+      parseParamAccessOffset(Call.Offsets)) 
     return true;
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -8986,31 +8986,31 @@ bool LLParser::parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
 /// ParamAccess
 ///   := '(' ParamNo ',' ParamAccessOffset [',' OptionalParamAccessCalls]? ')'
 /// OptionalParamAccessCalls := '(' Call [',' Call]* ')'
-bool LLParser::parseParamAccess(FunctionSummary::ParamAccess &Param,
-                                IdLocListType &IdLocList) {
-  if (parseToken(lltok::lparen, "expected '(' here") ||
-      parseParamNo(Param.ParamNo) ||
-      parseToken(lltok::comma, "expected ',' here") ||
-      parseParamAccessOffset(Param.Use))
+bool LLParser::parseParamAccess(FunctionSummary::ParamAccess &Param, 
+                                IdLocListType &IdLocList) { 
+  if (parseToken(lltok::lparen, "expected '(' here") || 
+      parseParamNo(Param.ParamNo) || 
+      parseToken(lltok::comma, "expected ',' here") || 
+      parseParamAccessOffset(Param.Use)) 
     return true;
 
   if (EatIfPresent(lltok::comma)) {
-    if (parseToken(lltok::kw_calls, "expected 'calls' here") ||
-        parseToken(lltok::colon, "expected ':' here") ||
-        parseToken(lltok::lparen, "expected '(' here"))
+    if (parseToken(lltok::kw_calls, "expected 'calls' here") || 
+        parseToken(lltok::colon, "expected ':' here") || 
+        parseToken(lltok::lparen, "expected '(' here")) 
       return true;
     do {
       FunctionSummary::ParamAccess::Call Call;
-      if (parseParamAccessCall(Call, IdLocList))
+      if (parseParamAccessCall(Call, IdLocList)) 
         return true;
       Param.Calls.push_back(Call);
     } while (EatIfPresent(lltok::comma));
 
-    if (parseToken(lltok::rparen, "expected ')' here"))
+    if (parseToken(lltok::rparen, "expected ')' here")) 
       return true;
   }
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -9018,53 +9018,53 @@ bool LLParser::parseParamAccess(FunctionSummary::ParamAccess &Param,
 
 /// OptionalParamAccesses
 ///   := 'params' ':' '(' ParamAccess [',' ParamAccess]* ')'
-bool LLParser::parseOptionalParamAccesses(
+bool LLParser::parseOptionalParamAccesses( 
     std::vector<FunctionSummary::ParamAccess> &Params) {
   assert(Lex.getKind() == lltok::kw_params);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
-  IdLocListType VContexts;
-  size_t CallsNum = 0;
+  IdLocListType VContexts; 
+  size_t CallsNum = 0; 
   do {
     FunctionSummary::ParamAccess ParamAccess;
-    if (parseParamAccess(ParamAccess, VContexts))
+    if (parseParamAccess(ParamAccess, VContexts)) 
       return true;
-    CallsNum += ParamAccess.Calls.size();
-    assert(VContexts.size() == CallsNum);
-    Params.emplace_back(std::move(ParamAccess));
+    CallsNum += ParamAccess.Calls.size(); 
+    assert(VContexts.size() == CallsNum); 
+    Params.emplace_back(std::move(ParamAccess)); 
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
-  // Now that the Params is finalized, it is safe to save the locations
-  // of any forward GV references that need updating later.
-  IdLocListType::const_iterator ItContext = VContexts.begin();
-  for (auto &PA : Params) {
-    for (auto &C : PA.Calls) {
-      if (C.Callee.getRef() == FwdVIRef)
-        ForwardRefValueInfos[ItContext->first].emplace_back(&C.Callee,
-                                                            ItContext->second);
-      ++ItContext;
-    }
-  }
-  assert(ItContext == VContexts.end());
-
+  // Now that the Params is finalized, it is safe to save the locations 
+  // of any forward GV references that need updating later. 
+  IdLocListType::const_iterator ItContext = VContexts.begin(); 
+  for (auto &PA : Params) { 
+    for (auto &C : PA.Calls) { 
+      if (C.Callee.getRef() == FwdVIRef) 
+        ForwardRefValueInfos[ItContext->first].emplace_back(&C.Callee, 
+                                                            ItContext->second); 
+      ++ItContext; 
+    } 
+  } 
+  assert(ItContext == VContexts.end()); 
+ 
   return false;
 }
 
 /// OptionalRefs
 ///   := 'refs' ':' '(' GVReference [',' GVReference]* ')'
-bool LLParser::parseOptionalRefs(std::vector<ValueInfo> &Refs) {
+bool LLParser::parseOptionalRefs(std::vector<ValueInfo> &Refs) { 
   assert(Lex.getKind() == lltok::kw_refs);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' in refs") ||
-      parseToken(lltok::lparen, "expected '(' in refs"))
+  if (parseToken(lltok::colon, "expected ':' in refs") || 
+      parseToken(lltok::lparen, "expected '(' in refs")) 
     return true;
 
   struct ValueContext {
@@ -9073,11 +9073,11 @@ bool LLParser::parseOptionalRefs(std::vector<ValueInfo> &Refs) {
     LocTy Loc;
   };
   std::vector<ValueContext> VContexts;
-  // parse each ref edge
+  // parse each ref edge 
   do {
     ValueContext VC;
     VC.Loc = Lex.getLoc();
-    if (parseGVReference(VC.VI, VC.GVId))
+    if (parseGVReference(VC.VI, VC.GVId)) 
       return true;
     VContexts.push_back(VC);
   } while (EatIfPresent(lltok::comma));
@@ -9102,15 +9102,15 @@ bool LLParser::parseOptionalRefs(std::vector<ValueInfo> &Refs) {
   // Now that the Refs vector is finalized, it is safe to save the locations
   // of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Infos = ForwardRefValueInfos[I.first];
+    auto &Infos = ForwardRefValueInfos[I.first]; 
     for (auto P : I.second) {
       assert(Refs[P.first].getRef() == FwdVIRef &&
              "Forward referenced ValueInfo expected to be empty");
-      Infos.emplace_back(&Refs[P.first], P.second);
+      Infos.emplace_back(&Refs[P.first], P.second); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' in refs"))
+  if (parseToken(lltok::rparen, "expected ')' in refs")) 
     return true;
 
   return false;
@@ -9120,47 +9120,47 @@ bool LLParser::parseOptionalRefs(std::vector<ValueInfo> &Refs) {
 ///   := 'typeidinfo' ':' '(' [',' TypeTests]? [',' TypeTestAssumeVCalls]?
 ///         [',' TypeCheckedLoadVCalls]?  [',' TypeTestAssumeConstVCalls]?
 ///         [',' TypeCheckedLoadConstVCalls]? ')'
-bool LLParser::parseOptionalTypeIdInfo(
+bool LLParser::parseOptionalTypeIdInfo( 
     FunctionSummary::TypeIdInfo &TypeIdInfo) {
   assert(Lex.getKind() == lltok::kw_typeIdInfo);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' in typeIdInfo"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' in typeIdInfo")) 
     return true;
 
   do {
     switch (Lex.getKind()) {
     case lltok::kw_typeTests:
-      if (parseTypeTests(TypeIdInfo.TypeTests))
+      if (parseTypeTests(TypeIdInfo.TypeTests)) 
         return true;
       break;
     case lltok::kw_typeTestAssumeVCalls:
-      if (parseVFuncIdList(lltok::kw_typeTestAssumeVCalls,
+      if (parseVFuncIdList(lltok::kw_typeTestAssumeVCalls, 
                            TypeIdInfo.TypeTestAssumeVCalls))
         return true;
       break;
     case lltok::kw_typeCheckedLoadVCalls:
-      if (parseVFuncIdList(lltok::kw_typeCheckedLoadVCalls,
+      if (parseVFuncIdList(lltok::kw_typeCheckedLoadVCalls, 
                            TypeIdInfo.TypeCheckedLoadVCalls))
         return true;
       break;
     case lltok::kw_typeTestAssumeConstVCalls:
-      if (parseConstVCallList(lltok::kw_typeTestAssumeConstVCalls,
+      if (parseConstVCallList(lltok::kw_typeTestAssumeConstVCalls, 
                               TypeIdInfo.TypeTestAssumeConstVCalls))
         return true;
       break;
     case lltok::kw_typeCheckedLoadConstVCalls:
-      if (parseConstVCallList(lltok::kw_typeCheckedLoadConstVCalls,
+      if (parseConstVCallList(lltok::kw_typeCheckedLoadConstVCalls, 
                               TypeIdInfo.TypeCheckedLoadConstVCalls))
         return true;
       break;
     default:
-      return error(Lex.getLoc(), "invalid typeIdInfo list type");
+      return error(Lex.getLoc(), "invalid typeIdInfo list type"); 
     }
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' in typeIdInfo"))
+  if (parseToken(lltok::rparen, "expected ')' in typeIdInfo")) 
     return true;
 
   return false;
@@ -9169,12 +9169,12 @@ bool LLParser::parseOptionalTypeIdInfo(
 /// TypeTests
 ///   ::= 'typeTests' ':' '(' (SummaryID | UInt64)
 ///         [',' (SummaryID | UInt64)]* ')'
-bool LLParser::parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests) {
+bool LLParser::parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests) { 
   assert(Lex.getKind() == lltok::kw_typeTests);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' in typeIdInfo"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' in typeIdInfo")) 
     return true;
 
   IdToIndexMapType IdToIndexMap;
@@ -9188,7 +9188,7 @@ bool LLParser::parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests) {
       // can only do so once the std::vector is finalized.
       IdToIndexMap[ID].push_back(std::make_pair(TypeTests.size(), Loc));
       Lex.Lex();
-    } else if (parseUInt64(GUID))
+    } else if (parseUInt64(GUID)) 
       return true;
     TypeTests.push_back(GUID);
   } while (EatIfPresent(lltok::comma));
@@ -9196,15 +9196,15 @@ bool LLParser::parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests) {
   // Now that the TypeTests vector is finalized, it is safe to save the
   // locations of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Ids = ForwardRefTypeIds[I.first];
+    auto &Ids = ForwardRefTypeIds[I.first]; 
     for (auto P : I.second) {
       assert(TypeTests[P.first] == 0 &&
              "Forward referenced type id GUID expected to be 0");
-      Ids.emplace_back(&TypeTests[P.first], P.second);
+      Ids.emplace_back(&TypeTests[P.first], P.second); 
     }
   }
 
-  if (parseToken(lltok::rparen, "expected ')' in typeIdInfo"))
+  if (parseToken(lltok::rparen, "expected ')' in typeIdInfo")) 
     return true;
 
   return false;
@@ -9212,34 +9212,34 @@ bool LLParser::parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests) {
 
 /// VFuncIdList
 ///   ::= Kind ':' '(' VFuncId [',' VFuncId]* ')'
-bool LLParser::parseVFuncIdList(
+bool LLParser::parseVFuncIdList( 
     lltok::Kind Kind, std::vector<FunctionSummary::VFuncId> &VFuncIdList) {
   assert(Lex.getKind() == Kind);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   IdToIndexMapType IdToIndexMap;
   do {
     FunctionSummary::VFuncId VFuncId;
-    if (parseVFuncId(VFuncId, IdToIndexMap, VFuncIdList.size()))
+    if (parseVFuncId(VFuncId, IdToIndexMap, VFuncIdList.size())) 
       return true;
     VFuncIdList.push_back(VFuncId);
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   // Now that the VFuncIdList vector is finalized, it is safe to save the
   // locations of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Ids = ForwardRefTypeIds[I.first];
+    auto &Ids = ForwardRefTypeIds[I.first]; 
     for (auto P : I.second) {
       assert(VFuncIdList[P.first].GUID == 0 &&
              "Forward referenced type id GUID expected to be 0");
-      Ids.emplace_back(&VFuncIdList[P.first].GUID, P.second);
+      Ids.emplace_back(&VFuncIdList[P.first].GUID, P.second); 
     }
   }
 
@@ -9248,35 +9248,35 @@ bool LLParser::parseVFuncIdList(
 
 /// ConstVCallList
 ///   ::= Kind ':' '(' ConstVCall [',' ConstVCall]* ')'
-bool LLParser::parseConstVCallList(
+bool LLParser::parseConstVCallList( 
     lltok::Kind Kind,
     std::vector<FunctionSummary::ConstVCall> &ConstVCallList) {
   assert(Lex.getKind() == Kind);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   IdToIndexMapType IdToIndexMap;
   do {
     FunctionSummary::ConstVCall ConstVCall;
-    if (parseConstVCall(ConstVCall, IdToIndexMap, ConstVCallList.size()))
+    if (parseConstVCall(ConstVCall, IdToIndexMap, ConstVCallList.size())) 
       return true;
     ConstVCallList.push_back(ConstVCall);
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   // Now that the ConstVCallList vector is finalized, it is safe to save the
   // locations of any forward GV references that need updating later.
   for (auto I : IdToIndexMap) {
-    auto &Ids = ForwardRefTypeIds[I.first];
+    auto &Ids = ForwardRefTypeIds[I.first]; 
     for (auto P : I.second) {
       assert(ConstVCallList[P.first].VFunc.GUID == 0 &&
              "Forward referenced type id GUID expected to be 0");
-      Ids.emplace_back(&ConstVCallList[P.first].VFunc.GUID, P.second);
+      Ids.emplace_back(&ConstVCallList[P.first].VFunc.GUID, P.second); 
     }
   }
 
@@ -9285,17 +9285,17 @@ bool LLParser::parseConstVCallList(
 
 /// ConstVCall
 ///   ::= '(' VFuncId ',' Args ')'
-bool LLParser::parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
+bool LLParser::parseConstVCall(FunctionSummary::ConstVCall &ConstVCall, 
                                IdToIndexMapType &IdToIndexMap, unsigned Index) {
-  if (parseToken(lltok::lparen, "expected '(' here") ||
-      parseVFuncId(ConstVCall.VFunc, IdToIndexMap, Index))
+  if (parseToken(lltok::lparen, "expected '(' here") || 
+      parseVFuncId(ConstVCall.VFunc, IdToIndexMap, Index)) 
     return true;
 
   if (EatIfPresent(lltok::comma))
-    if (parseArgs(ConstVCall.Args))
+    if (parseArgs(ConstVCall.Args)) 
       return true;
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -9304,13 +9304,13 @@ bool LLParser::parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
 /// VFuncId
 ///   ::= 'vFuncId' ':' '(' (SummaryID | 'guid' ':' UInt64) ','
 ///         'offset' ':' UInt64 ')'
-bool LLParser::parseVFuncId(FunctionSummary::VFuncId &VFuncId,
+bool LLParser::parseVFuncId(FunctionSummary::VFuncId &VFuncId, 
                             IdToIndexMapType &IdToIndexMap, unsigned Index) {
   assert(Lex.getKind() == lltok::kw_vFuncId);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   if (Lex.getKind() == lltok::SummaryID) {
@@ -9322,16 +9322,16 @@ bool LLParser::parseVFuncId(FunctionSummary::VFuncId &VFuncId,
     // can only do so once the caller's std::vector is finalized.
     IdToIndexMap[ID].push_back(std::make_pair(Index, Loc));
     Lex.Lex();
-  } else if (parseToken(lltok::kw_guid, "expected 'guid' here") ||
-             parseToken(lltok::colon, "expected ':' here") ||
-             parseUInt64(VFuncId.GUID))
+  } else if (parseToken(lltok::kw_guid, "expected 'guid' here") || 
+             parseToken(lltok::colon, "expected ':' here") || 
+             parseUInt64(VFuncId.GUID)) 
     return true;
 
-  if (parseToken(lltok::comma, "expected ',' here") ||
-      parseToken(lltok::kw_offset, "expected 'offset' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseUInt64(VFuncId.Offset) ||
-      parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::comma, "expected ',' here") || 
+      parseToken(lltok::kw_offset, "expected 'offset' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseUInt64(VFuncId.Offset) || 
+      parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -9341,12 +9341,12 @@ bool LLParser::parseVFuncId(FunctionSummary::VFuncId &VFuncId,
 ///   ::= 'flags' ':' '(' 'linkage' ':' OptionalLinkageAux ','
 ///         'notEligibleToImport' ':' Flag ',' 'live' ':' Flag ','
 ///         'dsoLocal' ':' Flag ',' 'canAutoHide' ':' Flag ')'
-bool LLParser::parseGVFlags(GlobalValueSummary::GVFlags &GVFlags) {
+bool LLParser::parseGVFlags(GlobalValueSummary::GVFlags &GVFlags) { 
   assert(Lex.getKind() == lltok::kw_flags);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   do {
@@ -9354,7 +9354,7 @@ bool LLParser::parseGVFlags(GlobalValueSummary::GVFlags &GVFlags) {
     switch (Lex.getKind()) {
     case lltok::kw_linkage:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'"))
+      if (parseToken(lltok::colon, "expected ':'")) 
         return true;
       bool HasLinkage;
       GVFlags.Linkage = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
@@ -9363,34 +9363,34 @@ bool LLParser::parseGVFlags(GlobalValueSummary::GVFlags &GVFlags) {
       break;
     case lltok::kw_notEligibleToImport:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag)) 
         return true;
       GVFlags.NotEligibleToImport = Flag;
       break;
     case lltok::kw_live:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag)) 
         return true;
       GVFlags.Live = Flag;
       break;
     case lltok::kw_dsoLocal:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag)) 
         return true;
       GVFlags.DSOLocal = Flag;
       break;
     case lltok::kw_canAutoHide:
       Lex.Lex();
-      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
+      if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag)) 
         return true;
       GVFlags.CanAutoHide = Flag;
       break;
     default:
-      return error(Lex.getLoc(), "expected gv flag type");
+      return error(Lex.getLoc(), "expected gv flag type"); 
     }
   } while (EatIfPresent(lltok::comma));
 
-  if (parseToken(lltok::rparen, "expected ')' here"))
+  if (parseToken(lltok::rparen, "expected ')' here")) 
     return true;
 
   return false;
@@ -9400,19 +9400,19 @@ bool LLParser::parseGVFlags(GlobalValueSummary::GVFlags &GVFlags) {
 ///   ::= 'varFlags' ':' '(' 'readonly' ':' Flag
 ///                      ',' 'writeonly' ':' Flag
 ///                      ',' 'constant' ':' Flag ')'
-bool LLParser::parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags) {
+bool LLParser::parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags) { 
   assert(Lex.getKind() == lltok::kw_varFlags);
   Lex.Lex();
 
-  if (parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::lparen, "expected '(' here"))
+  if (parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::lparen, "expected '(' here")) 
     return true;
 
   auto ParseRest = [this](unsigned int &Val) {
     Lex.Lex();
-    if (parseToken(lltok::colon, "expected ':'"))
+    if (parseToken(lltok::colon, "expected ':'")) 
       return true;
-    return parseFlag(Val);
+    return parseFlag(Val); 
   };
 
   do {
@@ -9439,19 +9439,19 @@ bool LLParser::parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags) {
       GVarFlags.VCallVisibility = Flag;
       break;
     default:
-      return error(Lex.getLoc(), "expected gvar flag type");
+      return error(Lex.getLoc(), "expected gvar flag type"); 
     }
   } while (EatIfPresent(lltok::comma));
-  return parseToken(lltok::rparen, "expected ')' here");
+  return parseToken(lltok::rparen, "expected ')' here"); 
 }
 
 /// ModuleReference
 ///   ::= 'module' ':' UInt
-bool LLParser::parseModuleReference(StringRef &ModulePath) {
-  // parse module id.
-  if (parseToken(lltok::kw_module, "expected 'module' here") ||
-      parseToken(lltok::colon, "expected ':' here") ||
-      parseToken(lltok::SummaryID, "expected module ID"))
+bool LLParser::parseModuleReference(StringRef &ModulePath) { 
+  // parse module id. 
+  if (parseToken(lltok::kw_module, "expected 'module' here") || 
+      parseToken(lltok::colon, "expected ':' here") || 
+      parseToken(lltok::SummaryID, "expected module ID")) 
     return true;
 
   unsigned ModuleID = Lex.getUIntVal();
@@ -9464,11 +9464,11 @@ bool LLParser::parseModuleReference(StringRef &ModulePath) {
 
 /// GVReference
 ///   ::= SummaryID
-bool LLParser::parseGVReference(ValueInfo &VI, unsigned &GVId) {
+bool LLParser::parseGVReference(ValueInfo &VI, unsigned &GVId) { 
   bool WriteOnly = false, ReadOnly = EatIfPresent(lltok::kw_readonly);
   if (!ReadOnly)
     WriteOnly = EatIfPresent(lltok::kw_writeonly);
-  if (parseToken(lltok::SummaryID, "expected GV ID"))
+  if (parseToken(lltok::SummaryID, "expected GV ID")) 
     return true;
 
   GVId = Lex.getUIntVal();