[libFuzzer] Diff 33 - [FuzzerSupport] Move Util implementations to Support directory.

[aizatsky]

Is it possible to record file moves in this change? Right now *Utils files look like deleted/added.

[mpividori]

@aizatsky Yes. It was my intention, using: "git mv"., but I think I did something wrong. I will update the diff.

[mpividori]

@aizatsky I needed to use the flag "-M" for "git diff-tree" to record the rename.
Also, this diff is self-contained.

lib/Fuzzer/CMakeLists.txt

 set(LIBFUZZER_FLAGS_BASE "${CMAKE_CXX_FLAGS}")
 # Disable the coverage and sanitizer instrumentation for the fuzzer itself.
 set(CMAKE_CXX_FLAGS "${LIBFUZZER_FLAGS_BASE} -fno-sanitize-coverage=trace-pc-guard,edge,trace-cmp,indirect-calls,8bit-counters -Werror")
 if( LLVM_USE_SANITIZE_COVERAGE )
   if(NOT "${LLVM_USE_SANITIZER}" STREQUAL "Address")
     message(FATAL_ERROR
       "LibFuzzer and its tests require LLVM_USE_SANITIZER=Address and "
       "LLVM_USE_SANITIZE_COVERAGE=YES to be set."
       )
   endif()
+
+  add_subdirectory(Support)
+
   add_library(LLVMFuzzerNoMainObjects OBJECT
     FuzzerCrossOver.cpp
     FuzzerDriver.cpp
     FuzzerExtFunctionsDlsym.cpp
     FuzzerExtFunctionsWeak.cpp
     FuzzerExtFunctionsWeakAlias.cpp
     FuzzerIO.cpp
     FuzzerIOPosix.cpp
     FuzzerIOWindows.cpp
     FuzzerLoop.cpp
     FuzzerMerge.cpp
     FuzzerMutate.cpp
     FuzzerSHA1.cpp
     FuzzerTracePC.cpp
     FuzzerTraceState.cpp
     FuzzerUtil.cpp
-    FuzzerUtilDarwin.cpp
-    FuzzerUtilLinux.cpp
-    FuzzerUtilPosix.cpp
-    FuzzerUtilWindows.cpp
     )
   add_library(LLVMFuzzerNoMain STATIC
     $<TARGET_OBJECTS:LLVMFuzzerNoMainObjects>
     )
   target_link_libraries(LLVMFuzzerNoMain ${PTHREAD_LIB})
+  target_link_libraries(LLVMFuzzerNoMain LLVMFuzzerSupport)
+
   add_library(LLVMFuzzer STATIC
     FuzzerMain.cpp
     $<TARGET_OBJECTS:LLVMFuzzerNoMainObjects>
     )
   target_link_libraries(LLVMFuzzer ${PTHREAD_LIB})
+  target_link_libraries(LLVMFuzzer LLVMFuzzerSupport)
 
   if( LLVM_INCLUDE_TESTS )
     add_subdirectory(test)
   endif()
 endif()

lib/Fuzzer/FuzzerDriver.cpp

 
 #include "FuzzerCorpus.h"
 #include "FuzzerInterface.h"
 #include "FuzzerInternal.h"
 #include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerRandom.h"
 #include "FuzzerTracePC.h"
+#include "Support/Util.h"
 #include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <cstring>
 #include <mutex>
 #include <string>
 #include <thread>
 

lib/Fuzzer/FuzzerLoop.cpp

 //===----------------------------------------------------------------------===//
 
 #include "FuzzerCorpus.h"
 #include "FuzzerInternal.h"
 #include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerRandom.h"
 #include "FuzzerTracePC.h"
+#include "Support/Util.h"
 #include <algorithm>
 #include <cstring>
 #include <memory>
 #include <set>
 
 #if defined(__has_include)
 #if __has_include(<sanitizer / coverage_interface.h>)
 #include <sanitizer/coverage_interface.h>

lib/Fuzzer/FuzzerMerge.cpp

 //===- FuzzerMerge.cpp - merging corpora ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Merging corpora.
 //===----------------------------------------------------------------------===//
 
 #include "FuzzerInternal.h"
 #include "FuzzerIO.h"
 #include "FuzzerMerge.h"
 #include "FuzzerTracePC.h"
