[yaml2obj] - Don't crash on invalid document.

[grimar]

Summary

Previously jaml2obj would segfault on empty document.
(without yaml description).
Patch fixes the issue.

[davide]

LGTM.

[grimar]

It was reverted because broke BB:
http://lab.llvm.org:8011/builders/llvm-hexagon-elf/builds/9781
Reopening.

[grimar]

• Changed approach to stop breaking tests from Support/YAMLIOTest.cpp.

[ruiu]

lib/ObjectYAML/ObjectYAML.cpp

38

I think this is not correct. You need to set an error because this is an error condition.

[grimar]

• Addressed review comment.

lib/ObjectYAML/ObjectYAML.cpp

38

I was not sure that empty document is an error. But ok, fixed.
In that case "Unknown document type!" message in following method looks excessive:
https://github.com/llvm-mirror/llvm/blob/master/tools/yaml2obj/yaml2obj.cpp#L48

[grimar]

Not sure it was the best approach possible. Abandoning.

lib/ObjectYAML/ObjectYAML.cpp

if (IO.outputting()) {
     if (ObjectFile.MachO)
       MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO);
     if (ObjectFile.FatMachO)
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
   } else {
     if (IO.mapTag("!ELF")) {
       ObjectFile.Elf.reset(new ELFYAML::Object());
       MappingTraits<ELFYAML::Object>::mapping(IO, *ObjectFile.Elf);
     } else if (IO.mapTag("!COFF")) {
       ObjectFile.Coff.reset(new COFFYAML::Object());
       MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff);
     } else if (IO.mapTag("!mach-o")) {
       ObjectFile.MachO.reset(new MachOYAML::Object());
       MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO);
     } else if (IO.mapTag("!fat-mach-o")) {
       ObjectFile.FatMachO.reset(new MachOYAML::UniversalBinary());
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
     } else if (IO.mapTag("!WASM")) {
       ObjectFile.Wasm.reset(new WasmYAML::Object());
       MappingTraits<WasmYAML::Object>::mapping(IO, *ObjectFile.Wasm);
     } else {
       Input &In = (Input &)IO;
-      std::string Tag = In.getCurrentNode()->getRawTag();
+      std::string Tag;
+      if (In.getCurrentNode())
+        Tag = In.getCurrentNode()->getRawTag();
       if (Tag.empty())
         IO.setError("YAML Object File missing document type tag!");
       else
         IO.setError(
             Twine("YAML Object File unsupported document type tag '") +
             Twine(Tag) + Twine("'!"));
     }
   }
 }

lib/Support/YAMLParser.cpp

Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM, bool ShowColors,
                std::error_code *EC)
     : scanner(new Scanner(InputBuffer, SM, ShowColors, EC)), CurrentDoc() {}
 
 Stream::~Stream() = default;
 
 bool Stream::failed() { return scanner->failed(); }
 
 void Stream::printError(Node *N, const Twine &Msg) {
-  scanner->printError( N->getSourceRange().Start
-                     , SourceMgr::DK_Error
-                     , Msg
-                     , N->getSourceRange());
+  scanner->printError(N ? N->getSourceRange().Start : SMLoc(),
+                      SourceMgr::DK_Error, Msg, N ? N->getSourceRange() : None);
 }
 
 document_iterator Stream::begin() {
   if (CurrentDoc)
     report_fatal_error("Can only iterate over the stream once");
 
   // Skip Stream-Start.
   scanner->getNext();

lib/Support/YAMLTraits.cpp

bool Input::nextDocument() {
   return ++DocIterator != Strm->end();
 }
 
 const Node *Input::getCurrentNode() const {
   return CurrentNode ? CurrentNode->_node : nullptr;
 }
 
 bool Input::mapTag(StringRef Tag, bool Default) {
+  if (!CurrentNode)
+    return false;
   std::string foundTag = CurrentNode->_node->getVerbatimTag();
   if (foundTag.empty()) {
     // If no tag found and 'Tag' is the default, say it was found.
     return Default;
   }
   // Return true iff found tag matches supplied tag.
   return Tag.equals(foundTag);
 }
void Input::scalarString(StringRef &S, bool) {
   } else {
     setError(CurrentNode, "unexpected scalar");
   }
 }
 
 void Input::blockScalarString(StringRef &S) { scalarString(S, false); }
 
 void Input::setError(HNode *hnode, const Twine &message) {
-  assert(hnode && "HNode must not be NULL");
-  this->setError(hnode->_node, message);
+  this->setError(hnode ? hnode->_node : (Node *)nullptr, message);
 }
 
 void Input::setError(Node *node, const Twine &message) {
   Strm->printError(node, message);
   EC = make_error_code(errc::invalid_argument);
 }
 
 std::unique_ptr<Input::HNode> Input::createHNodes(Node *N) {

test/Object/yaml2obj-invalid2.yaml

+# RUN: not yaml2obj %s 2>&1 | FileCheck %s
+# CHECK: <unknown>:0: error: YAML Object File missing document type tag!