Add writeAsBinary(raw_ostream &) method to BinaryRef.

Previously, yaml2coff.cpp had a writeHexData static helper function to
do this, but it is generally useful functionality.

Also, validate hex strings up-front to avoid running having to handle
errors "deep inside" the yaml2obj code (it also gives better diagnostics
than it used to).

llvm-svn: 183345

include/llvm/Object/YAML.h

@@ -48,6 +48,9 @@ public:
 
     return Ref.isBinary == isBinary && Ref.Data == Data;
   }
+  /// \brief Write the contents (regardless of whether it is binary or a
+  /// hex string) as binary to the given raw_ostream.
+  void writeAsBinary(raw_ostream &OS) const;
 };
 
 }

lib/Object/YAML.cpp

@@ -13,8 +13,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/YAML.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+using namespace object::yaml;
 
 void yaml::ScalarTraits<object::yaml::BinaryRef>::output(
     const object::yaml::BinaryRef &Val, void *, llvm::raw_ostream &Out) {
@@ -27,8 +29,35 @@ void yaml::ScalarTraits<object::yaml::BinaryRef>::output(
   }
 }
 
+// Can't find this anywhere else in the codebase (clang has one, but it has
+// some baggage). Deduplicate as required.
+static bool isHexDigit(uint8_t C) {
+  return ('0' <= C && C <= '9') ||
+         ('A' <= C && C <= 'F') ||
+         ('a' <= C && C <= 'f');
+}
+
 StringRef yaml::ScalarTraits<object::yaml::BinaryRef>::input(
     StringRef Scalar, void *, object::yaml::BinaryRef &Val) {
+  if (Scalar.size() % 2 != 0)
+    return "BinaryRef hex string must contain an even number of nybbles.";
+  // TODO: Can we improve YAMLIO to permit a more accurate diagnostic here?
+  // (e.g. a caret pointing to the offending character).
+  for (unsigned I = 0, N = Scalar.size(); I != N; ++I)
+    if (!isHexDigit(Scalar[I]))
+      return "BinaryRef hex string must contain only hex digits.";
   Val = object::yaml::BinaryRef(Scalar);
   return StringRef();
 }
+
+void BinaryRef::writeAsBinary(raw_ostream &OS) const {
+  if (isBinary) {
+    OS.write((const char *)Data.data(), Data.size());
+    return;
+  }
+  for (unsigned I = 0, N = Data.size(); I != N; I += 2) {
+    uint8_t Byte;
+    StringRef((const char *)&Data[I],  2).getAsInteger(16, Byte);
+    OS.write(Byte);
+  }
+}

tools/yaml2obj/yaml2coff.cpp

@@ -195,21 +195,6 @@ binary_le_impl<value_type> binary_le(value_type V) {
   return binary_le_impl<value_type>(V);
 }
 
-static bool writeHexData(StringRef Data, raw_ostream &OS) {
-  unsigned Size = Data.size();
-  if (Size % 2)
-    return false;
-
-  for (unsigned I = 0; I != Size; I += 2) {
-    uint8_t Byte;
-    if (Data.substr(I,  2).getAsInteger(16, Byte))
-      return false;
-    OS.write(Byte);
-  }
-
-  return true;
-}
-
 bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
   OS << binary_le(CP.Obj.Header.Machine)
      << binary_le(CP.Obj.Header.NumberOfSections)
@@ -239,13 +224,7 @@ bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
   for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
                                                 e = CP.Obj.Sections.end();
                                                 i != e; ++i) {
-    StringRef SecData = i->SectionData.getHex();
-    if (!SecData.empty()) {
-      if (!writeHexData(SecData, OS)) {
-        errs() << "SectionData must be a collection of pairs of hex bytes";
-        return false;
-      }
-    }
+    i->SectionData.writeAsBinary(OS);
     for (unsigned I2 = 0, E2 = i->Relocations.size(); I2 != E2; ++I2) {
       const COFF::relocation &R = i->Relocations[I2];
       OS << binary_le(R.VirtualAddress)
@@ -265,13 +244,7 @@ bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
        << binary_le(i->Header.Type)
        << binary_le(i->Header.StorageClass)
        << binary_le(i->Header.NumberOfAuxSymbols);
-    StringRef Data = i->AuxiliaryData.getHex();
-    if (!Data.empty()) {
-      if (!writeHexData(Data, OS)) {
-        errs() << "AuxiliaryData must be a collection of pairs of hex bytes";
-        return false;
-      }
-    }
+    i->AuxiliaryData.writeAsBinary(OS);
   }
 
   // Output string table.