[llvm-mc-fuzzer] Use LLVMFuzzerInitialize() instead of a custom main() and FuzzerDriver()

[kcc]

LGTM, thanks!

tools/llvm-mc-fuzzer/CMakeLists.txt

 if( LLVM_USE_SANITIZE_COVERAGE )
   include_directories(BEFORE
     ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/Fuzzer)
 
   set(LLVM_LINK_COMPONENTS
       AllTargetsDescs
       AllTargetsDisassemblers
       AllTargetsInfos
       MC
       MCDisassembler
       Support
       )
   add_llvm_tool(llvm-mc-fuzzer 
                 llvm-mc-fuzzer.cpp)
   target_link_libraries(llvm-mc-fuzzer
-                        LLVMFuzzerNoMain
+                        LLVMFuzzer
                         )
 endif()

tools/llvm-mc-fuzzer/llvm-mc-fuzzer.cpp

 static cl::list<std::string>
     MAttrs("mattr", cl::CommaSeparated,
            cl::desc("Target specific attributes (-mattr=help for details)"),
            cl::value_desc("a1,+a2,-a3,..."));
 // The feature string derived from -mattr's values.
 std::string FeaturesStr;
 
 static cl::list<std::string>
-    FuzzerArgv("fuzzer-args", cl::Positional,
+    FuzzerArgs("fuzzer-args", cl::Positional,
                cl::desc("Options to pass to the fuzzer"), cl::ZeroOrMore,
                cl::PositionalEatsArgs);
+static std::vector<char *> ModifiedArgv;
 
 int DisassembleOneInput(const uint8_t *Data, size_t Size) {
   char AssemblyText[AssemblyTextBufSize];
 
   std::vector<uint8_t> DataCopy(Data, Data + Size);
 
   LLVMDisasmContextRef Ctx = LLVMCreateDisasmCPUFeatures(
       TripleName.c_str(), MCPU.c_str(), FeaturesStr.c_str(), nullptr, 0,
do {
     InstructionsProcessed ++;
     if (InsnLimit != 0 && InstructionsProcessed < InsnLimit)
       break;
   } while (Consumed != 0);
   LLVMDisasmDispose(Ctx);
   return 0;
 }
 
-int main(int argc, char **argv) {
+int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+  if (Action == AC_Assemble)
+    errs() << "error: -assemble is not implemented\n";
+  else if (Action == AC_Disassemble)
+    return DisassembleOneInput(Data, Size);
+
+  llvm_unreachable("Unknown action");
+  return 0;
+}
+
+int LLVMFuzzerInitialize(int *argc, char ***argv) {
   // The command line is unusual compared to other fuzzers due to the need to
   // specify the target. Options like -triple, -mcpu, and -mattr work like
   // their counterparts in llvm-mc, while -fuzzer-args collects options for the
   // fuzzer itself.
   //
   // Examples:
   //
   // Fuzz the big-endian MIPS32R6 disassembler using 100,000 inputs of up to
   // 4-bytes each and use the contents of ./corpus as the test corpus:
   //   llvm-mc-fuzzer -triple mips-linux-gnu -mcpu=mips32r6 -disassemble \
   //       -fuzzer-args -max_len=4 -runs=100000 ./corpus
   //
   // Infinitely fuzz the little-endian MIPS64R2 disassembler with the MSA
   // feature enabled using up to 64-byte inputs:
   //   llvm-mc-fuzzer -triple mipsel-linux-gnu -mcpu=mips64r2 -mattr=msa \
   //       -disassemble -fuzzer-args ./corpus
   //
   // If your aim is to find instructions that are not tested, then it is
   // advisable to constrain the maximum input size to a single instruction
   // using -max_len as in the first example. This results in a test corpus of
   // individual instructions that test unique paths. Without this constraint,
   // there will be considerable redundancy in the corpus.
 
+  char **OriginalArgv = *argv;
+
   LLVMInitializeAllTargetInfos();
   LLVMInitializeAllTargetMCs();
   LLVMInitializeAllDisassemblers();
 
-  cl::ParseCommandLineOptions(argc, argv);
+  cl::ParseCommandLineOptions(*argc, OriginalArgv);
+
+  // Rebuild the argv without the arguments llvm-mc-fuzzer consumed so that
+  // the driver can parse its arguments.
+  //
+  // FuzzerArgs cannot provide the non-const pointer that OriginalArgv needs.
+  // Re-use the strings from OriginalArgv instead of copying FuzzerArg to a
+  // non-const buffer to avoid the need to clean up when the fuzzer terminates.
+  ModifiedArgv.push_back(OriginalArgv[0]);
+  for (const auto &FuzzerArg : FuzzerArgs) {
+    for (int i = 1; i < *argc; ++i) {
+      if (FuzzerArg == OriginalArgv[i])
+        ModifiedArgv.push_back(OriginalArgv[i]);
+    }
+  }
+  *argc = ModifiedArgv.size();
+  *argv = ModifiedArgv.data();
 
   // Package up features to be passed to target/subtarget
   // We have to pass it via a global since the callback doesn't
   // permit any user data.
   if (MAttrs.size()) {
     SubtargetFeatures Features;
     for (unsigned i = 0; i != MAttrs.size(); ++i)
       Features.AddFeature(MAttrs[i]);
     FeaturesStr = Features.getString();
   }
 
-  if (Action == AC_Assemble)
-    errs() << "error: -assemble is not implemented\n";
-  else if (Action == AC_Disassemble)
-    return fuzzer::FuzzerDriver(argc, argv, DisassembleOneInput);
-
-  llvm_unreachable("Unknown action");
-  return 1;
+  return 0;
 }