[libFuzzer] Decrease stack usage in unit tests

[aarongreen]

Summary

With 3 Dictionary objects, each containing space of ~16k DictionaryEntry objects, the MutationDispatcher object is fairly memory heavy. On platforms with a lower default stack size, this can cause panics in FuzzerUnittest as those tests stack-allocate the MutationDispatcher. This may be especially problematic for platforms that do not (yet) have a way to programmatically change their stack size, aside from link-time flags. In general, it seems more prudent to use the heap for an object of this size.

[kcc]

LGTM,
I'll land

lib/fuzzer/tests/FuzzerUnittest.cpp

 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   abort();
 }
 
 TEST(Fuzzer, CrossOver) {
   std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
   fuzzer::EF = t.get();
   Random Rand(0);
-  MutationDispatcher MD(Rand, {});
+  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 },
        { 0, 1, 2 },
        { 0, 1, 5 },
Unit Expected[] = {
        { 0, 5, 6, 1, 2, 7 },
        { 0, 5, 6, 1, 7, 2 },
        { 0, 5, 6, 7, 1, 2 }
   };
   for (size_t Len = 1; Len < 8; Len++) {
     Set<Unit> FoundUnits, ExpectedUnitsWitThisLength;
     for (int Iter = 0; Iter < 3000; Iter++) {
       C.resize(Len);
-      size_t NewSize = MD.CrossOver(A.data(), A.size(), B.data(), B.size(),
+      size_t NewSize = MD->CrossOver(A.data(), A.size(), B.data(), B.size(),
                                      C.data(), C.size());
       C.resize(NewSize);
       FoundUnits.insert(C);
     }
     for (const Unit &U : Expected)
       if (U.size() <= Len)
         ExpectedUnitsWitThisLength.insert(U);
     EXPECT_EQ(ExpectedUnitsWitThisLength, FoundUnits);
   }
void TestEraseBytes(Mutator M, int NumIter) {
   uint8_t REM10[6] = {0x00, 0x11, 0x22, 0x55, 0x66, 0x77};
 
   uint8_t REM11[5] = {0x33, 0x44, 0x55, 0x66, 0x77};
   uint8_t REM12[5] = {0x00, 0x11, 0x22, 0x33, 0x44};
   uint8_t REM13[5] = {0x00, 0x44, 0x55, 0x66, 0x77};
 
 
   Random Rand(0);
-  MutationDispatcher MD(Rand, {});
+  std::unique_ptr<MutationDispatcher> MD(new MutationDispatcher(Rand, {}));
   int FoundMask = 0;
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
-    size_t NewSize = (MD.*M)(T, sizeof(T), sizeof(T));
+    size_t NewSize = (*MD.*M)(T, sizeof(T), sizeof(T));
     if (NewSize == 7 && !memcmp(REM0, T, 7)) FoundMask |= 1 << 0;
     if (NewSize == 7 && !memcmp(REM1, T, 7)) FoundMask |= 1 << 1;
     if (NewSize == 7 && !memcmp(REM2, T, 7)) FoundMask |= 1 << 2;
     if (NewSize == 7 && !memcmp(REM3, T, 7)) FoundMask |= 1 << 3;
     if (NewSize == 7 && !memcmp(REM4, T, 7)) FoundMask |= 1 << 4;
     if (NewSize == 7 && !memcmp(REM5, T, 7)) FoundMask |= 1 << 5;
     if (NewSize == 7 && !memcmp(REM6, T, 7)) FoundMask |= 1 << 6;
     if (NewSize == 7 && !memcmp(REM7, T, 7)) FoundMask |= 1 << 7;

 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);
-  MutationDispatcher MD(Rand, {});
+  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};
   uint8_t INS5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0xF6, 0x55, 0x66};
   uint8_t INS6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xF7, 0x66};
   uint8_t INS7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xF8};
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
-    size_t NewSize = (MD.*M)(T, 7, 8);
+    size_t NewSize = (*MD.*M)(T, 7, 8);
     if (NewSize == 8 && !memcmp(INS0, T, 8)) FoundMask |= 1 << 0;
     if (NewSize == 8 && !memcmp(INS1, T, 8)) FoundMask |= 1 << 1;
     if (NewSize == 8 && !memcmp(INS2, T, 8)) FoundMask |= 1 << 2;
     if (NewSize == 8 && !memcmp(INS3, T, 8)) FoundMask |= 1 << 3;
     if (NewSize == 8 && !memcmp(INS4, T, 8)) FoundMask |= 1 << 4;
     if (NewSize == 8 && !memcmp(INS5, T, 8)) FoundMask |= 1 << 5;
     if (NewSize == 8 && !memcmp(INS6, T, 8)) FoundMask |= 1 << 6;
     if (NewSize == 8 && !memcmp(INS7, T, 8)) FoundMask |= 1 << 7;
   }
   EXPECT_EQ(FoundMask, 255);
 }
 
 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);
