Share /machine: handling code with llvm-cvtres too

[thakis]

Summary

r363016 let lld-link and llvm-lib share the /machine: parsing code.
This lets llvm-cvtres share it as well.

Making llvm-cvtres depend on llvm-lib seemed a bit strange (it doesn't
need llvm-lib's dependencies on BinaryFormat and BitReader) and I
couldn't find a good place to put this code. Since it's just a few
lines, put it in lib/Object for now.

[ruiu]

I can see why you created a new library, but it still look a bit odd that the actual library code is less than 40 lines. Do you think adding this to Object make sense? This is not really Object-related, but I guess adding a small amount of code there wouldn't harm anyone.

[thakis]

Ok, unless someone else objects to it I'll upload a modified version that puts the code in lib/Object instead tomorrow.

[thakis]

now in lib/object

[ruiu]

LGTM

lld/trunk/COFF/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "DebugTypes.h"
 #include "Driver.h"
 #include "Config.h"
+#include "DebugTypes.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "MarkLive.h"
 #include "MinGW.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Timer.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/COFFModuleDefinition.h"
+#include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TarWriter.h"

lld/trunk/COFF/SymbolTable.cpp

 #include "Driver.h"
 #include "LTO.h"
 #include "PDB.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Timer.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
 #include <utility>
 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
 
 static Timer LTOTimer("LTO", Timer::root());

llvm/trunk/include/llvm/Object/WindowsMachineFlag.h

+//===- WindowsMachineFlag.h -------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Functions for implementing the /machine: flag.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLDRIVERS_MACHINEFLAG_MACHINEFLAG_H
+#define LLVM_TOOLDRIVERS_MACHINEFLAG_MACHINEFLAG_H
+
+namespace llvm {
+
+class StringRef;
+namespace COFF {
+enum MachineTypes : unsigned;
+}
+
+// Returns a user-readable string for ARMNT, ARM64, AMD64, I386.
+// Other MachineTypes values must not be passed in.
+StringRef machineToStr(COFF::MachineTypes MT);
+
+// Maps /machine: arguments to a MachineTypes value.
+// Only returns ARMNT, ARM64, AMD64, I386, or IMAGE_FILE_MACHINE_UNKNOWN.
+COFF::MachineTypes getMachineType(StringRef S);
+
+}
+
+#endif

llvm/trunk/include/llvm/ToolDrivers/llvm-lib/LibDriver.h

 #ifndef LLVM_TOOLDRIVERS_LLVM_LIB_LIBDRIVER_H
 #define LLVM_TOOLDRIVERS_LLVM_LIB_LIBDRIVER_H
 
 namespace llvm {
 template <typename T> class ArrayRef;
 
 int libDriverMain(ArrayRef<const char *> ARgs);
 
-
-class StringRef;
-namespace COFF {
-enum MachineTypes : unsigned;
-}
-
-// Returns a user-readable string for ARMNT, ARM64, AMD64, I386.
-// Other MachineTypes values must not be pased in.
-StringRef machineToStr(COFF::MachineTypes MT);
-
-// Maps /machine: arguments to a MachineTypes value.
-// Only returns ARMNT, ARM64, AMD64, I386, or IMAGE_FILE_MACHINE_UNKNOWN.
-COFF::MachineTypes getMachineType(StringRef S);
-
 }
 
 #endif

llvm/trunk/lib/Object/CMakeLists.txt

add_llvm_library(LLVMObject
   ModuleSymbolTable.cpp
   Object.cpp
   ObjectFile.cpp
   RecordStreamer.cpp
   RelocationResolver.cpp
   SymbolicFile.cpp
   SymbolSize.cpp
   WasmObjectFile.cpp
+  WindowsMachineFlag.cpp
   WindowsResource.cpp
   XCOFFObjectFile.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
 
   DEPENDS
   intrinsics_gen
   llvm_vcsrevision_h
   )

llvm/trunk/lib/Object/WindowsMachineFlag.cpp

+//===- WindowsMachineFlag.cpp ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Functions for implementing the /machine: flag.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/WindowsMachineFlag.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/BinaryFormat/COFF.h"
+
+using namespace llvm;
+
+// Returns /machine's value.
+COFF::MachineTypes llvm::getMachineType(StringRef S) {
+  return StringSwitch<COFF::MachineTypes>(S.lower())
+      .Cases("x64", "amd64", COFF::IMAGE_FILE_MACHINE_AMD64)
+      .Cases("x86", "i386", COFF::IMAGE_FILE_MACHINE_I386)
+      .Case("arm", COFF::IMAGE_FILE_MACHINE_ARMNT)
+      .Case("arm64", COFF::IMAGE_FILE_MACHINE_ARM64)
+      .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
+}
+
+StringRef llvm::machineToStr(COFF::MachineTypes MT) {
+  switch (MT) {
+  case COFF::IMAGE_FILE_MACHINE_ARMNT:
+    return "arm";
+  case COFF::IMAGE_FILE_MACHINE_ARM64:
+    return "arm64";
+  case COFF::IMAGE_FILE_MACHINE_AMD64:
+    return "x64";
+  case COFF::IMAGE_FILE_MACHINE_I386:
+    return "x86";
+  default:
+    llvm_unreachable("unknown machine type");
+  }
+}

llvm/trunk/lib/ToolDrivers/llvm-lib/LibDriver.cpp

 
 #include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
for (auto &C : Archive.children(Err)) {
     Expected<StringRef> NameOrErr = C.getName();
     fatalOpenError(NameOrErr.takeError(), B->getBufferIdentifier());
     StringRef Name = NameOrErr.get();
     llvm::outs() << Name << '\n';
   }
   fatalOpenError(std::move(Err), B->getBufferIdentifier());
 }
 
