[lib/ObjectYAML] - Change interface to return `bool` instead of `int`. NFCI.

[grimar]

Summary

It was suggested in comments for D67445 to split this part.

[jhenderson]

LGTM.

[sbc100]

lib/ObjectYAML/yaml2obj.cpp

20

Is this comment still useful?

[grimar]

lib/ObjectYAML/yaml2obj.cpp

20

No, since D67445 introduced a different aproach and that is why I removed it.

include/llvm/ObjectYAML/yaml2obj.h

 namespace WasmYAML {
 struct Object;
 }
 
 namespace yaml {
 class Input;
 struct YamlObjectFile;
 
-int yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out);
-int yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out);
-int yaml2macho(YamlObjectFile &Doc, raw_ostream &Out);
-int yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out);
-int yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out);
+bool yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out);
+bool yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out);
+bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out);
+bool yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out);
+bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out);
 
 Error convertYAML(Input &YIn, raw_ostream &Out, unsigned DocNum = 1);
 
 /// Convenience function for tests.
 Expected<std::unique_ptr<object::ObjectFile>>
 yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml);
 
 } // namespace yaml
 } // namespace llvm
 
 #endif

lib/ObjectYAML/COFFEmitter.cpp

static bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
   if (CP.Obj.Header.PointerToSymbolTable)
     OS.write(&CP.StringTable[0], CP.StringTable.size());
   return true;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out) {
+bool yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out) {
   COFFParser CP(Doc);
   if (!CP.parse()) {
     errs() << "yaml2obj: Failed to parse YAML file!\n";
-    return 1;
+    return false;
   }
 
   if (!layoutOptionalHeader(CP)) {
     errs() << "yaml2obj: Failed to layout optional header for COFF file!\n";
-    return 1;
+    return false;
   }
 
   if (!layoutCOFF(CP)) {
     errs() << "yaml2obj: Failed to layout COFF file!\n";
-    return 1;
+    return false;
   }
   if (!writeCOFF(CP, Out)) {
     errs() << "yaml2obj: Failed to write COFF file!\n";
-    return 1;
+    return false;
   }
-  return 0;
+  return true;
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
   ELFState(ELFYAML::Object &D);
 public:
-  static int writeELF(raw_ostream &OS, ELFYAML::Object &Doc);
+  static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc);
 };
 } // end anonymous namespace
 
 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
   return A.size() * sizeof(T);
 }
 
 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
           DotDynstr.add(Name);
     }
   }
 
   DotDynstr.finalize();
 }
 
 template <class ELFT>
-int ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
+bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
   ELFState<ELFT> State(Doc);
 
   // Finalize .strtab and .dynstr sections. We do that early because want to
   // finalize the string table builders before writing the content of the
   // sections that might want to use them.
   State.finalizeStrings();
 
   State.buildSectionIndex();
bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
 
   std::vector<Elf_Shdr> SHeaders;
   State.initSectionHeaders(SHeaders, CBA);
 
   // Now we can decide segment offsets
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
   if (State.HasError)
-    return 1;
+    return false;
 
   State.writeELFHeader(CBA, OS);
   writeArrayData(OS, makeArrayRef(PHeaders));
   CBA.writeBlobToStream(OS);
   writeArrayData(OS, makeArrayRef(SHeaders));
