[Object][WebAssembly] Update format of error messages

[sbc100]

Summary

Error message should start with lowercase in accordance with
https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

[MaskRay]

Looks great!

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_OPCODE_F64_CONST:
     Expr.Value.Float64 = readFloat64(Ctx);
     break;
   case wasm::WASM_OPCODE_GLOBAL_GET:
     Expr.Value.Global = readULEB128(Ctx);
     break;
   case wasm::WASM_OPCODE_REF_NULL: {
     wasm::ValType Ty = static_cast<wasm::ValType>(readULEB128(Ctx));
     if (Ty != wasm::ValType::EXTERNREF) {
-      return make_error<GenericBinaryError>("Invalid type for ref.null",
+      return make_error<GenericBinaryError>("invalid type for ref.null",
                                             object_error::parse_failed);
     }
     break;
   }
   default:
-    return make_error<GenericBinaryError>("Invalid opcode in init_expr",
+    return make_error<GenericBinaryError>("invalid opcode in init_expr",
                                           object_error::parse_failed);
   }
 
   uint8_t EndOpcode = readOpcode(Ctx);
   if (EndOpcode != wasm::WASM_OPCODE_END) {
-    return make_error<GenericBinaryError>("Invalid init_expr",
+    return make_error<GenericBinaryError>("invalid init_expr",
                                           object_error::parse_failed);
   }
   return Error::success();
 }
 
 static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
   wasm::WasmLimits Result;
   Result.Flags = readVaruint32(Ctx);

 
 static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
                          WasmSectionOrderChecker &Checker) {
   Section.Offset = Ctx.Ptr - Ctx.Start;
   Section.Type = readUint8(Ctx);
   LLVM_DEBUG(dbgs() << "readSection type=" << Section.Type << "\n");
   uint32_t Size = readVaruint32(Ctx);
   if (Size == 0)
-    return make_error<StringError>("Zero length section",
+    return make_error<StringError>("zero length section",
                                    object_error::parse_failed);
   if (Ctx.Ptr + Size > Ctx.End)
-    return make_error<StringError>("Section too large",
+    return make_error<StringError>("section too large",
                                    object_error::parse_failed);
   if (Section.Type == wasm::WASM_SEC_CUSTOM) {
     WasmObjectFile::ReadContext SectionCtx;
     SectionCtx.Start = Ctx.Ptr;
     SectionCtx.Ptr = Ctx.Ptr;
     SectionCtx.End = Ctx.Ptr + Size;
 
     Section.Name = readString(SectionCtx);
 
     uint32_t SectionNameSize = SectionCtx.Ptr - SectionCtx.Start;
     Ctx.Ptr += SectionNameSize;
     Size -= SectionNameSize;
   }
 
   if (!Checker.isValidSectionOrder(Section.Type, Section.Name)) {
-    return make_error<StringError>("Out of order section type: " +
+    return make_error<StringError>("out of order section type: " +
                                        llvm::to_string(Section.Type),
                                    object_error::parse_failed);
   }
 
   Section.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
   Ctx.Ptr += Size;
   return Error::success();
 }
 
 WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
     : ObjectFile(Binary::ID_Wasm, Buffer) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
   Header.Magic = getData().substr(0, 4);
   if (Header.Magic != StringRef("\0asm", 4)) {
-    Err =
-        make_error<StringError>("Bad magic number", object_error::parse_failed);
+    Err = make_error<StringError>("invalid magic number",
+                                  object_error::parse_failed);
     return;
   }
 
   ReadContext Ctx;
   Ctx.Start = getData().bytes_begin();
   Ctx.Ptr = Ctx.Start + 4;
   Ctx.End = Ctx.Start + getData().size();
 
   if (Ctx.Ptr + 4 > Ctx.End) {
-    Err = make_error<StringError>("Missing version number",
+    Err = make_error<StringError>("missing version number",
                                   object_error::parse_failed);
     return;
   }
 
   Header.Version = readUint32(Ctx);
   if (Header.Version != wasm::WasmVersion) {
-    Err = make_error<StringError>("Bad version number",
+    Err = make_error<StringError>("invalid version number: " +
+                                      Twine(Header.Version),
                                   object_error::parse_failed);
     return;
   }
 
   WasmSection Sec;
   WasmSectionOrderChecker Checker;
   while (Ctx.Ptr < Ctx.End) {
     if ((Err = readSection(Sec, Ctx, Checker)))
Error WasmObjectFile::parseSection(WasmSection &Sec) {
   case wasm::WASM_SEC_CODE:
     return parseCodeSection(Ctx);
   case wasm::WASM_SEC_DATA:
     return parseDataSection(Ctx);
   case wasm::WASM_SEC_DATACOUNT:
     return parseDataCountSection(Ctx);
   default:
     return make_error<GenericBinaryError>(
-        "Invalid section type: " + Twine(Sec.Type), object_error::parse_failed);
+        "invalid section type: " + Twine(Sec.Type), object_error::parse_failed);
   }
 }
 
 Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   // See https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
   HasDylinkSection = true;
   DylinkInfo.MemorySize = readVaruint32(Ctx);
   DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   return Error::success();
 }
 
 Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
   llvm::DenseSet<uint64_t> SeenFunctions;
   llvm::DenseSet<uint64_t> SeenGlobals;
   llvm::DenseSet<uint64_t> SeenSegments;
   if (FunctionTypes.size() && !SeenCodeSection) {
-    return make_error<GenericBinaryError>("Names must come after code section",
+    return make_error<GenericBinaryError>("names must come after code section",
                                           object_error::parse_failed);
   }
 
   while (Ctx.Ptr < Ctx.End) {
     uint8_t Type = readUint8(Ctx);
     uint32_t Size = readVaruint32(Ctx);
     const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
     switch (Type) {
     case wasm::WASM_NAMES_FUNCTION:
     case wasm::WASM_NAMES_GLOBAL:
     case wasm::WASM_NAMES_DATA_SEGMENT: {
       uint32_t Count = readVaruint32(Ctx);
       while (Count--) {
         uint32_t Index = readVaruint32(Ctx);
         StringRef Name = readString(Ctx);
         wasm::NameType nameType = wasm::NameType::FUNCTION;
         if (Type == wasm::WASM_NAMES_FUNCTION) {
           if (!SeenFunctions.insert(Index).second)
             return make_error<GenericBinaryError>(
-                "Function named more than once", object_error::parse_failed);
+                "function named more than once", object_error::parse_failed);
           if (!isValidFunctionIndex(Index) || Name.empty())
-            return make_error<GenericBinaryError>("Invalid name entry",
+            return make_error<GenericBinaryError>("invalid name entry",
                                                   object_error::parse_failed);
 
           if (isDefinedFunctionIndex(Index))
             getDefinedFunction(Index).DebugName = Name;
         } else if (Type == wasm::WASM_NAMES_GLOBAL) {
           nameType = wasm::NameType::GLOBAL;
           if (!SeenGlobals.insert(Index).second)
-            return make_error<GenericBinaryError>("Global named more than once",
+            return make_error<GenericBinaryError>("global named more than once",
                                                   object_error::parse_failed);
           if (!isValidGlobalIndex(Index) || Name.empty())
-            return make_error<GenericBinaryError>("Invalid name entry",
+            return make_error<GenericBinaryError>("invalid name entry",
                                                   object_error::parse_failed);
         } else {
           nameType = wasm::NameType::DATA_SEGMENT;
           if (!SeenSegments.insert(Index).second)
             return make_error<GenericBinaryError>(
-                "Segment named more than once", object_error::parse_failed);
+                "segment named more than once", object_error::parse_failed);
           if (Index > DataSegments.size())
-            return make_error<GenericBinaryError>("Invalid named data segment",
+            return make_error<GenericBinaryError>("invalid named data segment",
                                                   object_error::parse_failed);
         }
         DebugNames.push_back(wasm::WasmDebugName{nameType, Index, Name});
       }
       break;
     }
     // Ignore local names for now
     case wasm::WASM_NAMES_LOCAL:
     default:
       Ctx.Ptr += Size;
       break;
     }
     if (Ctx.Ptr != SubSectionEnd)
       return make_error<GenericBinaryError>(
-          "Name sub-section ended prematurely", object_error::parse_failed);
+          "name sub-section ended prematurely", object_error::parse_failed);
   }
 
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Name section ended prematurely",
+    return make_error<GenericBinaryError>("name section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSection(ReadContext &Ctx) {
   HasLinkingSection = true;
   if (FunctionTypes.size() && !SeenCodeSection) {
     return make_error<GenericBinaryError>(
-        "Linking data must come after code section",
+        "linking data must come after code section",
         object_error::parse_failed);
   }
 
   LinkingData.Version = readVaruint32(Ctx);
   if (LinkingData.Version != wasm::WasmMetadataVersion) {
     return make_error<GenericBinaryError>(
-        "Unexpected metadata version: " + Twine(LinkingData.Version) +
+        "unexpected metadata version: " + Twine(LinkingData.Version) +
             " (Expected: " + Twine(wasm::WasmMetadataVersion) + ")",
         object_error::parse_failed);
   }
 
   const uint8_t *OrigEnd = Ctx.End;
   while (Ctx.Ptr < OrigEnd) {
     Ctx.End = OrigEnd;
     uint8_t Type = readUint8(Ctx);
     uint32_t Size = readVaruint32(Ctx);
     LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
                       << "\n");
     Ctx.End = Ctx.Ptr + Size;
     switch (Type) {
     case wasm::WASM_SYMBOL_TABLE:
       if (Error Err = parseLinkingSectionSymtab(Ctx))
         return Err;
       break;
     case wasm::WASM_SEGMENT_INFO: {
       uint32_t Count = readVaruint32(Ctx);
       if (Count > DataSegments.size())
-        return make_error<GenericBinaryError>("Too many segment names",
+        return make_error<GenericBinaryError>("too many segment names",
                                               object_error::parse_failed);
       for (uint32_t I = 0; I < Count; I++) {
         DataSegments[I].Data.Name = readString(Ctx);
         DataSegments[I].Data.Alignment = readVaruint32(Ctx);
         DataSegments[I].Data.LinkerFlags = readVaruint32(Ctx);
       }
       break;
     }
     case wasm::WASM_INIT_FUNCS: {
       uint32_t Count = readVaruint32(Ctx);
       LinkingData.InitFunctions.reserve(Count);
       for (uint32_t I = 0; I < Count; I++) {
         wasm::WasmInitFunc Init;
         Init.Priority = readVaruint32(Ctx);
         Init.Symbol = readVaruint32(Ctx);
         if (!isValidFunctionSymbol(Init.Symbol))
-          return make_error<GenericBinaryError>("Invalid function symbol: " +
+          return make_error<GenericBinaryError>("invalid function symbol: " +
                                                     Twine(Init.Symbol),
                                                 object_error::parse_failed);
         LinkingData.InitFunctions.emplace_back(Init);
       }
       break;
     }
     case wasm::WASM_COMDAT_INFO:
       if (Error Err = parseLinkingSectionComdat(Ctx))
         return Err;
       break;
     default:
       Ctx.Ptr += Size;
       break;
     }
     if (Ctx.Ptr != Ctx.End)
       return make_error<GenericBinaryError>(
-          "Linking sub-section ended prematurely", object_error::parse_failed);
+          "linking sub-section ended prematurely", object_error::parse_failed);
   }
   if (Ctx.Ptr != OrigEnd)
-    return make_error<GenericBinaryError>("Linking section ended prematurely",
+    return make_error<GenericBinaryError>("linking section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   LinkingData.SymbolTable.reserve(Count);
   Symbols.reserve(Count);
case wasm::WASM_SYMBOL_TYPE_DATA:
         Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_SECTION: {
       if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
           wasm::WASM_SYMBOL_BINDING_LOCAL)
         return make_error<GenericBinaryError>(
-            "Section symbols must have local binding",
+            "section symbols must have local binding",
             object_error::parse_failed);
       Info.ElementIndex = readVaruint32(Ctx);
       // Use somewhat unique section name as symbol name.
       StringRef SectionName = Sections[Info.ElementIndex].Name;
       Info.Name = SectionName;
       break;
     }
 
case wasm::WASM_SYMBOL_TYPE_EVENT: {
         if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
       }
       break;
     }
 
     default:
-      return make_error<GenericBinaryError>("Invalid symbol type: " +
+      return make_error<GenericBinaryError>("invalid symbol type: " +
                                                 Twine(unsigned(Info.Kind)),
                                             object_error::parse_failed);
     }
 
     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
             wasm::WASM_SYMBOL_BINDING_LOCAL &&
         !SymbolNames.insert(Info.Name).second)
-      return make_error<GenericBinaryError>("Duplicate symbol name " +
+      return make_error<GenericBinaryError>("duplicate symbol name " +
                                                 Twine(Info.Name),
                                             object_error::parse_failed);
     LinkingData.SymbolTable.emplace_back(Info);
     Symbols.emplace_back(LinkingData.SymbolTable.back(), GlobalType, TableType,
                          EventType, Signature);
     LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
   }
 
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
   uint32_t ComdatCount = readVaruint32(Ctx);
   StringSet<> ComdatSet;
   for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
     StringRef Name = readString(Ctx);
     if (Name.empty() || !ComdatSet.insert(Name).second)
-      return make_error<GenericBinaryError>("Bad/duplicate COMDAT name " +
+      return make_error<GenericBinaryError>("bad/duplicate COMDAT name " +
                                                 Twine(Name),
                                             object_error::parse_failed);
     LinkingData.Comdats.emplace_back(Name);
     uint32_t Flags = readVaruint32(Ctx);
     if (Flags != 0)
-      return make_error<GenericBinaryError>("Unsupported COMDAT flags",
+      return make_error<GenericBinaryError>("unsupported COMDAT flags",
                                             object_error::parse_failed);
 
     uint32_t EntryCount = readVaruint32(Ctx);
     while (EntryCount--) {
       unsigned Kind = readVaruint32(Ctx);
       unsigned Index = readVaruint32(Ctx);
       switch (Kind) {
       default:
-        return make_error<GenericBinaryError>("Invalid COMDAT entry type",
+        return make_error<GenericBinaryError>("invalid COMDAT entry type",
                                               object_error::parse_failed);
       case wasm::WASM_COMDAT_DATA:
         if (Index >= DataSegments.size())
           return make_error<GenericBinaryError>(
               "COMDAT data index out of range", object_error::parse_failed);
         if (DataSegments[Index].Data.Comdat != UINT32_MAX)
-          return make_error<GenericBinaryError>("Data segment in two COMDATs",
+          return make_error<GenericBinaryError>("data segment in two COMDATs",
                                                 object_error::parse_failed);
         DataSegments[Index].Data.Comdat = ComdatIndex;
         break;
       case wasm::WASM_COMDAT_FUNCTION:
         if (!isDefinedFunctionIndex(Index))
           return make_error<GenericBinaryError>(
               "COMDAT function index out of range", object_error::parse_failed);
         if (getDefinedFunction(Index).Comdat != UINT32_MAX)
-          return make_error<GenericBinaryError>("Function in two COMDATs",
+          return make_error<GenericBinaryError>("function in two COMDATs",
                                                 object_error::parse_failed);
         getDefinedFunction(Index).Comdat = ComdatIndex;
         break;
       case wasm::WASM_COMDAT_SECTION:
         if (Index >= Sections.size())
           return make_error<GenericBinaryError>(
               "COMDAT section index out of range", object_error::parse_failed);
         if (Sections[Index].Type != wasm::WASM_SEC_CUSTOM)
           return make_error<GenericBinaryError>(
-              "Non-custom section in a COMDAT", object_error::parse_failed);
+              "non-custom section in a COMDAT", object_error::parse_failed);
         Sections[Index].Comdat = ComdatIndex;
         break;
       }
     }
   }
   return Error::success();
 }
 
 Error WasmObjectFile::parseProducersSection(ReadContext &Ctx) {
   llvm::SmallSet<StringRef, 3> FieldsSeen;
   uint32_t Fields = readVaruint32(Ctx);
   for (size_t I = 0; I < Fields; ++I) {
     StringRef FieldName = readString(Ctx);
     if (!FieldsSeen.insert(FieldName).second)
       return make_error<GenericBinaryError>(
-          "Producers section does not have unique fields",
+          "producers section does not have unique fields",
           object_error::parse_failed);
     std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
     if (FieldName == "language") {
       ProducerVec = &ProducerInfo.Languages;
     } else if (FieldName == "processed-by") {
       ProducerVec = &ProducerInfo.Tools;
     } else if (FieldName == "sdk") {
       ProducerVec = &ProducerInfo.SDKs;
     } else {
       return make_error<GenericBinaryError>(
-          "Producers section field is not named one of language, processed-by, "
+          "producers section field is not named one of language, processed-by, "
           "or sdk",
           object_error::parse_failed);
     }
     uint32_t ValueCount = readVaruint32(Ctx);
     llvm::SmallSet<StringRef, 8> ProducersSeen;
     for (size_t J = 0; J < ValueCount; ++J) {
       StringRef Name = readString(Ctx);
       StringRef Version = readString(Ctx);
       if (!ProducersSeen.insert(Name).second) {
         return make_error<GenericBinaryError>(
-            "Producers section contains repeated producer",
+            "producers section contains repeated producer",
             object_error::parse_failed);
       }
       ProducerVec->emplace_back(std::string(Name), std::string(Version));
     }
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Producers section ended prematurely",
+    return make_error<GenericBinaryError>("producers section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseTargetFeaturesSection(ReadContext &Ctx) {
   llvm::SmallSet<std::string, 8> FeaturesSeen;
   uint32_t FeatureCount = readVaruint32(Ctx);
   for (size_t I = 0; I < FeatureCount; ++I) {
     wasm::WasmFeatureEntry Feature;
     Feature.Prefix = readUint8(Ctx);
     switch (Feature.Prefix) {
     case wasm::WASM_FEATURE_PREFIX_USED:
     case wasm::WASM_FEATURE_PREFIX_REQUIRED:
     case wasm::WASM_FEATURE_PREFIX_DISALLOWED:
       break;
     default:
-      return make_error<GenericBinaryError>("Unknown feature policy prefix",
+      return make_error<GenericBinaryError>("unknown feature policy prefix",
                                             object_error::parse_failed);
     }
     Feature.Name = std::string(readString(Ctx));
     if (!FeaturesSeen.insert(Feature.Name).second)
       return make_error<GenericBinaryError>(
-          "Target features section contains repeated feature \"" +
+          "target features section contains repeated feature \"" +
               Feature.Name + "\"",
           object_error::parse_failed);
     TargetFeatures.push_back(Feature);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>(
-        "Target features section ended prematurely",
+        "target features section ended prematurely",
         object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
   uint32_t SectionIndex = readVaruint32(Ctx);
   if (SectionIndex >= Sections.size())
-    return make_error<GenericBinaryError>("Invalid section index",
+    return make_error<GenericBinaryError>("invalid section index",
                                           object_error::parse_failed);
   WasmSection &Section = Sections[SectionIndex];
   uint32_t RelocCount = readVaruint32(Ctx);
   uint32_t EndOffset = Section.Content.size();
   uint32_t PreviousOffset = 0;
   while (RelocCount--) {
     wasm::WasmRelocation Reloc = {};
     uint32_t type = readVaruint32(Ctx);
     Reloc.Type = type;
     Reloc.Offset = readVaruint32(Ctx);
     if (Reloc.Offset < PreviousOffset)
-      return make_error<GenericBinaryError>("Relocations not in offset order",
+      return make_error<GenericBinaryError>("relocations not in offset order",
                                             object_error::parse_failed);
     PreviousOffset = Reloc.Offset;
     Reloc.Index = readVaruint32(Ctx);
     switch (type) {
     case wasm::R_WASM_FUNCTION_INDEX_LEB:
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_SLEB64:
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_TABLE_INDEX_I64:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
       if (!isValidFunctionSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation function index",
-                                              object_error::parse_failed);
+        return make_error<GenericBinaryError>(
+            "invalid relocation function index", object_error::parse_failed);
       break;
     case wasm::R_WASM_TABLE_NUMBER_LEB:
       if (!isValidTableSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation table index",
+        return make_error<GenericBinaryError>("invalid relocation table index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_TYPE_INDEX_LEB:
       if (Reloc.Index >= Signatures.size())
-        return make_error<GenericBinaryError>("Bad relocation type index",
+        return make_error<GenericBinaryError>("invalid relocation type index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
       // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
       // symbols to refer to their GOT entries.
       if (!isValidGlobalSymbol(Reloc.Index) &&
           !isValidDataSymbol(Reloc.Index) &&
           !isValidFunctionSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation global index",
+        return make_error<GenericBinaryError>("invalid relocation global index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_GLOBAL_INDEX_I32:
       if (!isValidGlobalSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation global index",
+        return make_error<GenericBinaryError>("invalid relocation global index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_EVENT_INDEX_LEB:
       if (!isValidEventSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation event index",
+        return make_error<GenericBinaryError>("invalid relocation event index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
       if (!isValidDataSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation data index",
+        return make_error<GenericBinaryError>("invalid relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB64:
     case wasm::R_WASM_MEMORY_ADDR_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_I64:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
       if (!isValidDataSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation data index",
+        return make_error<GenericBinaryError>("invalid relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint64(Ctx);
       break;
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
       if (!isValidFunctionSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation function index",
-                                              object_error::parse_failed);
+        return make_error<GenericBinaryError>(
+            "invalid relocation function index", object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
     case wasm::R_WASM_FUNCTION_OFFSET_I64:
       if (!isValidFunctionSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation function index",
-                                              object_error::parse_failed);
+        return make_error<GenericBinaryError>(
+            "invalid relocation function index", object_error::parse_failed);
       Reloc.Addend = readVarint64(Ctx);
       break;
     case wasm::R_WASM_SECTION_OFFSET_I32:
       if (!isValidSectionSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("Bad relocation section index",
-                                              object_error::parse_failed);
+        return make_error<GenericBinaryError>(
+            "invalid relocation section index", object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
     default:
-      return make_error<GenericBinaryError>(
-          "Bad relocation type: " + Twine(type), object_error::parse_failed);
+      return make_error<GenericBinaryError>("invalid relocation type: " +
+                                                Twine(type),
+                                            object_error::parse_failed);
     }
 
     // Relocations must fit inside the section, and must appear in order.  They
     // also shouldn't overlap a function/element boundary, but we don't bother
     // to check that.
     uint64_t Size = 5;
     if (Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LEB64 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_SLEB64 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_REL_SLEB64)
       Size = 10;
     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
         Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
         Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
         Reloc.Type == wasm::R_WASM_GLOBAL_INDEX_I32)
       Size = 4;
     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I64 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I64 ||
         Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I64)
       Size = 8;
     if (Reloc.Offset + Size > EndOffset)
-      return make_error<GenericBinaryError>("Bad relocation offset",
+      return make_error<GenericBinaryError>("invalid relocation offset",
                                             object_error::parse_failed);
 
     Section.Relocations.push_back(Reloc);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Reloc section ended prematurely",
+    return make_error<GenericBinaryError>("reloc section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
   if (Sec.Name == "dylink") {
     if (Error Err = parseDylinkSection(Ctx))
       return Err;

 
 Error WasmObjectFile::parseTypeSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   Signatures.reserve(Count);
   while (Count--) {
     wasm::WasmSignature Sig;
     uint8_t Form = readUint8(Ctx);
     if (Form != wasm::WASM_TYPE_FUNC) {
-      return make_error<GenericBinaryError>("Invalid signature type",
+      return make_error<GenericBinaryError>("invalid signature type",
                                             object_error::parse_failed);
     }
     uint32_t ParamCount = readVaruint32(Ctx);
     Sig.Params.reserve(ParamCount);
     while (ParamCount--) {
       uint32_t ParamType = readUint8(Ctx);
       Sig.Params.push_back(wasm::ValType(ParamType));
     }
     uint32_t ReturnCount = readVaruint32(Ctx);
     while (ReturnCount--) {
       uint32_t ReturnType = readUint8(Ctx);
       Sig.Returns.push_back(wasm::ValType(ReturnType));
     }
     Signatures.push_back(std::move(Sig));
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Type section ended prematurely",
+    return make_error<GenericBinaryError>("type section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   Imports.reserve(Count);
   for (uint32_t I = 0; I < Count; I++) {
case wasm::WASM_EXTERNAL_MEMORY:
         HasMemory64 = true;
       break;
     case wasm::WASM_EXTERNAL_TABLE: {
       Im.Table = readTableType(Ctx);
       NumImportedTables++;
       auto ElemType = Im.Table.ElemType;
       if (ElemType != wasm::WASM_TYPE_FUNCREF &&
           ElemType != wasm::WASM_TYPE_EXTERNREF)
-        return make_error<GenericBinaryError>("Invalid table element type",
+        return make_error<GenericBinaryError>("invalid table element type",
                                               object_error::parse_failed);
       break;
     }
     case wasm::WASM_EXTERNAL_EVENT:
       NumImportedEvents++;
       Im.Event.Attribute = readVarint32(Ctx);
       Im.Event.SigIndex = readVarint32(Ctx);
       break;
     default:
-      return make_error<GenericBinaryError>("Unexpected import kind",
+      return make_error<GenericBinaryError>("unexpected import kind",
                                             object_error::parse_failed);
     }
     Imports.push_back(Im);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Import section ended prematurely",
+    return make_error<GenericBinaryError>("import section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   FunctionTypes.reserve(Count);
   Functions.resize(Count);
   uint32_t NumTypes = Signatures.size();
   while (Count--) {
     uint32_t Type = readVaruint32(Ctx);
     if (Type >= NumTypes)
-      return make_error<GenericBinaryError>("Invalid function type",
+      return make_error<GenericBinaryError>("invalid function type",
                                             object_error::parse_failed);
     FunctionTypes.push_back(Type);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Function section ended prematurely",
+    return make_error<GenericBinaryError>("function section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
   TableSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Tables.reserve(Count);
   while (Count--) {
     wasm::WasmTable T;
     T.Type = readTableType(Ctx);
     T.Index = NumImportedTables + Tables.size();
     Tables.push_back(T);
     auto ElemType = Tables.back().Type.ElemType;
     if (ElemType != wasm::WASM_TYPE_FUNCREF &&
         ElemType != wasm::WASM_TYPE_EXTERNREF) {
-      return make_error<GenericBinaryError>("Invalid table element type",
+      return make_error<GenericBinaryError>("invalid table element type",
                                             object_error::parse_failed);
     }
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Table section ended prematurely",
+    return make_error<GenericBinaryError>("table section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseMemorySection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   Memories.reserve(Count);
   while (Count--) {
     auto Limits = readLimits(Ctx);
     if (Limits.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
       HasMemory64 = true;
     Memories.push_back(Limits);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Memory section ended prematurely",
+    return make_error<GenericBinaryError>("memory section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseEventSection(ReadContext &Ctx) {
   EventSection = Sections.size();
   uint32_t Count = readVarint32(Ctx);
   Events.reserve(Count);
   while (Count--) {
     wasm::WasmEvent Event;
     Event.Index = NumImportedEvents + Events.size();
     Event.Type.Attribute = readVaruint32(Ctx);
     Event.Type.SigIndex = readVarint32(Ctx);
     Events.push_back(Event);
   }
 
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Event section ended prematurely",
+    return make_error<GenericBinaryError>("event section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseGlobalSection(ReadContext &Ctx) {
   GlobalSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Globals.reserve(Count);
   while (Count--) {
     wasm::WasmGlobal Global;
     Global.Index = NumImportedGlobals + Globals.size();
     Global.Type.Type = readUint8(Ctx);
     Global.Type.Mutable = readVaruint1(Ctx);
     if (Error Err = readInitExpr(Global.InitExpr, Ctx))
       return Err;
     Globals.push_back(Global);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Global section ended prematurely",
+    return make_error<GenericBinaryError>("global section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   Exports.reserve(Count);
   for (uint32_t I = 0; I < Count; I++) {
     wasm::WasmExport Ex;
     Ex.Name = readString(Ctx);
     Ex.Kind = readUint8(Ctx);
     Ex.Index = readVaruint32(Ctx);
     switch (Ex.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
 
       if (!isDefinedFunctionIndex(Ex.Index))
-        return make_error<GenericBinaryError>("Invalid function export",
+        return make_error<GenericBinaryError>("invalid function export",
                                               object_error::parse_failed);
       getDefinedFunction(Ex.Index).ExportName = Ex.Name;
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
       if (!isValidGlobalIndex(Ex.Index))
-        return make_error<GenericBinaryError>("Invalid global export",
+        return make_error<GenericBinaryError>("invalid global export",
                                               object_error::parse_failed);
       break;
     case wasm::WASM_EXTERNAL_EVENT:
       if (!isValidEventIndex(Ex.Index))
-        return make_error<GenericBinaryError>("Invalid event export",
+        return make_error<GenericBinaryError>("invalid event export",
                                               object_error::parse_failed);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
     case wasm::WASM_EXTERNAL_TABLE:
       break;
     default:
-      return make_error<GenericBinaryError>("Unexpected export kind",
+      return make_error<GenericBinaryError>("unexpected export kind",
                                             object_error::parse_failed);
     }
     Exports.push_back(Ex);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Export section ended prematurely",
+    return make_error<GenericBinaryError>("export section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
   return Index < NumImportedFunctions + FunctionTypes.size();
 }
 

 wasm::WasmEvent &WasmObjectFile::getDefinedEvent(uint32_t Index) {
   assert(isDefinedEventIndex(Index));
   return Events[Index - NumImportedEvents];
 }
 
 Error WasmObjectFile::parseStartSection(ReadContext &Ctx) {
   StartFunction = readVaruint32(Ctx);
   if (!isValidFunctionIndex(StartFunction))
-    return make_error<GenericBinaryError>("Invalid start function",
+    return make_error<GenericBinaryError>("invalid start function",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
   SeenCodeSection = true;
   CodeSection = Sections.size();
   uint32_t FunctionCount = readVaruint32(Ctx);
   if (FunctionCount != FunctionTypes.size()) {
-    return make_error<GenericBinaryError>("Invalid function count",
+    return make_error<GenericBinaryError>("invalid function count",
                                           object_error::parse_failed);
   }
 
   for (uint32_t i = 0; i < FunctionCount; i++) {
     wasm::WasmFunction& Function = Functions[i];
     const uint8_t *FunctionStart = Ctx.Ptr;
     uint32_t Size = readVaruint32(Ctx);
     const uint8_t *FunctionEnd = Ctx.Ptr + Size;
for (uint32_t i = 0; i < FunctionCount; i++) {
     uint32_t BodySize = FunctionEnd - Ctx.Ptr;
     Function.Body = ArrayRef<uint8_t>(Ctx.Ptr, BodySize);
     // This will be set later when reading in the linking metadata section.
     Function.Comdat = UINT32_MAX;
     Ctx.Ptr += BodySize;
     assert(Ctx.Ptr == FunctionEnd);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Code section ended prematurely",
+    return make_error<GenericBinaryError>("code section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseElemSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   ElemSegments.reserve(Count);
   while (Count--) {
     wasm::WasmElemSegment Segment;
     Segment.TableIndex = readVaruint32(Ctx);
     if (Segment.TableIndex != 0) {
-      return make_error<GenericBinaryError>("Invalid TableIndex",
+      return make_error<GenericBinaryError>("invalid TableIndex",
                                             object_error::parse_failed);
     }
     if (Error Err = readInitExpr(Segment.Offset, Ctx))
       return Err;
     uint32_t NumElems = readVaruint32(Ctx);
     while (NumElems--) {
       Segment.Functions.push_back(readVaruint32(Ctx));
     }
     ElemSegments.push_back(Segment);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Elem section ended prematurely",
+    return make_error<GenericBinaryError>("elem section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseDataSection(ReadContext &Ctx) {
   DataSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   if (DataCount && Count != DataCount.getValue())
     return make_error<GenericBinaryError>(
-        "Number of data segments does not match DataCount section");
+        "number of data segments does not match DataCount section");
   DataSegments.reserve(Count);
   while (Count--) {
     WasmSegment Segment;
     Segment.Data.InitFlags = readVaruint32(Ctx);
     Segment.Data.MemoryIndex =
         (Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
             ? readVaruint32(Ctx)
             : 0;
     if ((Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
       if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
         return Err;
     } else {
       Segment.Data.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
       Segment.Data.Offset.Value.Int32 = 0;
     }
     uint32_t Size = readVaruint32(Ctx);
     if (Size > (size_t)(Ctx.End - Ctx.Ptr))
-      return make_error<GenericBinaryError>("Invalid segment size",
+      return make_error<GenericBinaryError>("invalid segment size",
                                             object_error::parse_failed);
     Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
     // The rest of these Data fields are set later, when reading in the linking
     // metadata section.
     Segment.Data.Alignment = 0;
     Segment.Data.LinkerFlags = 0;
     Segment.Data.Comdat = UINT32_MAX;
     Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
     Ctx.Ptr += Size;
     DataSegments.push_back(Segment);
   }
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("Data section ended prematurely",
+    return make_error<GenericBinaryError>("data section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseDataCountSection(ReadContext &Ctx) {
   DataCount = readVaruint32(Ctx);
   return Error::success();
 }
WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return SymbolRef::ST_Debug;
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return SymbolRef::ST_Other;
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return SymbolRef::ST_Other;
   }
 
-  llvm_unreachable("Unknown WasmSymbol::SymbolType");
+  llvm_unreachable("unknown WasmSymbol::SymbolType");
   return SymbolRef::ST_Other;
 }
 
 Expected<section_iterator>
 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
   const WasmSymbol &Sym = getWasmSymbol(Symb);
   if (Sym.isUndefined())
     return section_end();
case wasm::WASM_SYMBOL_TYPE_DATA:
     return DataSection;
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return EventSection;
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return TableSection;
   default:
-    llvm_unreachable("Unknown WasmSymbol::SymbolType");
+    llvm_unreachable("unknown WasmSymbol::SymbolType");
   }
 }
 
 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
 
 Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {
   const WasmSection &S = Sections[Sec.d.a];
 #define ECase(X)                                                               \

llvm/test/Object/wasm-bad-metadata-version.yaml

 # RUN: yaml2obj %s | not llvm-objdump -h - 2>&1 | FileCheck %s
 
 !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            CUSTOM
     Name:            linking
     Version:         0
 
-# CHECK: {{.*}}: Unexpected metadata version: 0 (Expected: 2)
+# CHECK: {{.*}}: unexpected metadata version: 0 (Expected: 2)

llvm/test/Object/wasm-bad-reloc-type.test

 RUN: not llvm-objdump -s %p/Inputs/WASM/bad-reloc-type.wasm 2>&1 | FileCheck %s
 
-CHECK: Bad relocation type: 63
+CHECK: invalid relocation type: 63

llvm/test/Object/wasm-bad-symbol-type.test

 RUN: not llvm-objdump -s %p/Inputs/WASM/bad-symbol-type.wasm 2>&1 | FileCheck %s
 
-CHECK: Invalid symbol type: 63
+CHECK: invalid symbol type: 63

llvm/test/Object/wasm-duplicate-name.test

- Type:            CUSTOM
     Name:            name
     FunctionNames:
       - Index:         0
         Name:          a
       - Index:         0
         Name:          b
 ...
 
-# CHECK: {{.*}}: Function named more than once
+# CHECK: {{.*}}: function named more than once

llvm/test/Object/wasm-invalid-file.yaml

 # RUN: yaml2obj %s -o %t.wasm
 # RUN: echo -e -n "\x01" >> %t.wasm
 # Append a new section but truncate the encoding of the section size
 # RUN: not --crash llvm-objdump -h %t.wasm 2>&1 | FileCheck %s -check-prefix=CHECK-LEB-DECODE
 
 !WASM
 FileHeader:
   Version:         0x00000001
 
 # CHECK-LEB-DECODE: malformed uleb128, extends past end
 
 # RUN: echo -en "\x99hello" >> %t.wasm
 # Append a section size that extends beyond the end of the file
 # RUN: not llvm-objdump -h %t.wasm 2>&1 | FileCheck %s -check-prefix=CHECK-SECTION-SIZE
 
-# CHECK-SECTION-SIZE: '{{.*}}.wasm': Section too large
+# CHECK-SECTION-SIZE: '{{.*}}.wasm': section too large
 
 # RUN: yaml2obj %s -o %t.wasm
 # # Append an section with invalid type (type 0x20, size 0x1, content 0x0)
 # RUN: echo -e -n "\x20\x01\x00" >> %t.wasm
 # RUN: not llvm-objdump -h %t.wasm 2>&1 | FileCheck %s -check-prefix=CHECK-SECTION-TYPE
-# CHECK-SECTION-TYPE: '{{.*}}.wasm': Invalid section type: 32
+# CHECK-SECTION-TYPE: '{{.*}}.wasm': invalid section type: 32

llvm/test/Object/wasm-invalid-section-order.test

 # RUN: not obj2yaml %p/Inputs/WASM/invalid-section-order.wasm 2>&1 | FileCheck %s
-# CHECK: {{.*}}: Out of order section type: 10
+# CHECK: {{.*}}: out of order section type: 10
 
 # Inputs/WASM/invalid-section-order.wasm is generated from this ll file, by
 # modifying WasmObjectWriter to incorrectly write the data section before the
 # code section.
 #
 # target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 # target triple = "wasm32-unknown-unknown"
 #
 # @data = global i32 0, align 4
 #
 # define void @foo() {
 # entry:
 #   ret void
 # }

llvm/test/Object/wasm-invalid-start.test

 # RUN: yaml2obj %s | not llvm-objdump -h - 2>&1 | FileCheck %s
 
 !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            START
     StartFunction:   0
 
-# CHECK: {{.*}}: Invalid start function
+# CHECK: {{.*}}: invalid start function

llvm/test/Object/wasm-missing-version.test

 # RUN: not llvm-objdump -h %p/Inputs/WASM/missing-version.wasm 2>&1 | FileCheck %s
-# CHECK: {{.*}}: Missing version number
+# CHECK: {{.*}}: missing version number

llvm/test/ObjectYAML/wasm/header_invalid_version.yaml

 # RUN: yaml2obj %s | not obj2yaml 2>&1 | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000002
 ...
-# CHECK: Error reading file: <stdin>: Bad version number
+# CHECK: Error reading file: <stdin>: invalid version number: 2

llvm/test/ObjectYAML/wasm/invalid_export.yaml

 # RUN: yaml2obj < %s | not obj2yaml 2>&1 | FileCheck %s
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            EXPORT
     Exports:
       - Name:            invalid_function_index
         Kind:            FUNCTION
         Index:           0x00000001
 
-# CHECK: Error reading file: <stdin>: Invalid function export
+# CHECK: Error reading file: <stdin>: invalid function export

llvm/test/ObjectYAML/wasm/producers_section_repeat.yaml

 # RUN: yaml2obj %s | not obj2yaml 2>&1 | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            CUSTOM
     Name:            producers
     Languages:
       - Name:        C++
         Version:     C++11
       - Name:        C++
         Version:     C++17
 ...
-# CHECK:  Producers section contains repeated producer
+# CHECK: producers section contains repeated producer

llvm/test/tools/llvm-objdump/wasm/wasm-corrupt-section.test

 # RUN: not llvm-objdump -h %p/Inputs/corrupt-section.wasm 2>&1 | FileCheck %s
-# CHECK: '{{.*}}corrupt-section.wasm': Section too large
+# CHECK: '{{.*}}corrupt-section.wasm': section too large

llvm/test/tools/llvm-readobj/wasm/wasm-invalid.test

 # RUN: yaml2obj %s | not llvm-readobj --symbols - 2>&1 | FileCheck %s
 
 --- !WASM
 FileHeader:
   Version:         0x0000000c
 
-# CHECK: error: '<stdin>': Bad version number
+# CHECK: error: '<stdin>': invalid version number: 12