This is an archive of the discontinued LLVM Phabricator instance.

Differential D18705

[libfuzzer] adding license headers to cpp files
ClosedPublic

Authored by aizatsky on Apr 1 2016, 11:38 AM.

Details

Reviewers
eugenis
Commits
rGf13cbee12e97: [libfuzzer] adding license headers to cpp files
rL265174: [libfuzzer] adding license headers to cpp files

Diff Detail

Repository
rL LLVM

Event Timeline

aizatsky updated this revision to Diff 52402.Apr 1 2016, 11:38 AM
aizatsky retitled this revision from to [libfuzzer] adding license headers to cpp files.
aizatsky updated this object.
aizatsky added a reviewer: eugenis.Apr 1 2016, 11:39 AM
aizatsky added a subscriber: llvm-commits.
Closed by commit rL265174: [libfuzzer] adding license headers to cpp files (authored by aizatsky). · Explain WhyApr 1 2016, 11:44 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 52404

llvm/trunk/lib/Fuzzer/test/BufferOverflowOnInput.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the string "Hi!". // Simple test for a fuzzer. The fuzzer must find the string "Hi!".
#include <assert.h> #include <assert.h>
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
static volatile bool SeedLargeBuffer; static volatile bool SeedLargeBuffer;
Show All 12 Lines

llvm/trunk/lib/Fuzzer/test/CallerCalleeTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. // Simple test for a fuzzer.
// Try to find the target using the indirect caller-callee pairs. // Try to find the target using the indirect caller-callee pairs.
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
#include <iostream> #include <iostream>
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/trunk/lib/Fuzzer/test/CounterTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Test for a fuzzer: must find the case where a particular basic block is // Test for a fuzzer: must find the case where a particular basic block is
// executed many times. // executed many times.
#include <iostream> #include <iostream>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
int Num = 0; int Num = 0;
for (size_t i = 0; i < Size; i++) for (size_t i = 0; i < Size; i++)
if (Data[i] == 'A' + i) if (Data[i] == 'A' + i)
Num++; Num++;
if (Num >= 4) { if (Num >= 4) {
std::cerr << "BINGO!\n"; std::cerr << "BINGO!\n";
exit(1); exit(1);
} }
return 0; return 0;
} }

llvm/trunk/lib/Fuzzer/test/CustomMutatorTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a cutom mutator. // Simple test for a cutom mutator.
#include <assert.h> #include <assert.h>
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
#include "FuzzerInterface.h" #include "FuzzerInterface.h"
Show All 27 Lines

llvm/trunk/lib/Fuzzer/test/FourIndependentBranchesTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the string "FUZZ". // Simple test for a fuzzer. The fuzzer must find the string "FUZZ".
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
int bits = 0; int bits = 0;
Show All 11 Lines

llvm/trunk/lib/Fuzzer/test/FullCoverageSetTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the string "FUZZER". // Simple test for a fuzzer. The fuzzer must find the string "FUZZER".
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
int bits = 0; int bits = 0;
Show All 13 Lines

llvm/trunk/lib/Fuzzer/test/FuzzerFnAdapterUnittest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
#include "FuzzerFnAdapter.h" #include "FuzzerFnAdapter.h"
#include "gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace fuzzer { namespace fuzzer {
namespace impl { namespace impl {
template <typename... Args> template <typename... Args>
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

llvm/trunk/lib/Fuzzer/test/FuzzerUnittest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
#include "FuzzerInternal.h" #include "FuzzerInternal.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <set> #include <set>
using namespace fuzzer; using namespace fuzzer;
// For now, have LLVMFuzzerTestOneInput just to make it link. // For now, have LLVMFuzzerTestOneInput just to make it link.
// Later we may want to make unittests that actually call LLVMFuzzerTestOneInput. // Later we may want to make unittests that actually call LLVMFuzzerTestOneInput.
▲ Show 20 Lines • Show All 414 Lines • Show Last 20 Lines

llvm/trunk/lib/Fuzzer/test/InitializeTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Make sure LLVMFuzzerInitialize is called. // Make sure LLVMFuzzerInitialize is called.
#include <assert.h> #include <assert.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
Show All 15 Lines

llvm/trunk/lib/Fuzzer/test/LeakTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Test with a leak. // Test with a leak.
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
static volatile void *Sink; static volatile void *Sink;
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
Sink = new int; Sink = new int;
return 0; return 0;
} }

llvm/trunk/lib/Fuzzer/test/LeakTimeoutTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Test with a leak. // Test with a leak.
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
static volatile int *Sink; static volatile int *Sink;
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
if (!Size) return 0; if (!Size) return 0;
Sink = new int; Sink = new int;
Sink = new int; Sink = new int;
while (Sink) *Sink = 0; // Infinite loop. while (Sink) *Sink = 0; // Infinite loop.
return 0; return 0;
} }

