Refactored clang-fuzzer in preparation for adding new loop-proto-fuzzer

[emmettneyman]

Summary

Refactored LLVMFuzzerInitialize function into its own file.

Copied and renamed files in preparation for new loop-proto-fuzzer.

[vitalybuka]

tools/clang-fuzzer/CMakeLists.txt

17

this file is missing

tools/clang-fuzzer/ExampleClangProtoFuzzer.cpp

29

don't keep dead code

tools/clang-fuzzer/proto-to-cxx/proto_to_cxx_main.cpp

26

Probably some debug changes?

tools/clang-fuzzer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS ${LLVM_TARGETS_TO_BUILD} FuzzMutate)
 set(CXX_FLAGS_NOFUZZ ${CMAKE_CXX_FLAGS})
 set(DUMMY_MAIN DummyClangFuzzer.cpp)
 if(LLVM_LIB_FUZZING_ENGINE)
   unset(DUMMY_MAIN)
 elseif(LLVM_USE_SANITIZE_COVERAGE)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer")
   set(CXX_FLAGS_NOFUZZ "${CXX_FLAGS_NOFUZZ} -fsanitize=fuzzer-no-link")
   unset(DUMMY_MAIN)
 endif()
 
 # Needed by LLVM's CMake checks because this file defines multiple targets.
 set(LLVM_OPTIONAL_SOURCES
   ClangFuzzer.cpp
   DummyClangFuzzer.cpp
   ExampleClangProtoFuzzer.cpp
+  FuzzerInitialize.cpp
   )
 
 if(CLANG_ENABLE_PROTO_FUZZER)
   # Create protobuf .h and .cc files, and put them in a library for use by
   # clang-proto-fuzzer components.
   find_package(Protobuf REQUIRED)
   add_definitions(-DGOOGLE_PROTOBUF_NO_RTTI)
   include_directories(${PROTOBUF_INCLUDE_DIRS})
if(CLANG_ENABLE_PROTO_FUZZER)
 
   # Build the protobuf->C++ translation library and driver.
   add_clang_subdirectory(proto-to-cxx)
 
   # Build the protobuf fuzzer
   add_clang_executable(clang-proto-fuzzer
     ${DUMMY_MAIN}
     ExampleClangProtoFuzzer.cpp
+    FuzzerInitialize.cpp
     )
 
   target_link_libraries(clang-proto-fuzzer
     PRIVATE
     ${ProtobufMutator_LIBRARIES}
     ${PROTOBUF_LIBRARIES}
     ${LLVM_LIB_FUZZING_ENGINE}
     clangCXXProto

tools/clang-fuzzer/ExampleClangProtoFuzzer.cpp

 ///  then linked into the Fuzzer library.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "cxx_proto.pb.h"
 #include "handle-cxx/handle_cxx.h"
 #include "proto-to-cxx/proto_to_cxx.h"
 
+#include "FuzzerInitialize.h"
+
 #include "src/libfuzzer/libfuzzer_macro.h"
 
 #include <cstring>
 
 using namespace clang_fuzzer;
 
+/*
 static std::vector<const char *> CLArgs;
 
 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
   CLArgs.push_back("-O2");
   for (int I = 1; I < *argc; I++) {
     if (strcmp((*argv)[I], "-ignore_remaining_args=1") == 0) {
       for (I++; I < *argc; I++)
         CLArgs.push_back((*argv)[I]);
       break;
     }
   }
   return 0;
 }
+*/
 
-DEFINE_BINARY_PROTO_FUZZER(const Function& input) {
+DEFINE_PROTO_FUZZER(const Function& input) {
   auto S = FunctionToString(input);
   HandleCXX(S, CLArgs);
 }

tools/clang-fuzzer/proto-to-cxx/proto_to_cxx.h

 #include <cstdint>
 #include <cstddef>
 #include <string>
 
 namespace clang_fuzzer {
 class Function;
 std::string FunctionToString(const Function &input);
 std::string ProtoToCxx(const uint8_t *data, size_t size);
+std::string ProtoStringToCxx(const std::string& data);
 }

tools/clang-fuzzer/proto-to-cxx/proto_to_cxx.cpp

 //==-- proto_to_cxx.cpp - Protobuf-C++ conversion --------------------------==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements functions for converting between protobufs and C++.
 //
 //===----------------------------------------------------------------------===//
 
 #include "proto_to_cxx.h"
 #include "cxx_proto.pb.h"
 
+// The following is needed to convert protos in human-readable form
+#include <google/protobuf/text_format.h>
+
+
 #include <ostream>
 #include <sstream>
 
 namespace clang_fuzzer {
 
 // Forward decls.
 std::ostream &operator<<(std::ostream &os, const BinaryOp &x);
 std::ostream &operator<<(std::ostream &os, const StatementSeq &x);
std::string FunctionToString(const Function &input) {
   std::ostringstream os;
   os << input;
   return os.str();
 
 }
 std::string ProtoToCxx(const uint8_t *data, size_t size) {
   Function message;
   if (!message.ParsePartialFromArray(data, size))
-    return "#error invalid proto\n";
+    return "#error invalid proto, may not be binary encoded\n";
+  return FunctionToString(message);
+}
+std::string ProtoStringToCxx(const std::string& data) {
+  Function message;
+  if (!google::protobuf::TextFormat::ParseFromString(data, &message))
+    return "#error invalid proto, may not be string encoded\n";
   return FunctionToString(message);
 }
 
 } // namespace clang_fuzzer

tools/clang-fuzzer/proto-to-cxx/proto_to_cxx_main.cpp

 #include "proto_to_cxx.h"
 
 int main(int argc, char **argv) {
   for (int i = 1; i < argc; i++) {
     std::fstream in(argv[i]);
     std::string str((std::istreambuf_iterator<char>(in)),
                     std::istreambuf_iterator<char>());
     std::cout << "// " << argv[i] << std::endl;
-    std::cout << clang_fuzzer::ProtoToCxx(
-        reinterpret_cast<const uint8_t *>(str.data()), str.size());
+    //std::cout << clang_fuzzer::ProtoToCxx(
+    //    reinterpret_cast<const uint8_t *>(str.data()), str.size());
+    std::cout << clang_fuzzer::ProtoStringToCxx(str);
   }
 }