-  return 0;
+  return true;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out) {
+bool yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out) {
   bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
   bool Is64Bit = Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
   if (Is64Bit) {
     if (IsLE)
       return ELFState<object::ELF64LE>::writeELF(Out, Doc);
     return ELFState<object::ELF64BE>::writeELF(Out, Doc);
   }
   if (IsLE)
     return ELFState<object::ELF32LE>::writeELF(Out, Doc);
   return ELFState<object::ELF32BE>::writeELF(Out, Doc);
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/MachOEmitter.cpp

if (currOffset < Offset)
     ZeroFillBytes(OS, Offset - currOffset);
 }
 
 } // end anonymous namespace
 
 namespace llvm {
 namespace yaml {
 
-int yaml2macho(YamlObjectFile &Doc, raw_ostream &Out) {
+bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out) {
   UniversalWriter Writer(Doc);
   if (auto Err = Writer.writeMachO(Out)) {
     errs() << toString(std::move(Err));
-    return 1;
+    return false;
   }
-  return 0;
+  return true;
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/MinidumpEmitter.cpp

static Directory layout(BlobAllocator &File, Stream &S) {
   Result.Location.DataSize =
       DataEnd.getValueOr(File.tell()) - Result.Location.RVA;
   return Result;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2minidump(MinidumpYAML::Object &Obj, raw_ostream &Out) {
+bool yaml2minidump(MinidumpYAML::Object &Obj, raw_ostream &Out) {
   BlobAllocator File;
   File.allocateObject(Obj.Header);
 
   std::vector<Directory> StreamDirectory(Obj.Streams.size());
   Obj.Header.StreamDirectoryRVA =
       File.allocateArray(makeArrayRef(StreamDirectory));
   Obj.Header.NumberOfStreams = StreamDirectory.size();
 
   for (auto &Stream : enumerate(Obj.Streams))
     StreamDirectory[Stream.index()] = layout(File, *Stream.value());
 
   File.writeTo(Out);
-  return 0;
+  return true;
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/WasmEmitter.cpp

 using namespace llvm;
 
 namespace {
 /// This parses a yaml stream that represents a Wasm object file.
 /// See docs/yaml2obj for the yaml scheema.
 class WasmWriter {
 public:
   WasmWriter(WasmYAML::Object &Obj) : Obj(Obj) {}
-  int writeWasm(raw_ostream &OS);
+  bool writeWasm(raw_ostream &OS);
 
 private:
   int writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
                         uint32_t SectionIndex);
 
   int writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
for (auto Reloc : Sec.Relocations) {
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
     case wasm::R_WASM_SECTION_OFFSET_I32:
       encodeULEB128(Reloc.Addend, OS);
     }
   }
   return 0;
 }
 
-int WasmWriter::writeWasm(raw_ostream &OS) {
+bool WasmWriter::writeWasm(raw_ostream &OS) {
   // Write headers
   OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
   writeUint32(OS, Obj.Header.Version);
 
   // Write each section
   llvm::object::WasmSectionOrderChecker Checker;
   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     StringRef SecName = "";
     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
       SecName = S->Name;
     if (!Checker.isValidSectionOrder(Sec->Type, SecName)) {
       errs() << "Out of order section type: " << Sec->Type << "\n";
-      return 1;
+      return false;
     }
     encodeULEB128(Sec->Type, OS);
     std::string OutString;
     raw_string_ostream StringStream(OutString);
     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get())) {
       if (auto Err = writeSectionContent(StringStream, *S))
         return Err;
     } else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get())) {
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     } else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get())) {
       if (auto Err = writeSectionContent(StringStream, *S))
         return Err;
     } else if (auto S = dyn_cast<WasmYAML::DataCountSection>(Sec.get())) {
       if (auto Err = writeSectionContent(StringStream, *S))
         return Err;
     } else {
       errs() << "Unknown section type: " << Sec->Type << "\n";
-      return 1;
+      return false;
     }
     StringStream.flush();
 
     // Write the section size followed by the content
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }
 
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     raw_string_ostream StringStream(OutString);
     writeRelocSection(StringStream, *Sec, SectionIndex++);
     StringStream.flush();
 
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }
 
-  return 0;
+  return true;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out) {
+bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out) {
   WasmWriter Writer(Doc);
-
   return Writer.writeWasm(Out);
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/yaml2obj.cpp

 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/YAMLTraits.h"
 
 namespace llvm {
 namespace yaml {
 
 Error convertYAML(yaml::Input &YIn, raw_ostream &Out, unsigned DocNum) {
-  // TODO: make yaml2* functions return Error instead of int.
-  auto IntToErr = [](int Ret) -> Error {
-    if (Ret)
+  auto BoolToErr = [](bool Ret) -> Error {
+    if (!Ret)
       return createStringError(errc::invalid_argument, "yaml2obj failed");
     return Error::success();
   };
 
   unsigned CurDocNum = 0;
   do {
     if (++CurDocNum == DocNum) {
       yaml::YamlObjectFile Doc;
       YIn >> Doc;
       if (std::error_code EC = YIn.error())
         return createStringError(EC, "Failed to parse YAML input!");
       if (Doc.Elf)
-        return IntToErr(yaml2elf(*Doc.Elf, Out));
+        return BoolToErr(yaml2elf(*Doc.Elf, Out));
       if (Doc.Coff)
-        return IntToErr(yaml2coff(*Doc.Coff, Out));
+        return BoolToErr(yaml2coff(*Doc.Coff, Out));
       if (Doc.MachO || Doc.FatMachO)
-        return IntToErr(yaml2macho(Doc, Out));
+        return BoolToErr(yaml2macho(Doc, Out));
       if (Doc.Minidump)
-        return IntToErr(yaml2minidump(*Doc.Minidump, Out));
+        return BoolToErr(yaml2minidump(*Doc.Minidump, Out));
       if (Doc.Wasm)
-        return IntToErr(yaml2wasm(*Doc.Wasm, Out));
+        return BoolToErr(yaml2wasm(*Doc.Wasm, Out));
       return createStringError(errc::invalid_argument,
                                "Unknown document type!");
     }
   } while (YIn.nextDocument());
 
   return createStringError(errc::invalid_argument,
                            "Cannot find the %u%s document", DocNum,
                            getOrdinalSuffix(DocNum).data());