Add ExternalFunctions to fuzzer::TestEnvironment.

[aarongreen]

Summary

For tests that need to use fuzzer::EF, this change moves the unique_ptr holding the ExternalFunctions to the global test environment. This simplifies writing individual tests and mitigates one source of errors during test tear-down and repetition, e.g when using --gtest_repeat=<n>.

This is change 8 of (at least) 18 for cross-process fuzzing support.

[aarongreen]

Rebase

[morehouse]

LGTM

[aarongreen]

Multiprocess fuzzing will not be supported by the libFuzzer maintainers. Fuchsia has implemented a new approach with their Component Fuzzing Framework (RFC-117).

compiler-rt/lib/fuzzer/tests/FuzzerTestUtil.h

 //===- FuzzerTestUtil.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
 //
 //===----------------------------------------------------------------------===//
 // Test support shared between unit tests.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FUZZER_TEST_UTIL_H
 #define LLVM_FUZZER_TEST_UTIL_H
 
+#include "FuzzerExtFunctions.h"
 #include "FuzzerTracePC.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 #include <cstdint>
 #include <initializer_list>
 #include <memory>
-#include <vector>
 
 namespace fuzzer {
 
 // Helper environment to ensure that:
 // * The PRNG is seeded deterministically.
+// * The ExternalFunctions are allocated.
 class TestEnvironment : public testing::Environment {
 public:
-  void SetUp() override { srand(0); }
+  void SetUp() override {
+    srand(0);
+    ExtFuncs.reset(new ExternalFunctions());
+    EF = ExtFuncs.get();
+  }
+
+  void TearDown() override { EF = nullptr; }
+
+private:
+  std::unique_ptr<ExternalFunctions> ExtFuncs;
 };
 
 // Test utilities for picking repeatable psuedorandom numbers.
 template <typename T>
 typename std::enable_if<std::is_integral<T>::value, T>::type Pick() {
   return static_cast<T>(rand() & std::numeric_limits<T>::max());
 }
 

compiler-rt/lib/fuzzer/tests/FuzzerUnittest.cpp

#if LIBFUZZER_WINDOWS
   EXPECT_EQ(Basename("foo\\bar/baz"), "baz");
   EXPECT_EQ(Basename("\\bar"), "bar");
   EXPECT_EQ(Basename("foo\\x"), "x");
   EXPECT_EQ(Basename("foo\\"), "");
 #endif
 }
 
 TEST(Fuzzer, CrossOver) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   Unit A({0, 1, 2}), B({5, 6, 7});
   Unit C;
   Unit Expected[] = {
        { 0 },
        { 0, 1 },
        { 0, 5 },
TEST(Fuzzer, Hash) {
   U.push_back('d');
   EXPECT_EQ("81fe8bfe87576c3ecb22426f8e57847382917acf", fuzzer::Hash(U));
 }
 
 typedef size_t (MutationDispatcher::*Mutator)(uint8_t *Data, size_t Size,
                                               size_t MaxSize);
 
 void TestEraseBytes(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   uint8_t REM0[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t REM1[8] = {0x00, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t REM2[8] = {0x00, 0x11, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t REM3[8] = {0x00, 0x11, 0x22, 0x44, 0x55, 0x66, 0x77};
   uint8_t REM4[8] = {0x00, 0x11, 0x22, 0x33, 0x55, 0x66, 0x77};
   uint8_t REM5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x66, 0x77};
   uint8_t REM6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x77};
   uint8_t REM7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

 TEST(FuzzerMutate, EraseBytes1) {
   TestEraseBytes(&MutationDispatcher::Mutate_EraseBytes, 200);
 }
 TEST(FuzzerMutate, EraseBytes2) {
   TestEraseBytes(&MutationDispatcher::Mutate, 2000);
 }
 
 void TestInsertByte(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   uint8_t INS0[8] = {0xF1, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
   uint8_t INS1[8] = {0x00, 0xF2, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
   uint8_t INS2[8] = {0x00, 0x11, 0xF3, 0x22, 0x33, 0x44, 0x55, 0x66};
   uint8_t INS3[8] = {0x00, 0x11, 0x22, 0xF4, 0x33, 0x44, 0x55, 0x66};
   uint8_t INS4[8] = {0x00, 0x11, 0x22, 0x33, 0xF5, 0x44, 0x55, 0x66};

 TEST(FuzzerMutate, InsertByte1) {
   TestInsertByte(&MutationDispatcher::Mutate_InsertByte, 1 << 15);
 }
 TEST(FuzzerMutate, InsertByte2) {
   TestInsertByte(&MutationDispatcher::Mutate, 1 << 17);
 }
 
 void TestInsertRepeatedBytes(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   uint8_t INS0[7] = {0x00, 0x11, 0x22, 0x33, 'a', 'a', 'a'};
   uint8_t INS1[7] = {0x00, 0x11, 0x22, 'a', 'a', 'a', 0x33};
   uint8_t INS2[7] = {0x00, 0x11, 'a', 'a', 'a', 0x22, 0x33};
   uint8_t INS3[7] = {0x00, 'a', 'a', 'a', 0x11, 0x22, 0x33};
   uint8_t INS4[7] = {'a', 'a', 'a', 0x00, 0x11, 0x22, 0x33};

 TEST(FuzzerMutate, InsertRepeatedBytes1) {
   TestInsertRepeatedBytes(&MutationDispatcher::Mutate_InsertRepeatedBytes, 10000);
 }
 TEST(FuzzerMutate, InsertRepeatedBytes2) {
   TestInsertRepeatedBytes(&MutationDispatcher::Mutate, 300000);
 }
 
 void TestChangeByte(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   uint8_t CH0[8] = {0xF0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH1[8] = {0x00, 0xF1, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH2[8] = {0x00, 0x11, 0xF2, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH3[8] = {0x00, 0x11, 0x22, 0xF3, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH4[8] = {0x00, 0x11, 0x22, 0x33, 0xF4, 0x55, 0x66, 0x77};

 TEST(FuzzerMutate, ChangeByte1) {
   TestChangeByte(&MutationDispatcher::Mutate_ChangeByte, 1 << 15);
 }
 TEST(FuzzerMutate, ChangeByte2) {
   TestChangeByte(&MutationDispatcher::Mutate, 1 << 17);
 }
 
 void TestChangeBit(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   uint8_t CH0[8] = {0x01, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH1[8] = {0x00, 0x13, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH2[8] = {0x00, 0x11, 0x02, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH3[8] = {0x00, 0x11, 0x22, 0x37, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH4[8] = {0x00, 0x11, 0x22, 0x33, 0x54, 0x55, 0x66, 0x77};

 TEST(FuzzerMutate, ChangeBit1) {
   TestChangeBit(&MutationDispatcher::Mutate_ChangeBit, 1 << 16);
 }
 TEST(FuzzerMutate, ChangeBit2) {
   TestChangeBit(&MutationDispatcher::Mutate, 1 << 18);
 }
 
 void TestShuffleBytes(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   uint8_t CH0[7] = {0x00, 0x22, 0x11, 0x33, 0x44, 0x55, 0x66};
   uint8_t CH1[7] = {0x11, 0x00, 0x33, 0x22, 0x44, 0x55, 0x66};
   uint8_t CH2[7] = {0x00, 0x33, 0x11, 0x22, 0x44, 0x55, 0x66};
   uint8_t CH3[7] = {0x00, 0x11, 0x22, 0x44, 0x55, 0x66, 0x33};
   uint8_t CH4[7] = {0x00, 0x11, 0x22, 0x33, 0x55, 0x44, 0x66};

 TEST(FuzzerMutate, ShuffleBytes1) {
   TestShuffleBytes(&MutationDispatcher::Mutate_ShuffleBytes, 1 << 17);
 }
 TEST(FuzzerMutate, ShuffleBytes2) {
   TestShuffleBytes(&MutationDispatcher::Mutate, 1 << 20);
 }
 
 void TestCopyPart(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   uint8_t CH0[7] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x11};
   uint8_t CH1[7] = {0x55, 0x66, 0x22, 0x33, 0x44, 0x55, 0x66};
   uint8_t CH2[7] = {0x00, 0x55, 0x66, 0x33, 0x44, 0x55, 0x66};
   uint8_t CH3[7] = {0x00, 0x11, 0x22, 0x00, 0x11, 0x22, 0x66};
   uint8_t CH4[7] = {0x00, 0x11, 0x11, 0x22, 0x33, 0x55, 0x66};

 }
 TEST(FuzzerMutate, CopyPart2) {
   TestCopyPart(&MutationDispatcher::Mutate, 1 << 13);
 }
 TEST(FuzzerMutate, CopyPartNoInsertAtMaxSize) {
   // This (non exhaustively) tests if `Mutate_CopyPart` tries to perform an
   // insert on an input of size `MaxSize`.  Performing an insert in this case
   // will lead to the mutation failing.
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   uint8_t Data[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x11, 0x22};
   size_t MaxSize = sizeof(Data);
   for (int count = 0; count < (1 << 18); ++count) {
     size_t NewSize = MD->Mutate_CopyPart(Data, MaxSize, MaxSize);
     ASSERT_EQ(NewSize, MaxSize);
   }
 }
 
 void TestAddWordFromDictionary(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   uint8_t Word1[4] = {0xAA, 0xBB, 0xCC, 0xDD};
   uint8_t Word2[3] = {0xFF, 0xEE, 0xEF};
   MD->AddWordToManualDictionary(Word(Word1, sizeof(Word1)));
   MD->AddWordToManualDictionary(Word(Word2, sizeof(Word2)));
   int FoundMask = 0;
   uint8_t CH0[7] = {0x00, 0x11, 0x22, 0xAA, 0xBB, 0xCC, 0xDD};
TestAddWordFromDictionary(
       &MutationDispatcher::Mutate_AddWordFromManualDictionary, 1 << 15);
 }
 
 TEST(FuzzerMutate, AddWordFromDictionary2) {
   TestAddWordFromDictionary(&MutationDispatcher::Mutate, 1 << 15);
 }
 
 void TestChangeASCIIInteger(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
 
   uint8_t CH0[8] = {'1', '2', '3', '4', '5', '6', '7', '7'};
   uint8_t CH1[8] = {'1', '2', '3', '4', '5', '6', '7', '9'};
   uint8_t CH2[8] = {'2', '4', '6', '9', '1', '3', '5', '6'};
   uint8_t CH3[8] = {'0', '6', '1', '7', '2', '8', '3', '9'};
   int FoundMask = 0;
TestChangeASCIIInteger(&MutationDispatcher::Mutate_ChangeASCIIInteger,
                          1 << 15);
 }
 
 TEST(FuzzerMutate, ChangeASCIIInteger2) {
   TestChangeASCIIInteger(&MutationDispatcher::Mutate, 1 << 15);
 }
 
 void TestChangeBinaryInteger(Mutator M, int NumIter) {
-  std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
-  fuzzer::EF = t.get();
   Random Rand(0);
   std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
 
   uint8_t CH0[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x79};
   uint8_t CH1[8] = {0x00, 0x11, 0x22, 0x31, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH2[8] = {0xff, 0x10, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH3[8] = {0x00, 0x11, 0x2a, 0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t CH4[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x4f, 0x66, 0x77};