-  MutationDispatcher MD(Rand, {});
+  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};
 
   uint8_t INS5[8] = {0x00, 0x11, 0x22, 0x33, 'b', 'b', 'b', 'b'};
   uint8_t INS6[8] = {0x00, 0x11, 0x22, 'b', 'b', 'b', 'b', 0x33};
   uint8_t INS7[8] = {0x00, 0x11, 'b', 'b', 'b', 'b', 0x22, 0x33};
   uint8_t INS8[8] = {0x00, 'b', 'b', 'b', 'b', 0x11, 0x22, 0x33};
   uint8_t INS9[8] = {'b', 'b', 'b', 'b', 0x00, 0x11, 0x22, 0x33};
 
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33};
-    size_t NewSize = (MD.*M)(T, 4, 8);
+    size_t NewSize = (*MD.*M)(T, 4, 8);
     if (NewSize == 7 && !memcmp(INS0, T, 7)) FoundMask |= 1 << 0;
     if (NewSize == 7 && !memcmp(INS1, T, 7)) FoundMask |= 1 << 1;
     if (NewSize == 7 && !memcmp(INS2, T, 7)) FoundMask |= 1 << 2;
     if (NewSize == 7 && !memcmp(INS3, T, 7)) FoundMask |= 1 << 3;
     if (NewSize == 7 && !memcmp(INS4, T, 7)) FoundMask |= 1 << 4;
 
     if (NewSize == 8 && !memcmp(INS5, T, 8)) FoundMask |= 1 << 5;
     if (NewSize == 8 && !memcmp(INS6, T, 8)) FoundMask |= 1 << 6;

 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);
-  MutationDispatcher MD(Rand, {});
+  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};
   uint8_t CH5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0xF5, 0x66, 0x77};
   uint8_t CH6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xF5, 0x77};
   uint8_t CH7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xF7};
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[9] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
-    size_t NewSize = (MD.*M)(T, 8, 9);
+    size_t NewSize = (*MD.*M)(T, 8, 9);
     if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
     if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
     if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
     if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
     if (NewSize == 8 && !memcmp(CH4, T, 8)) FoundMask |= 1 << 4;
     if (NewSize == 8 && !memcmp(CH5, T, 8)) FoundMask |= 1 << 5;
     if (NewSize == 8 && !memcmp(CH6, T, 8)) FoundMask |= 1 << 6;
     if (NewSize == 8 && !memcmp(CH7, T, 8)) FoundMask |= 1 << 7;
   }
   EXPECT_EQ(FoundMask, 255);
 }
 
 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);
