libcxx/fuzzing/fuzz_test.cpp

   1 // -*- C++ -*-
   2 //===------------------------- fuzz_test.cpp ------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 //  A simple program for running regressions on the fuzzing routines.
  11 //  This code is not part of any shipping product.
  12 //
  13 //  To build:
  14 //      clang++ -std=c++11 fuzz_test.cpp fuzzing.cpp
  15 //
  16 //  To use:
  17 //      fuzz_test -r partial_sort [-v] files...
  18 //
  19 //  Each file should contain a test case.
  20
  21 //  TODO: should add some memory tracking, too.
  22
  23
  24 #include <iostream>
  25 #include <fstream>
  26 #include <iterator>
  27 #include <vector>
  28 #include <map>
  29 #include <chrono>
  30
  31 #include "fuzzing.h"
  32
  33 //  ==== Count memory allocations ====
  34
  35 struct MemoryCounters {
  36     size_t totalAllocationCount;
  37     size_t netAllocationCount;
  38     size_t totalBytesAllocated;
  39     };
  40
  41 MemoryCounters gMemoryCounters;
  42
  43 void ZeroMemoryCounters() {
  44     gMemoryCounters.totalAllocationCount = 0;
  45     gMemoryCounters.netAllocationCount = 0;
  46     gMemoryCounters.totalBytesAllocated = 0;
  47 }
  48
  49 void* operator new(std::size_t size)
  50 {
  51     if (size == 0) size = 1;
  52     void *p = ::malloc(size);
  53     if (p == NULL)
  54         throw std::bad_alloc();
  55     gMemoryCounters.totalAllocationCount += 1;
  56     gMemoryCounters.netAllocationCount  += 1;
  57     gMemoryCounters.totalBytesAllocated += size;
  58     return p;
  59 }
  60
  61 void* operator new(std::size_t size, const std::nothrow_t&) noexcept
  62 {
  63     try { return operator new(size); }
  64     catch (const std::bad_alloc &) {}
  65     return nullptr;
  66 }
  67
  68 void* operator new[](std::size_t size)
  69 {
  70     return ::operator new(size);
  71 }
  72
  73 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept
  74 {
  75     try { return operator new(size); }
  76     catch (const std::bad_alloc &) {}
  77     return nullptr;
  78 }
  79
  80 void  operator delete(void* ptr) noexcept
  81 {
  82     if (ptr)
  83         ::free(ptr);
  84     gMemoryCounters.netAllocationCount -= 1;
  85 }
  86
  87 void  operator delete(void* ptr, const std::nothrow_t&) noexcept
  88 {
  89     ::operator delete(ptr);
  90 }
  91
  92 void  operator delete[](void* ptr) noexcept
  93 {
  94     ::operator delete(ptr);
  95 }
  96
  97 void  operator delete[](void* ptr, const std::nothrow_t&) noexcept
  98 {
  99     ::operator delete(ptr);
 100 }
 101
 102 //  ==== End count memory allocations ====
 103
 104
 105 typedef int (*FuzzProc) (const uint8_t *data, size_t size);
 106
 107 const std::map<std::string, FuzzProc> procs = {
 108     {"sort",                fuzzing::sort},
 109     {"stable_sort",         fuzzing::stable_sort},
 110     {"partition",           fuzzing::partition},
 111     {"partition_copy",      fuzzing::partition_copy},
 112     {"stable_partition",    fuzzing::stable_partition},
 113     {"unique",              fuzzing::unique},
 114     {"unique_copy",         fuzzing::unique_copy},
 115     {"nth_element",         fuzzing::nth_element},
 116     {"partial_sort",        fuzzing::partial_sort},
 117     {"partial_sort_copy",   fuzzing::partial_sort_copy},
 118     {"make_heap",           fuzzing::make_heap},
 119     {"push_heap",           fuzzing::push_heap},
 120     {"pop_heap",            fuzzing::pop_heap},
 121     {"regex_ECMAScript",    fuzzing::regex_ECMAScript},
 122     {"regex_POSIX",         fuzzing::regex_POSIX},
 123     {"regex_extended",      fuzzing::regex_extended},
 124     {"regex_awk",           fuzzing::regex_awk},
 125     {"regex_grep",          fuzzing::regex_grep},
 126     {"regex_egrep",         fuzzing::regex_egrep},
 127     {"search",              fuzzing::search}
 128 };
 129
 130
 131
 132 bool verbose = false;
 133
 134 void test_one(const char *filename, FuzzProc fp)
 135 {
 136     std::vector<uint8_t> v;
 137     std::ifstream f (filename, std::ios::binary);
 138     if (!f.is_open())
 139         std::cerr << "## Can't open '" << filename << "'" << std::endl;
 140     else
 141     {
 142         typedef std::istream_iterator<uint8_t> Iter;
 143         std::copy(Iter(f), Iter(), std::back_inserter(v));
 144         if (verbose)
 145             std::cout << "File '" << filename << "' contains " << v.size() << " entries" << std::endl;
 146         ZeroMemoryCounters();
 147         const auto start_time = std::chrono::high_resolution_clock::now();
 148         int ret = fp (v.data(), v.size());
 149         const auto finish_time = std::chrono::high_resolution_clock::now();
 150         MemoryCounters mc = gMemoryCounters;
 151         if (ret != 0)
 152             std::cerr << "## Failure code: " << ret << std::endl;
 153         if (verbose)
 154         {
 155             std::cout << "Execution time: "
 156                 << std::chrono::duration_cast<std::chrono::milliseconds>(finish_time - start_time).count()
 157                 << " milliseconds" << std::endl;
 158             std::cout << "Memory: "
 159                       << mc.totalBytesAllocated  << " bytes allocated ("
 160                       << mc.totalAllocationCount << " allocations); "
 161                       << mc.netAllocationCount   << " allocations remain" << std::endl;
 162         }
 163     }
 164 }
 165
 166 void usage (const char *name)
 167 {
 168     std::cout << "Usage: " << name << " -r proc [-v] files..." << std::endl;
 169     std::cout << "Supported routines:" << std::endl;
 170     for (const auto &p : procs)
 171         std::cout << "    " << p.first << std::endl;
 172     std::cout << std::endl;
 173 }
 174
 175 // Poor man's command-line options
 176 const std::string dashR("-r");
 177 const std::string dashV("-v");
 178
 179 int main(int argc, char *argv[])
 180 {
 181     if (argc < 4 || dashR != argv[1] || procs.find(argv[2]) == procs.end())
 182         usage(argv[0]);
 183     else {
 184         FuzzProc fp = procs.find(argv[2])->second;
 185         int firstFile = 3;
 186         if (dashV == argv[firstFile])
 187         {
 188             verbose = true;
 189             ++firstFile;
 190         }
 191         for (int i = firstFile; i < argc; ++i)
 192             test_one(argv[i], fp);
 193         }
 194 }