Update WindowsResource to provide parsing and writing for accelerators.

[ecbeckmann]

Summary

first patch

llvm/include/llvm/Object/WindowsResource.h

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 
+#include <unordered_map>
+
 namespace llvm {
 namespace object {
 
 class WindowsResource;
 
 class ResourceEntryRef {
 public:
   Error moveNext(bool &End);
+  Error getType(uint16_t &Type);
+  Error checkNameString(bool &isString);
 
 private:
   friend class WindowsResource;
 
   ResourceEntryRef(BinaryStreamRef Ref, const WindowsResource *Owner,
                    Error &Err);
+
   Error loadNext();
 
   BinaryStreamReader Reader;
   BinaryStreamRef HeaderBytes;
   BinaryStreamRef DataBytes;
   const WindowsResource *OwningRes = nullptr;
 };
 

 private:
   friend class ResourceEntryRef;
 
   WindowsResource(MemoryBufferRef Source);
 
   BinaryByteStream BBS;
 };
 
+class WindowsResourceParser {
+public:
+  Parser();
+
+  Error parse(std::unique_ptr<object::Binary> Bin);
+
+private:
+  class TreeNode {
+  public:
+    explicit TreeNode(uint32_t ID)
+      : ID(ID), Name("") {}
+    TreeNode& addChild(uint32_t ID) {
+      auto Child = Children.find(ID);
+      if ( Child == Children.end()) {
+        struct TreeNode NewChild(ID);
+        Child = Children.insert(std::make_pair<unsigned, TreeNode>(ID, NewChild));
+      }
+      return *Child;
+    }
+
+  private:
+    uint32_t ID;
+    std::string Name;
+    std::unordered_map<unsigned, struct TreeNode> Children;
+
+  };
+
+  TreeNode Root;
+};
+
 } // namespace object
 } // namespace llvm
 
 #endif

llvm/lib/Object/WindowsResource.cpp

 //===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the .res file class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Object/Error.h"
+#include "llvm/Support/COFF.h"
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
 static const size_t ResourceMagicSize = 16;
 
 static const size_t NullEntrySize = 16;
if (Reader.bytesRemaining() == 0) {
     End = true;
     return Error::success();
   }
   RETURN_IF_ERROR(loadNext());
 
   return Error::success();
 }
 
+Error ResourceEntryRef::getType(uint16_t &TypeID) {
+  BinaryStreamReader TypeReader(HeaderBytes);
+  RETURN_IF_ERROR(TypeReader.skip(sizeof(uint16_t)));
+  RETURN_IF_ERROR(TypeReader.readInteger(TypeID));
+}
+
+Error ResourceEntryRef::checkNameString(bool &isString) {
+  BinaryStreamReader NameChecker(HeaderBytes);
+  RETURN_IF_ERROR(NameChecker.skip(4));
+  uint16_t IDFlag;
+  RETURN_IF_ERROR(NameChecker.readInteger(IDFlag));
+  if (IDFlag == 0xffff)
+    isString = false;
+  else
+    isString = true;
+  return Error::success();
+}
+
 Error ResourceEntryRef::loadNext() {
   uint32_t DataSize;
   RETURN_IF_ERROR(Reader.readInteger(DataSize));
   uint32_t HeaderSize;
   RETURN_IF_ERROR(Reader.readInteger(HeaderSize));
   // The data and header size ints are themselves part of the header, so we must
   // subtract them from the size.
   RETURN_IF_ERROR(
       Reader.readStreamRef(HeaderBytes, HeaderSize - 2 * sizeof(uint32_t)));
   RETURN_IF_ERROR(Reader.readStreamRef(DataBytes, DataSize));
   RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t)));
   return Error::success();
 }
 
+WindowsResourceParser::WindowsResourceParser() {
+}
+
+Error WindowsResourceParser::parse(std::unique_ptr<object::Binary> Bin) {
+  WindowsResource *RF = dyn_cast<WindowsResource>(Bin.get());
+  if (!RF) {
+    return make_error<GenericBinaryError>("Parser not given valid resource file!",
+                                         object_error::invalid_file_type);
+  }
+
+  auto EntryOrErr = RF->getHeadEntry();
+  if (!EntryOrErr)
+    return EntryOrErr.takeError();
+
+  ResourceEntryRef Entry = EntryOrErr.get();
+  bool End = false;
+
+  while (!End) {
+    uint16_t Type = Entry.getType();
+    TreeNode& TypeNode = Root.addChild(Type);
+
+    bool IsStringName;
+    RETURN_IF_ERROR(Entry.checkNameString(IsStringName));
+  }
+
+  return Error::success();
+}
+
 } // namespace object
 } // namespace llvm

llvm/tools/llvm-cvtres/llvm-cvtres.cpp

int main(int argc_, const char *argv_[]) {
 
   if (InputArgs.hasArg(OPT_OUT)) {
     OutputFile = InputArgs.getLastArgValue(OPT_OUT);
   } else {
     OutputFile = StringRef(InputFiles[0]);
     llvm::sys::path::replace_extension(OutputFile, ".obj");
   }
 
+  outs() << "Machine: ";
+  switch (Machine) {
+  case machine::ARM:
+    outs() << "ARM\n";
+    break;
+  case machine::X86:
+    outs() << "X86\n";
+    break;
+  default:
+    outs() << "X64\n";
+  }
+
+
+  WindowsResourceParser Parser();
+
   for (const auto &File : InputFiles) {
-    Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
+    Expected<std::unique_ptr<object::Binary>> BinaryOrErr =
         object::createBinary(File);
     if (!BinaryOrErr)
       reportError(File, errorToErrorCode(BinaryOrErr.takeError()));
 
-    Binary &Binary = *BinaryOrErr.get().getBinary();
+    Binary &Binary = BinaryOrErr.get()->getBinary();
 
     WindowsResource *RF = dyn_cast<WindowsResource>(&Binary);
     if (!RF)
       reportError(File + ": unrecognized file format.\n");
 
     int EntryNumber = 0;
     Expected<ResourceEntryRef> EntryOrErr = RF->getHeadEntry();
     if (!EntryOrErr)
       error(EntryOrErr.takeError());
     ResourceEntryRef Entry = EntryOrErr.get();
     bool End = false;
     while (!End) {
       error(Entry.moveNext(End));
       EntryNumber++;
     }
     outs() << "Number of resources: " << EntryNumber << "\n";
+
+    error(Parser.parse(std::move(BinaryOrErr.get())));
+
   }
-  outs() << "Machine: ";
-  switch (Machine) {
-  case machine::ARM:
-    outs() << "ARM\n";
-    break;
-  case machine::X86:
-    outs() << "X86\n";
-    break;
-  default:
-    outs() << "X64\n";
-  }
+
+  WriteCOFF(&Parser);
+
   return 0;
 }