-  MutationDispatcher MD(Rand, {});
+  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};
   uint8_t CH5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x54, 0x66, 0x77};
   uint8_t CH6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x76, 0x77};
   uint8_t CH7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xF7};
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[9] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
-    size_t NewSize = (MD.*M)(T, 8, 9);
+    size_t NewSize = (*MD.*M)(T, 8, 9);
     if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
     if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
     if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
     if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
     if (NewSize == 8 && !memcmp(CH4, T, 8)) FoundMask |= 1 << 4;
     if (NewSize == 8 && !memcmp(CH5, T, 8)) FoundMask |= 1 << 5;
     if (NewSize == 8 && !memcmp(CH6, T, 8)) FoundMask |= 1 << 6;
     if (NewSize == 8 && !memcmp(CH7, T, 8)) FoundMask |= 1 << 7;
   }
   EXPECT_EQ(FoundMask, 255);
 }
 
 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);
-  MutationDispatcher MD(Rand, {});
+  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};
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[7] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
-    size_t NewSize = (MD.*M)(T, 7, 7);
+    size_t NewSize = (*MD.*M)(T, 7, 7);
     if (NewSize == 7 && !memcmp(CH0, T, 7)) FoundMask |= 1 << 0;
     if (NewSize == 7 && !memcmp(CH1, T, 7)) FoundMask |= 1 << 1;
     if (NewSize == 7 && !memcmp(CH2, T, 7)) FoundMask |= 1 << 2;
     if (NewSize == 7 && !memcmp(CH3, T, 7)) FoundMask |= 1 << 3;
     if (NewSize == 7 && !memcmp(CH4, T, 7)) FoundMask |= 1 << 4;
   }
   EXPECT_EQ(FoundMask, 31);
 }
 
 TEST(FuzzerMutate, ShuffleBytes1) {
   TestShuffleBytes(&MutationDispatcher::Mutate_ShuffleBytes, 1 << 16);
 }
 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);
-  MutationDispatcher MD(Rand, {});
+  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};
 
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[7] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
-    size_t NewSize = (MD.*M)(T, 7, 7);
+    size_t NewSize = (*MD.*M)(T, 7, 7);
     if (NewSize == 7 && !memcmp(CH0, T, 7)) FoundMask |= 1 << 0;
     if (NewSize == 7 && !memcmp(CH1, T, 7)) FoundMask |= 1 << 1;
     if (NewSize == 7 && !memcmp(CH2, T, 7)) FoundMask |= 1 << 2;
     if (NewSize == 7 && !memcmp(CH3, T, 7)) FoundMask |= 1 << 3;
     if (NewSize == 7 && !memcmp(CH4, T, 7)) FoundMask |= 1 << 4;
   }
 
   uint8_t CH5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x11, 0x22};
   uint8_t CH6[8] = {0x22, 0x33, 0x44, 0x00, 0x11, 0x22, 0x33, 0x44};
   uint8_t CH7[8] = {0x00, 0x11, 0x22, 0x00, 0x11, 0x22, 0x33, 0x44};
   uint8_t CH8[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x22, 0x33, 0x44};
   uint8_t CH9[8] = {0x00, 0x11, 0x22, 0x22, 0x33, 0x44, 0x33, 0x44};
 
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
-    size_t NewSize = (MD.*M)(T, 5, 8);
+    size_t NewSize = (*MD.*M)(T, 5, 8);
     if (NewSize == 8 && !memcmp(CH5, T, 8)) FoundMask |= 1 << 5;
     if (NewSize == 8 && !memcmp(CH6, T, 8)) FoundMask |= 1 << 6;
     if (NewSize == 8 && !memcmp(CH7, T, 8)) FoundMask |= 1 << 7;
     if (NewSize == 8 && !memcmp(CH8, T, 8)) FoundMask |= 1 << 8;
     if (NewSize == 8 && !memcmp(CH9, T, 8)) FoundMask |= 1 << 9;
   }
 
   EXPECT_EQ(FoundMask, 1023);
 }
 
 TEST(FuzzerMutate, CopyPart1) {
   TestCopyPart(&MutationDispatcher::Mutate_CopyPart, 1 << 10);
 }
 TEST(FuzzerMutate, CopyPart2) {
   TestCopyPart(&MutationDispatcher::Mutate, 1 << 13);
 }
 
 void TestAddWordFromDictionary(Mutator M, int NumIter) {
   std::unique_ptr<ExternalFunctions> t(new ExternalFunctions());
   fuzzer::EF = t.get();
   Random Rand(0);
-  MutationDispatcher MD(Rand, {});
+  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)));
+  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};
   uint8_t CH1[7] = {0x00, 0x11, 0xAA, 0xBB, 0xCC, 0xDD, 0x22};
   uint8_t CH2[7] = {0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0x11, 0x22};
   uint8_t CH3[7] = {0xAA, 0xBB, 0xCC, 0xDD, 0x00, 0x11, 0x22};
   uint8_t CH4[6] = {0x00, 0x11, 0x22, 0xFF, 0xEE, 0xEF};
   uint8_t CH5[6] = {0x00, 0x11, 0xFF, 0xEE, 0xEF, 0x22};
   uint8_t CH6[6] = {0x00, 0xFF, 0xEE, 0xEF, 0x11, 0x22};
   uint8_t CH7[6] = {0xFF, 0xEE, 0xEF, 0x00, 0x11, 0x22};
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[7] = {0x00, 0x11, 0x22};
-    size_t NewSize = (MD.*M)(T, 3, 7);
+    size_t NewSize = (*MD.*M)(T, 3, 7);
     if (NewSize == 7 && !memcmp(CH0, T, 7)) FoundMask |= 1 << 0;
     if (NewSize == 7 && !memcmp(CH1, T, 7)) FoundMask |= 1 << 1;
     if (NewSize == 7 && !memcmp(CH2, T, 7)) FoundMask |= 1 << 2;
     if (NewSize == 7 && !memcmp(CH3, T, 7)) FoundMask |= 1 << 3;
     if (NewSize == 6 && !memcmp(CH4, T, 6)) FoundMask |= 1 << 4;
     if (NewSize == 6 && !memcmp(CH5, T, 6)) FoundMask |= 1 << 5;
     if (NewSize == 6 && !memcmp(CH6, T, 6)) FoundMask |= 1 << 6;
     if (NewSize == 6 && !memcmp(CH7, T, 6)) FoundMask |= 1 << 7;

 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);
