llvm-mt: handle initial merge, not considering namespaces.

[ecbeckmann]

Summary

This patch does a simple merge, where "mergeable" elements are combined, and
all others are simply appended. This does not yet apply the tricky namespace
rules.

[ecbeckmann]

Diff against correct patch.

[ecbeckmann]

Diffed against wrong base patch

llvm/cmake/config-ix.cmake

else()
       else()
         message(STATUS "OCaml bindings disabled, need ctypes >=0.4.")
       endif()
     endif()
   endif()
 endif()
 
 string(REPLACE " " ";" LLVM_BINDINGS_LIST "${LLVM_BINDINGS}")
+
+if (NOT LIBXML2_FOUND AND NOT LLVM_DISABLE_LIBXML2 AND NOT (CMAKE_SYSTEM_NAME MATCHES "Windows"))
+  find_package(LibXml2)
+endif()
+
+if (LIBXML2_FOUND AND NOT LLVM_DISABLE_LIBXML2)
+  add_definitions( -DLIBXML2_ENABLED )
+  list(APPEND CMAKE_REQUIRED_LIBRARIES ${LIBXML2_LIBRARIES})
+  include_directories(${LIBXML2_INCLUDE_DIR})
+endif()

llvm/include/llvm/Support/WindowsManifestMerger.h

 #include "llvm/Support/Error.h"
 
 #if LLVM_LIBXML2_ENABLED
 #include <libxml/xmlreader.h>
 #endif
 
 namespace llvm {
 
+static const char * const MT_Strings[] {
+  "application",
+  "assemblyIdentity",
+  "compatibility",
+  "noInherit",
+  "requestedExecutionLevel",
+  "requestedPrivileges",
+  "security",
+  "trustInfo",
+};
+
+static const std::vector<std::string> MTMergeableElements(MT_Strings, std::end(MT_Strings));
+
 class MemoryBuffer;
 
 #if LLVM_LIBXML2_ENABLED
 typedef xmlDocPtr XMLDocumentImpl;
 typedef xmlNodePtr XMLNodeImpl;
 #else
 typedef void *XMLDocumentImpl;
 typedef void *XMLNodeImpl;
 #endif
 
 class WindowsManifestError : public ErrorInfo<WindowsManifestError, ECError> {
 public:
   static char ID;
   WindowsManifestError(const Twine &Msg);
+  WindowsManifestError(const Twine &Prefix, const Twine &Message);
   void log(raw_ostream &OS) const override;
 
 private:
   std::string Msg;
 };
 
 class WindowsManifestMerger {
 public:

llvm/lib/Support/CMakeLists.txt

elseif( CMAKE_HOST_UNIX )
   if( UNIX AND NOT (BEOS OR HAIKU) )
     set(system_libs ${system_libs} m)
   endif()
   if( LLVM_LIBXML2_ENABLED )
     set(system_libs ${system_libs} ${LIBXML2_LIBS})
   endif()
 endif( MSVC OR MINGW )
 
+set(system_libs ${system_libs} ${LIBXML2_LIBRARIES})
+
 add_llvm_library(LLVMSupport
   AMDGPUCodeObjectMetadata.cpp
   APFloat.cpp
   APInt.cpp
   APSInt.cpp
   ARMBuildAttrs.cpp
   ARMAttributeParser.cpp
   ARMWinEH.cpp

llvm/lib/Support/WindowsManifestMerger.cpp

 //
 //===---------------------------------------------------------------------===//
 
 #include "llvm/Support/WindowsManifestMerger.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <stdarg.h>
 
+using namespace llvm;
+
 namespace llvm {
 
   char WindowsManifestError::ID = 0;
 
   WindowsManifestError::WindowsManifestError(const Twine &Msg) : Msg(Msg.str()) {}
 
+  WindowsManifestError::WindowsManifestError(const Twine &Prefix, const Twine &Message) : Msg((Prefix.concat(Message)).str()) {}
+
   void WindowsManifestError::log(raw_ostream &OS) const { OS << Msg; }
 
+  bool isMergeableElement(const unsigned char* ElementName) {
+  //outs() << "Check if " << std::string(reinterpret_cast<const char *>(ElementName)) << " is mergeable\n";
+    bool result = std::find(MTMergeableElements.begin(), MTMergeableElements.end(), std::string(reinterpret_cast<const char *>(ElementName))) != MTMergeableElements.end();
+  //outs() << "result = " << result << "\n";
+    return result;
+  }
+
+  XMLNodeImpl hasChildWithName(XMLNodeImpl Parent, const unsigned char* ElementName) {
+  #if defined(LIBXML2_ENABLED)
+    for (XMLNodeImpl Child = Parent->children ; Child; Child = Child->next)
+      if (strcmp(reinterpret_cast<const char *>(Child->name), reinterpret_cast<const char *>(ElementName)) == 0) {
+        outs() << "found child with name " << std::string(reinterpret_cast<const char *>(ElementName)) << "\n";
+        return Child;
+      }
+  #endif
+      return nullptr;
+    }
+
+    const unsigned char* hasAttribute(XMLNodeImpl Node, const unsigned char* AttributeName) {
+  #if defined(LIBXML2_ENABLED)
+      for (xmlAttrPtr Attribute = Node->properties; Attribute != nullptr; Attribute = Attribute->next) {
+        if (strcmp(reinterpret_cast<const char *>(Attribute->name), reinterpret_cast<const char *>(AttributeName)) == 0) return Attribute->children->content;
+      }
+  #endif
+      return nullptr;
+    }
+
+    Error mergeAttributes(XMLNodeImpl OriginalNode, XMLNodeImpl AdditionalNode) {
+  #if defined(LIBXML2_ENABLED)
+      for (xmlAttrPtr Attribute = AdditionalNode->properties; Attribute != nullptr; Attribute = Attribute->next) {
+        if (const unsigned char* OriginalValue = hasAttribute(OriginalNode, Attribute->name)) {
+         if (strcmp(reinterpret_cast<const char *>(OriginalValue), reinterpret_cast<const char *>(Attribute->children->content)) != 0)
+          return make_error<WindowsManifestError>("conflicting attributes for ", reinterpret_cast<const char *>(OriginalNode->name));
+      } else
+      xmlSetProp(OriginalNode, Attribute->name, Attribute->children->content);
+    }
+  #endif
+    return Error::success();
+  }
+
+  Error treeMerge(XMLNodeImpl OriginalRoot, XMLNodeImpl AdditionalRoot) {
+  #if defined(LIBXML2_ENABLED)
+    outs() << "treeMerging " << std::string(reinterpret_cast<const char *>(OriginalRoot->name)) << "\n";
+    XMLNodeImpl AdditionalFirstChild = AdditionalRoot->children;
+    if (AdditionalFirstChild != nullptr) {
+    xmlNode Temp;
+    for (XMLNodeImpl Child = AdditionalFirstChild; Child; Child = Child->next) {
+      XMLNodeImpl OriginalChildWithName;
+      if((strcmp(reinterpret_cast<const char*>(Child->name), "text") != 0) && (strcmp(reinterpret_cast<const char*>(Child->name), "comment") != 0)) {
+        outs() << "analyzing " << std::string(reinterpret_cast<const char *>(Child->name)) << "\n";
+        if (!(OriginalChildWithName = hasChildWithName(OriginalRoot, Child->name)) || !isMergeableElement(Child->name)) {
+          outs() << "about to add " << std::string(reinterpret_cast<const char *>(Child->name)) << "\n";
+          xmlAddChild(OriginalRoot, Child);
+          Temp.next = Child->next;
+          Child->next = nullptr;
+          Child = &Temp;
+      //xmlNewTextChild(OriginalRoot, nullptr, reinterpret_cast<const unsigned char *>("text"), reinterpret_cast<const unsigned char *>("\n"));
+        } else {
+          if(auto E = treeMerge(OriginalChildWithName, Child))
+            return E;
+        }
+      }
+    }
+  }
+    if(auto E = mergeAttributes(OriginalRoot, AdditionalRoot))
+     return E;
+    xmlTextMerge(OriginalRoot, AdditionalRoot);
+  #endif
+    outs() << "pop " << std::string(reinterpret_cast<const char *>(OriginalRoot->name)) << "\n";
+    return Error::success();
+  }
+
 Error WindowsManifestMerger::merge(const MemoryBuffer &Manifest) {
 #if LLVM_LIBXML2_ENABLED
   xmlSetGenericErrorFunc((void *)this, WindowsManifestMerger::errorCallback);
   XMLDocumentImpl ManifestXML =
       xmlReadMemory(Manifest.getBufferStart(), Manifest.getBufferSize(),
-                    "manifest.xml", nullptr, 0);
+                    "manifest.xml", nullptr, XML_PARSE_NOBLANKS);
   xmlSetGenericErrorFunc(nullptr, nullptr);
   if (auto E = getParseError())
     return E;
+  if (CombinedRoot == nullptr)
   CombinedRoot = xmlDocGetRootElement(ManifestXML);
+    else {
+      return (treeMerge(CombinedRoot, xmlDocGetRootElement(ManifestXML)));
+    }
 #endif
     return Error::success();
   }
 
 std::unique_ptr<MemoryBuffer> WindowsManifestMerger::getMergedManifest() {
 #if LLVM_LIBXML2_ENABLED
   unsigned char *XmlBuff;
   int BufferSize = 0;
   if (CombinedRoot) {
     std::unique_ptr<xmlDoc> OutputDoc(xmlNewDoc((const unsigned char *)"1.0"));
     xmlDocSetRootElement(OutputDoc.get(), CombinedRoot);
-    xmlDocDumpMemory(OutputDoc.get(), &XmlBuff, &BufferSize);
+      xmlKeepBlanksDefault(0);
+      xmlDocDumpFormatMemory(OutputDoc.get(), &XmlBuff, &BufferSize, 1);
   }
   if (BufferSize == 0)
     return nullptr;
   return MemoryBuffer::getMemBuffer(
       StringRef(reinterpret_cast<const char *>(XmlBuff), (size_t)BufferSize));
 #else
   return nullptr;
 #endif
 }
 
   void WindowsManifestMerger::errorCallback(void *Ctx, const char *Format, ...) {
     auto *Merger = (WindowsManifestMerger *)Ctx;
     Merger->ParseErrorOccurred = true;
   }
 
 Error WindowsManifestMerger::getParseError() {
   if (!ParseErrorOccurred)
     return Error::success();
   return make_error<WindowsManifestError>("invalid xml document");
 }
 
 } // namespace llvm

llvm/test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           llvm-dwp
           llvm-extract
           llvm-lib
           llvm-link
           llvm-lto2
           llvm-mc
           llvm-mcmarkup
           llvm-modextract
-          llvm-mt
           llvm-nm
           llvm-objdump
           llvm-opt-report
           llvm-pdbutil
           llvm-profdata
           llvm-ranlib
           llvm-readobj
           llvm-readelf
set(LLVM_TEST_DEPENDS ${LLVM_TEST_DEPENDS}
           ocaml_llvm_ipo
           ocaml_llvm_passmgr_builder
           ocaml_llvm_scalar_opts
           ocaml_llvm_transform_utils
           ocaml_llvm_vectorize
         )
 endif()
 
+if (LIBXML2_FOUND AND NOT LLVM_DISABLE_LIBXML2)
+  set(LLVM_TEST_DEPENDS ${LLVM_TEST_DEPENDS}
+          llvm-mt
+        )
+endif()
+
 add_custom_target(llvm-test-depends DEPENDS ${LLVM_TEST_DEPENDS})
 set_target_properties(llvm-test-depends PROPERTIES FOLDER "Tests")
 
 add_lit_testsuite(check-llvm "Running the LLVM regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   PARAMS llvm_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
          llvm_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
   DEPENDS ${LLVM_TEST_DEPENDS}

llvm/test/tools/llvm-mt/Inputs/additional.manifest

 <?xml version="1.0"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
   <trustInfo>
     <security>
       <requestedPrivileges>
-         <requestedExecutionLevel level="3" uiAccess="1"/>
+         <requestedExecutionLevel level="3" admin="false"/>
       </requestedPrivileges>
     </security>
   </trustInfo>
   <dependency>
     <dependentAssembly>
-      <assemblyIdentity program="displayDriver"/>
+      <assemblyIdentity program="logDisplay"/>
     </dependentAssembly>
   </dependency>
 </assembly>

llvm/test/tools/llvm-mt/Inputs/conflicting.manifest

+<?xml version="1.0"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1">
+  <trustInfo>
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="2" uiAccess="1"/>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+</assembly>

llvm/test/tools/llvm-mt/Inputs/test_manifest.manifest

 <?xml version="1.0"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1">
   <trustInfo>
     <security>
       <requestedPrivileges>
-         <requestedExecutionLevel level="3" uiAccess="1"/>
       </requestedPrivileges>
     </security>
   </trustInfo>
   <dependency>
     <dependentAssembly>
       <assemblyIdentity program="displayDriver"/>
     </dependentAssembly>
   </dependency>
 </assembly>

llvm/test/tools/llvm-mt/conflicting.test

+REQUIRES: libxml2
+UNSUPPORTED: windows
+
+RUN: not llvm-mt /manifest %p/Inputs/test_manifest.manifest /manifest \
+RUN:   %p/Inputs/conflicting.manifest /out:%t 2>&1 >/dev/null | FileCheck %s
+
+CHECK: llvm-mt error: conflicting attributes for requestedExecutionLevel

llvm/test/tools/llvm-mt/simple_merge.test

+REQUIRES: libxml2
+UNSUPPORTED: windows
+
+RUN: llvm-mt /manifest %p/Inputs/test_manifest.manifest /manifest \
+RUN:   %p/Inputs/additional.manifest /out:%t
+RUN: FileCheck %s -input-file=%t
+
+CHECK:      <?xml version="1.0"?>
+CHECK-NEXT: <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+CHECK-NEXT: <trustInfo>
+CHECK-NEXT: <security>
+CHECK-NEXT: <requestedPrivileges>
+CHECK-NEXT: <requestedExecutionLevel level="3" uiAccess="1" admin="false"/>
+CHECK-NEXT: </requestedPrivileges>
+CHECK-NEXT: </security>
+CHECK-NEXT: </trustInfo>
+CHECK-NEXT: <dependency>
+CHECK-NEXT: <dependentAssembly>
+CHECK-NEXT: <assemblyIdentity program="displayDriver"/>
+CHECK-NEXT: </dependentAssembly>
+CHECK-NEXT: </dependency>
+CHECK-NEXT: <dependency>
+CHECK-NEXT: <dependentAssembly>
+CHECK-NEXT: <assemblyIdentity program="logDisplay"/>
+CHECK-NEXT: </dependentAssembly>
+CHECK-NEXT: </dependency>
+CHECK-NEXT: </assembly>

llvm/tools/llvm-mt/llvm-mt.cpp

int main(int argc, const char **argv) {
   PrettyStackTraceProgram X(argc, argv);
 
   ExitOnErr.setBanner("llvm-mt: ");
 
   SmallVector<const char *, 256> argv_buf;
   SpecificBumpPtrAllocator<char> ArgAllocator;
   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
       argv_buf, makeArrayRef(argv, argc), ArgAllocator)));
-
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   CvtResOptTable T;
   unsigned MAI, MAC;
   ArrayRef<const char *> ArgsArr = makeArrayRef(argv + 1, argc);
   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 
   for (auto &Arg : InputArgs) {
if (InputArgs.hasArg(OPT_out)) {
     OutputFile = InputFiles[0];
   } else {
     reportError("no output file specified");
   }
 
   WindowsManifestMerger Merger;
 
   for (const auto &File : InputFiles) {
+    outs() << "FOUND NEW INPUT\n";
     ErrorOr<std::unique_ptr<MemoryBuffer>> ManifestOrErr =
         MemoryBuffer::getFile(File);
     if (!ManifestOrErr)
       reportError(File, ManifestOrErr.getError());
     MemoryBuffer &Manifest = *ManifestOrErr.get();
     error(Merger.merge(Manifest));
   }