llvm/trunk/lib/Fuzzer/test/MemcmpTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find a particular string. // Simple test for a fuzzer. The fuzzer must find a particular string.
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
// TODO: check other sizes. // TODO: check other sizes.
Show All 20 Lines

llvm/trunk/lib/Fuzzer/test/NthRunCrashTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Crash on the N-th execution. // Crash on the N-th execution.
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
static int Counter; static int Counter;
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
if (Counter++ == 1000) { if (Counter++ == 1000) {
std::cout << "BINGO; Found the target, exiting\n"; std::cout << "BINGO; Found the target, exiting\n";
exit(1); exit(1);
} }
return 0; return 0;
} }

llvm/trunk/lib/Fuzzer/test/NullDerefTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the string "Hi!". // Simple test for a fuzzer. The fuzzer must find the string "Hi!".
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
static volatile int Sink; static volatile int Sink;
static volatile int *Null = 0; static volatile int *Null = 0;
Show All 15 Lines

llvm/trunk/lib/Fuzzer/test/RepeatedMemcmp.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
int Matches = 0; int Matches = 0;
Show All 11 Lines

llvm/trunk/lib/Fuzzer/test/SimpleCmpTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find several narrow ranges. // Simple test for a fuzzer. The fuzzer must find several narrow ranges.
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <cstdio> #include <cstdio>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
if (Size < 14) return 0; if (Size < 14) return 0;
Show All 23 Lines

llvm/trunk/lib/Fuzzer/test/SimpleDictionaryTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. // Simple test for a fuzzer.
// The fuzzer must find a string based on dictionary words: // The fuzzer must find a string based on dictionary words:
// "Elvis" // "Elvis"
// "Presley" // "Presley"
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
Show All 18 Lines

llvm/trunk/lib/Fuzzer/test/SimpleFnAdapterTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer Fn adapter. The fuzzer has to find two non-empty // Simple test for a fuzzer Fn adapter. The fuzzer has to find two non-empty
// vectors with the same content. // vectors with the same content.
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include "FuzzerFnAdapter.h" #include "FuzzerFnAdapter.h"
Show All 13 Lines

llvm/trunk/lib/Fuzzer/test/SimpleHashTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// This test computes a checksum of the data (all but the last 4 bytes), // This test computes a checksum of the data (all but the last 4 bytes),
// and then compares the last 4 bytes with the computed value. // and then compares the last 4 bytes with the computed value.
// A fuzzer with cmp traces is expected to defeat this check. // A fuzzer with cmp traces is expected to defeat this check.
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <cstdio> #include <cstdio>
Show All 29 Lines

llvm/trunk/lib/Fuzzer/test/SimpleTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the string "Hi!". // Simple test for a fuzzer. The fuzzer must find the string "Hi!".
#include <assert.h> #include <assert.h>
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
static volatile int Sink; static volatile int Sink;
Show All 16 Lines

llvm/trunk/lib/Fuzzer/test/SpamyTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// The test spams to stderr and stdout. // The test spams to stderr and stdout.
#include <assert.h> #include <assert.h>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
Show All 10 Lines

llvm/trunk/lib/Fuzzer/test/StrcmpTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Break through a series of strcmp. // Break through a series of strcmp.
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
bool Eq(const uint8_t *Data, size_t Size, const char *Str) { bool Eq(const uint8_t *Data, size_t Size, const char *Str) {
Show All 21 Lines

llvm/trunk/lib/Fuzzer/test/StrncmpTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find a particular string. // Simple test for a fuzzer. The fuzzer must find a particular string.
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
static volatile int sink; static volatile int sink;
Show All 17 Lines

llvm/trunk/lib/Fuzzer/test/SwitchTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the interesting switch value. // Simple test for a fuzzer. The fuzzer must find the interesting switch value.
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <cstddef> #include <cstddef>
static volatile int Sink; static volatile int Sink;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/trunk/lib/Fuzzer/test/ThreadedTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Threaded test for a fuzzer. The fuzzer should not crash. // Threaded test for a fuzzer. The fuzzer should not crash.
#include <assert.h> #include <assert.h>
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
#include <thread> #include <thread>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
Show All 15 Lines

llvm/trunk/lib/Fuzzer/test/TimeoutTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// Simple test for a fuzzer. The fuzzer must find the string "Hi!". // Simple test for a fuzzer. The fuzzer must find the string "Hi!".
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
static volatile int Sink; static volatile int Sink;
Show All 15 Lines

llvm/trunk/lib/Fuzzer/test/UninstrumentedTest.cpp

// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// This test should not be instrumented. // This test should not be instrumented.
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
return 0; return 0;
} }