-  MutationDispatcher MD(Rand, {});
+  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;
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[8] = {'1', '2', '3', '4', '5', '6', '7', '8'};
-    size_t NewSize = (MD.*M)(T, 8, 8);
+    size_t NewSize = (*MD.*M)(T, 8, 8);
     /**/ if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
     else if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
     else if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
     else if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
     else if (NewSize == 8)                       FoundMask |= 1 << 4;
   }
   EXPECT_EQ(FoundMask, 31);
 }
 
 TEST(FuzzerMutate, ChangeASCIIInteger1) {
   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);
-  MutationDispatcher MD(Rand, {});
+  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};
   uint8_t CH5[8] = {0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88};
   uint8_t CH6[8] = {0x00, 0x11, 0x22, 0x00, 0x00, 0x00, 0x08, 0x77}; // Size
   uint8_t CH7[8] = {0x00, 0x08, 0x00, 0x33, 0x44, 0x55, 0x66, 0x77}; // Sw(Size)
 
   int FoundMask = 0;
   for (int i = 0; i < NumIter; i++) {
     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
-    size_t NewSize = (MD.*M)(T, 8, 8);
+    size_t NewSize = (*MD.*M)(T, 8, 8);
     /**/ if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
     else if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
     else if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
     else if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
     else if (NewSize == 8 && !memcmp(CH4, T, 8)) FoundMask |= 1 << 4;
     else if (NewSize == 8 && !memcmp(CH5, T, 8)) FoundMask |= 1 << 5;
     else if (NewSize == 8 && !memcmp(CH6, T, 8)) FoundMask |= 1 << 6;
     else if (NewSize == 8 && !memcmp(CH7, T, 8)) FoundMask |= 1 << 7;