-#include "FuzzerUtil.h"
+#include "Support/Util.h"
 
 #include <fstream>
 #include <iterator>
 #include <sstream>
 
 namespace fuzzer {
 
 bool Merger::Parse(const std::string &Str, bool ParseCoverage) {

lib/Fuzzer/FuzzerMutate.cpp

 //===----------------------------------------------------------------------===//
 
 #include "FuzzerCorpus.h"
 #include "FuzzerDefs.h"
 #include "FuzzerExtFunctions.h"
 #include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerOptions.h"
+#include "Support/Util.h"
 
 namespace fuzzer {
 
 const size_t Dictionary::kMaxDictSize;
 
 static void PrintASCII(const Word &W, const char *PrintAfter) {
   PrintASCII(W.data(), W.size(), PrintAfter);
 }

lib/Fuzzer/FuzzerTracePC.cpp

 
 #include "FuzzerCorpus.h"
 #include "FuzzerDefs.h"
 #include "FuzzerDictionary.h"
 #include "FuzzerExtFunctions.h"
 #include "FuzzerIO.h"
 #include "FuzzerTracePC.h"
 #include "FuzzerValueBitMap.h"
+#include "Support/Util.h"
 #include <map>
 #include <set>
 #include <sstream>
 
 namespace fuzzer {
 
 TracePC TPC;
 

lib/Fuzzer/FuzzerTraceState.cpp

 //===----------------------------------------------------------------------===//
 
 #include "FuzzerDictionary.h"
 #include "FuzzerInternal.h"
 #include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerRandom.h"
 #include "FuzzerTracePC.h"
+#include "Support/Util.h"
 #include <algorithm>
 #include <cstring>
 #include <map>
 #include <set>
 #include <thread>
 
 namespace fuzzer {
 

lib/Fuzzer/FuzzerUtil.h

 bool IsASCII(const uint8_t *Data, size_t Size);
 
 std::string Base64(const Unit &U);
 
 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC);
 
 std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC);
 
-unsigned NumberOfCpuCores();
-
-bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out);
-
-// Platform specific functions.
-void SetSignalHandler(const FuzzingOptions& Options);
-
-void SleepSeconds(int Seconds);
-
-unsigned long GetPid();
-
-size_t GetPeakRSSMb();
-
-int ExecuteCommand(const std::string &Command);
-
-FILE *OpenProcessPipe(const char *Command, const char *Mode);
-
-const void *SearchMemory(const void *haystack, size_t haystacklen,
-                         const void *needle, size_t needlelen);
-
-std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
-                              const char *X1, const char *X2);
-
-inline std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
-                                     const char *X) {
-  return CloneArgsWithoutX(Args, X, X);
-}
-
 }  // namespace fuzzer
 
 #endif  // LLVM_FUZZER_UTIL_H

lib/Fuzzer/FuzzerUtil.cpp

 
 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC) {
   if (EF->__sanitizer_symbolize_pc)
     Printf("%s", DescribePC(SymbolizedFMT, PC).c_str());
   else
     Printf(FallbackFMT, PC);
 }
 
-unsigned NumberOfCpuCores() {
-  unsigned N = std::thread::hardware_concurrency();
-  if (!N) {
-    Printf("WARNING: std::thread::hardware_concurrency not well defined for "
-           "your platform. Assuming CPU count of 1.\n");
-    N = 1;
-  }
-  return N;
-}
-
-bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out) {
-  FILE *Pipe = OpenProcessPipe(Command.c_str(), "r");
-  if (!Pipe) return false;
-  char Buff[1024];
-  size_t N;
-  while ((N = fread(Buff, 1, sizeof(Buff), Pipe)) > 0)
-    Out->append(Buff, N);
-  return true;
-}
-
 }  // namespace fuzzer

lib/Fuzzer/Support/CMakeLists.txt

+add_library(LLVMFuzzerSupport STATIC
+  Util.cpp
+  UtilDarwin.cpp
+  UtilLinux.cpp
+  UtilPosix.cpp
+  UtilWindows.cpp
+  )

lib/Fuzzer/Support/Util.h

