[libFuzzer] Diff 34 - [FuzzerSupport] Move IO implementations to Support directory.

[aizatsky]

Files here have to be marked as moved as well.

[mpividori]

Update diff to create a self-contained patch.

lib/Fuzzer/CMakeLists.txt

if( LLVM_USE_SANITIZE_COVERAGE )
   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
     )

lib/Fuzzer/FuzzerCorpus.h

 //===- FuzzerCorpus.h - Internal header for the Fuzzer ----------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // fuzzer::InputCorpus
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FUZZER_CORPUS
 #define LLVM_FUZZER_CORPUS
 
 #include "FuzzerDefs.h"
-#include "FuzzerIO.h"
 #include "FuzzerRandom.h"
 #include "FuzzerSHA1.h"
 #include "FuzzerTracePC.h"
+#include "Support/UtilIO.h"
 #include <numeric>
 #include <random>
 #include <unordered_set>
 
 namespace fuzzer {
 
 struct InputInfo {
   Unit U;  // The actual input data.

lib/Fuzzer/FuzzerDictionary.h

 //===- FuzzerDictionary.h - Internal header for the Fuzzer ------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // fuzzer::Dictionary
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FUZZER_DICTIONARY_H
 #define LLVM_FUZZER_DICTIONARY_H
 
 #include "FuzzerDefs.h"
-#include "FuzzerIO.h"
 #include "FuzzerUtil.h"
+#include "Support/UtilIO.h"
 #include <algorithm>
 #include <limits>
 
 namespace fuzzer {
 // A simple POD sized array of bytes.
 template <size_t kMaxSize> class FixedWord {
 public:
   FixedWord() {}

lib/Fuzzer/FuzzerDriver.cpp

 //===- FuzzerDriver.cpp - FuzzerDriver function and flags -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // FuzzerDriver and flag parsing.
 //===----------------------------------------------------------------------===//
 
 #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 "Support/UtilIO.h"
 #include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <cstring>
 #include <mutex>
 #include <string>
 #include <thread>
 

lib/Fuzzer/FuzzerExtFunctionsDlsym.cpp

 // Apple platforms for now. We don't use this approach on Linux because it
 // requires that clients of LibFuzzer pass ``--export-dynamic`` to the linker.
 // That is a complication we don't wish to expose to clients right now.
 //===----------------------------------------------------------------------===//
 #include "Support/Platform.h"
 #if LIBFUZZER_APPLE
 
 #include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
+#include "Support/UtilIO.h"
 #include <dlfcn.h>
 
 using namespace fuzzer;
 
 template <typename T>
 static T GetFnPtr(const char *FnName, bool WarnIfMissing) {
   dlerror(); // Clear any previous errors.
   void *Fn = dlsym(RTLD_DEFAULT, FnName);

lib/Fuzzer/FuzzerExtFunctionsWeak.cpp

 // clients of LibFuzzer to pass ``-U _<symbol_name>`` to the linker to allow
 // weak symbols to be undefined. That is a complication we don't want to expose
 // to clients right now.
 //===----------------------------------------------------------------------===//
 #include "Support/Platform.h"
 #if LIBFUZZER_LINUX
 
 #include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
+#include "Support/UtilIO.h"
 
 extern "C" {
 // Declare these symbols as weak to allow them to be optionally defined.
 #define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN)                            \
   __attribute__((weak)) RETURN_TYPE NAME FUNC_SIG
 
 #include "FuzzerExtFunctions.def"
 

lib/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp

 //===- FuzzerExtFunctionsWeakAlias.cpp - Interface to external functions --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Implementation using weak aliases. Works for Windows.
 //===----------------------------------------------------------------------===//
 #include "Support/Platform.h"
 #if LIBFUZZER_WINDOWS
 
 #include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
+#include "Support/UtilIO.h"
 
 using namespace fuzzer;
 
 extern "C" {
 // Declare these symbols as weak to allow them to be optionally defined.
 #define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN)                            \
   RETURN_TYPE NAME##Def FUNC_SIG {                                             \
     Printf("ERROR: Function \"%s\" not defined.\n", #NAME);                    \

lib/Fuzzer/FuzzerLoop.cpp

 //===- FuzzerLoop.cpp - Fuzzer's main loop --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Fuzzer's main loop.
 //===----------------------------------------------------------------------===//
 
 #include "FuzzerCorpus.h"
 #include "FuzzerInternal.h"
-#include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerRandom.h"
 #include "FuzzerTracePC.h"
 #include "Support/Util.h"
+#include "Support/UtilIO.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 "Support/Util.h"
+#include "Support/UtilIO.h"
 
 #include <fstream>
 #include <iterator>
 #include <sstream>
 
 namespace fuzzer {
 
 bool Merger::Parse(const std::string &Str, bool ParseCoverage) {

lib/Fuzzer/FuzzerMutate.cpp

 //===- FuzzerMutate.cpp - Mutate a test input -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Mutate a test input.
 //===----------------------------------------------------------------------===//
 
 #include "FuzzerCorpus.h"
 #include "FuzzerDefs.h"
 #include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerOptions.h"
 #include "Support/Util.h"
+#include "Support/UtilIO.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

 // the callback required for -fsanitize-coverage=trace-pc-guard instrumentation.
 //
 //===----------------------------------------------------------------------===//
 
 #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 "Support/UtilIO.h"
 #include <map>
 #include <set>
 #include <sstream>
 
 namespace fuzzer {
 
 TracePC TPC;
 

lib/Fuzzer/FuzzerTraceState.cpp

 //===- FuzzerTraceState.cpp - Trace-based fuzzer mutator ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Data tracing.
 //===----------------------------------------------------------------------===//
 
 #include "FuzzerDictionary.h"
 #include "FuzzerInternal.h"
-#include "FuzzerIO.h"
 #include "FuzzerMutate.h"
 #include "FuzzerRandom.h"
 #include "FuzzerTracePC.h"
 #include "Support/Util.h"
+#include "Support/UtilIO.h"
 #include <algorithm>
 #include <cstring>
 #include <map>
 #include <set>
 #include <thread>
 
 namespace fuzzer {
 

lib/Fuzzer/FuzzerUtil.cpp

 //===- FuzzerUtil.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.
 //===----------------------------------------------------------------------===//
 
 #include "FuzzerUtil.h"
-#include "FuzzerIO.h"
 #include "FuzzerInternal.h"
+#include "Support/UtilIO.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>
 #include <sys/types.h>

lib/Fuzzer/Support/CMakeLists.txt

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

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 "UtilIO.h"
 #include <cstring>
 #include <errno.h>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>
 #include <sys/types.h>
 #include <thread>
 

lib/Fuzzer/Support/UtilDarwin.cpp

 //===- 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 "Platform.h"
 #if LIBFUZZER_APPLE
 
-#include "../FuzzerIO.h"
+#include "UtilIO.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/UtilIO.h

-//===- FuzzerIO.h - Internal header for IO utils ----------------*- C++ -* ===//
+//===- UtilIO.h - Internal header for IO utils ------------------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // IO interface.
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_FUZZER_IO_H
-#define LLVM_FUZZER_IO_H
+#ifndef LLVM_FUZZER_SUPPORT_UTIL_IO_H
+#define LLVM_FUZZER_SUPPORT_UTIL_IO_H
 
-#include "FuzzerDefs.h"
+#include <string>
+#include <vector>
 
 namespace fuzzer {
 
+typedef std::vector<uint8_t> Unit;
+
 long GetEpoch(const std::string &Path);
 
 Unit FileToVector(const std::string &Path, size_t MaxSize = 0,
                   bool ExitOnError = true);
 
 std::string FileToString(const std::string &Path);
 
 void CopyFileToErr(const std::string &Path);

 int CloseFile(int Fd);
 
 int DuplicateFile(int Fd);
 
 void RemoveFile(const std::string &Path);
 
 }  // namespace fuzzer
 
-#endif  // LLVM_FUZZER_IO_H
+#endif  // LLVM_FUZZER_SUPPORT_UTIL_IO_H

lib/Fuzzer/Support/UtilIO.cpp

-//===- FuzzerIO.cpp - IO utils. -------------------------------------------===//
+//===- UtilIO.cpp - IO utils. ---------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // IO functions.
 //===----------------------------------------------------------------------===//
 
-#include "FuzzerIO.h"
-#include "FuzzerDefs.h"
-#include "FuzzerExtFunctions.h"
+#include "UtilIO.h"
+#include "../FuzzerDefs.h"
+#include "../FuzzerExtFunctions.h"
 #include <algorithm>
 #include <cstdarg>
 #include <fstream>
 #include <iterator>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 namespace fuzzer {

lib/Fuzzer/Support/UtilIOPosix.cpp

-//===- FuzzerIOPosix.cpp - IO utils for Posix. ----------------------------===//
+//===- UtilIOPosix.cpp - IO utils for Posix. ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // IO functions implementation using Posix API.
 //===----------------------------------------------------------------------===//
-#include "Support/Platform.h"
+#include "Platform.h"
 #if LIBFUZZER_POSIX
 
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
+#include "UtilIO.h"
 #include <cstdarg>
 #include <cstdio>
+#include <cstring>
 #include <dirent.h>
 #include <fstream>
 #include <iterator>
 #include <libgen.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 

lib/Fuzzer/Support/UtilIOWindows.cpp

-//===- FuzzerIOWindows.cpp - IO utils for Windows. ------------------------===//
+//===- UtilIOWindows.cpp - IO utils for Windows. --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // IO functions implementation for Windows.
 //===----------------------------------------------------------------------===//
-#include "Support/Platform.h"
+#include "Platform.h"
 #if LIBFUZZER_WINDOWS
 
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
+#include "UtilIO.h"
+#include <cassert>
 #include <cstdarg>
 #include <cstdio>
 #include <fstream>
 #include <io.h>
 #include <iterator>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <windows.h>

lib/Fuzzer/Support/UtilPosix.cpp

 //===- 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 "Platform.h"
 #if LIBFUZZER_POSIX
-#include "../FuzzerIO.h"
+#include "UtilIO.h"
 #include "../FuzzerInternal.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <iomanip>
 #include <signal.h>
 #include <sstream>

lib/Fuzzer/Support/UtilWindows.cpp

 //===- 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 "Platform.h"
 #if LIBFUZZER_WINDOWS
-#include "../FuzzerIO.h"
+#include "UtilIO.h"
 #include "../FuzzerInternal.h"
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <errno.h>
 #include <iomanip>
 #include <signal.h>
 #include <sstream>