-// Returns /machine's value.
-COFF::MachineTypes llvm::getMachineType(StringRef S) {
-  return StringSwitch<COFF::MachineTypes>(S.lower())
-      .Cases("x64", "amd64", COFF::IMAGE_FILE_MACHINE_AMD64)
-      .Cases("x86", "i386", COFF::IMAGE_FILE_MACHINE_I386)
-      .Case("arm", COFF::IMAGE_FILE_MACHINE_ARMNT)
-      .Case("arm64", COFF::IMAGE_FILE_MACHINE_ARM64)
-      .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
-}
-
-StringRef llvm::machineToStr(COFF::MachineTypes MT) {
-  switch (MT) {
-  case COFF::IMAGE_FILE_MACHINE_ARMNT:
-    return "arm";
-  case COFF::IMAGE_FILE_MACHINE_ARM64:
-    return "arm64";
-  case COFF::IMAGE_FILE_MACHINE_AMD64:
-    return "x64";
-  case COFF::IMAGE_FILE_MACHINE_I386:
-    return "x86";
-  default:
-    llvm_unreachable("unknown machine type");
-  }
-}
-
 int llvm::libDriverMain(ArrayRef<const char *> ArgsArr) {
   BumpPtrAllocator Alloc;
   StringSaver Saver(Alloc);
 
   // Parse command line arguments.
   SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
   cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs);
   ArgsArr = NewArgs;

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

 //===- llvm-cvtres.cpp - Serialize .res files into .obj ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Serialize .res files into .obj files.  This is intended to be a
 // platform-independent port of Microsoft's cvtres.exe.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BinaryStreamError.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
if (InputArgs.hasArg(OPT_HELP)) {
     T.PrintHelp(outs(), "llvm-cvtres [options] file...", "Resource Converter");
     return 0;
   }
 
   bool Verbose = InputArgs.hasArg(OPT_VERBOSE);
 
   COFF::MachineTypes MachineType;
 
-  if (InputArgs.hasArg(OPT_MACHINE)) {
-    std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();
-    MachineType = StringSwitch<COFF::MachineTypes>(MachineString)
-                      .Case("ARM", COFF::IMAGE_FILE_MACHINE_ARMNT)
-                      .Case("ARM64", COFF::IMAGE_FILE_MACHINE_ARM64)
-                      .Case("X64", COFF::IMAGE_FILE_MACHINE_AMD64)
-                      .Case("X86", COFF::IMAGE_FILE_MACHINE_I386)
-                      .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
-    if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN)
-      reportError("Unsupported machine architecture");
+  if (opt::Arg *Arg = InputArgs.getLastArg(OPT_MACHINE)) {
+    MachineType = getMachineType(Arg->getValue());
+    if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
+      reportError(Twine("Unsupported machine architecture ") + Arg->getValue() +
+                  "\n");
+    }
   } else {
     if (Verbose)
       outs() << "Machine architecture not specified; assumed X64.\n";
     MachineType = COFF::IMAGE_FILE_MACHINE_AMD64;
   }
 
   std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
 
   if (InputFiles.size() == 0) {
     reportError("No input file specified.\n");
   }
 
   SmallString<128> OutputFile;
 
-  if (InputArgs.hasArg(OPT_OUT)) {
-    OutputFile = InputArgs.getLastArgValue(OPT_OUT);
+  if (opt::Arg *Arg = InputArgs.getLastArg(OPT_OUT)) {
+    OutputFile = Arg->getValue();
   } else {
     OutputFile = sys::path::filename(StringRef(InputFiles[0]));
     sys::path::replace_extension(OutputFile, ".obj");
   }
 
   uint32_t DateTimeStamp;
   if (llvm::opt::Arg *Arg = InputArgs.getLastArg(OPT_TIMESTAMP)) {
     StringRef Value(Arg->getValue());
     if (Value.getAsInteger(0, DateTimeStamp))
       reportError(Twine("invalid timestamp: ") + Value +
             ".  Expected 32-bit integer\n");
   } else {
     DateTimeStamp = getTime();
   }
 
-  if (Verbose) {
-    outs() << "Machine: ";
-    switch (MachineType) {
-    case COFF::IMAGE_FILE_MACHINE_ARM64:
-      outs() << "ARM64\n";
-      break;
-    case COFF::IMAGE_FILE_MACHINE_ARMNT:
-      outs() << "ARM\n";
-      break;
-    case COFF::IMAGE_FILE_MACHINE_I386:
-      outs() << "X86\n";
-      break;
-    default:
-      outs() << "X64\n";
-    }
-  }
+  if (Verbose)
+    outs() << "Machine: " << machineToStr(MachineType) << '\n';
 
   WindowsResourceParser Parser;
 
   for (const auto &File : InputFiles) {
     Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
     if (!BinaryOrErr)
       reportError(File, errorToErrorCode(BinaryOrErr.takeError()));
 

llvm/trunk/utils/gn/secondary/llvm/lib/Object/BUILD.gn

sources = [
     "ModuleSymbolTable.cpp",
     "Object.cpp",
     "ObjectFile.cpp",
     "RecordStreamer.cpp",
     "RelocationResolver.cpp",
     "SymbolSize.cpp",
     "SymbolicFile.cpp",
     "WasmObjectFile.cpp",
+    "WindowsMachineFlag.cpp",
     "WindowsResource.cpp",
     "XCOFFObjectFile.cpp",
   ]
 }