+//===- Util.h - Internal header for the Fuzzer Utils ------------*- C++ -* ===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Util portable functions.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FUZZER_SUPPORT_UTIL_H
+#define LLVM_FUZZER_SUPPORT_UTIL_H
+
+#include "../FuzzerDefs.h"
+#include <string>
+#include <vector>
+
+namespace fuzzer {
+
+typedef std::vector<uint8_t> Unit;
+
+unsigned NumberOfCpuCores();
+
+int ExecuteCommand(const std::string &Command);
+
+bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out);
+
+FILE *OpenProcessPipe(const char *Command, const char *Mode);
+
+
+std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
+                              const char *X1, const char *X2);
+
+inline std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
+                                     const char *X) {
+  return CloneArgsWithoutX(Args, X, X);
+}
+
+void SetSignalHandler(const FuzzingOptions& Options);
+
+void SleepSeconds(int Seconds);
+
+unsigned long GetPid();
+
+size_t GetPeakRSSMb();
+
+const void *SearchMemory(const void *haystack, size_t haystacklen,
+                         const void *needle, size_t needlelen);
+
+}  // namespace fuzzer
+
+#endif  // LLVM_FUZZER_SUPPORT_UTIL_H

lib/Fuzzer/Support/Util.cpp

+//===- Util.cpp - Misc utils ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Util portable functions.
+//===----------------------------------------------------------------------===//
+
+#include "Util.h"
+#include "../FuzzerIO.h"
+#include <cstring>
+#include <errno.h>
+#include <signal.h>
+#include <sstream>
+#include <stdio.h>
+#include <sys/types.h>
+#include <thread>
+
+namespace fuzzer {
+
+unsigned NumberOfCpuCores() {
+  unsigned N = std::thread::hardware_concurrency();
+  if (!N) {
+    Printf("WARNING: std::thread::hardware_concurrency not well defined for "
+           "your platform. Assuming CPU count of 1.\n");
+    N = 1;
+  }
+  return N;
+}
+
+bool ExecuteCommandAndReadOutput(const std::string &Command, std::string *Out) {
+  FILE *Pipe = OpenProcessPipe(Command.c_str(), "r");
+  if (!Pipe) return false;
+  char Buff[1024];
+  size_t N;
+  while ((N = fread(Buff, 1, sizeof(Buff), Pipe)) > 0)
+    Out->append(Buff, N);
+  return true;
+}
+
+}  // namespace fuzzer

lib/Fuzzer/Support/UtilDarwin.cpp

-//===- FuzzerUtilDarwin.cpp - Misc utils ----------------------------------===//
+//===- UtilDarwin.cpp - Misc utils ----------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Misc utils for Darwin.
 //===----------------------------------------------------------------------===//
-#include "Support/Platform.h"
+#include "Platform.h"
 #if LIBFUZZER_APPLE
 
-#include "FuzzerIO.h"
+#include "../FuzzerIO.h"
 #include <mutex>
 #include <signal.h>
 #include <spawn.h>
 #include <sys/wait.h>
 
 // There is no header for this on macOS so declare here
 extern "C" char **environ;
 

lib/Fuzzer/Support/UtilLinux.cpp

-//===- FuzzerUtilLinux.cpp - Misc utils for Linux. ------------------------===//
+//===- UtilLinux.cpp - Misc utils for Linux. ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Misc utils for Linux.
 //===----------------------------------------------------------------------===//
-#include "Support/Platform.h"
+#include "Platform.h"
 #if LIBFUZZER_LINUX
 
 #include <stdlib.h>
+#include <string>
 
 namespace fuzzer {
 
 int ExecuteCommand(const std::string &Command) {
   return system(Command.c_str());
 }
 
 } // namespace fuzzer
 
 #endif // LIBFUZZER_LINUX

lib/Fuzzer/Support/UtilPosix.cpp

-//===- FuzzerUtilPosix.cpp - Misc utils for Posix. ------------------------===//
+//===- UtilPosix.cpp - Misc utils for Posix. ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Misc utils implementation using Posix API.
 //===----------------------------------------------------------------------===//
-#include "Support/Platform.h"
+#include "Platform.h"
 #if LIBFUZZER_POSIX
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
+#include "../FuzzerIO.h"
+#include "../FuzzerInternal.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <iomanip>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>

lib/Fuzzer/Support/UtilWindows.cpp

-//===- FuzzerUtilWindows.cpp - Misc utils for Windows. --------------------===//
+//===- UtilWindows.cpp - Misc utils for Windows. --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Misc utils implementation for Windows.
 //===----------------------------------------------------------------------===//
-#include "Support/Platform.h"
+#include "Platform.h"
 #if LIBFUZZER_WINDOWS
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
+#include "../FuzzerIO.h"
+#include "../FuzzerInternal.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <iomanip>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>