diff options
Diffstat (limited to 'test/fuzzer')
125 files changed, 5145 insertions, 338 deletions
diff --git a/test/fuzzer/AbsNegAndConstant64Test.cpp b/test/fuzzer/AbsNegAndConstant64Test.cpp index abeb784e9a11..0ba80b61d033 100644 --- a/test/fuzzer/AbsNegAndConstant64Test.cpp +++ b/test/fuzzer/AbsNegAndConstant64Test.cpp @@ -14,7 +14,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { uint64_t y; memcpy(&x, Data, sizeof(x)); memcpy(&y, Data + sizeof(x), sizeof(y)); - if (llabs(x) < 0 && y == 0xbaddcafedeadbeefULL) { + volatile int64_t abs_x = llabs(x); + if (abs_x < 0 && y == 0xbaddcafedeadbeefULL) { printf("BINGO; Found the target, exiting; x = 0x%lx y 0x%lx\n", x, y); fflush(stdout); exit(1); diff --git a/test/fuzzer/AbsNegAndConstantTest.cpp b/test/fuzzer/AbsNegAndConstantTest.cpp index 049db0a60c3d..a3f534980010 100644 --- a/test/fuzzer/AbsNegAndConstantTest.cpp +++ b/test/fuzzer/AbsNegAndConstantTest.cpp @@ -14,7 +14,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { unsigned y; memcpy(&x, Data, sizeof(x)); memcpy(&y, Data + sizeof(x), sizeof(y)); - if (abs(x) < 0 && y == 0xbaddcafe) { + volatile int abs_x = abs(x); + if (abs_x < 0 && y == 0xbaddcafe) { printf("BINGO; Found the target, exiting; x = 0x%x y 0x%x\n", x, y); fflush(stdout); exit(1); diff --git a/test/fuzzer/AcquireCrashStateTest.cpp b/test/fuzzer/AcquireCrashStateTest.cpp new file mode 100644 index 000000000000..0fe71fd46bf4 --- /dev/null +++ b/test/fuzzer/AcquireCrashStateTest.cpp @@ -0,0 +1,18 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. + +// Ensures that error reports are suppressed after +// __sanitizer_acquire_crash_state() has been called the first time. +#include "sanitizer/common_interface_defs.h" + +#include <cassert> +#include <cstdint> +#include <cstdlib> + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + assert(Data); + if (Size == 0) return 0; + __sanitizer_acquire_crash_state(); + exit(0); // No report should be generated here. +} + diff --git a/test/fuzzer/Bingo.h b/test/fuzzer/Bingo.h new file mode 100644 index 000000000000..09fc61e2a0cb --- /dev/null +++ b/test/fuzzer/Bingo.h @@ -0,0 +1 @@ +#define BINGO aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa diff --git a/test/fuzzer/CMakeLists.txt b/test/fuzzer/CMakeLists.txt index bd511123255b..ef46ec4a9061 100644 --- a/test/fuzzer/CMakeLists.txt +++ b/test/fuzzer/CMakeLists.txt @@ -1,43 +1,109 @@ set(LIBFUZZER_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS}) -list(REMOVE_ITEM LIBFUZZER_TEST_DEPS SanitizerLintCheck) if (NOT COMPILER_RT_STANDALONE_BUILD) list(APPEND LIBFUZZER_TEST_DEPS fuzzer asan ubsan) + if (COMPILER_RT_HAS_MSAN) + list(APPEND LIBFUZZER_TEST_DEPS msan) + endif() + if (COMPILER_RT_HAS_DFSAN) + list(APPEND LIBFUZZER_TEST_DEPS dfsan) + endif() + if(NOT APPLE AND COMPILER_RT_HAS_LLD) + list(APPEND LIBFUZZER_TEST_DEPS lld) + endif() +endif() + +if (APPLE) + darwin_filter_host_archs(FUZZER_SUPPORTED_ARCH FUZZER_SUPPORTED_ARCH) endif() if(COMPILER_RT_INCLUDE_TESTS) list(APPEND LIBFUZZER_TEST_DEPS FuzzerUnitTests) endif() -set(LIBFUZZER_TESTSUITES) - +add_custom_target(check-fuzzer) if(COMPILER_RT_INCLUDE_TESTS) # libFuzzer unit tests. configure_lit_site_cfg( ${CMAKE_CURRENT_SOURCE_DIR}/unit/lit.site.cfg.in ${CMAKE_CURRENT_BINARY_DIR}/unit/lit.site.cfg) - list(APPEND LIBFUZZER_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/unit) + add_lit_testsuite(check-fuzzer-unit "Running Fuzzer unit tests" + ${CMAKE_CURRENT_BINARY_DIR}/unit + DEPENDS ${LIBFUZZER_TEST_DEPS}) + set_target_properties(check-fuzzer-unit PROPERTIES FOLDER "Compiler-RT Tests") + add_dependencies(check-fuzzer check-fuzzer-unit) endif() -foreach(arch ${FUZZER_SUPPORTED_ARCH}) - set(LIBFUZZER_TEST_COMPILER ${COMPILER_RT_TEST_COMPILER}) - get_test_cc_for_arch(${arch} LIBFUZZER_TEST_COMPILER LIBFUZZER_TEST_FLAGS) +macro(test_fuzzer stdlib) + cmake_parse_arguments(TEST "" "" "DEPS" ${ARGN}) + string(REPLACE "+" "x" stdlib_name ${stdlib}) + string(REPLACE "-" ";" stdlib_list ${stdlib_name}) + set(STDLIB_CAPITALIZED "") + foreach(part IN LISTS stdlib_list) + string(SUBSTRING ${part} 0 1 first_letter) + string(TOUPPER ${first_letter} first_letter) + string(REGEX REPLACE "^.(.*)" "${first_letter}\\1" part "${part}") + set(STDLIB_CAPITALIZED "${STDLIB_CAPITALIZED}${part}") + endforeach() + foreach(arch ${FUZZER_SUPPORTED_ARCH}) + set(LIBFUZZER_TEST_COMPILER ${COMPILER_RT_TEST_COMPILER}) + get_test_cc_for_arch(${arch} LIBFUZZER_TEST_COMPILER LIBFUZZER_TEST_FLAGS) - string(TOUPPER ${arch} ARCH_UPPER_CASE) - set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config) + set(LIBFUZZER_TEST_APPLE_PLATFORM "osx") - # LIT-based libFuzzer tests. - configure_lit_site_cfg( - ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in - ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg - ) - list(APPEND LIBFUZZER_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}) + set(LIBFUZZER_TEST_STDLIB ${stdlib}) + + string(TOUPPER ${arch} ARCH_UPPER_CASE) + set(CONFIG_NAME ${ARCH_UPPER_CASE}${STDLIB_CAPITALIZED}${OS_NAME}Config) -endforeach() + # LIT-based libFuzzer tests. + configure_lit_site_cfg( + ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in + ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg + ) -set(EXCLUDE_FROM_ALL ON) + add_lit_testsuite(check-fuzzer-${stdlib_name}-${arch} + "Running libFuzzer ${stdlib} tests for arch ${arch}" + ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/ + DEPENDS ${LIBFUZZER_TEST_DEPS}) + if(TEST_DEPS) + add_dependencies(check-fuzzer-${stdlib_name}-${arch} ${TEST_DEPS}) + endif() + set_target_properties(check-fuzzer-${stdlib_name}-${arch} + PROPERTIES FOLDER "Compiler-RT Tests") + add_dependencies(check-fuzzer check-fuzzer-${stdlib_name}-${arch}) + endforeach() +endmacro() -add_lit_testsuite(check-fuzzer "Running Fuzzer tests" - ${LIBFUZZER_TESTSUITES} - DEPENDS ${LIBFUZZER_TEST_DEPS}) -set_target_properties(check-fuzzer PROPERTIES FOLDER "Compiler-RT Tests") +test_fuzzer("default") +if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") + if(TARGET cxx_shared) + test_fuzzer("libc++" DEPS cxx_shared) + endif() + if(TARGET cxx_static) + test_fuzzer("static-libc++" DEPS cxx_static) + endif() +endif() + +if (APPLE) + set(EXCLUDE_FROM_ALL ON) + + foreach(arch ${DARWIN_ios_ARCHS}) + set(LIBFUZZER_TEST_APPLE_PLATFORM "ios") + set(LIBFUZZER_TEST_TARGET_ARCH ${arch}) + set(LIBFUZZER_TEST_FLAGS "-arch ${arch} -isysroot ${DARWIN_ios_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}") + set(LIBFUZZER_TEST_CONFIG_SUFFIX "-${arch}-${LIBFUZZER_TEST_APPLE_PLATFORM}") + string(TOUPPER ${arch} ARCH_UPPER_CASE) + set(CONFIG_NAME "IOS${ARCH_UPPER_CASE}Config") + configure_lit_site_cfg( + ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in + ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg + ) + add_lit_testsuite(check-fuzzer-ios-${arch} "libFuzzer iOS ${arch} tests" + ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/ + DEPENDS ${LIBFUZZER_TEST_DEPS}) + + endforeach() + + set(EXCLUDE_FROM_ALL OFF) +endif() diff --git a/test/fuzzer/CleanseTest.cpp b/test/fuzzer/CleanseTest.cpp index ee1845701269..d4efa12bb207 100644 --- a/test/fuzzer/CleanseTest.cpp +++ b/test/fuzzer/CleanseTest.cpp @@ -1,7 +1,7 @@ // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -// Test the the fuzzer is able to 'cleanse' the reproducer +// Test the fuzzer is able to 'cleanse' the reproducer // by replacing all irrelevant bytes with garbage. #include <cstddef> #include <cstdint> diff --git a/test/fuzzer/ExplodeDFSanLabelsTest.cpp b/test/fuzzer/ExplodeDFSanLabelsTest.cpp new file mode 100644 index 000000000000..0decff8ff086 --- /dev/null +++ b/test/fuzzer/ExplodeDFSanLabelsTest.cpp @@ -0,0 +1,23 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. + +// When tracing data flow, explode the number of DFSan labels. +#include <cstddef> +#include <cstdint> + +static volatile int sink; + +__attribute__((noinline)) +void f(uint8_t a, uint8_t b, uint8_t c, uint8_t d) { + if (a == b + 1 && c == d + 2) + sink++; +} + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + for (size_t a = 0; a < Size; a++) + for (size_t b = 0; b < Size; b++) + for (size_t c = 0; c < Size; c++) + for (size_t d = 0; d < Size; d++) + f(Data[a], Data[b], Data[c], Data[d]); + return 0; +} diff --git a/test/fuzzer/LeakTest.cpp b/test/fuzzer/LeakTest.cpp index ea89e3901057..f259e9d359f4 100644 --- a/test/fuzzer/LeakTest.cpp +++ b/test/fuzzer/LeakTest.cpp @@ -5,7 +5,7 @@ #include <cstddef> #include <cstdint> -static volatile void *Sink; +static void * volatile Sink; extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { if (Size > 0 && *Data == 'H') { diff --git a/test/fuzzer/MultipleConstraintsOnSmallInputTest.cpp b/test/fuzzer/MultipleConstraintsOnSmallInputTest.cpp new file mode 100644 index 000000000000..8e24acbcf2d9 --- /dev/null +++ b/test/fuzzer/MultipleConstraintsOnSmallInputTest.cpp @@ -0,0 +1,4129 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// echo -en 'Im_so_cute&pretty_:)' > crash +// +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdio.h> + +// Force noinline, as this test might be interesting for experimenting with +// data flow tracing approach started in https://reviews.llvm.org/D46666. +__attribute__((noinline)) +int func1(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 15 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func2(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 80 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func3(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 48 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func4(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) ^ a3; + if ( v > 44 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func5(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 72 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func6(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 72 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func7(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 43 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func8(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func9(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func10(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 83 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func11(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 117 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func12(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func13(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 80 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func14(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func15(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 116 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func16(uint8_t a1) { + char v = a1 >> 5; + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func17(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func18(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 28 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func19(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 18 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func20(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 47 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func21(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = (((a1 ^ a2))) & a3; + if ( v > 108 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func22(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func23(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 7 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func24(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 25 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func25(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func26(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 41 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func27(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 14 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func28(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func29(uint8_t a1) { + char v = a1 >> 5; + if ( v > 48 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func30(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func31(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 45 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func32(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func33(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func34(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 95 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func35(uint8_t a1) { + char v = a1 >> 5; + if ( v > 12 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func36(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 121 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func37(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func38(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 61 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func39(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func40(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 125 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func41(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func42(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = (((a1 ^ a2))) & a3; + if ( v > 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func43(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func44(uint8_t a1) { + char v = a1 >> 5; + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func45(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func46(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 106 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func47(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 33 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func48(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func49(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 58 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func50(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 42 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func51(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 46 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func52(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func53(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func54(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 23 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func55(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 17 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func56(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 90 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func57(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func58(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 102 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func59(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 49 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func60(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 26 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func61(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 55 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func62(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 103 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func63(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func64(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 34 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func65(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 90 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func66(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 4 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func67(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 50 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func68(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 37 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func69(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 48 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func70(uint8_t a1) { + char v = a1 << 6; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func71(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 85 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func72(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func73(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 30 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func74(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func75(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) | a3; + if ( v <= 59 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func76(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func77(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 30 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func78(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 32 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func79(uint8_t a1) { + char v = 16 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func80(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 ^ a2)) | a3; + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func81(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 120 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func82(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 81 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func83(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 119 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func84(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func85(uint8_t a1) { + char v = 2 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func86(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func87(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 84 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func88(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func89(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 47 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func90(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 60 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func91(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 13 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func92(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 38 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func93(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func94(uint8_t a1) { + char v = 16 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func95(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func96(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func97(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 48 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func98(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 102 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func99(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 96 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func100(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 ^ a2)) | a3; + if ( v != 127 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func101(uint8_t a1) { + char v = 4 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func102(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 43 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func103(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 95 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func104(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = (((a1 ^ a2))) & a3; + if ( v <= 2 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func105(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 65 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func106(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 24 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func107(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func108(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func109(uint8_t a1) { + char v = 2 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func110(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 101 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func111(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) | a3; + if ( v <= 121 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func112(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 40 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func113(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 50 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func114(uint8_t a1) { + char v = a1 << 6; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func115(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 12 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func116(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func117(uint8_t a1) { + char v = a1 >> 5; + if ( v > 79 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func118(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func119(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 44 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func120(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) | a3; + if ( v <= 28 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func121(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 93 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func122(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 40 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func123(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func124(uint8_t a1) { + char v = a1 >> 5; + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func125(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func126(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func127(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 8 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func128(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func129(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 3 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func130(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 102 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func131(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 68 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func132(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 73 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func133(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 68 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func134(uint8_t a1) { + char v = 16 * a1; + if ( v > 125 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func135(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 79 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func136(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 6 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func137(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func138(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func139(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func140(uint8_t a1) { + char v = a1 >> 5; + if ( v > 74 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func141(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func142(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 89 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func143(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 46 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func144(uint8_t a1) { + char v = 16 * a1; + if ( v <= 29 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func145(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 77 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func146(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 12 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func147(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func148(uint8_t a1) { + char v = a1 >> 5; + if ( v > 27 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func149(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func150(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 122 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func151(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 3 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func152(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 56 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func153(uint8_t a1) { + char v = 16 * a1; + if ( v <= 3 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func154(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 43 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func155(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func156(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func157(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func158(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func159(uint8_t a1) { + char v = a1 >> 5; + if ( v > 88 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func160(uint8_t a1) { + char v = ~a1; + if ( v > 33 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func161(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 46 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func162(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func163(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) | a3; + if ( v <= 9 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func164(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 96 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func165(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func166(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func167(uint8_t a1) { + char v = a1 >> 5; + if ( v > 91 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func168(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func169(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 32 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func170(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 32 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func171(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func172(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func173(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func174(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 90 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func175(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 32 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func176(uint8_t a1) { + char v = 16 * a1; + if ( v <= 61 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func177(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 33 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func178(uint8_t a1) { + char v = a1 >> 5; + if ( v > 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func179(uint8_t a1) { + char v = ~a1; + if ( v > 64 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func180(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 95 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func181(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 48 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func182(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 113 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func183(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 41 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func184(uint8_t a1) { + char v = 16 * a1; + if ( v <= 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func185(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func186(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func187(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 43 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func188(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 57 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func189(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func190(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 103 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func191(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 92 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func192(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func193(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) | a3; + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func194(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 20 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func195(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 82 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func196(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 117 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func197(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 50 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func198(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func199(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v == 127 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func200(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func201(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func202(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 56 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func203(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 95 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func204(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func205(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 ^ a2)) | a3; + if ( v > 95 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func206(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 78 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func207(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 7 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func208(uint8_t a1) { + char v = a1 >> 5; + if ( v > 123 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func209(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func210(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 101 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func211(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 61 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func212(uint8_t a1) { + char v = 16 * a1; + if ( v <= 73 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func213(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 34 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func214(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func215(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 5 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func216(uint8_t a1) { + char v = ~a1; + if ( v > 85 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func217(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 113 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func218(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 61 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func219(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 90 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func220(uint8_t a1) { + char v = a1 >> 5; + if ( v > 106 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func221(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func222(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 84 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func223(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 81 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func224(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func225(uint8_t a1) { + char v = a1 >> 5; + if ( v > 49 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func226(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func227(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func228(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 81 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func229(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 41 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func230(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 82 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func231(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 84 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func232(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 34 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func233(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func234(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 90 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func235(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 73 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func236(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 12 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func237(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 9 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func238(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 42 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func239(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 44 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func240(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 14 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func241(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func242(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 74 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func243(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 102 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func244(uint8_t a1) { + char v = 4 * a1; + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func245(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 87 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func246(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 29 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func247(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 51 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func248(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 74 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func249(uint8_t a1) { + char v = 4 * a1; + if ( v <= 103 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func250(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 56 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func251(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 11 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func252(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func253(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 22 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func254(uint8_t a1, uint8_t a2, uint8_t a3) { + char v = ((a1 & a2)) | a3; + if ( v > 122 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func255(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 74 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func256(uint8_t a1) { + char v = 4 * a1; + if ( v <= 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func257(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func258(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 102 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func259(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 74 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func260(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 27 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func261(uint8_t a1) { + char v = 4 * a1; + if ( v <= 58 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func262(uint8_t a1) { + char v = 4 * a1; + if ( v <= 77 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func263(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 3 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func264(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 13 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func265(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 47 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func266(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 39 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func267(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v == 127 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func268(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 66 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func269(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 47 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func270(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func271(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 122 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func272(uint8_t a1) { + char v = 4 * a1; + if ( v <= 65 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func273(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 120 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func274(uint8_t a1) { + char v = 4 * a1; + if ( v <= 83 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func275(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 99 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func276(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func277(uint8_t a1) { + char v = a1 >> 5; + if ( v > 42 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func278(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func279(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 110 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func280(uint8_t a1) { + char v = 4 * a1; + if ( v <= 92 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func281(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 59 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func282(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func283(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func284(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func285(uint8_t a1) { + char v = ~a1; + if ( v > 17 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func286(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func287(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 78 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func288(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 47 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func289(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 90 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func290(uint8_t a1) { + char v = 16 * a1; + if ( v <= 78 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func291(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 30 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func292(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func293(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func294(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func295(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 17 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func296(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 86 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func297(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 120 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func298(uint8_t a1) { + char v = 16 * a1; + if ( v <= 46 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func299(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func300(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 5 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func301(uint8_t a1) { + char v = ~a1; + if ( v > 17 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func302(uint8_t a1) { + char v = ~a1; + if ( v > 113 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func303(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func304(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 73 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func305(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 60 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func306(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 119 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func307(uint8_t a1) { + char v = ~a1; + if ( v > 21 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func308(uint8_t a1) { + char v = ~a1; + if ( v > 107 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func309(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 44 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func310(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 57 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func311(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 59 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func312(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func313(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func314(uint8_t a1) { + char v = a1 >> 5; + if ( v > 58 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func315(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func316(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 101 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func317(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 99 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func318(uint8_t a1) { + char v = 16 * a1; + if ( v <= 78 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func319(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 16 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func320(uint8_t a1) { + char v = ~a1; + if ( v > 10 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func321(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func322(uint8_t a1) { + char v = a1 >> 5; + if ( v > 3 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func323(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func324(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func325(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func326(uint8_t a1) { + char v = 16 * a1; + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func327(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 101 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func328(uint8_t a1) { + char v = a1 >> 5; + if ( v > 18 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func329(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func330(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func331(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func332(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 103 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func333(uint8_t a1) { + char v = 16 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func334(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 38 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func335(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func336(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func337(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func338(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func339(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 47 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func340(uint8_t a1) { + char v = a1 >> 5; + if ( v <= 0 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func341(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func342(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func343(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 58 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func344(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 91 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func345(uint8_t a1) { + char v = 16 * a1; + if ( v <= 72 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func346(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func347(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func348(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func349(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 57 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func350(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func351(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 99 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func352(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 63 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func353(uint8_t a1) { + char v = a1 >> 5; + if ( v > 81 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func354(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func355(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func356(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func357(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 72 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func358(uint8_t a1) { + char v = 16 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func359(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 110 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func360(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func361(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 68 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func362(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 91 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func363(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func364(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 99 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func365(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 40 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func366(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v <= 31 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func367(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func368(uint8_t a1) { + char v = a1 >> 5; + if ( v > 96 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func369(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func370(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 42 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func371(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 118 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func372(uint8_t a1) { + char v = (char)a1 >> 1; + if ( v > 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func373(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func374(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func375(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 64 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func376(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 110 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func377(uint8_t a1) { + char v = 4 * a1; + if ( v <= 104 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func378(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v > 112 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func379(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 62 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func380(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 48 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func381(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 58 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func382(uint8_t a1) { + char v = 4 * a1; + if ( v <= 104 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func383(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 50 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func384(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 38 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func385(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 85 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func386(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 18 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func387(uint8_t a1) { + char v = 4 * a1; + if ( v <= 97 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func388(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func389(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 26 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func390(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 67 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func391(uint8_t a1) { + char v = 4 * a1; + if ( v <= 103 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func392(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v > 50 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func393(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v <= 22 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func394(uint8_t a1) { + char v = 4 * a1; + if ( v <= 103 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func395(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 38 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func396(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 52 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func397(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 17 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func398(uint8_t a1) { + char v = 4 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func399(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 92 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func400(uint8_t a1, uint8_t a2) { + char v = (a1 & a2); + if ( v <= 55 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func401(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 81 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func402(uint8_t a1) { + char v = 4 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func403(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 94 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func404(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func405(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func406(uint8_t a1, uint8_t a2) { + char v = (a1 ^ a2); + if ( v > 101 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func407(uint8_t a1) { + char v = 4 * a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func408(uint8_t a1, uint8_t a2) { + char v = a1 | a2; + if ( v <= 44 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func409(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +__attribute__((noinline)) +int func410(uint8_t a1) { + char v = ~a1; + if ( v > 1 ) + return 0; + return 1; +} + +int api(const uint8_t *data, size_t size) { + if (size != 20) return 0; + + if (func1(data[0], data[1]) == 0) + return 0; + if (func2(data[0], data[1]) == 0) + return 0; + if (func3(data[18], data[1]) == 0) + return 0; + if (func4(data[7], data[4], data[0]) == 0) + return 0; + if (func5(data[0], data[2]) == 0) + return 0; + if (func6(data[11], data[17]) == 0) + return 0; + if (func7(data[0], data[13]) == 0) + return 0; + if (func8(data[13], data[10]) == 0) + return 0; + if (func9(data[11], data[16]) == 0) + return 0; + if (func10(data[10], data[8]) == 0) + return 0; + if (func11(data[19], data[5]) == 0) + return 0; + if (func12(data[0], data[1]) == 0) + return 0; + if (func13(data[17], data[3]) == 0) + return 0; + if (func14(data[14]) == 0) + return 0; + if (func15(data[13], data[15]) == 0) + return 0; + if (func16(data[0]) == 0) + return 0; + if (func17(data[19]) == 0) + return 0; + if (func18(data[1], data[11]) == 0) + return 0; + if (func19(data[12], data[15]) == 0) + return 0; + if (func20(data[13], data[1]) == 0) + return 0; + if (func21(data[10], data[19], data[12]) == 0) + return 0; + if (func22(data[6]) == 0) + return 0; + if (func23(data[1], data[9]) == 0) + return 0; + if (func24(data[16]) == 0) + return 0; + if (func25(data[6]) == 0) + return 0; + if (func26(data[4], data[12]) == 0) + return 0; + if (func27(data[16]) == 0) + return 0; + if (func28(data[14]) == 0) + return 0; + if (func29(data[0]) == 0) + return 0; + if (func30(data[19]) == 0) + return 0; + if (func31(data[0], data[1]) == 0) + return 0; + if (func32(data[0], data[1]) == 0) + return 0; + if (func33(data[14]) == 0) + return 0; + if (func34(data[0], data[19]) == 0) + return 0; + if (func35(data[0]) == 0) + return 0; + if (func36(data[16], data[7]) == 0) + return 0; + if (func37(data[19]) == 0) + return 0; + if (func38(data[15], data[3]) == 0) + return 0; + if (func39(data[19], data[15]) == 0) + return 0; + if (func40(data[0], data[1]) == 0) + return 0; + if (func41(data[18], data[1]) == 0) + return 0; + if (func42(data[16], data[5], data[1]) == 0) + return 0; + if (func43(data[14]) == 0) + return 0; + if (func44(data[0]) == 0) + return 0; + if (func45(data[19]) == 0) + return 0; + if (func46(data[4], data[19]) == 0) + return 0; + if (func47(data[8], data[7]) == 0) + return 0; + if (func48(data[6], data[7]) == 0) + return 0; + if (func49(data[18], data[1]) == 0) + return 0; + if (func50(data[2], data[8]) == 0) + return 0; + if (func51(data[2], data[13]) == 0) + return 0; + if (func52(data[3], data[8]) == 0) + return 0; + if (func53(data[16], data[18]) == 0) + return 0; + if (func54(data[10], data[9]) == 0) + return 0; + if (func55(data[18], data[1]) == 0) + return 0; + if (func56(data[0], data[1]) == 0) + return 0; + if (func57(data[16], data[1]) == 0) + return 0; + if (func58(data[18], data[1]) == 0) + return 0; + if (func59(data[18], data[3]) == 0) + return 0; + if (func60(data[9], data[1]) == 0) + return 0; + if (func61(data[0], data[1]) == 0) + return 0; + if (func62(data[13], data[1]) == 0) + return 0; + if (func63(data[18], data[1]) == 0) + return 0; + if (func64(data[0], data[1]) == 0) + return 0; + if (func65(data[0], data[1]) == 0) + return 0; + if (func66(data[11], data[14]) == 0) + return 0; + if (func67(data[5], data[11]) == 0) + return 0; + if (func68(data[18], data[1]) == 0) + return 0; + if (func69(data[0], data[6]) == 0) + return 0; + if (func70(data[2]) == 0) + return 0; + if (func71(data[0], data[1]) == 0) + return 0; + if (func72(data[9], data[10]) == 0) + return 0; + if (func73(data[10], data[8]) == 0) + return 0; + if (func74(data[19], data[17]) == 0) + return 0; + if (func75(data[0], data[17], data[8]) == 0) + return 0; + if (func76(data[17], data[18]) == 0) + return 0; + if (func77(data[18], data[9]) == 0) + return 0; + if (func78(data[3], data[6]) == 0) + return 0; + if (func79(data[16]) == 0) + return 0; + if (func80(data[7], data[3], data[17]) == 0) + return 0; + if (func81(data[0], data[1]) == 0) + return 0; + if (func82(data[10], data[18]) == 0) + return 0; + if (func83(data[6], data[7]) == 0) + return 0; + if (func84(data[0], data[6]) == 0) + return 0; + if (func85(data[12]) == 0) + return 0; + if (func86(data[0], data[1]) == 0) + return 0; + if (func87(data[6], data[1]) == 0) + return 0; + if (func88(data[18], data[1]) == 0) + return 0; + if (func89(data[0], data[6]) == 0) + return 0; + if (func90(data[0], data[1]) == 0) + return 0; + if (func91(data[18], data[1]) == 0) + return 0; + if (func92(data[0], data[6]) == 0) + return 0; + if (func93(data[13], data[10]) == 0) + return 0; + if (func94(data[2]) == 0) + return 0; + if (func95(data[0], data[1]) == 0) + return 0; + if (func96(data[0], data[11]) == 0) + return 0; + if (func97(data[18], data[1]) == 0) + return 0; + if (func98(data[0], data[6]) == 0) + return 0; + if (func99(data[0], data[19]) == 0) + return 0; + if (func100(data[14], data[18], data[3]) == 0) + return 0; + if (func101(data[14]) == 0) + return 0; + if (func102(data[6], data[1]) == 0) + return 0; + if (func103(data[5], data[1]) == 0) + return 0; + if (func104(data[14], data[3], data[10]) == 0) + return 0; + if (func105(data[18], data[1]) == 0) + return 0; + if (func106(data[0], data[6]) == 0) + return 0; + if (func107(data[6]) == 0) + return 0; + if (func108(data[9], data[10]) == 0) + return 0; + if (func109(data[7]) == 0) + return 0; + if (func110(data[9], data[17]) == 0) + return 0; + if (func111(data[16], data[15], data[18]) == 0) + return 0; + if (func112(data[0], data[16]) == 0) + return 0; + if (func113(data[18], data[3]) == 0) + return 0; + if (func114(data[3]) == 0) + return 0; + if (func115(data[0], data[1]) == 0) + return 0; + if (func116(data[14]) == 0) + return 0; + if (func117(data[0]) == 0) + return 0; + if (func118(data[19]) == 0) + return 0; + if (func119(data[0], data[6]) == 0) + return 0; + if (func120(data[9], data[5], data[0]) == 0) + return 0; + if (func121(data[0], data[1]) == 0) + return 0; + if (func122(data[12], data[4]) == 0) + return 0; + if (func123(data[14]) == 0) + return 0; + if (func124(data[0]) == 0) + return 0; + if (func125(data[19]) == 0) + return 0; + if (func126(data[14]) == 0) + return 0; + if (func127(data[1], data[9]) == 0) + return 0; + if (func128(data[19]) == 0) + return 0; + if (func129(data[11], data[14]) == 0) + return 0; + if (func130(data[11], data[9]) == 0) + return 0; + if (func131(data[12], data[15]) == 0) + return 0; + if (func132(data[0], data[2]) == 0) + return 0; + if (func133(data[13], data[1]) == 0) + return 0; + if (func134(data[7]) == 0) + return 0; + if (func135(data[13], data[5]) == 0) + return 0; + if (func136(data[12], data[14]) == 0) + return 0; + if (func137(data[9], data[4]) == 0) + return 0; + if (func138(data[6]) == 0) + return 0; + if (func139(data[14]) == 0) + return 0; + if (func140(data[0]) == 0) + return 0; + if (func141(data[19]) == 0) + return 0; + if (func142(data[11], data[9]) == 0) + return 0; + if (func143(data[12], data[15]) == 0) + return 0; + if (func144(data[7]) == 0) + return 0; + if (func145(data[19], data[7]) == 0) + return 0; + if (func146(data[4], data[6]) == 0) + return 0; + if (func147(data[6]) == 0) + return 0; + if (func148(data[0]) == 0) + return 0; + if (func149(data[19]) == 0) + return 0; + if (func150(data[11], data[9]) == 0) + return 0; + if (func151(data[12], data[15]) == 0) + return 0; + if (func152(data[13], data[1]) == 0) + return 0; + if (func153(data[7]) == 0) + return 0; + if (func154(data[2], data[8]) == 0) + return 0; + if (func155(data[13], data[5]) == 0) + return 0; + if (func156(data[6]) == 0) + return 0; + if (func157(data[6]) == 0) + return 0; + if (func158(data[14]) == 0) + return 0; + if (func159(data[0]) == 0) + return 0; + if (func160(data[19]) == 0) + return 0; + if (func161(data[12], data[15]) == 0) + return 0; + if (func162(data[5]) == 0) + return 0; + if (func163(data[6], data[7], data[3]) == 0) + return 0; + if (func164(data[13], data[5]) == 0) + return 0; + if (func165(data[6]) == 0) + return 0; + if (func166(data[14]) == 0) + return 0; + if (func167(data[0]) == 0) + return 0; + if (func168(data[19]) == 0) + return 0; + if (func169(data[11], data[9]) == 0) + return 0; + if (func170(data[9], data[11]) == 0) + return 0; + if (func171(data[6]) == 0) + return 0; + if (func172(data[14]) == 0) + return 0; + if (func173(data[19]) == 0) + return 0; + if (func174(data[11], data[9]) == 0) + return 0; + if (func175(data[12], data[15]) == 0) + return 0; + if (func176(data[7]) == 0) + return 0; + if (func177(data[13], data[5]) == 0) + return 0; + if (func178(data[0]) == 0) + return 0; + if (func179(data[19]) == 0) + return 0; + if (func180(data[11], data[9]) == 0) + return 0; + if (func181(data[12], data[15]) == 0) + return 0; + if (func182(data[13], data[1]) == 0) + return 0; + if (func183(data[7], data[17]) == 0) + return 0; + if (func184(data[7]) == 0) + return 0; + if (func185(data[6]) == 0) + return 0; + if (func186(data[4], data[12]) == 0) + return 0; + if (func187(data[2], data[8]) == 0) + return 0; + if (func188(data[16]) == 0) + return 0; + if (func189(data[6]) == 0) + return 0; + if (func190(data[4], data[12]) == 0) + return 0; + if (func191(data[16]) == 0) + return 0; + if (func192(data[19]) == 0) + return 0; + if (func193(data[19], data[4], data[2]) == 0) + return 0; + if (func194(data[11], data[9]) == 0) + return 0; + if (func195(data[12], data[15]) == 0) + return 0; + if (func196(data[13], data[15]) == 0) + return 0; + if (func197(data[13], data[1]) == 0) + return 0; + if (func198(data[19], data[5]) == 0) + return 0; + if (func199(data[13], data[5]) == 0) + return 0; + if (func200(data[6]) == 0) + return 0; + if (func201(data[4], data[12]) == 0) + return 0; + if (func202(data[5], data[17]) == 0) + return 0; + if (func203(data[16]) == 0) + return 0; + if (func204(data[6]) == 0) + return 0; + if (func205(data[7], data[3], data[17]) == 0) + return 0; + if (func206(data[4], data[12]) == 0) + return 0; + if (func207(data[16]) == 0) + return 0; + if (func208(data[0]) == 0) + return 0; + if (func209(data[19]) == 0) + return 0; + if (func210(data[11], data[9]) == 0) + return 0; + if (func211(data[13], data[1]) == 0) + return 0; + if (func212(data[7]) == 0) + return 0; + if (func213(data[13], data[5]) == 0) + return 0; + if (func214(data[6]) == 0) + return 0; + if (func215(data[4], data[12]) == 0) + return 0; + if (func216(data[6]) == 0) + return 0; + if (func217(data[4], data[12]) == 0) + return 0; + if (func218(data[16]) == 0) + return 0; + if (func219(data[16]) == 0) + return 0; + if (func220(data[0]) == 0) + return 0; + if (func221(data[19]) == 0) + return 0; + if (func222(data[0], data[1]) == 0) + return 0; + if (func223(data[0], data[1]) == 0) + return 0; + if (func224(data[14]) == 0) + return 0; + if (func225(data[0]) == 0) + return 0; + if (func226(data[19]) == 0) + return 0; + if (func227(data[0], data[1]) == 0) + return 0; + if (func228(data[0], data[1]) == 0) + return 0; + if (func229(data[18], data[1]) == 0) + return 0; + if (func230(data[0], data[1]) == 0) + return 0; + if (func231(data[17], data[3]) == 0) + return 0; + if (func232(data[0], data[1]) == 0) + return 0; + if (func233(data[18], data[1]) == 0) + return 0; + if (func234(data[0], data[1]) == 0) + return 0; + if (func235(data[18], data[4]) == 0) + return 0; + if (func236(data[18], data[1]) == 0) + return 0; + if (func237(data[0], data[1]) == 0) + return 0; + if (func238(data[2], data[8]) == 0) + return 0; + if (func239(data[13], data[0]) == 0) + return 0; + if (func240(data[0], data[1]) == 0) + return 0; + if (func241(data[0], data[1]) == 0) + return 0; + if (func242(data[18], data[1]) == 0) + return 0; + if (func243(data[0], data[6]) == 0) + return 0; + if (func244(data[2]) == 0) + return 0; + if (func245(data[0], data[1]) == 0) + return 0; + if (func246(data[1], data[11]) == 0) + return 0; + if (func247(data[18], data[1]) == 0) + return 0; + if (func248(data[0], data[6]) == 0) + return 0; + if (func249(data[2]) == 0) + return 0; + if (func250(data[0], data[1]) == 0) + return 0; + if (func251(data[4], data[6]) == 0) + return 0; + if (func252(data[0], data[1]) == 0) + return 0; + if (func253(data[18], data[1]) == 0) + return 0; + if (func254(data[16], data[15], data[18]) == 0) + return 0; + if (func255(data[0], data[6]) == 0) + return 0; + if (func256(data[2]) == 0) + return 0; + if (func257(data[16], data[18]) == 0) + return 0; + if (func258(data[0], data[1]) == 0) + return 0; + if (func259(data[0], data[6]) == 0) + return 0; + if (func260(data[9], data[13]) == 0) + return 0; + if (func261(data[2]) == 0) + return 0; + if (func262(data[2]) == 0) + return 0; + if (func263(data[0], data[1]) == 0) + return 0; + if (func264(data[0], data[1]) == 0) + return 0; + if (func265(data[0], data[6]) == 0) + return 0; + if (func266(data[7], data[4]) == 0) + return 0; + if (func267(data[16], data[7]) == 0) + return 0; + if (func268(data[0], data[1]) == 0) + return 0; + if (func269(data[0], data[1]) == 0) + return 0; + if (func270(data[18], data[1]) == 0) + return 0; + if (func271(data[13], data[3]) == 0) + return 0; + if (func272(data[2]) == 0) + return 0; + if (func273(data[0], data[1]) == 0) + return 0; + if (func274(data[2]) == 0) + return 0; + if (func275(data[0], data[1]) == 0) + return 0; + if (func276(data[14]) == 0) + return 0; + if (func277(data[0]) == 0) + return 0; + if (func278(data[19]) == 0) + return 0; + if (func279(data[0], data[6]) == 0) + return 0; + if (func280(data[2]) == 0) + return 0; + if (func281(data[0], data[1]) == 0) + return 0; + if (func282(data[8], data[0]) == 0) + return 0; + if (func283(data[14]) == 0) + return 0; + if (func284(data[19]) == 0) + return 0; + if (func285(data[14]) == 0) + return 0; + if (func286(data[19]) == 0) + return 0; + if (func287(data[11], data[9]) == 0) + return 0; + if (func288(data[12], data[15]) == 0) + return 0; + if (func289(data[13], data[1]) == 0) + return 0; + if (func290(data[7]) == 0) + return 0; + if (func291(data[13], data[5]) == 0) + return 0; + if (func292(data[6]) == 0) + return 0; + if (func293(data[14]) == 0) + return 0; + if (func294(data[19]) == 0) + return 0; + if (func295(data[11], data[9]) == 0) + return 0; + if (func296(data[12], data[15]) == 0) + return 0; + if (func297(data[12], data[4]) == 0) + return 0; + if (func298(data[7]) == 0) + return 0; + if (func299(data[13], data[5]) == 0) + return 0; + if (func300(data[12], data[14]) == 0) + return 0; + if (func301(data[6]) == 0) + return 0; + if (func302(data[14]) == 0) + return 0; + if (func303(data[19]) == 0) + return 0; + if (func304(data[11], data[9]) == 0) + return 0; + if (func305(data[12], data[15]) == 0) + return 0; + if (func306(data[13], data[1]) == 0) + return 0; + if (func307(data[6]) == 0) + return 0; + if (func308(data[19]) == 0) + return 0; + if (func309(data[12], data[15]) == 0) + return 0; + if (func310(data[13], data[1]) == 0) + return 0; + if (func311(data[13], data[5]) == 0) + return 0; + if (func312(data[6]) == 0) + return 0; + if (func313(data[14]) == 0) + return 0; + if (func314(data[0]) == 0) + return 0; + if (func315(data[9]) == 0) + return 0; + if (func316(data[11], data[9]) == 0) + return 0; + if (func317(data[13], data[1]) == 0) + return 0; + if (func318(data[7]) == 0) + return 0; + if (func319(data[13], data[4]) == 0) + return 0; + if (func320(data[16]) == 0) + return 0; + if (func321(data[4]) == 0) + return 0; + if (func322(data[0]) == 0) + return 0; + if (func323(data[19]) == 0) + return 0; + if (func324(data[11], data[9]) == 0) + return 0; + if (func325(data[12], data[15]) == 0) + return 0; + if (func326(data[7]) == 0) + return 0; + if (func327(data[13], data[5]) == 0) + return 0; + if (func328(data[0]) == 0) + return 0; + if (func329(data[19]) == 0) + return 0; + if (func330(data[11], data[9]) == 0) + return 0; + if (func331(data[12], data[15]) == 0) + return 0; + if (func332(data[13], data[1]) == 0) + return 0; + if (func333(data[4]) == 0) + return 0; + if (func334(data[13], data[5]) == 0) + return 0; + if (func335(data[6]) == 0) + return 0; + if (func336(data[4], data[12]) == 0) + return 0; + if (func337(data[16]) == 0) + return 0; + if (func338(data[6]) == 0) + return 0; + if (func339(data[16]) == 0) + return 0; + if (func340(data[0]) == 0) + return 0; + if (func341(data[19]) == 0) + return 0; + if (func342(data[11], data[9]) == 0) + return 0; + if (func343(data[12], data[15]) == 0) + return 0; + if (func344(data[13], data[1]) == 0) + return 0; + if (func345(data[7]) == 0) + return 0; + if (func346(data[13], data[5]) == 0) + return 0; + if (func347(data[6]) == 0) + return 0; + if (func348(data[4], data[12]) == 0) + return 0; + if (func349(data[16]) == 0) + return 0; + if (func350(data[6]) == 0) + return 0; + if (func351(data[4], data[12]) == 0) + return 0; + if (func352(data[16]) == 0) + return 0; + if (func353(data[0]) == 0) + return 0; + if (func354(data[19]) == 0) + return 0; + if (func355(data[11], data[9]) == 0) + return 0; + if (func356(data[8], data[15]) == 0) + return 0; + if (func357(data[7], data[1]) == 0) + return 0; + if (func358(data[17]) == 0) + return 0; + if (func359(data[3], data[5]) == 0) + return 0; + if (func360(data[6]) == 0) + return 0; + if (func361(data[4], data[12]) == 0) + return 0; + if (func362(data[16]) == 0) + return 0; + if (func363(data[6]) == 0) + return 0; + if (func364(data[4], data[12]) == 0) + return 0; + if (func365(data[16]) == 0) + return 0; + if (func366(data[16]) == 0) + return 0; + if (func367(data[14]) == 0) + return 0; + if (func368(data[0]) == 0) + return 0; + if (func369(data[19]) == 0) + return 0; + if (func370(data[3], data[1]) == 0) + return 0; + if (func371(data[4], data[1]) == 0) + return 0; + if (func372(data[16]) == 0) + return 0; + if (func373(data[14]) == 0) + return 0; + if (func374(data[19]) == 0) + return 0; + if (func375(data[0], data[1]) == 0) + return 0; + if (func376(data[0], data[1]) == 0) + return 0; + if (func377(data[2]) == 0) + return 0; + if (func378(data[0], data[1]) == 0) + return 0; + if (func379(data[0], data[1]) == 0) + return 0; + if (func380(data[18], data[1]) == 0) + return 0; + if (func381(data[0], data[6]) == 0) + return 0; + if (func382(data[2]) == 0) + return 0; + if (func383(data[8], data[1]) == 0) + return 0; + if (func384(data[5], data[1]) == 0) + return 0; + if (func385(data[18], data[1]) == 0) + return 0; + if (func386(data[0], data[6]) == 0) + return 0; + if (func387(data[2]) == 0) + return 0; + if (func388(data[0], data[1]) == 0) + return 0; + if (func389(data[18], data[1]) == 0) + return 0; + if (func390(data[0], data[6]) == 0) + return 0; + if (func391(data[2]) == 0) + return 0; + if (func392(data[18], data[1]) == 0) + return 0; + if (func393(data[0], data[6]) == 0) + return 0; + if (func394(data[2]) == 0) + return 0; + if (func395(data[0], data[1]) == 0) + return 0; + if (func396(data[0], data[1]) == 0) + return 0; + if (func397(data[18], data[1]) == 0) + return 0; + if (func398(data[9]) == 0) + return 0; + if (func399(data[0], data[1]) == 0) + return 0; + if (func400(data[0], data[1]) == 0) + return 0; + if (func401(data[8], data[6]) == 0) + return 0; + if (func402(data[12]) == 0) + return 0; + if (func403(data[0], data[1]) == 0) + return 0; + if (func404(data[12]) == 0) + return 0; + if (func405(data[1]) == 0) + return 0; + if (func406(data[0], data[6]) == 0) + return 0; + if (func407(data[4]) == 0) + return 0; + if (func408(data[0], data[1]) == 0) + return 0; + if (func409(data[14]) == 0) + return 0; + if (func410(data[14]) == 0) + return 0; + + fprintf(stderr, "BINGO\n"); + abort(); + return 1; +} + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (api(Data, Size)) { + // Should've crashed before getting here. + return 0; + } + return 0; +} + diff --git a/test/fuzzer/NullDerefTest.cpp b/test/fuzzer/NullDerefTest.cpp index 1b44b682ace6..48df0f54cfe0 100644 --- a/test/fuzzer/NullDerefTest.cpp +++ b/test/fuzzer/NullDerefTest.cpp @@ -5,7 +5,7 @@ #include <cstddef> #include <cstdint> #include <cstdlib> -#include <iostream> +#include <cstdio> static volatile int Sink; static volatile int *Null = 0; @@ -16,7 +16,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { if (Size > 1 && Data[1] == 'i') { Sink = 2; if (Size > 2 && Data[2] == '!') { - std::cout << "Found the target, dereferencing NULL\n"; + printf("Found the target, dereferencing NULL\n"); *Null = 1; } } diff --git a/test/fuzzer/OnlySomeBytesTest.cpp b/test/fuzzer/OnlySomeBytesTest.cpp new file mode 100644 index 000000000000..076cda063459 --- /dev/null +++ b/test/fuzzer/OnlySomeBytesTest.cpp @@ -0,0 +1,40 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. + +// Find ABCxxFxUxZxxx... (2048+ bytes, 'x' is any byte) +#include <assert.h> +#include <cstddef> +#include <cstdint> +#include <cstdlib> +#include <cstring> +#include <cstdio> + +const size_t N = 2048; +typedef const uint8_t *IN; + +static volatile int one = 1; + +extern "C" { +__attribute__((noinline)) void bad() { + fprintf(stderr, "BINGO\n"); + if (one) + abort(); +} + +__attribute__((noinline)) void f0(IN in) { + uint32_t x = in[5] + 251 * in[7] + 251 * 251 * in[9]; + if (x == 'F' + 251 * 'U' + 251 * 251 * 'Z') + bad(); +} + +__attribute__((noinline)) void fC(IN in) { if (in[2] == 'C') f0(in); } +__attribute__((noinline)) void fB(IN in) { if (in[1] == 'B') fC(in); } +__attribute__((noinline)) void fA(IN in) { if (in[0] == 'A') fB(in); } + +} // extern "C" + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (Size < N) return 0; + fA((IN)Data); + return 0; +} diff --git a/test/fuzzer/PrintUnstableStatsTest.cpp b/test/fuzzer/PrintUnstableStatsTest.cpp new file mode 100644 index 000000000000..078eb4c3d971 --- /dev/null +++ b/test/fuzzer/PrintUnstableStatsTest.cpp @@ -0,0 +1,69 @@ +#include <assert.h> +#include <cstdint> +#include <cstdio> +#include <cstdlib> + +int x = 0; +bool skip0 = false; +bool skip1 = false; +bool skip2 = false; + +__attribute__((noinline)) void det0() { x++; } +__attribute__((noinline)) void det1() { x++; } +__attribute__((noinline)) void det2() { x++; } +__attribute__((noinline)) void det3() { x++; } +__attribute__((noinline)) void det4() { x++; } + +__attribute__((noinline)) void ini0() { x++; } +__attribute__((noinline)) void ini1() { x++; } +__attribute__((noinline)) void ini2() { x++; } + +__attribute__((noinline)) void t0() { x++; } +__attribute__((noinline)) void t1() { x++; } +__attribute__((noinline)) void t2() { x++; } +__attribute__((noinline)) void t3() { x++; } +__attribute__((noinline)) void t4() { x++; } + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (Size == 1 && Data[0] == 'A' && !skip0) { + skip0 = true; + ini0(); + } + if (Size == 1 && Data[0] == 'B' && !skip1) { + skip1 = true; + ini1(); + } + if (Size == 1 && Data[0] == 'C' && !skip2) { + skip2 = true; + ini2(); + } + + det0(); + det1(); + int a = rand(); + det2(); + + switch (a % 5) { + case 0: + t0(); + break; + case 1: + t1(); + break; + case 2: + t2(); + break; + case 3: + t3(); + break; + case 4: + t4(); + break; + default: + assert(false); + } + + det3(); + det4(); + return 0; +} diff --git a/test/fuzzer/ShrinkValueProfileTest.cpp b/test/fuzzer/ShrinkValueProfileTest.cpp index 86e4e3cb0d9a..dddf493da697 100644 --- a/test/fuzzer/ShrinkValueProfileTest.cpp +++ b/test/fuzzer/ShrinkValueProfileTest.cpp @@ -1,7 +1,7 @@ // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -// Test that we can find the minimal item in the corpus (3 bytes: "FUZ"). +// Test that we can find the minimal item in the corpus (4 bytes: "FUZZ"). #include <cstddef> #include <cstdint> #include <cstdio> diff --git a/test/fuzzer/SimpleCmpTest.cpp b/test/fuzzer/SimpleCmpTest.cpp index 8acad4ac77e8..3bb28c17318b 100644 --- a/test/fuzzer/SimpleCmpTest.cpp +++ b/test/fuzzer/SimpleCmpTest.cpp @@ -17,15 +17,15 @@ bool PrintOnce(int Line) { } extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { - if (Size != 22) return 0; + if (Size != 24) return 0; uint64_t x = 0; int64_t y = 0; int32_t z = 0; - uint16_t a = 0; + uint32_t a = 0; memcpy(&x, Data, 8); // 8 memcpy(&y, Data + 8, 8); // 16 memcpy(&z, Data + 16, sizeof(z)); // 20 - memcpy(&a, Data + 20, sizeof(a)); // 22 + memcpy(&a, Data + 20, sizeof(a)); // 24 const bool k32bit = sizeof(void*) == 4; if ((k32bit || x > 1234567890) && PrintOnce(__LINE__) && diff --git a/test/fuzzer/SimpleTestStdio.cpp b/test/fuzzer/SimpleTestStdio.cpp new file mode 100644 index 000000000000..ed7fe1cb3f67 --- /dev/null +++ b/test/fuzzer/SimpleTestStdio.cpp @@ -0,0 +1,26 @@ +// 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!". +#include <assert.h> +#include <cstdint> +#include <cstdio> +#include <cstdlib> + +static volatile int Sink; + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + assert(Data); + if (Size > 0 && Data[0] == 'H') { + Sink = 1; + if (Size > 1 && Data[1] == 'i') { + Sink = 2; + if (Size > 2 && Data[2] == '!') { + fprintf(stderr, "BINGO; Found the target, exiting\n"); + exit(0); + } + } + } + return 0; +} + diff --git a/test/fuzzer/SwapCmpTest.cpp b/test/fuzzer/SwapCmpTest.cpp index bbfbefe6ab71..5aa47beb22bb 100644 --- a/test/fuzzer/SwapCmpTest.cpp +++ b/test/fuzzer/SwapCmpTest.cpp @@ -11,14 +11,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { if (Size < 14) return 0; uint64_t x = 0; uint32_t y = 0; - uint16_t z = 0; + uint32_t z = 0; memcpy(&x, Data, sizeof(x)); memcpy(&y, Data + Size / 2, sizeof(y)); memcpy(&z, Data + Size - sizeof(z), sizeof(z)); x = __builtin_bswap64(x); y = __builtin_bswap32(y); - z = __builtin_bswap16(z); + z = __builtin_bswap32(z); const bool k32bit = sizeof(void*) == 4; if ((k32bit || x == 0x46555A5A5A5A5546ULL) && @@ -26,7 +26,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { y == 0x66757A7A && true ) { - if (Data[Size - 3] == 'z') { + if (Data[Size - 5] == 'z') { fprintf(stderr, "BINGO; Found the target\n"); exit(1); } diff --git a/test/fuzzer/SymbolizeDeadlock.cpp b/test/fuzzer/SymbolizeDeadlock.cpp new file mode 100644 index 000000000000..5be1be804bce --- /dev/null +++ b/test/fuzzer/SymbolizeDeadlock.cpp @@ -0,0 +1,35 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. + +// Tests that deadlocks do not occur when an OOM occurs during symbolization. + +#include <cassert> +#include <cstdint> +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <unistd.h> + +#include "Bingo.h" + +volatile unsigned Sink = 0; + +// Do not inline this function. We want to trigger NEW_FUNC symbolization when +// libFuzzer finds this function. We use a macro to make the name as long +// possible, hoping to increase the time spent in symbolization and increase the +// chances of triggering a deadlock. +__attribute__((noinline)) void BINGO() { + // Busy work. Inserts a delay here so the deadlock is more likely to trigger. + for (unsigned i = 0; i < 330000000; i++) Sink += i; +} + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + assert(Data); + if (Size < 3) return 0; + if (Data[0] == 'F' && + Data[1] == 'U' && + Data[2] == 'Z') + BINGO(); + return 0; +} + diff --git a/test/fuzzer/ThreadedLeakTest.cpp b/test/fuzzer/ThreadedLeakTest.cpp index 538d3b434808..59f3671fe9db 100644 --- a/test/fuzzer/ThreadedLeakTest.cpp +++ b/test/fuzzer/ThreadedLeakTest.cpp @@ -6,7 +6,7 @@ #include <cstdint> #include <thread> -static volatile int *Sink; +static int * volatile Sink; extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { if (Size == 0) return 0; diff --git a/test/fuzzer/ThreeBytes.cpp b/test/fuzzer/ThreeBytes.cpp new file mode 100644 index 000000000000..754a5b0b56a1 --- /dev/null +++ b/test/fuzzer/ThreeBytes.cpp @@ -0,0 +1,14 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. + +// Find FUZ +#include <cstddef> +#include <cstdint> +#include <cstdlib> + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (Size < 3) return 0; + uint32_t x = Data[0] + 251 * Data[1] + 251 * 251 * Data[2]; + if (x == 'F' + 251 * 'U' + 251 * 251 * 'Z') abort(); + return 0; +} diff --git a/test/fuzzer/ThreeFunctionsTest.cpp b/test/fuzzer/ThreeFunctionsTest.cpp new file mode 100644 index 000000000000..1278cb05633d --- /dev/null +++ b/test/fuzzer/ThreeFunctionsTest.cpp @@ -0,0 +1,36 @@ +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. + +// Find "FUZZME", the target has 3 different functions. +#include <assert.h> +#include <cstddef> +#include <cstdint> +#include <cstdlib> +#include <cstdio> + +extern "C" +__attribute__((noinline)) +bool Func1(const uint8_t *Data, size_t Size) { + // assumes Size >= 5, doesn't check it. + return Data[4] == 'M'; +} + +extern "C" +__attribute__((noinline)) +bool Func2(const uint8_t *Data, size_t Size) { + return Size >= 6 && Data[5] == 'E'; +} + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (Size >= 5 + && Data[0] == 'F' + && Data[1] == 'U' + && Data[2] == 'Z' + && Data[3] == 'Z' + && Func1(Data, Size) + && Func2(Data, Size)) { + fprintf(stderr, "BINGO\n"); + abort(); + } + return 0; +} diff --git a/test/fuzzer/TraceMallocThreadedTest.cpp b/test/fuzzer/TraceMallocThreadedTest.cpp index 5603af344cb7..0183d939af51 100644 --- a/test/fuzzer/TraceMallocThreadedTest.cpp +++ b/test/fuzzer/TraceMallocThreadedTest.cpp @@ -7,11 +7,12 @@ #include <cstddef> #include <cstdint> #include <cstring> +#include <cstdlib> #include <thread> extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { auto C = [&] { - volatile void *a = malloc(5639); + void * volatile a = malloc(5639); free((void *)a); }; std::thread T[] = {std::thread(C), std::thread(C), std::thread(C), diff --git a/test/fuzzer/UninitializedStrlen.cpp b/test/fuzzer/UninitializedStrlen.cpp new file mode 100644 index 000000000000..5a4e778df94b --- /dev/null +++ b/test/fuzzer/UninitializedStrlen.cpp @@ -0,0 +1,14 @@ +#include <cstdint> +#include <cstring> + +volatile size_t Sink; + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (Size < 4) return 0; + if (Data[0] == 'F' && Data[1] == 'U' && Data[2] == 'Z' && Data[3] == 'Z') { + char uninit[7]; + Sink = strlen(uninit); + } + return 0; +} + diff --git a/test/fuzzer/UseAfterDtor.cpp b/test/fuzzer/UseAfterDtor.cpp new file mode 100644 index 000000000000..dcefca5cc7d5 --- /dev/null +++ b/test/fuzzer/UseAfterDtor.cpp @@ -0,0 +1,27 @@ +#include <cstdint> +#include <cstdio> + +struct Simple { + int x_; + Simple() { + x_ = 5; + } + ~Simple() { + x_ += 1; + } +}; + +Simple *volatile SimpleSink; + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + if (Size < 4) return 0; + if (Data[0] == 'F' && Data[1] == 'U' && Data[2] == 'Z' && Data[3] == 'Z') { + { + Simple S; + SimpleSink = &S; + } + if (SimpleSink->x_) fprintf(stderr, "Failed to catch use-after-dtor\n"); + } + return 0; +} + diff --git a/test/fuzzer/acquire-crash-state.test b/test/fuzzer/acquire-crash-state.test new file mode 100644 index 000000000000..952ec735be6f --- /dev/null +++ b/test/fuzzer/acquire-crash-state.test @@ -0,0 +1,3 @@ +RUN: %cpp_compiler %S/AcquireCrashStateTest.cpp -o %t +RUN: %run %t 2>&1 | FileCheck %s +CHECK-NOT: fuzz target exited diff --git a/test/fuzzer/afl-driver-extra-stats.test b/test/fuzzer/afl-driver-extra-stats.test index a6de53302002..cddb683e6dec 100644 --- a/test/fuzzer/afl-driver-extra-stats.test +++ b/test/fuzzer/afl-driver-extra-stats.test @@ -1,8 +1,9 @@ -RUN: %no_fuzzer_cpp_compiler -fno-sanitize-coverage=edge,trace-cmp,indirect-calls,8bit-counters,trace-pc-guard %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest +XFAIL: ios +RUN: %no_fuzzer_cpp_compiler %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest ; Test that not specifying an extra stats file isn't broken. RUN: unset AFL_DRIVER_EXTRA_STATS_FILENAME -RUN: %t-AFLDriverTest +RUN: %run %t-AFLDriverTest ; Test that specifying an invalid extra stats file causes a crash. RUN: ASAN_OPTIONS= AFL_DRIVER_EXTRA_STATS_FILENAME=%T not --crash %t-AFLDriverTest diff --git a/test/fuzzer/afl-driver-stderr.test b/test/fuzzer/afl-driver-stderr.test index be0efaa8f03e..d3d739d3b977 100644 --- a/test/fuzzer/afl-driver-stderr.test +++ b/test/fuzzer/afl-driver-stderr.test @@ -1,12 +1,14 @@ -RUN: %no_fuzzer_cpp_compiler -fno-sanitize-coverage=edge,trace-cmp,indirect-calls,8bit-counters,trace-pc-guard %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest +XFAIL: ios +UNSUPPORTED: freebsd +RUN: %no_fuzzer_cpp_compiler %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest ; Test that not specifying a stderr file isn't broken. RUN: unset AFL_DRIVER_STDERR_DUPLICATE_FILENAME -RUN: %t-AFLDriverTest +RUN: %run %t-AFLDriverTest ; Test that specifying an invalid file causes a crash. -RUN: ASAN_OPTIONS= AFL_DRIVER_STDERR_DUPLICATE_FILENAME="%T" not --crash %t-AFLDriverTest +RUN: ASAN_OPTIONS= AFL_DRIVER_STDERR_DUPLICATE_FILENAME="%T" not --crash %run %t-AFLDriverTest ; Test that a file is created when specified as the duplicate stderr. -RUN: AFL_DRIVER_STDERR_DUPLICATE_FILENAME=%t %t-AFLDriverTest +RUN: AFL_DRIVER_STDERR_DUPLICATE_FILENAME=%t %run %t-AFLDriverTest RUN: stat %t diff --git a/test/fuzzer/afl-driver.test b/test/fuzzer/afl-driver.test index 32e7d03b43c0..552bafb0bf34 100644 --- a/test/fuzzer/afl-driver.test +++ b/test/fuzzer/afl-driver.test @@ -1,29 +1,29 @@ REQUIRES: linux -RUN: %no_fuzzer_cpp_compiler -fno-sanitize-coverage=edge,trace-cmp,indirect-calls,8bit-counters,trace-pc-guard %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest +RUN: %no_fuzzer_cpp_compiler %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest RUN: echo -n "abc" > %t.file3 RUN: echo -n "abcd" > %t.file4 -RUN: %t-AFLDriverTest < %t.file3 2>&1 | FileCheck %s --check-prefix=CHECK1 +RUN: %run %t-AFLDriverTest < %t.file3 2>&1 | FileCheck %s --check-prefix=CHECK1 CHECK1: __afl_persistent_loop calle, Count = 1000 CHECK1: LLVMFuzzerTestOneInput called; Size = 3 -RUN: %t-AFLDriverTest < %t.file3 -42 2>&1 | FileCheck %s --check-prefix=CHECK2 +RUN: %run %t-AFLDriverTest < %t.file3 -42 2>&1 | FileCheck %s --check-prefix=CHECK2 CHECK2: __afl_persistent_loop calle, Count = 42 CHECK2: LLVMFuzzerTestOneInput called; Size = 3 -RUN: %t-AFLDriverTest < %t.file3 666 2>&1 | FileCheck %s --check-prefix=CHECK3 +RUN: %run %t-AFLDriverTest < %t.file3 666 2>&1 | FileCheck %s --check-prefix=CHECK3 CHECK3: WARNING: using the deprecated call style CHECK3: __afl_persistent_loop calle, Count = 666 CHECK3: LLVMFuzzerTestOneInput called; Size = 3 -RUN: %t-AFLDriverTest %t.file3 2>&1 | FileCheck %s --check-prefix=CHECK4 +RUN: %run %t-AFLDriverTest %t.file3 2>&1 | FileCheck %s --check-prefix=CHECK4 CHECK4: LLVMFuzzerTestOneInput called; Size = 3 -RUN: %t-AFLDriverTest %t.file3 %t.file4 2>&1 | FileCheck %s --check-prefix=CHECK5 +RUN: %run %t-AFLDriverTest %t.file3 %t.file4 2>&1 | FileCheck %s --check-prefix=CHECK5 CHECK5: LLVMFuzzerTestOneInput called; Size = 3 CHECK5: LLVMFuzzerTestOneInput called; Size = 4 diff --git a/test/fuzzer/bad-strcmp.test b/test/fuzzer/bad-strcmp.test index fd1621a4e1eb..7fb2a6f07353 100644 --- a/test/fuzzer/bad-strcmp.test +++ b/test/fuzzer/bad-strcmp.test @@ -1,2 +1,2 @@ RUN: %cpp_compiler %S/BadStrcmpTest.cpp -o %t-BadStrcmpTest -RUN: %t-BadStrcmpTest -runs=100000 +RUN: %run %t-BadStrcmpTest -runs=100000 diff --git a/test/fuzzer/bogus-initialize.test b/test/fuzzer/bogus-initialize.test new file mode 100644 index 000000000000..2dff2d5a2639 --- /dev/null +++ b/test/fuzzer/bogus-initialize.test @@ -0,0 +1,4 @@ +RUN: %cpp_compiler %S/BogusInitializeTest.cpp -o %t-BogusInitializeTest + +RUN: not %run %t-BogusInitializeTest 2>&1 | FileCheck %s --check-prefix=BOGUS_INITIALIZE +BOGUS_INITIALIZE: argv[0] has been modified in LLVMFuzzerInitialize diff --git a/test/fuzzer/buffer-overflow-on-input.test b/test/fuzzer/buffer-overflow-on-input.test new file mode 100644 index 000000000000..6e40b75d70bc --- /dev/null +++ b/test/fuzzer/buffer-overflow-on-input.test @@ -0,0 +1,5 @@ +RUN: %cpp_compiler %S/BufferOverflowOnInput.cpp -o %t-BufferOverflowOnInput + +RUN: not %run %t-BufferOverflowOnInput 2>&1 | FileCheck %s --check-prefix=OOB +OOB: AddressSanitizer: heap-buffer-overflow +OOB: is located 0 bytes to the right of 3-byte region diff --git a/test/fuzzer/caller-callee.test b/test/fuzzer/caller-callee.test index e4eccdc307ad..679e4a6f65a4 100644 --- a/test/fuzzer/caller-callee.test +++ b/test/fuzzer/caller-callee.test @@ -1,3 +1,4 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/CallerCalleeTest.cpp -o %t-CallerCalleeTest CHECK: BINGO -RUN: not %t-CallerCalleeTest -use_value_profile=1 -cross_over=0 -seed=1 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-CallerCalleeTest -use_value_profile=1 -cross_over=0 -seed=1 -runs=10000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/cleanse.test b/test/fuzzer/cleanse.test index 8e45dc77d9ea..3447fcf0ff26 100644 --- a/test/fuzzer/cleanse.test +++ b/test/fuzzer/cleanse.test @@ -1,4 +1,4 @@ RUN: %cpp_compiler %S/CleanseTest.cpp -o %t-CleanseTest RUN: echo -n 0123456789ABCDEFGHIZ > %t-in -RUN: %t-CleanseTest -cleanse_crash=1 %t-in -exact_artifact_path=%t-out +RUN: %run %t-CleanseTest -cleanse_crash=1 %t-in -exact_artifact_path=%t-out RUN: echo -n ' 1 5 A Z' | diff - %t-out diff --git a/test/fuzzer/counters.test b/test/fuzzer/counters.test new file mode 100644 index 000000000000..f75d3a03783f --- /dev/null +++ b/test/fuzzer/counters.test @@ -0,0 +1,9 @@ +XFAIL: ios +UNSUPPORTED: aarch64 +RUN: %cpp_compiler %S/CounterTest.cpp -o %t-CounterTest +RUN: not %run %t-CounterTest -max_len=6 -seed=1 -timeout=15 2>&1 | FileCheck %s --check-prefix=COUNTERS + +COUNTERS: INITED {{.*}} {{bits:|ft:}} +COUNTERS: NEW {{.*}} {{bits:|ft:}} {{[1-9]*}} +COUNTERS: NEW {{.*}} {{bits:|ft:}} {{[1-9]*}} +COUNTERS: BINGO diff --git a/test/fuzzer/coverage.test b/test/fuzzer/coverage.test index 9a2179d91add..3b2341f21f69 100644 --- a/test/fuzzer/coverage.test +++ b/test/fuzzer/coverage.test @@ -1,21 +1,18 @@ +UNSUPPORTED: aarch64 RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/NullDerefTest.cpp -o %t-NullDerefTest -RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/DSO1.cpp -fPIC -shared -o %t-DSO1.so -RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/DSO2.cpp -fPIC -shared -o %t-DSO2.so -RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/DSOTestMain.cpp %S/DSOTestExtra.cpp -L. %t-DSO1.so %t-DSO2.so -o %t-DSOTest +RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/DSO1.cpp -fPIC %ld_flags_rpath_so1 -shared -o %dynamiclib1 +RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/DSO2.cpp -fPIC %ld_flags_rpath_so2 -shared -o %dynamiclib2 +RUN: %cpp_compiler -mllvm -use-unknown-locations=Disable %S/DSOTestMain.cpp %S/DSOTestExtra.cpp %ld_flags_rpath_exe1 %ld_flags_rpath_exe2 -o %t-DSOTest CHECK: COVERAGE: -CHECK-DAG: COVERED: {{.*}}in LLVMFuzzerTestOneInput {{.*}}NullDerefTest.cpp:13 -CHECK-DAG: COVERED: {{.*}}in LLVMFuzzerTestOneInput {{.*}}NullDerefTest.cpp:14 -CHECK-DAG: COVERED: {{.*}}in LLVMFuzzerTestOneInput {{.*}}NullDerefTest.cpp:16 -RUN: not %t-NullDerefTest -print_coverage=1 2>&1 | FileCheck %s +CHECK: COVERED_FUNC: {{.*}}LLVMFuzzerTestOneInput {{.*}}NullDerefTest.cpp:13 +RUN: not %run %t-NullDerefTest -print_coverage=1 2>&1 | FileCheck %s -RUN: %t-DSOTest -print_coverage=1 -runs=0 2>&1 | FileCheck %s --check-prefix=DSO +RUN: %run %t-DSOTest -print_coverage=1 -runs=0 2>&1 | FileCheck %s --check-prefix=DSO DSO: COVERAGE: -DSO-DAG: COVERED:{{.*}}DSO1{{.*}}DSO1.cpp -DSO-DAG: COVERED:{{.*}}DSO2{{.*}}DSO2.cpp -DSO-DAG: COVERED:{{.*}}LLVMFuzzerTestOneInput{{.*}}DSOTestMain -DSO-DAG: UNCOVERED_LINE:{{.*}}DSO1{{.*}}DSO1.cpp -DSO-DAG: UNCOVERED_LINE:{{.*}}DSO2{{.*}}DSO2.cpp -DSO-DAG: UNCOVERED_FUNC: in Uncovered1 -DSO-DAG: UNCOVERED_FUNC: in Uncovered2 -DSO-DAG: UNCOVERED_LINE: in LLVMFuzzerTestOneInput +DSO-DAG: COVERED_FUNC:{{.*}}1{{.*}} +DSO-DAG: COVERED_FUNC:{{.*}}2{{.*}} +DSO-DAG: COVERED_FUNC:{{.*}}LLVMFuzzerTestOneInput{{.*}}DSOTestMain +DSO-DAG: UNCOVERED_PC:{{.*}}1 +DSO-DAG: UNCOVERED_PC:{{.*}}2 +DSO-DAG: UNCOVERED_PC:{{.*}}DSOTestMain diff --git a/test/fuzzer/cxxstring.test b/test/fuzzer/cxxstring.test index 7bb341ba22b4..65edeec1964a 100644 --- a/test/fuzzer/cxxstring.test +++ b/test/fuzzer/cxxstring.test @@ -1,6 +1,6 @@ -UNSUPPORTED: windows +UNSUPPORTED: windows,freebsd RUN: %cpp_compiler %S/CxxStringEqTest.cpp -o %t-CxxStringEqTest -RUN: not %t-CxxStringEqTest -seed=1 -runs=1000000 2>&1 | FileCheck %s +RUN: not %run %t-CxxStringEqTest -seed=1 -runs=1000000 2>&1 | FileCheck %s CHECK: BINGO diff --git a/test/fuzzer/dataflow.test b/test/fuzzer/dataflow.test new file mode 100644 index 000000000000..64f083735cb9 --- /dev/null +++ b/test/fuzzer/dataflow.test @@ -0,0 +1,84 @@ +# Tests the data flow tracer. +REQUIRES: linux +UNSUPPORTED: aarch64 + +# Build the tracer and the test. +RUN: %no_fuzzer_cpp_compiler -c -fno-sanitize=all -fsanitize=dataflow %S/../../lib/fuzzer/dataflow/DataFlow.cpp -o %t-DataFlow.o +RUN: %no_fuzzer_cpp_compiler -fno-sanitize=all -fsanitize=dataflow -fsanitize-coverage=trace-pc-guard,pc-table,func,trace-cmp %S/ThreeFunctionsTest.cpp %t-DataFlow.o -o %t-ThreeFunctionsTestDF +RUN: %no_fuzzer_cpp_compiler -fno-sanitize=all -fsanitize=dataflow -fsanitize-coverage=trace-pc-guard,pc-table,func,trace-cmp %S/ExplodeDFSanLabelsTest.cpp %t-DataFlow.o -o %t-ExplodeDFSanLabelsTestDF +RUN: %cpp_compiler %S/ThreeFunctionsTest.cpp -o %t-ThreeFunctionsTest + +# Dump the function list. +RUN: %t-ThreeFunctionsTestDF 2>&1 | FileCheck %s --check-prefix=FUNC_LIST +FUNC_LIST-DAG: LLVMFuzzerTestOneInput +FUNC_LIST-DAG: Func1 +FUNC_LIST-DAG: Func2 + +# Prepare the inputs. +RUN: rm -rf %t/IN +RUN: mkdir -p %t/IN +RUN: echo -n ABC > %t/IN/ABC +RUN: echo -n FUABC > %t/IN/FUABC +RUN: echo -n FUZZR > %t/IN/FUZZR +RUN: echo -n FUZZM > %t/IN/FUZZM +RUN: echo -n FUZZMU > %t/IN/FUZZMU +RUN: echo -n 1234567890123456 > %t/IN/1234567890123456 + +# ABC: No data is used, the only used label is 4 (corresponds to the size) +RUN:%t-ThreeFunctionsTestDF 0 3 %t/IN/ABC | FileCheck %s --check-prefix=IN_ABC +IN_ABC: F{{[012]}} 0001 +IN_ABC-NOT: F + +# FUABC: First 3 bytes are checked, Func1/Func2 are not called. +RUN:%t-ThreeFunctionsTestDF 0 5 %t/IN/FUABC | FileCheck %s --check-prefix=IN_FUABC +IN_FUABC: F{{[012]}} 111001 +IN_FUABC-NOT: F + +# FUZZR: 5 bytes are used (4 in one function, 5-th in the other), Func2 is not called. +RUN:%t-ThreeFunctionsTestDF 0 5 %t/IN/FUZZR | FileCheck %s --check-prefix=IN_FUZZR +IN_FUZZR-DAG: F{{[012]}} 111101 +IN_FUZZR-DAG: F{{[012]}} 000010 +IN_FUZZR-NOT: F + +# FUZZM: 5 bytes are used, both Func1 and Func2 are called, Func2 depends only on size (label 6). +RUN:%t-ThreeFunctionsTestDF 0 5 %t/IN/FUZZM | FileCheck %s --check-prefix=IN_FUZZM +IN_FUZZM-DAG: F{{[012]}} 000010 +IN_FUZZM-DAG: F{{[012]}} 111101 +IN_FUZZM-DAG: F{{[012]}} 000001 + +# FUZZMU: 6 bytes are used, both Func1 and Func2 are called, Func2 depends on byte 6 and size (label 7) +RUN:%t-ThreeFunctionsTestDF 0 6 %t/IN/FUZZMU | FileCheck %s --check-prefix=IN_FUZZMU + +# Test merge_data_flow +RUN:rm -f %t-merge-* +RUN:%t-ThreeFunctionsTestDF 0 2 %t/IN/FUZZMU > %t-merge-1 +RUN:%t-ThreeFunctionsTestDF 2 4 %t/IN/FUZZMU > %t-merge-2 +RUN:%t-ThreeFunctionsTestDF 4 6 %t/IN/FUZZMU > %t-merge-3 +RUN:%libfuzzer_src/scripts/merge_data_flow.py %t-merge-* | FileCheck %s --check-prefix=IN_FUZZMU + +# Test collect_data_flow +RUN: %libfuzzer_src/scripts/collect_data_flow.py %t-ThreeFunctionsTestDF %t/IN/FUZZMU | FileCheck %s --check-prefix=IN_FUZZMU + +IN_FUZZMU-DAG: F{{[012]}} 0000100 +IN_FUZZMU-DAG: F{{[012]}} 1111001 +IN_FUZZMU-DAG: F{{[012]}} 0000011 + +# A very simple test will cause DFSan to die with "out of labels" +RUN: not %t-ExplodeDFSanLabelsTestDF 0 16 %t/IN/1234567890123456 2>&1 | FileCheck %s --check-prefix=OUT_OF_LABELS +OUT_OF_LABELS: ==FATAL: DataFlowSanitizer: out of labels +# However we can run the same test piece by piece. +RUN: %t-ExplodeDFSanLabelsTestDF 0 2 %t/IN/1234567890123456 +RUN: %t-ExplodeDFSanLabelsTestDF 2 4 %t/IN/1234567890123456 +RUN: %t-ExplodeDFSanLabelsTestDF 4 6 %t/IN/1234567890123456 +# Or we can use collect_data_flow +RUN: %libfuzzer_src/scripts/collect_data_flow.py %t-ExplodeDFSanLabelsTestDF %t/IN/1234567890123456 + +# Test that we can run collect_data_flow on the entire corpus dir +RUN: rm -rf %t/OUT +RUN: %libfuzzer_src/scripts/collect_data_flow.py %t-ThreeFunctionsTestDF %t/IN %t/OUT +RUN: %t-ThreeFunctionsTest -data_flow_trace=%t/OUT -runs=0 -focus_function=Func2 2>&1 | FileCheck %s --check-prefix=USE_DATA_FLOW_TRACE +USE_DATA_FLOW_TRACE: INFO: Focus function is set to 'Func2' +USE_DATA_FLOW_TRACE: INFO: DataFlowTrace: reading from {{.*}}/OUT +USE_DATA_FLOW_TRACE-DAG: a8eefe2fd5d6b32028f355fafa3e739a6bf5edc => |000001| +USE_DATA_FLOW_TRACE-DGA: d28cb407e8e1a702c72d25473f0553d3ec172262 => |0000011| +USE_DATA_FLOW_TRACE: INFO: DataFlowTrace: 6 trace files, 3 functions, 2 traces with focus function diff --git a/test/fuzzer/deep-recursion.test b/test/fuzzer/deep-recursion.test index 22475f91263a..f65104004bf9 100644 --- a/test/fuzzer/deep-recursion.test +++ b/test/fuzzer/deep-recursion.test @@ -1,5 +1,5 @@ # Test that we can find a stack overflow REQUIRES: linux RUN: %cpp_compiler %S/DeepRecursionTest.cpp -o %t -RUN: not %t -seed=1 -runs=100000000 2>&1 | FileCheck %s +RUN: not %run %t -seed=1 -runs=100000000 2>&1 | FileCheck %s CHECK: ERROR: libFuzzer: deadly signal diff --git a/test/fuzzer/disable-leaks.test b/test/fuzzer/disable-leaks.test index bc120d98b38a..1c65884e3213 100644 --- a/test/fuzzer/disable-leaks.test +++ b/test/fuzzer/disable-leaks.test @@ -1,5 +1,6 @@ REQUIRES: lsan +UNSUPPORTED: aarch64 RUN: %cpp_compiler %S/AccumulateAllocationsTest.cpp -o %t-AccumulateAllocationsTest -RUN: %t-AccumulateAllocationsTest -detect_leaks=1 -runs=100000 2>&1 | FileCheck %s --check-prefix=ACCUMULATE_ALLOCS +RUN: %run %t-AccumulateAllocationsTest -detect_leaks=1 -runs=100000 2>&1 | FileCheck %s --check-prefix=ACCUMULATE_ALLOCS ACCUMULATE_ALLOCS: INFO: libFuzzer disabled leak detection after every mutation diff --git a/test/fuzzer/dso.test b/test/fuzzer/dso.test new file mode 100644 index 000000000000..fc1fe23818f0 --- /dev/null +++ b/test/fuzzer/dso.test @@ -0,0 +1,7 @@ +RUN: %cpp_compiler %S/DSO1.cpp -fPIC %ld_flags_rpath_so1 -shared -o %dynamiclib1 +RUN: %cpp_compiler %S/DSO2.cpp -fPIC %ld_flags_rpath_so2 -shared -o %dynamiclib2 +RUN: %cpp_compiler %S/DSOTestMain.cpp %S/DSOTestExtra.cpp %ld_flags_rpath_exe1 %ld_flags_rpath_exe2 -o %t-DSOTest + +RUN: not %run %t-DSOTest 2>&1 | FileCheck %s --check-prefix=DSO +DSO: INFO: Loaded 3 modules +DSO: BINGO diff --git a/test/fuzzer/dump_coverage.test b/test/fuzzer/dump_coverage.test index b240089ce239..41e193824de6 100644 --- a/test/fuzzer/dump_coverage.test +++ b/test/fuzzer/dump_coverage.test @@ -1,20 +1,21 @@ -RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO1.cpp -fPIC -shared -o %t-DSO1.so -RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO2.cpp -fPIC -shared -o %t-DSO2.so -RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSOTestMain.cpp %S/DSOTestExtra.cpp -L. %t-DSO1.so %t-DSO2.so -o %t-DSOTest +UNSUPPORTED: freebsd +RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO1.cpp -fPIC -shared -o %dynamiclib1 %ld_flags_rpath_so1 +RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO2.cpp -fPIC -shared -o %dynamiclib2 %ld_flags_rpath_so2 +RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSOTestMain.cpp %S/DSOTestExtra.cpp %ld_flags_rpath_exe1 %ld_flags_rpath_exe2 -o %t-DSOTest RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/NullDerefTest.cpp -o %t-NullDerefTest RUN: rm -rf %t_workdir && mkdir -p %t_workdir -RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' not %t-NullDerefTest -dump_coverage=1 2>&1 | FileCheck %s +RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' not %run %t-NullDerefTest -dump_coverage=1 2>&1 | FileCheck %s RUN: sancov -covered-functions %t-NullDerefTest* %t_workdir/*.sancov | FileCheck %s --check-prefix=SANCOV -RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' %t-DSOTest -dump_coverage=1 -runs=0 2>&1 | FileCheck %s --check-prefix=DSO -RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' not %t-NullDerefTest -dump_coverage=0 2>&1 | FileCheck %s --check-prefix=NOCOV +RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' %run %t-DSOTest -dump_coverage=1 -runs=0 2>&1 | FileCheck -allow-deprecated-dag-overlap %s --check-prefix=DSO +RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' not %run %t-NullDerefTest -dump_coverage=0 2>&1 | FileCheck %s --check-prefix=NOCOV CHECK: SanitizerCoverage: {{.*}}NullDerefTest.{{.*}}.sancov: {{.*}} PCs written SANCOV: LLVMFuzzerTestOneInput DSO: SanitizerCoverage: {{.*}}DSOTest.{{.*}}.sancov: {{.*}} PCs written -DSO-DAG: SanitizerCoverage: {{.*}}DSO1.{{.*}}.sancov: {{.*}} PCs written -DSO-DAG: SanitizerCoverage: {{.*}}DSO2.{{.*}}.sancov: {{.*}} PCs written +DSO-DAG: SanitizerCoverage: {{.*}}.{{.*}}.sancov: {{.*}} PCs written +DSO-DAG: SanitizerCoverage: {{.*}}2.{{.*}}.sancov: {{.*}} PCs written NOCOV-NOT: SanitizerCoverage: {{.*}} PCs written diff --git a/test/fuzzer/equivalence-signals.test b/test/fuzzer/equivalence-signals.test index 7951636e85f8..1da66f1474f1 100644 --- a/test/fuzzer/equivalence-signals.test +++ b/test/fuzzer/equivalence-signals.test @@ -1,9 +1,14 @@ +REQUIRES: this-test-is-deprecated # Run EquivalenceATest against itself with a small timeout # to stress the signal handling and ensure that shmem doesn't mind # the signals. +UNSUPPORTED: freebsd + +# The test is not supported on Darwin +UNSUPPORTED: darwin RUN: %cpp_compiler %S/EquivalenceATest.cpp -o %t-EquivalenceATest -RUN: %t-EquivalenceATest -timeout=1 -run_equivalence_server=EQUIV_SIG_TEST & export APID=$! +RUN: %run %t-EquivalenceATest -timeout=1 -run_equivalence_server=EQ_SIG_TEST & export APID=$! RUN: sleep 3 -RUN: %t-EquivalenceATest -timeout=1 -use_equivalence_server=EQUIV_SIG_TEST -runs=500000 2>&1 +RUN: %run %t-EquivalenceATest -timeout=1 -use_equivalence_server=EQ_SIG_TEST -runs=500000 2>&1 RUN: kill -9 $APID diff --git a/test/fuzzer/equivalence.test b/test/fuzzer/equivalence.test index 12964f478a45..2438811f2809 100644 --- a/test/fuzzer/equivalence.test +++ b/test/fuzzer/equivalence.test @@ -1,9 +1,11 @@ +REQUIRES: this-test-is-deprecated +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/EquivalenceATest.cpp -o %t-EquivalenceATest RUN: %cpp_compiler %S/EquivalenceBTest.cpp -o %t-EquivalenceBTest -RUN: %t-EquivalenceATest -run_equivalence_server=EQUIV_TEST & export APID=$! +RUN: %run %t-EquivalenceATest -run_equivalence_server=EQUIV_TEST & export APID=$! RUN: sleep 3 -RUN: not %t-EquivalenceBTest -use_equivalence_server=EQUIV_TEST -max_len=4096 2>&1 | FileCheck %s +RUN: not %run %t-EquivalenceBTest -use_equivalence_server=EQUIV_TEST -max_len=4096 2>&1 | FileCheck %s CHECK: ERROR: libFuzzer: equivalence-mismatch. Sizes: {{.*}}; offset 2 CHECK: SUMMARY: libFuzzer: equivalence-mismatch RUN: kill -9 $APID diff --git a/test/fuzzer/exit-report.test b/test/fuzzer/exit-report.test index f754c1376c43..65d91c5cd88a 100644 --- a/test/fuzzer/exit-report.test +++ b/test/fuzzer/exit-report.test @@ -1,5 +1,5 @@ RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest -RUN: not %t-SimpleTest 2>&1 | FileCheck %s +RUN: not %run %t-SimpleTest 2>&1 | FileCheck %s CHECK: ERROR: libFuzzer: fuzz target exited CHECK: SUMMARY: libFuzzer: fuzz target exited diff --git a/test/fuzzer/exit_on_src_pos.test b/test/fuzzer/exit_on_src_pos.test index 6a42c7ae9539..ad0fa0a7ce4e 100644 --- a/test/fuzzer/exit_on_src_pos.test +++ b/test/fuzzer/exit_on_src_pos.test @@ -1,8 +1,9 @@ # Temporary use -mllvm -use-unknown-locations=Disable so that # all instructions have debug info (file line numbers) attached. -RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest -mllvm -use-unknown-locations=Disable -RUN: %cpp_compiler %S/ShrinkControlFlowTest.cpp -o %t-ShrinkControlFlowTest +# TODO: Find out why test fails on Darwin with -O2. +RUN: %cpp_compiler -O0 %S/SimpleTest.cpp -o %t-SimpleTest -mllvm -use-unknown-locations=Disable +RUN: %cpp_compiler -O0 %S/ShrinkControlFlowTest.cpp -o %t-ShrinkControlFlowTest -RUN: %t-SimpleTest -exit_on_src_pos=SimpleTest.cpp:18 2>&1 | FileCheck %s --check-prefix=EXIT_ON_SRC_POS -RUN: %t-ShrinkControlFlowTest -exit_on_src_pos=Foo 2>&1 | FileCheck %s --check-prefix=EXIT_ON_SRC_POS +RUN: %run %t-SimpleTest -exit_on_src_pos=SimpleTest.cpp:18 2>&1 | FileCheck %s --check-prefix=EXIT_ON_SRC_POS +RUN: %run %t-ShrinkControlFlowTest -exit_on_src_pos=Foo 2>&1 | FileCheck %s --check-prefix=EXIT_ON_SRC_POS EXIT_ON_SRC_POS: INFO: found line matching '{{.*}}', exiting. diff --git a/test/fuzzer/extra-counters.test b/test/fuzzer/extra-counters.test index 230f74a1b0bb..a93f775dcfc5 100644 --- a/test/fuzzer/extra-counters.test +++ b/test/fuzzer/extra-counters.test @@ -1,7 +1,7 @@ REQUIRES: linux RUN: %cpp_compiler %S/TableLookupTest.cpp -o %t-TableLookupTest -RUN: not %t-TableLookupTest -print_final_stats=1 2>&1 | FileCheck %s -CHECK: BINGO +RUN: not %run %t-TableLookupTest -print_final_stats=1 2>&1 | FileCheck %s +CHECK: INFO: {{[0-9]+}} Extra Counters // Expecting >= 4096 new_units_added CHECK: stat::new_units_added:{{.*[4][0-9][0-9][0-9]}} diff --git a/test/fuzzer/fprofile-instr-generate.test b/test/fuzzer/fprofile-instr-generate.test deleted file mode 100644 index 2a3ec96f10f7..000000000000 --- a/test/fuzzer/fprofile-instr-generate.test +++ /dev/null @@ -1,7 +0,0 @@ -# Test libFuzzer + -fprofile-instr-generate -REQUIRES: linux -RUN: %cpp_compiler %S/SimpleTest.cpp -fsanitize-coverage=0 -fprofile-instr-generate -o %t-SimpleTest-fprofile-instr-generate -CHECK-NOT: INFO: Loaded 1 modules -CHECK: INFO: {{.*}} Clang Coverage Counters -CHECK: BINGO -RUN: not %t-SimpleTest-fprofile-instr-generate -runs=1000000 -seed=1 -use_clang_coverage=1 2>&1 | FileCheck %s diff --git a/test/fuzzer/full-coverage-set.test b/test/fuzzer/full-coverage-set.test new file mode 100644 index 000000000000..629873d4eb39 --- /dev/null +++ b/test/fuzzer/full-coverage-set.test @@ -0,0 +1,3 @@ +CHECK: BINGO +RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t-FullCoverageSetTest +#not %run %t-FullCoverageSetTest -timeout=15 -seed=1 -mutate_depth=2 -use_full_coverage_set=1 2>&1 | FileCheck %s diff --git a/test/fuzzer/fuzzer-customcrossover.test b/test/fuzzer/fuzzer-customcrossover.test index 5a78307c7a3b..0835081f289a 100644 --- a/test/fuzzer/fuzzer-customcrossover.test +++ b/test/fuzzer/fuzzer-customcrossover.test @@ -1,8 +1,8 @@ RUN: %cpp_compiler %S/CustomCrossOverTest.cpp -o %t-CustomCrossOverTest -RUN: not %t-CustomCrossOverTest -seed=1 -runs=1000000 2>&1 | FileCheck %s --check-prefix=CHECK_CO +RUN: not %run %t-CustomCrossOverTest -seed=1 -runs=1000000 2>&1 | FileCheck %s --check-prefix=CHECK_CO Disable cross_over, verify that we can't find the target w/o it. -RUN: %t-CustomCrossOverTest -seed=1 -runs=1000000 -cross_over=0 2>&1 | FileCheck %s --check-prefix=CHECK_NO_CO +RUN: %run %t-CustomCrossOverTest -seed=1 -runs=1000000 -cross_over=0 2>&1 | FileCheck %s --check-prefix=CHECK_NO_CO CHECK_CO: In LLVMFuzzerCustomCrossover CHECK_CO: BINGO diff --git a/test/fuzzer/fuzzer-customcrossoverandmutate.test b/test/fuzzer/fuzzer-customcrossoverandmutate.test index 4a7dfba2ab8b..e538d866ff2d 100644 --- a/test/fuzzer/fuzzer-customcrossoverandmutate.test +++ b/test/fuzzer/fuzzer-customcrossoverandmutate.test @@ -1,2 +1,2 @@ RUN: %cpp_compiler %S/CustomCrossOverAndMutateTest.cpp -o %t-CustomCrossOverAndMutateTest -RUN: %t-CustomCrossOverAndMutateTest -seed=1 -runs=100000 +RUN: %run %t-CustomCrossOverAndMutateTest -seed=1 -runs=100000 diff --git a/test/fuzzer/fuzzer-custommutator.test b/test/fuzzer/fuzzer-custommutator.test index 7a693cd47324..51aef2373cca 100644 --- a/test/fuzzer/fuzzer-custommutator.test +++ b/test/fuzzer/fuzzer-custommutator.test @@ -1,5 +1,5 @@ RUN: %cpp_compiler %S/CustomMutatorTest.cpp -o %t-CustomMutatorTest -RUN: not %t-CustomMutatorTest 2>&1 | FileCheck %s --check-prefix=LLVMFuzzerCustomMutator +RUN: not %run %t-CustomMutatorTest 2>&1 | FileCheck %s --check-prefix=LLVMFuzzerCustomMutator LLVMFuzzerCustomMutator: In LLVMFuzzerCustomMutator LLVMFuzzerCustomMutator: BINGO diff --git a/test/fuzzer/fuzzer-dict.test b/test/fuzzer/fuzzer-dict.test index 48c91dc1d6fe..d396f6950a13 100644 --- a/test/fuzzer/fuzzer-dict.test +++ b/test/fuzzer/fuzzer-dict.test @@ -3,6 +3,6 @@ RUN: %cpp_compiler %S/SimpleDictionaryTest.cpp -o %t-SimpleDictionaryTest CHECK: BINGO Done1000000: Done 1000000 runs in -RUN: not %t-SimpleDictionaryTest -dict=%S/dict1.txt -seed=1 -runs=1000003 2>&1 | FileCheck %s -RUN: %t-SimpleDictionaryTest -seed=1 -runs=1000000 2>&1 | FileCheck %s --check-prefix=Done1000000 +RUN: not %run %t-SimpleDictionaryTest -dict=%S/dict1.txt -seed=1 -runs=1000003 2>&1 | FileCheck %s +RUN: %run %t-SimpleDictionaryTest -seed=1 -runs=1000000 2>&1 | FileCheck %s --check-prefix=Done1000000 diff --git a/test/fuzzer/fuzzer-dirs.test b/test/fuzzer/fuzzer-dirs.test index 9b6e4d1eedda..3c742b52da4c 100644 --- a/test/fuzzer/fuzzer-dirs.test +++ b/test/fuzzer/fuzzer-dirs.test @@ -5,17 +5,17 @@ RUN: mkdir -p %t/SUB1/SUB2/SUB3 RUN: echo a > %t/SUB1/a RUN: echo b > %t/SUB1/SUB2/b RUN: echo c > %t/SUB1/SUB2/SUB3/c -RUN: %t-SimpleTest %t/SUB1 -runs=0 2>&1 | FileCheck %s --check-prefix=SUBDIRS +RUN: %run %t-SimpleTest %t/SUB1 -runs=0 2>&1 | FileCheck %s --check-prefix=SUBDIRS SUBDIRS: INFO: seed corpus: files: 3 min: 2b max: 2b total: 6b RUN: echo -n zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz > %t/SUB1/f64 RUN: cat %t/SUB1/f64 %t/SUB1/f64 %t/SUB1/f64 %t/SUB1/f64 > %t/SUB1/f256 RUN: cat %t/SUB1/f256 %t/SUB1/f256 %t/SUB1/f256 %t/SUB1/f256 > %t/SUB1/f1024 RUN: cat %t/SUB1/f1024 %t/SUB1/f1024 %t/SUB1/f1024 %t/SUB1/f1024 > %t/SUB1/f4096 RUN: cat %t/SUB1/f4096 %t/SUB1/f4096 > %t/SUB1/f8192 -RUN: %t-SimpleTest %t/SUB1 -runs=0 2>&1 | FileCheck %s --check-prefix=LONG +RUN: %run %t-SimpleTest %t/SUB1 -runs=0 2>&1 | FileCheck %s --check-prefix=LONG LONG: INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 8192 bytes RUN: rm -rf %t/SUB1 -RUN: not %t-SimpleTest NONEXISTENT_DIR 2>&1 | FileCheck %s --check-prefix=NONEXISTENT_DIR -NONEXISTENT_DIR: No such directory: NONEXISTENT_DIR; exiting +RUN: not %run %t-SimpleTest NONEXISTENT_DIR 2>&1 | FileCheck %s --check-prefix=NONEXISTENT_DIR +NONEXISTENT_DIR: No such file or directory: NONEXISTENT_DIR; exiting diff --git a/test/fuzzer/fuzzer-fdmask.test b/test/fuzzer/fuzzer-fdmask.test index 3f04993b5d7e..09f29782b8a8 100644 --- a/test/fuzzer/fuzzer-fdmask.test +++ b/test/fuzzer/fuzzer-fdmask.test @@ -1,28 +1,28 @@ RUN: %cpp_compiler %S/SpamyTest.cpp -o %t-SpamyTest -RUN: %t-SpamyTest -runs=1 2>&1 | FileCheck %s --check-prefix=FD_MASK_0 -RUN: %t-SpamyTest -runs=1 -close_fd_mask=0 2>&1 | FileCheck %s --check-prefix=FD_MASK_0 -RUN: %t-SpamyTest -runs=1 -close_fd_mask=1 2>&1 | FileCheck %s --check-prefix=FD_MASK_1 -RUN: %t-SpamyTest -runs=1 -close_fd_mask=2 2>&1 | FileCheck %s --check-prefix=FD_MASK_2 -RUN: %t-SpamyTest -runs=1 -close_fd_mask=3 2>&1 | FileCheck %s --check-prefix=FD_MASK_3 +RUN: %run %t-SpamyTest -runs=1 2>&1 | FileCheck %s --check-prefix=FD_MASK_0 +RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=0 2>&1 | FileCheck %s --check-prefix=FD_MASK_0 +RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=1 2>&1 | FileCheck %s --check-prefix=FD_MASK_1 +RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=2 2>&1 | FileCheck %s --check-prefix=FD_MASK_2 +RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=3 2>&1 | FileCheck %s --check-prefix=FD_MASK_3 -FD_MASK_0: PRINTF_STDOUT -FD_MASK_0: PRINTF_STDERR -FD_MASK_0: STREAM_COUT -FD_MASK_0: STREAM_CERR -FD_MASK_0: INITED +FD_MASK_0-DAG: PRINTF_STDOUT +FD_MASK_0-DAG: PRINTF_STDERR +FD_MASK_0-DAG: STREAM_COUT +FD_MASK_0-DAG: STREAM_CERR +FD_MASK_0-DAG: INITED FD_MASK_1-NOT: PRINTF_STDOUT -FD_MASK_1: PRINTF_STDERR +FD_MASK_1-DAG: PRINTF_STDERR FD_MASK_1-NOT: STREAM_COUT -FD_MASK_1: STREAM_CERR -FD_MASK_1: INITED +FD_MASK_1-DAG: STREAM_CERR +FD_MASK_1-DAG: INITED -FD_MASK_2: PRINTF_STDOUT +FD_MASK_2-DAG: PRINTF_STDOUT +FD_MASK_2-DAG: STREAM_COUT +FD_MASK_2-DAG: INITED FD_MASK_2-NOT: PRINTF_STDERR -FD_MASK_2: STREAM_COUT -FD_MASK_2-NOTE: STREAM_CERR -FD_MASK_2: INITED +FD_MASK_2-NOT: STREAM_CERR FD_MASK_3-NOT: PRINTF_STDOUT FD_MASK_3-NOT: PRINTF_STDERR diff --git a/test/fuzzer/fuzzer-finalstats.test b/test/fuzzer/fuzzer-finalstats.test index 4f983bea825e..d8c991e30847 100644 --- a/test/fuzzer/fuzzer-finalstats.test +++ b/test/fuzzer/fuzzer-finalstats.test @@ -1,12 +1,12 @@ RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest -RUN: %t-SimpleTest -seed=1 -runs=77 -print_final_stats=1 2>&1 | FileCheck %s --check-prefix=FINAL_STATS +RUN: %run %t-SimpleTest -seed=1 -runs=77 -print_final_stats=1 2>&1 | FileCheck %s --check-prefix=FINAL_STATS FINAL_STATS: stat::number_of_executed_units: 77 FINAL_STATS: stat::average_exec_per_sec: 0 FINAL_STATS: stat::new_units_added: FINAL_STATS: stat::slowest_unit_time_sec: 0 FINAL_STATS: stat::peak_rss_mb: -RUN: %t-SimpleTest %S/dict1.txt -runs=33 -print_final_stats=1 2>&1 | FileCheck %s --check-prefix=FINAL_STATS1 +RUN: %run %t-SimpleTest %S/dict1.txt -runs=33 -print_final_stats=1 2>&1 | FileCheck %s --check-prefix=FINAL_STATS1 FINAL_STATS1: stat::number_of_executed_units: 33 FINAL_STATS1: stat::peak_rss_mb: diff --git a/test/fuzzer/fuzzer-flags.test b/test/fuzzer/fuzzer-flags.test index b812b01695d8..916c6eed889f 100644 --- a/test/fuzzer/fuzzer-flags.test +++ b/test/fuzzer/fuzzer-flags.test @@ -1,19 +1,19 @@ RUN: %cpp_compiler %S/FlagsTest.cpp -o %t-FlagsTest -RUN: %t-FlagsTest -runs=10 -foo_bar=1 2>&1 | FileCheck %s --check-prefix=FOO_BAR +RUN: %run %t-FlagsTest -runs=10 -foo_bar=1 2>&1 | FileCheck %s --check-prefix=FOO_BAR FOO_BAR: WARNING: unrecognized flag '-foo_bar=1'; use -help=1 to list all flags FOO_BAR: BINGO -RUN: %t-FlagsTest -runs=10 --max_len=100 2>&1 | FileCheck %s --check-prefix=DASH_DASH +RUN: %run %t-FlagsTest -runs=10 --max_len=100 2>&1 | FileCheck %s --check-prefix=DASH_DASH DASH_DASH: WARNING: did you mean '-max_len=100' (single dash)? DASH_DASH: INFO: A corpus is not provided, starting from an empty corpus -RUN: %t-FlagsTest -help=1 2>&1 | FileCheck %s --check-prefix=NO_INTERNAL +RUN: %run %t-FlagsTest -help=1 2>&1 | FileCheck %s --check-prefix=NO_INTERNAL NO_INTERNAL-NOT: internal flag -RUN: %t-FlagsTest --foo-bar -runs=10 -ignore_remaining_args=1 --baz -help=1 test 2>&1 | FileCheck %s --check-prefix=PASSTHRU +RUN: %run %t-FlagsTest --foo-bar -runs=10 -ignore_remaining_args=1 --baz -help=1 test 2>&1 | FileCheck %s --check-prefix=PASSTHRU PASSTHRU: BINGO --foo-bar --baz -help=1 test RUN: mkdir -p %t/T0 %t/T1 RUN: echo z > %t/T1/z -RUN: %t-FlagsTest -runs=10 --foo-bar -merge=1 %t/T0 %t/T1 -ignore_remaining_args=1 --baz -help=1 test 2>&1 | FileCheck %s --check-prefix=PASSTHRU-MERGE +RUN: %run %t-FlagsTest -runs=10 --foo-bar -merge=1 %t/T0 %t/T1 -ignore_remaining_args=1 --baz -help=1 test 2>&1 | FileCheck %s --check-prefix=PASSTHRU-MERGE PASSTHRU-MERGE: BINGO --foo-bar --baz -help=1 test diff --git a/test/fuzzer/fuzzer-leak.test b/test/fuzzer/fuzzer-leak.test index 0652a88f9d5d..2b61811d5d1b 100644 --- a/test/fuzzer/fuzzer-leak.test +++ b/test/fuzzer/fuzzer-leak.test @@ -1,10 +1,11 @@ REQUIRES: lsan + RUN: %cpp_compiler %S/LeakTest.cpp -o %t-LeakTest RUN: %cpp_compiler %S/ThreadedLeakTest.cpp -o %t-ThreadedLeakTest RUN: %cpp_compiler %S/LeakTimeoutTest.cpp -o %t-LeakTimeoutTest RUN: rm -rf %t-corpus && mkdir -p %t-corpus -RUN: not %t-LeakTest -runs=100000 -detect_leaks=1 %t-corpus 2>&1 | FileCheck %s --check-prefix=LEAK_DURING +RUN: not %run %t-LeakTest -runs=100000 -detect_leaks=1 %t-corpus 2>&1 | FileCheck %s --check-prefix=LEAK_DURING LEAK_DURING: ERROR: LeakSanitizer: detected memory leaks LEAK_DURING: Direct leak of 4 byte(s) in 1 object(s) allocated from: LEAK_DURING: INFO: to ignore leaks on libFuzzer side use -detect_leaks=0 @@ -13,29 +14,29 @@ LEAK_DURING-NOT: DONE LEAK_DURING-NOT: Done // Verify leaking input was not added to corpus -RUN: %t-LeakTest -runs=0 %t-corpus +RUN: %run %t-LeakTest -runs=0 %t-corpus -RUN: not %t-LeakTest -runs=0 -detect_leaks=1 %S 2>&1 | FileCheck %s --check-prefix=LEAK_IN_CORPUS +RUN: not %run %t-LeakTest -runs=0 -detect_leaks=1 %S 2>&1 | FileCheck %s --check-prefix=LEAK_IN_CORPUS LEAK_IN_CORPUS: ERROR: LeakSanitizer: detected memory leaks LEAK_IN_CORPUS: INFO: a leak has been found in the initial corpus. -RUN: not %t-LeakTest -runs=100000000 %S/hi.txt 2>&1 | FileCheck %s --check-prefix=MULTI_RUN_LEAK +RUN: not %run %t-LeakTest -runs=100000000 %S/hi.txt 2>&1 | FileCheck %s --check-prefix=MULTI_RUN_LEAK MULTI_RUN_LEAK-NOT: pulse MULTI_RUN_LEAK: LeakSanitizer: detected memory leaks -RUN: not %t-LeakTest -runs=100000 -detect_leaks=0 2>&1 | FileCheck %s --check-prefix=LEAK_AFTER -RUN: not %t-LeakTest -runs=100000 2>&1 | FileCheck %s --check-prefix=LEAK_DURING -RUN: not %t-ThreadedLeakTest -runs=100000 -detect_leaks=0 2>&1 | FileCheck %s --check-prefix=LEAK_AFTER -RUN: not %t-ThreadedLeakTest -runs=100000 2>&1 | FileCheck %s --check-prefix=LEAK_DURING +RUN: not %run %t-LeakTest -runs=100000 -detect_leaks=0 2>&1 | FileCheck %s --check-prefix=LEAK_AFTER +RUN: not %run %t-LeakTest -runs=100000 2>&1 | FileCheck %s --check-prefix=LEAK_DURING +RUN: not %run %t-ThreadedLeakTest -runs=100000 -detect_leaks=0 2>&1 | FileCheck %s --check-prefix=LEAK_AFTER +RUN: not %run %t-ThreadedLeakTest -runs=100000 2>&1 | FileCheck %s --check-prefix=LEAK_DURING LEAK_AFTER: Done 100000 runs in LEAK_AFTER: ERROR: LeakSanitizer: detected memory leaks -RUN: not %t-LeakTest -runs=100000 -max_len=1 2>&1 | FileCheck %s --check-prefix=MAX_LEN_1 +RUN: not %run %t-LeakTest -runs=100000 -max_len=1 2>&1 | FileCheck %s --check-prefix=MAX_LEN_1 MAX_LEN_1: Test unit written to ./leak-7cf184f4c67ad58283ecb19349720b0cae756829 -RUN: not %t-LeakTimeoutTest -timeout=1 2>&1 | FileCheck %s --check-prefix=LEAK_TIMEOUT +RUN: not %run %t-LeakTimeoutTest -timeout=1 2>&1 | FileCheck %s --check-prefix=LEAK_TIMEOUT LEAK_TIMEOUT: ERROR: libFuzzer: timeout after LEAK_TIMEOUT-NOT: LeakSanitizer -RUN: %t-LeakTest -error_exitcode=0 +RUN: %run %t-LeakTest -error_exitcode=0 diff --git a/test/fuzzer/fuzzer-mutationstats.test b/test/fuzzer/fuzzer-mutationstats.test new file mode 100644 index 000000000000..95743a818d1f --- /dev/null +++ b/test/fuzzer/fuzzer-mutationstats.test @@ -0,0 +1,5 @@ +RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-MutationStatsTest +RUN: not %run %t-MutationStatsTest -print_mutation_stats=1 2>&1 | FileCheck %s + +# Ensures there are some non-zero values in the usefulness percentages printed. +CHECK: stat::mutation_usefulness: {{[0-9]+\.[0-9]+}} diff --git a/test/fuzzer/fuzzer-oom-with-profile.test b/test/fuzzer/fuzzer-oom-with-profile.test index 75cf48430a46..918197abd5a2 100644 --- a/test/fuzzer/fuzzer-oom-with-profile.test +++ b/test/fuzzer/fuzzer-oom-with-profile.test @@ -1,6 +1,6 @@ REQUIRES: linux RUN: %cpp_compiler %S/OutOfMemoryTest.cpp -o %t-OutOfMemoryTest -RUN: not %t-OutOfMemoryTest -rss_limit_mb=300 2>&1 | FileCheck %s +RUN: not %run %t-OutOfMemoryTest -rss_limit_mb=300 2>&1 | FileCheck %s CHECK: ERROR: libFuzzer: out-of-memory (used: {{.*}}; limit: 300Mb) CHECK: Live Heap Allocations CHECK: Test unit written to ./oom- diff --git a/test/fuzzer/fuzzer-oom.test b/test/fuzzer/fuzzer-oom.test index 308c4c5cd394..e82fb47c5bed 100644 --- a/test/fuzzer/fuzzer-oom.test +++ b/test/fuzzer/fuzzer-oom.test @@ -1,16 +1,17 @@ +UNSUPPORTED: aarch64 RUN: %cpp_compiler %S/OutOfMemoryTest.cpp -o %t-OutOfMemoryTest RUN: %cpp_compiler %S/OutOfMemorySingleLargeMallocTest.cpp -o %t-OutOfMemorySingleLargeMallocTest RUN: %cpp_compiler %S/AccumulateAllocationsTest.cpp -o %t-AccumulateAllocationsTest -RUN: not %t-OutOfMemoryTest -rss_limit_mb=300 2>&1 | FileCheck %s +RUN: not %run %t-OutOfMemoryTest -rss_limit_mb=300 2>&1 | FileCheck %s CHECK: ERROR: libFuzzer: out-of-memory (used: {{.*}}; limit: 300Mb) CHECK: Test unit written to ./oom- SUMMARY: libFuzzer: out-of-memory -RUN: not %t-OutOfMemorySingleLargeMallocTest -rss_limit_mb=300 2>&1 | FileCheck %s --check-prefix=SINGLE_LARGE_MALLOC -RUN: not %t-OutOfMemorySingleLargeMallocTest -malloc_limit_mb=300 2>&1 | FileCheck %s --check-prefix=SINGLE_LARGE_MALLOC -RUN: not %t-OutOfMemorySingleLargeMallocTest -rss_limit_mb=1000 -malloc_limit_mb=300 2>&1 | FileCheck %s --check-prefix=SINGLE_LARGE_MALLOC +RUN: not %run %t-OutOfMemorySingleLargeMallocTest -rss_limit_mb=300 2>&1 | FileCheck %s --check-prefix=SINGLE_LARGE_MALLOC +RUN: not %run %t-OutOfMemorySingleLargeMallocTest -malloc_limit_mb=300 2>&1 | FileCheck %s --check-prefix=SINGLE_LARGE_MALLOC +RUN: not %run %t-OutOfMemorySingleLargeMallocTest -rss_limit_mb=1000 -malloc_limit_mb=300 2>&1 | FileCheck %s --check-prefix=SINGLE_LARGE_MALLOC We used to check for "out-of-memory (malloc(53{{.*}}))", but that would fail sometimes, so now we accept any OOM message. @@ -19,4 +20,4 @@ SINGLE_LARGE_MALLOC: libFuzzer: out-of-memory SINGLE_LARGE_MALLOC: in LLVMFuzzerTestOneInput # Check that -rss_limit_mb=0 means no limit. -RUN: %t-AccumulateAllocationsTest -runs=1000 -rss_limit_mb=0 +RUN: %run %t-AccumulateAllocationsTest -runs=1000 -rss_limit_mb=0 diff --git a/test/fuzzer/fuzzer-printcovpcs.test b/test/fuzzer/fuzzer-printcovpcs.test index e55ce14aa72f..decf0a7e5fff 100644 --- a/test/fuzzer/fuzzer-printcovpcs.test +++ b/test/fuzzer/fuzzer-printcovpcs.test @@ -1,5 +1,7 @@ +XFAIL: ios +UNSUPPORTED: aarch64 RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest -RUN: not %t-SimpleTest -print_pcs=1 -seed=1 2>&1 | FileCheck %s --check-prefix=PCS +RUN: not %run %t-SimpleTest -print_pcs=1 -seed=1 2>&1 | FileCheck %s --check-prefix=PCS PCS-NOT: NEW_PC PCS:INITED PCS:NEW_PC: {{0x[a-f0-9]+}} diff --git a/test/fuzzer/fuzzer-runs.test b/test/fuzzer/fuzzer-runs.test index 04987eee5029..b3f20c475aa9 100644 --- a/test/fuzzer/fuzzer-runs.test +++ b/test/fuzzer/fuzzer-runs.test @@ -1,9 +1,9 @@ RUN: mkdir -p %t RUN: %cpp_compiler %S/NthRunCrashTest.cpp -o %t-NthRunCrashTest RUN: echo abcd > %t/NthRunCrashTest.in -RUN: %t-NthRunCrashTest %t/NthRunCrashTest.in -RUN: %t-NthRunCrashTest %t/NthRunCrashTest.in -runs=10 -RUN: not %t-NthRunCrashTest %t/NthRunCrashTest.in -runs=10000 2>&1 | FileCheck %s +RUN: %run %t-NthRunCrashTest %t/NthRunCrashTest.in +RUN: %run %t-NthRunCrashTest %t/NthRunCrashTest.in -runs=10 +RUN: not %run %t-NthRunCrashTest %t/NthRunCrashTest.in -runs=10000 2>&1 | FileCheck %s RUN: rm %t/NthRunCrashTest.in CHECK: BINGO diff --git a/test/fuzzer/fuzzer-seed.test b/test/fuzzer/fuzzer-seed.test index a69ea5432849..b6343ffa3dd7 100644 --- a/test/fuzzer/fuzzer-seed.test +++ b/test/fuzzer/fuzzer-seed.test @@ -1,4 +1,4 @@ RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-SimpleCmpTest -RUN: %t-SimpleCmpTest -seed=-1 -runs=0 2>&1 | FileCheck %s --check-prefix=CHECK_SEED_MINUS_ONE +RUN: %run %t-SimpleCmpTest -seed=-1 -runs=0 2>&1 | FileCheck %s --check-prefix=CHECK_SEED_MINUS_ONE CHECK_SEED_MINUS_ONE: Seed: 4294967295 diff --git a/test/fuzzer/fuzzer-segv.test b/test/fuzzer/fuzzer-segv.test index 4d3c7575f7a8..0c4fafe08077 100644 --- a/test/fuzzer/fuzzer-segv.test +++ b/test/fuzzer/fuzzer-segv.test @@ -1,8 +1,8 @@ RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-NullDerefTest -RUN: env ASAN_OPTIONS=handle_segv=0 not %t-NullDerefTest 2>&1 | FileCheck %s --check-prefix=LIBFUZZER_OWN_SEGV_HANDLER +RUN: env ASAN_OPTIONS=handle_segv=0 not %run %t-NullDerefTest 2>&1 | FileCheck %s --check-prefix=LIBFUZZER_OWN_SEGV_HANDLER LIBFUZZER_OWN_SEGV_HANDLER: == ERROR: libFuzzer: deadly signal LIBFUZZER_OWN_SEGV_HANDLER: SUMMARY: libFuzzer: deadly signal LIBFUZZER_OWN_SEGV_HANDLER: Test unit written to ./crash- -RUN: env ASAN_OPTIONS=handle_segv=1 not %t-NullDerefTest 2>&1 | FileCheck %s --check-prefix=LIBFUZZER_ASAN_SEGV_HANDLER +RUN: env ASAN_OPTIONS=handle_segv=1 not %run %t-NullDerefTest 2>&1 | FileCheck %s --check-prefix=LIBFUZZER_ASAN_SEGV_HANDLER LIBFUZZER_ASAN_SEGV_HANDLER: ERROR: AddressSanitizer: {{SEGV|access-violation}} on unknown address diff --git a/test/fuzzer/fuzzer-singleinputs.test b/test/fuzzer/fuzzer-singleinputs.test index 468da5622af9..704f9caa57f9 100644 --- a/test/fuzzer/fuzzer-singleinputs.test +++ b/test/fuzzer/fuzzer-singleinputs.test @@ -1,15 +1,15 @@ RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-NullDerefTest RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest -RUN: not %t-NullDerefTest %S/hi.txt 2>&1 | FileCheck %s --check-prefix=SingleInput +RUN: not %run %t-NullDerefTest %S/hi.txt 2>&1 | FileCheck %s --check-prefix=SingleInput SingleInput-NOT: Test unit written to ./crash- RUN: rm -rf %tmp/SINGLE_INPUTS RUN: mkdir -p %tmp/SINGLE_INPUTS RUN: echo aaa > %tmp/SINGLE_INPUTS/aaa RUN: echo bbb > %tmp/SINGLE_INPUTS/bbb -RUN: %t-SimpleTest %tmp/SINGLE_INPUTS/aaa %tmp/SINGLE_INPUTS/bbb 2>&1 | FileCheck %s --check-prefix=SINGLE_INPUTS -RUN: %t-SimpleTest -max_len=2 %tmp/SINGLE_INPUTS/aaa %tmp/SINGLE_INPUTS/bbb 2>&1 | FileCheck %s --check-prefix=SINGLE_INPUTS +RUN: %run %t-SimpleTest %tmp/SINGLE_INPUTS/aaa %tmp/SINGLE_INPUTS/bbb 2>&1 | FileCheck %s --check-prefix=SINGLE_INPUTS +RUN: %run %t-SimpleTest -max_len=2 %tmp/SINGLE_INPUTS/aaa %tmp/SINGLE_INPUTS/bbb 2>&1 | FileCheck %s --check-prefix=SINGLE_INPUTS RUN: rm -rf %tmp/SINGLE_INPUTS SINGLE_INPUTS: SimpleTest{{.*}}: Running 2 inputs 1 time(s) each. SINGLE_INPUTS: aaa in diff --git a/test/fuzzer/fuzzer-threaded.test b/test/fuzzer/fuzzer-threaded.test index 572ed5a35518..3321e19585c0 100644 --- a/test/fuzzer/fuzzer-threaded.test +++ b/test/fuzzer/fuzzer-threaded.test @@ -1,8 +1,8 @@ CHECK: Done 1000 runs in RUN: %cpp_compiler %S/ThreadedTest.cpp -o %t-ThreadedTest -RUN: %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s -RUN: %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s -RUN: %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s -RUN: %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s +RUN: %run %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s +RUN: %run %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s +RUN: %run %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s +RUN: %run %t-ThreadedTest -use_traces=1 -runs=1000 2>&1 | FileCheck %s diff --git a/test/fuzzer/fuzzer-timeout.test b/test/fuzzer/fuzzer-timeout.test index 41f4ba364398..a924cde73373 100644 --- a/test/fuzzer/fuzzer-timeout.test +++ b/test/fuzzer/fuzzer-timeout.test @@ -1,6 +1,6 @@ RUN: %cpp_compiler %S/TimeoutTest.cpp -o %t-TimeoutTest RUN: %cpp_compiler %S/TimeoutEmptyTest.cpp -o %t-TimeoutEmptyTest -RUN: not %t-TimeoutTest -timeout=1 2>&1 | FileCheck %s --check-prefix=TimeoutTest +RUN: not %run %t-TimeoutTest -timeout=1 2>&1 | FileCheck %s --check-prefix=TimeoutTest TimeoutTest: ALARM: working on the last Unit for TimeoutTest: Test unit written to ./timeout- TimeoutTest: == ERROR: libFuzzer: timeout after @@ -9,13 +9,13 @@ TimeoutTest: #1 TimeoutTest: #2 TimeoutTest: SUMMARY: libFuzzer: timeout -RUN: not %t-TimeoutTest -timeout=1 %S/hi.txt 2>&1 | FileCheck %s --check-prefix=SingleInputTimeoutTest +RUN: not %run %t-TimeoutTest -timeout=1 %S/hi.txt 2>&1 | FileCheck %s --check-prefix=SingleInputTimeoutTest SingleInputTimeoutTest: ALARM: working on the last Unit for {{[1-3]}} seconds SingleInputTimeoutTest-NOT: Test unit written to ./timeout- -RUN: %t-TimeoutTest -timeout=1 -timeout_exitcode=0 +RUN: %run %t-TimeoutTest -timeout=1 -timeout_exitcode=0 -RUN: not %t-TimeoutEmptyTest -timeout=1 2>&1 | FileCheck %s --check-prefix=TimeoutEmptyTest +RUN: not %run %t-TimeoutEmptyTest -timeout=1 2>&1 | FileCheck %s --check-prefix=TimeoutEmptyTest TimeoutEmptyTest: ALARM: working on the last Unit for TimeoutEmptyTest: == ERROR: libFuzzer: timeout after TimeoutEmptyTest: SUMMARY: libFuzzer: timeout diff --git a/test/fuzzer/fuzzer-ubsan.test b/test/fuzzer/fuzzer-ubsan.test index 49c190cd034b..6bc2c3863668 100644 --- a/test/fuzzer/fuzzer-ubsan.test +++ b/test/fuzzer/fuzzer-ubsan.test @@ -1,5 +1,5 @@ RUN: %cpp_compiler -fsanitize=undefined -fno-sanitize-recover=all %S/SignedIntOverflowTest.cpp -o %t-SignedIntOverflowTest-Ubsan -RUN: not %t-SignedIntOverflowTest-Ubsan 2>&1 | FileCheck %s +RUN: not %run %t-SignedIntOverflowTest-Ubsan 2>&1 | FileCheck %s CHECK: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int' CHECK: Test unit written to ./crash- diff --git a/test/fuzzer/fuzzer.test b/test/fuzzer/fuzzer.test deleted file mode 100644 index 29bc8f0ce795..000000000000 --- a/test/fuzzer/fuzzer.test +++ /dev/null @@ -1,70 +0,0 @@ -CHECK: BINGO -Done1000000: Done 1000000 runs in -RUN: %cpp_compiler %S/BogusInitializeTest.cpp -o %t-BogusInitializeTest -RUN: %cpp_compiler %S/BufferOverflowOnInput.cpp -o %t-BufferOverflowOnInput -RUN: %cpp_compiler %S/CounterTest.cpp -o %t-CounterTest -RUN: %cpp_compiler %S/DSO1.cpp -fPIC -shared -o %t-DSO1.so -RUN: %cpp_compiler %S/DSO2.cpp -fPIC -shared -o %t-DSO2.so -RUN: %cpp_compiler %S/DSOTestMain.cpp %S/DSOTestExtra.cpp -L. %t-DSO1.so %t-DSO2.so -o %t-DSOTest -RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t-FullCoverageSetTest -RUN: %cpp_compiler %S/InitializeTest.cpp -o %t-InitializeTest -RUN: %cpp_compiler %S/NotinstrumentedTest.cpp -fsanitize-coverage=0 -o %t-NotinstrumentedTest-NoCoverage -RUN: %cpp_compiler %S/NullDerefOnEmptyTest.cpp -o %t-NullDerefOnEmptyTest -RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-NullDerefTest -RUN: %cpp_compiler %S/SimpleCmpTest.cpp -o %t-SimpleCmpTest -RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest -RUN: %cpp_compiler %S/StrncmpOOBTest.cpp -o %t-StrncmpOOBTest - -RUN: not %t-SimpleTest 2>&1 | FileCheck %s - -# only_ascii mode. Will perform some minimal self-validation. -RUN: not %t-SimpleTest -only_ascii=1 2>&1 - -RUN: %t-SimpleCmpTest -max_total_time=1 -use_cmp=0 2>&1 | FileCheck %s --check-prefix=MaxTotalTime -MaxTotalTime: Done {{.*}} runs in {{.}} second(s) - -RUN: not %t-NullDerefTest 2>&1 | FileCheck %s --check-prefix=NullDerefTest -RUN: not %t-NullDerefTest -close_fd_mask=3 2>&1 | FileCheck %s --check-prefix=NullDerefTest -NullDerefTest: ERROR: AddressSanitizer: {{SEGV|access-violation}} on unknown address -NullDerefTest: Test unit written to ./crash- -RUN: not %t-NullDerefTest -artifact_prefix=ZZZ 2>&1 | FileCheck %s --check-prefix=NullDerefTestPrefix -NullDerefTestPrefix: Test unit written to ZZZcrash- -RUN: not %t-NullDerefTest -artifact_prefix=ZZZ -exact_artifact_path=FOOBAR 2>&1 | FileCheck %s --check-prefix=NullDerefTestExactPath -NullDerefTestExactPath: Test unit written to FOOBAR - -RUN: not %t-NullDerefOnEmptyTest -print_final_stats=1 2>&1 | FileCheck %s --check-prefix=NULL_DEREF_ON_EMPTY -NULL_DEREF_ON_EMPTY: stat::number_of_executed_units: - -#not %t-FullCoverageSetTest -timeout=15 -seed=1 -mutate_depth=2 -use_full_coverage_set=1 2>&1 | FileCheck %s - -RUN: not %t-CounterTest -max_len=6 -seed=1 -timeout=15 2>&1 | FileCheck %s --check-prefix=COUNTERS - -COUNTERS: INITED {{.*}} {{bits:|ft:}} -COUNTERS: NEW {{.*}} {{bits:|ft:}} {{[1-9]*}} -COUNTERS: NEW {{.*}} {{bits:|ft:}} {{[1-9]*}} -COUNTERS: BINGO - -# Don't run UninstrumentedTest for now since we build libFuzzer itself with asan. -DISABLED: not %t-UninstrumentedTest-Uninstrumented 2>&1 | FileCheck %s --check-prefix=UNINSTRUMENTED -UNINSTRUMENTED: ERROR: __sanitizer_set_death_callback is not defined. Exiting. - -RUN: not %t-NotinstrumentedTest-NoCoverage 2>&1 | FileCheck %s --check-prefix=NO_COVERAGE -NO_COVERAGE: ERROR: no interesting inputs were found. Is the code instrumented for coverage? Exiting - -RUN: not %t-BufferOverflowOnInput 2>&1 | FileCheck %s --check-prefix=OOB -OOB: AddressSanitizer: heap-buffer-overflow -OOB: is located 0 bytes to the right of 3-byte region - -RUN: not %t-InitializeTest -use_value_profile=1 2>&1 | FileCheck %s - -RUN: not %t-DSOTest 2>&1 | FileCheck %s --check-prefix=DSO -DSO: INFO: Loaded 3 modules -DSO: BINGO - -RUN: env ASAN_OPTIONS=strict_string_checks=1 not %t-StrncmpOOBTest -seed=1 -runs=1000000 2>&1 | FileCheck %s --check-prefix=STRNCMP -STRNCMP: AddressSanitizer: heap-buffer-overflow -STRNCMP-NOT: __sanitizer_weak_hook_strncmp -STRNCMP: in LLVMFuzzerTestOneInput - -RUN: not %t-BogusInitializeTest 2>&1 | FileCheck %s --check-prefix=BOGUS_INITIALIZE -BOGUS_INITIALIZE: argv[0] has been modified in LLVMFuzzerInitialize diff --git a/test/fuzzer/gc-sections.test b/test/fuzzer/gc-sections.test index 8785bb00ec1b..b8abfbbdf17b 100644 --- a/test/fuzzer/gc-sections.test +++ b/test/fuzzer/gc-sections.test @@ -1,12 +1,14 @@ -REQUIRES: linux +REQUIRES: linux, lld-available No gc-sections: RUN: %cpp_compiler %S/GcSectionsTest.cpp -o %t RUN: nm %t | grep UnusedFunctionShouldBeRemovedByLinker | count 1 -With gc-sections. Currently, we can't remove unused code. -DISABLED: %cpp_compiler %S/GcSectionsTest.cpp -o %t -ffunction-sections -Wl,-gc-sections -DISABLED: nm %t | grep UnusedFunctionShouldBeRemovedByLinker | count 1 +With gc-sections. Currently, we can't remove unused code except with LLD. +RUN: %cpp_compiler %S/GcSectionsTest.cpp -o %t -fuse-ld=lld -ffunction-sections -Wl,-gc-sections +RUN: nm %t | not grep UnusedFunctionShouldBeRemovedByLinker +RUN: %run %t -runs=0 2>&1 | FileCheck %s +CHECK-NOT: ERROR: The size of coverage PC tables does not match With gc sections, with trace-pc. Unused code is removed. RUN: %cpp_compiler %S/GcSectionsTest.cpp -o %t -fsanitize-coverage=0 -fsanitize-coverage=trace-pc -ffunction-sections -Wl,-gc-sections diff --git a/test/fuzzer/handle-unstable.test b/test/fuzzer/handle-unstable.test new file mode 100644 index 000000000000..798ee2dc042f --- /dev/null +++ b/test/fuzzer/handle-unstable.test @@ -0,0 +1,42 @@ +# Tests -handle_unstable +UNSUPPORTED: aarch64 + +RUN: %cpp_compiler %S/PrintUnstableStatsTest.cpp -o %t-HandleUnstableTest + +; Normal +RUN: %run %t-HandleUnstableTest -print_coverage=1 -runs=100000 2>&1 | FileCheck %s --check-prefix=NORMAL +NORMAL-DAG: det0() +NORMAL-DAG: det1() +NORMAL-DAG: det2() +NORMAL-DAG: det3() +NORMAL-DAG: det4() +NORMAL-DAG: ini0() +NORMAL-DAG: ini1() +NORMAL-DAG: ini2() +NORMAL-DAG: t0() +NORMAL-DAG: t1() +NORMAL-DAG: t2() +NORMAL-DAG: t3() +NORMAL-DAG: t4() + +; MinUnstable +RUN: %run %t-HandleUnstableTest -print_coverage=1 -handle_unstable=1 -runs=100000 2>&1 | FileCheck %s --check-prefix=MIN +MIN-NOT: ini0() +MIN-NOT: ini1() +MIN-NOT: ini2() +MIN: det0() +MIN: det1() +MIN: det2() +MIN: det3() +MIN: det4() + +; ZeroUnstable +RUN: %run %t-HandleUnstableTest -print_coverage=1 -handle_unstable=2 -runs=1 2>&1 | FileCheck %s --check-prefix=ZERO +ZERO-NOT: ini0() +ZERO-NOT: ini1() +ZERO-NOT: ini2() +ZERO: det0() +ZERO: det1() +ZERO: det2() +ZERO: det3() +ZERO: det4() diff --git a/test/fuzzer/initialize.test b/test/fuzzer/initialize.test new file mode 100644 index 000000000000..dc6e8697558e --- /dev/null +++ b/test/fuzzer/initialize.test @@ -0,0 +1,3 @@ +CHECK: BINGO +RUN: %cpp_compiler %S/InitializeTest.cpp -o %t-InitializeTest +RUN: not %run %t-InitializeTest -use_value_profile=1 2>&1 | FileCheck %s diff --git a/test/fuzzer/inline-8bit-counters.test b/test/fuzzer/inline-8bit-counters.test deleted file mode 100644 index 76ae1f537f72..000000000000 --- a/test/fuzzer/inline-8bit-counters.test +++ /dev/null @@ -1,4 +0,0 @@ -RUN: %cpp_compiler %S/SimpleTest.cpp -fno-sanitize-coverage=trace-pc-guard -fsanitize-coverage=inline-8bit-counters -o %t-SimpleTest-Inline8bitCounters -CHECK: INFO: Loaded 1 modules ({{.*}} inline 8-bit counters) -CHECK: BINGO -RUN: not %t-SimpleTest-Inline8bitCounters -runs=1000000 -seed=1 2>&1 | FileCheck %s diff --git a/test/fuzzer/lit.cfg b/test/fuzzer/lit.cfg index 0350a1ad7797..8a44860d4a5d 100644 --- a/test/fuzzer/lit.cfg +++ b/test/fuzzer/lit.cfg @@ -2,7 +2,7 @@ import lit.formats import sys import os -config.name = "LLVMFuzzer" +config.name = "libFuzzer" + config.name_suffix config.test_format = lit.formats.ShTest(True) config.suffixes = ['.test'] config.test_source_root = os.path.dirname(__file__) @@ -25,12 +25,20 @@ else: config.test_format = lit.formats.ShTest(execute_external) # LeakSanitizer is not supported on OSX right now. -if sys.platform.startswith('darwin'): +if sys.platform.startswith('darwin') or sys.platform.startswith('freebsd'): lit_config.note('lsan feature unavailable') else: lit_config.note('lsan feature available') config.available_features.add('lsan') +# MemorySanitizer is not supported on OSX right now +if sys.platform.startswith('darwin'): + lit_config.note('msan feature unavailable') + assert 'msan' not in config.available_features +else: + lit_config.note('msan feature available') + config.available_features.add('msan') + if sys.platform.startswith('win') or sys.platform.startswith('cygwin'): config.available_features.add('windows') @@ -49,18 +57,36 @@ config.substitutions.append(('%build_dir', config.cmake_binary_dir)) libfuzzer_src_root = os.path.join(config.compiler_rt_src_root, "lib", "fuzzer") config.substitutions.append(('%libfuzzer_src', libfuzzer_src_root)) -def generate_compiler_cmd(is_cpp=True, fuzzer_enabled=True): - compiler_cmd = config.c_compiler - link_cmd = '-lc++' if 'darwin' in config.target_triple else '-lstdc++' - std_cmd = '-std=c++11' if is_cpp else '' - sanitizers = ['address'] +def generate_compiler_cmd(is_cpp=True, fuzzer_enabled=True, msan_enabled=False): + compiler_cmd = config.clang + extra_cmd = config.target_flags + if config.clang and config.stdlib == 'libc++': + link_cmd = '-stdlib=libc++ -Wl,-rpath=%s' % config.runtime_library_dir + elif config.clang and config.stdlib == 'static-libc++': + link_cmd = '-stdlib=libc++ -lc++abi -static-libstdc++ -Wl,-rpath=%s' % ( + config.runtime_library_dir) + elif any(x in config.target_triple for x in ('darwin', 'freebsd')): + link_cmd = '-lc++' + else: + link_cmd = '-lstdc++' + + std_cmd = '--driver-mode=g++ -std=c++11' if is_cpp else '' + if msan_enabled: + sanitizers = ['memory'] + else: + sanitizers = ['address'] if fuzzer_enabled: sanitizers.append('fuzzer') sanitizers_cmd = ('-fsanitize=%s' % ','.join(sanitizers)) - isysroot_cmd = config.osx_sysroot_flag if config.osx_sysroot_flag else '' - include_cmd = '-I%s' % libfuzzer_src_root - return '%s %s %s -gline-tables-only %s %s %s' % ( - compiler_cmd, std_cmd, link_cmd, isysroot_cmd, sanitizers_cmd, include_cmd) + return " ".join([ + compiler_cmd, + std_cmd, + link_cmd, + "-O2 -gline-tables-only", + sanitizers_cmd, + "-I%s" % libfuzzer_src_root, + extra_cmd + ]) config.substitutions.append(('%cpp_compiler', generate_compiler_cmd(is_cpp=True, fuzzer_enabled=True) @@ -77,3 +103,13 @@ config.substitutions.append(('%no_fuzzer_cpp_compiler', config.substitutions.append(('%no_fuzzer_c_compiler', generate_compiler_cmd(is_cpp=False, fuzzer_enabled=False) )) + +config.substitutions.append(('%msan_compiler', + generate_compiler_cmd(is_cpp=True, fuzzer_enabled=True, msan_enabled=True) + )) + +if config.host_os == 'Darwin': + if config.target_arch in ["x86_64", "x86_64h"]: + config.parallelism_group = "darwin-64bit-sanitizer" + elif config.apple_platform != "osx" and not config.apple_platform.endswith("sim"): + config.parallelism_group = "darwin-ios-device-sanitizer" diff --git a/test/fuzzer/lit.site.cfg.in b/test/fuzzer/lit.site.cfg.in index 7f70c8f67d69..b333c78e59e9 100644 --- a/test/fuzzer/lit.site.cfg.in +++ b/test/fuzzer/lit.site.cfg.in @@ -1,17 +1,24 @@ @LIT_SITE_CFG_IN_HEADER@ -config.test_exec_root = "@CMAKE_CURRENT_BINARY_DIR@" - config.cpp_compiler = "@LIBFUZZER_TEST_COMPILER@" config.target_flags = "@LIBFUZZER_TEST_FLAGS@" config.c_compiler = "@LIBFUZZER_TEST_COMPILER@" +config.stdlib = "@LIBFUZZER_TEST_STDLIB@" +config.apple_platform = "@LIBFUZZER_TEST_APPLE_PLATFORM@" +config.name_suffix = "@LIBFUZZER_TEST_CONFIG_SUFFIX@" config.osx_sysroot_flag = "@OSX_SYSROOT_FLAG@" config.cmake_binary_dir = "@CMAKE_BINARY_DIR@" +config.llvm_library_dir = "@LLVM_LIBRARY_DIR@" config.target_triple = "@TARGET_TRIPLE@" # Load common config for all compiler-rt lit tests. lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured") +if config.enable_per_target_runtime_dir: + config.runtime_library_dir = config.compiler_rt_libdir +else: + config.runtime_library_dir = "@LLVM_LIBRARY_DIR@" + lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg") diff --git a/test/fuzzer/max-number-of-runs.test b/test/fuzzer/max-number-of-runs.test index efe7a9c0f629..c1fa93101510 100644 --- a/test/fuzzer/max-number-of-runs.test +++ b/test/fuzzer/max-number-of-runs.test @@ -1,10 +1,10 @@ RUN: %cpp_compiler %S/AccumulateAllocationsTest.cpp -o %t-AccumulateAllocationsTest -RUN: %t-AccumulateAllocationsTest -seed=1 -runs=2 2>&1 | FileCheck %s --check-prefix=CHECK1 +RUN: %run %t-AccumulateAllocationsTest -seed=1 -runs=2 2>&1 | FileCheck %s --check-prefix=CHECK1 CHECK1: Done 2 runs -RUN: %t-AccumulateAllocationsTest -seed=1 -runs=3 2>&1 | FileCheck %s --check-prefix=CHECK2 +RUN: %run %t-AccumulateAllocationsTest -seed=1 -runs=3 2>&1 | FileCheck %s --check-prefix=CHECK2 CHECK2: Done 3 runs -RUN: %t-AccumulateAllocationsTest -seed=1 -runs=4 2>&1 | FileCheck %s --check-prefix=CHECK3 +RUN: %run %t-AccumulateAllocationsTest -seed=1 -runs=4 2>&1 | FileCheck %s --check-prefix=CHECK3 CHECK3: Done 4 runs diff --git a/test/fuzzer/memcmp.test b/test/fuzzer/memcmp.test index 3431a524ced5..5657cab41dfc 100644 --- a/test/fuzzer/memcmp.test +++ b/test/fuzzer/memcmp.test @@ -1,3 +1,4 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/MemcmpTest.cpp -o %t-MemcmpTest -RUN: not %t-MemcmpTest -seed=1 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-MemcmpTest -seed=1 -runs=10000000 2>&1 | FileCheck %s CHECK: BINGO diff --git a/test/fuzzer/memcmp64.test b/test/fuzzer/memcmp64.test index 223c3bd42a7d..24d14bf73bbf 100644 --- a/test/fuzzer/memcmp64.test +++ b/test/fuzzer/memcmp64.test @@ -1,3 +1,4 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/Memcmp64BytesTest.cpp -o %t-Memcmp64BytesTest -RUN: not %t-Memcmp64BytesTest -seed=1 -runs=1000000 2>&1 | FileCheck %s +RUN: not %run %t-Memcmp64BytesTest -seed=1 -runs=1000000 2>&1 | FileCheck %s CHECK: BINGO diff --git a/test/fuzzer/merge-control-file.test b/test/fuzzer/merge-control-file.test index 2da5c4ccfb2b..64b747116a9f 100644 --- a/test/fuzzer/merge-control-file.test +++ b/test/fuzzer/merge-control-file.test @@ -1,3 +1,4 @@ +XFAIL: ios RUN: mkdir -p %t RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t/T @@ -10,9 +11,9 @@ RUN: echo ..Z... > %t/T0/3 # Test what happens if the control file is junk. RUN: echo JUNK > %t/MCF -RUN: not %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=JUNK +RUN: not %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=JUNK RUN: echo 3 > %t/MCF; echo 0 >> %t/MCF; echo %t/T1/1 >> %t/MCF -RUN: not %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=JUNK +RUN: not %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=JUNK JUNK: MERGE-OUTER: non-empty control file provided: {{.*}}MCF JUNK: MERGE-OUTER: bad control file, will overwrite it @@ -21,18 +22,18 @@ JUNK: MERGE-OUTER: bad control file, will overwrite it RUN: rm -f %t/T1/*; cp %t/T0/* %t/T1 RUN: echo 3 > %t/MCF; echo 0 >> %t/MCF; echo %t/T1/1 >> %t/MCF; echo %t/T1/2 >> %t/MCF; echo %t/T1/3 >> %t/MCF -RUN: %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=OK_0 +RUN: %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=OK_0 OK_0: MERGE-OUTER: control file ok, 3 files total, first not processed file 0 OK_0: MERGE-OUTER: 3 new files with {{.*}} new features added RUN: rm -f %t/T1/*; cp %t/T0/* %t/T1 RUN: echo 3 > %t/MCF; echo 0 >> %t/MCF; echo %t/T1/1 >> %t/MCF; echo %t/T1/2 >> %t/MCF; echo %t/T1/3 >> %t/MCF -RUN: %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF -save_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=SAVE_SUMMARY +RUN: %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF -save_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=SAVE_SUMMARY SAVE_SUMMARY: MERGE-OUTER: writing coverage summary for 3 files to {{.*}}/SUMMARY RUN: rm -f %t/T1/*; cp %t/T0/* %t/T1 RUN: echo 3 > %t/MCF; echo 0 >> %t/MCF; echo %t/T1/1 >> %t/MCF; echo %t/T1/2 >> %t/MCF; echo %t/T1/3 >> %t/MCF -RUN: %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF -load_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=LOAD_SUMMARY +RUN: %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF -load_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=LOAD_SUMMARY LOAD_SUMMARY: MERGE-OUTER: coverage summary loaded from RUN: rm -f %t/T1/*; cp %t/T0/* %t/T1 @@ -41,7 +42,7 @@ RUN: echo STARTED 0 1 >> %t/MCF RUN: echo DONE 0 11 >> %t/MCF RUN: echo STARTED 1 2 >> %t/MCF RUN: echo DONE 1 12 >> %t/MCF -RUN: %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=OK_2 +RUN: %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=OK_2 OK_2: MERGE-OUTER: control file ok, 3 files total, first not processed file 2 OK_2: MERGE-OUTER: 3 new files with {{.*}} new features added @@ -53,5 +54,5 @@ RUN: echo STARTED 1 2 >> %t/MCF RUN: echo DONE 1 12 >> %t/MCF RUN: echo STARTED 2 2 >> %t/MCF RUN: echo DONE 2 13 >> %t/MCF -RUN: %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=OK_3 +RUN: %run %t/T -merge=1 %t/T1 %t/T2 -merge_control_file=%t/MCF 2>&1 | FileCheck %s --check-prefix=OK_3 OK_3: MERGE-OUTER: nothing to do, merge has been completed before diff --git a/test/fuzzer/merge-posix.test b/test/fuzzer/merge-posix.test index e34e3a325b74..db0a48b5481e 100644 --- a/test/fuzzer/merge-posix.test +++ b/test/fuzzer/merge-posix.test @@ -1,3 +1,4 @@ +XFAIL: ios RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t-FullCoverageSetTest RUN: rm -rf %tmp/T1 %tmp/T2 @@ -15,9 +16,9 @@ RUN: echo ....E. > %tmp/T2/5 RUN: echo .....R > %tmp/T2/6 # Check that we can report an error if file size exceeded -RUN: (ulimit -f 1; not %t-FullCoverageSetTest -merge=1 %tmp/T1 %tmp/T2 2>&1 | FileCheck %s --check-prefix=SIGXFSZ) +RUN: (ulimit -f 1; not %run %t-FullCoverageSetTest -merge=1 %tmp/T1 %tmp/T2 2>&1 | FileCheck %s --check-prefix=SIGXFSZ) SIGXFSZ: ERROR: libFuzzer: file size exceeded # Check that we honor TMPDIR -RUN: TMPDIR=DIR_DOES_NOT_EXIST not %t-FullCoverageSetTest -merge=1 %tmp/T1 %tmp/T2 2>&1 | FileCheck %s --check-prefix=TMPDIR +RUN: TMPDIR=DIR_DOES_NOT_EXIST not %run %t-FullCoverageSetTest -merge=1 %tmp/T1 %tmp/T2 2>&1 | FileCheck %s --check-prefix=TMPDIR TMPDIR: MERGE-OUTER: failed to write to the control file: DIR_DOES_NOT_EXIST/libFuzzerTemp diff --git a/test/fuzzer/merge-sigusr.test b/test/fuzzer/merge-sigusr.test index efb00daa4643..a03e5440a8b8 100644 --- a/test/fuzzer/merge-sigusr.test +++ b/test/fuzzer/merge-sigusr.test @@ -1,4 +1,5 @@ # Check that libFuzzer honors SIGUSR1/SIGUSR2 +UNSUPPORTED: darwin RUN: rm -rf %t RUN: mkdir -p %t RUN: %cpp_compiler %S/SleepOneSecondTest.cpp -o %t/LFSIGUSR @@ -12,7 +13,7 @@ RUN: echo e > %t/C2/e RUN: echo f > %t/C2/f RUN: echo g > %t/C2/g -RUN: %t/LFSIGUSR -merge=1 -merge_control_file=%t/MCF %t/C1 %t/C2 2> %t/log & export PID=$! +RUN: %run %t/LFSIGUSR -merge=1 -merge_control_file=%t/MCF %t/C1 %t/C2 2> %t/log & export PID=$! RUN: sleep 3 RUN: pkill -SIGUSR2 -f %t/LFSIGUSR RUN: sleep 3 diff --git a/test/fuzzer/merge-summary.test b/test/fuzzer/merge-summary.test index 3e21c23ef38d..116cf1db8755 100644 --- a/test/fuzzer/merge-summary.test +++ b/test/fuzzer/merge-summary.test @@ -9,9 +9,9 @@ RUN: echo F..... > %t/T2/a RUN: echo .U.... > %t/T2/b RUN: echo ..Z... > %t/T2/c -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -save_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=SAVE_SUMMARY +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -save_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=SAVE_SUMMARY SAVE_SUMMARY: MERGE-OUTER: writing coverage summary for 6 files to {{.*}}SUMMARY RUN: rm %t/T1/* -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -load_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=LOAD_SUMMARY +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -load_coverage_summary=%t/SUMMARY 2>&1 | FileCheck %s --check-prefix=LOAD_SUMMARY LOAD_SUMMARY: MERGE-OUTER: coverage summary loaded from {{.*}}SUMMAR LOAD_SUMMARY: MERGE-OUTER: 0 new files with 0 new features added diff --git a/test/fuzzer/merge.test b/test/fuzzer/merge.test index d17405595eb7..ec41c82b9344 100644 --- a/test/fuzzer/merge.test +++ b/test/fuzzer/merge.test @@ -1,3 +1,4 @@ +XFAIL: ios CHECK: BINGO RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t-FullCoverageSetTest @@ -10,7 +11,7 @@ RUN: echo ..Z... > %t/T0/3 # T1 has 3 elements, T2 is empty. RUN: cp %t/T0/* %t/T1/ -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=CHECK1 +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=CHECK1 CHECK1: MERGE-OUTER: 3 files, 3 in the initial corpus CHECK1: MERGE-OUTER: 0 new files with 0 new features added @@ -22,12 +23,12 @@ RUN: echo .U.... > %t/T2/b RUN: echo ..Z... > %t/T2/c # T1 has 3 elements, T2 has 6 elements, only 3 are new. -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=CHECK2 +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=CHECK2 CHECK2: MERGE-OUTER: 9 files, 3 in the initial corpus CHECK2: MERGE-OUTER: 3 new files with 3 new features added # Now, T1 has 6 units and T2 has no new interesting units. -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=CHECK3 +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=CHECK3 CHECK3: MERGE-OUTER: 12 files, 6 in the initial corpus CHECK3: MERGE-OUTER: 0 new files with 0 new features added @@ -35,14 +36,14 @@ CHECK3: MERGE-OUTER: 0 new files with 0 new features added RUN: rm %t/T1/* RUN: cp %t/T0/* %t/T1/ RUN: echo looooooooong > %t/T2/looooooooong -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -max_len=6 2>&1 | FileCheck %s --check-prefix=MAX_LEN +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -max_len=6 2>&1 | FileCheck %s --check-prefix=MAX_LEN MAX_LEN: MERGE-OUTER: 3 new files # Check that we respect -merge_control_file=FILE RUN: rm %t/T1/* RUN: cp %t/T0/* %t/T1/ RUN: rm -f %t/MCF -RUN: %t-FullCoverageSetTest -merge=1 -merge_control_file=%t/MCF %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=MCF +RUN: %run %t-FullCoverageSetTest -merge=1 -merge_control_file=%t/MCF %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=MCF RUN: grep STARTED %t/MCF RUN: grep DONE %t/MCF MCF: MERGE-INNER: using the control file {{.*}}MCF @@ -53,18 +54,18 @@ MCF: MERGE-OUTER: 3 new files RUN: rm %t/T1/* RUN: cp %t/T0/* %t/T1/ RUN: echo 'FUZZER' > %t/T2/FUZZER -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=MERGE_WITH_CRASH +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=MERGE_WITH_CRASH MERGE_WITH_CRASH: MERGE-OUTER: succesfull in 2 attempt(s) MERGE_WITH_CRASH: MERGE-OUTER: 3 new files # Check that we actually limit the size with max_len RUN: rm %t/T1/* %t/T2/* RUN: echo 'FUZZER' > %t/T2/FUZZER -RUN: %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -max_len=5 2>&1 | FileCheck %s --check-prefix=MERGE_LEN5 +RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 -max_len=5 2>&1 | FileCheck %s --check-prefix=MERGE_LEN5 RUN: not grep FUZZER %t/T1/* RUN: grep FUZZE %t/T1/* MERGE_LEN5: MERGE-OUTER: succesfull in 1 attempt(s) RUN: rm -rf %t/T1/* %t/T2/* -RUN: not %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=EMPTY +RUN: not %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=EMPTY EMPTY: MERGE-OUTER: zero succesfull attempts, exiting diff --git a/test/fuzzer/minimize_crash.test b/test/fuzzer/minimize_crash.test index 77ab370fa899..de44b8747e04 100644 --- a/test/fuzzer/minimize_crash.test +++ b/test/fuzzer/minimize_crash.test @@ -1,16 +1,17 @@ RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-NullDerefTest RUN: %cpp_compiler %S/SingleByteInputTest.cpp -o %t-SingleByteInputTest +RUN: mkdir -p %t.dir -RUN: echo 'Hi!rv349f34t3gg' > not_minimal_crash -RUN: %t-NullDerefTest -minimize_crash=1 not_minimal_crash -max_total_time=2 2>&1 | FileCheck %s -CHECK: CRASH_MIN: failed to minimize beyond ./minimized-from-{{.*}} (3 bytes), exiting -RUN: %t-NullDerefTest -minimize_crash=1 not_minimal_crash -max_total_time=2 -exact_artifact_path=exact_minimized_path 2>&1 | FileCheck %s --check-prefix=CHECK_EXACT -CHECK_EXACT: CRASH_MIN: failed to minimize beyond exact_minimized_path (3 bytes), exiting -RUN: rm not_minimal_crash minimized-from-* exact_minimized_path +RUN: echo 'Hi!rv349f34t3gg' > %t.dir/not_minimal_crash +RUN: %run %t-NullDerefTest -minimize_crash=1 %t.dir/not_minimal_crash -max_total_time=2 2>&1 | FileCheck %s +CHECK: CRASH_MIN: failed to minimize beyond {{.*}}minimized-from{{.*}} (3 bytes), exiting +RUN: %run %t-NullDerefTest -minimize_crash=1 %t.dir/not_minimal_crash -max_total_time=2 -exact_artifact_path=%t.exact_minimized_path 2>&1 | FileCheck %s --check-prefix=CHECK_EXACT +CHECK_EXACT: CRASH_MIN: failed to minimize beyond {{.*}}exact_minimized_path{{.*}} (3 bytes), exiting +RUN: rm %t.dir/not_minimal_crash %t.exact_minimized_path -RUN: echo -n 'abcd*xyz' > not_minimal_crash -RUN: %t-SingleByteInputTest -minimize_crash=1 not_minimal_crash -exact_artifact_path=exact_minimized_path 2>&1 | FileCheck %s --check-prefix=MIN1 -MIN1: Test unit written to exact_minimized_path -MIN1: Test unit written to exact_minimized_path +RUN: echo -n 'abcd*xyz' > %t.dir/not_minimal_crash +RUN: %run %t-SingleByteInputTest -minimize_crash=1 %t.dir/not_minimal_crash -exact_artifact_path=%t.exact_minimized_path 2>&1 | FileCheck %s --check-prefix=MIN1 +MIN1: Test unit written to {{.*}}exact_minimized_path +MIN1: Test unit written to {{.*}}exact_minimized_path MIN1: INFO: The input is small enough, exiting -MIN1: CRASH_MIN: failed to minimize beyond exact_minimized_path (1 bytes), exiting +MIN1: CRASH_MIN: failed to minimize beyond {{.*}}exact_minimized_path (1 bytes), exiting diff --git a/test/fuzzer/minimize_two_crashes.test b/test/fuzzer/minimize_two_crashes.test index e6ff9990ffd8..3c528f707666 100644 --- a/test/fuzzer/minimize_two_crashes.test +++ b/test/fuzzer/minimize_two_crashes.test @@ -1,10 +1,12 @@ # Test that the minimizer stops when it sees a differe bug. +UNSUPPORTED: freebsd -RUN: %cpp_compiler %S/TwoDifferentBugsTest.cpp -o %t-TwoDifferentBugsTest +# TODO: Find out why test fails on Darwin with -O2. +RUN: %cpp_compiler -O0 %S/TwoDifferentBugsTest.cpp -o %t-TwoDifferentBugsTest RUN: rm -rf %t && mkdir %t RUN: echo H12345678901234667888090 > %t/long_crash -RUN: env ASAN_OPTIONS=dedup_token_length=3 %t-TwoDifferentBugsTest -seed=1 -minimize_crash=1 %t/long_crash -exact_artifact_path=%t/result 2>&1 | FileCheck %s +RUN: env ASAN_OPTIONS=dedup_token_length=3 %run %t-TwoDifferentBugsTest -seed=1 -minimize_crash=1 %t/long_crash -exact_artifact_path=%t/result 2>&1 | FileCheck %s CHECK: DedupToken1: DEDUP_TOKEN: Bar CHECK: DedupToken2: DEDUP_TOKEN: Bar @@ -12,7 +14,7 @@ CHECK: DedupToken1: DEDUP_TOKEN: Bar CHECK: DedupToken2: DEDUP_TOKEN: Foo CHECK: CRASH_MIN: mismatch in dedup tokens -RUN: not %t-TwoDifferentBugsTest %t/result 2>&1 | FileCheck %s --check-prefix=VERIFY +RUN: not %run %t-TwoDifferentBugsTest %t/result 2>&1 | FileCheck %s --check-prefix=VERIFY VERIFY: ERROR: AddressSanitizer: VERIFY: in Bar diff --git a/test/fuzzer/msan.test b/test/fuzzer/msan.test new file mode 100644 index 000000000000..2e0339bb8ff7 --- /dev/null +++ b/test/fuzzer/msan.test @@ -0,0 +1,24 @@ +REQUIRES: msan +RUN: %msan_compiler %S/SimpleTestStdio.cpp -o %t +RUN: not %run %t -seed=1 -runs=10000000 2>&1 | FileCheck %s --check-prefix=NO-REPORT + +RUN: %msan_compiler %S/SimpleCmpTest.cpp -o %t +RUN: not %run %t -seed=1 -runs=10000000 2>&1 | FileCheck %s --check-prefix=NO-REPORT + +RUN: %msan_compiler %S/MemcmpTest.cpp -o %t +RUN: not %run %t -seed=1 -runs=10000000 2>&1 | FileCheck %s --check-prefix=NO-REPORT + +RUN: %msan_compiler %S/StrcmpTest.cpp -o %t +RUN: not %run %t -seed=1 -runs=10000000 2>&1 | FileCheck %s --check-prefix=NO-REPORT + +NO-REPORT-NOT: MemorySanitizer +NO-REPORT: BINGO + + +RUN: %msan_compiler %S/UseAfterDtor.cpp -o %t +RUN: MSAN_OPTIONS=poison_in_dtor=1 not %run %t -seed=1 -runs=10000000 2>&1 | FileCheck %s --check-prefix=REPORT + +RUN: %msan_compiler %S/UninitializedStrlen.cpp -o %t +RUN: not %run %t -seed=1 -runs=10000000 2>&1 | FileCheck %s --check-prefix=REPORT + +REPORT: MemorySanitizer: use-of-uninitialized-value diff --git a/test/fuzzer/not-instrumented.test b/test/fuzzer/not-instrumented.test new file mode 100644 index 000000000000..2330c4770067 --- /dev/null +++ b/test/fuzzer/not-instrumented.test @@ -0,0 +1,4 @@ +RUN: %cpp_compiler %S/NotinstrumentedTest.cpp -fsanitize-coverage=0 -o %t-NotinstrumentedTest-NoCoverage +RUN: not %run %t-NotinstrumentedTest-NoCoverage 2>&1 | FileCheck %s --check-prefix=NO_COVERAGE + +NO_COVERAGE: ERROR: no interesting inputs were found. Is the code instrumented for coverage? Exiting diff --git a/test/fuzzer/null-deref-on-empty.test b/test/fuzzer/null-deref-on-empty.test new file mode 100644 index 000000000000..f159a79f4838 --- /dev/null +++ b/test/fuzzer/null-deref-on-empty.test @@ -0,0 +1,4 @@ +RUN: %cpp_compiler %S/NullDerefOnEmptyTest.cpp -o %t-NullDerefOnEmptyTest + +RUN: not %run %t-NullDerefOnEmptyTest -print_final_stats=1 2>&1 | FileCheck %s --check-prefix=NULL_DEREF_ON_EMPTY +NULL_DEREF_ON_EMPTY: stat::number_of_executed_units: diff --git a/test/fuzzer/null-deref.test b/test/fuzzer/null-deref.test new file mode 100644 index 000000000000..31eb5990da33 --- /dev/null +++ b/test/fuzzer/null-deref.test @@ -0,0 +1,10 @@ +RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-NullDerefTest + +RUN: not %run %t-NullDerefTest 2>&1 | FileCheck %s --check-prefix=NullDerefTest +RUN: not %run %t-NullDerefTest -close_fd_mask=3 2>&1 | FileCheck %s --check-prefix=NullDerefTest +NullDerefTest: ERROR: AddressSanitizer: {{SEGV|access-violation}} on unknown address +NullDerefTest: Test unit written to ./crash- +RUN: not %run %t-NullDerefTest -artifact_prefix=ZZZ 2>&1 | FileCheck %s --check-prefix=NullDerefTestPrefix +NullDerefTestPrefix: Test unit written to ZZZcrash- +RUN: not %run %t-NullDerefTest -artifact_prefix=ZZZ -exact_artifact_path=FOOBAR 2>&1 | FileCheck %s --check-prefix=NullDerefTestExactPath +NullDerefTestExactPath: Test unit written to FOOBAR diff --git a/test/fuzzer/only-some-bytes.test b/test/fuzzer/only-some-bytes.test new file mode 100644 index 000000000000..fbfef14c7850 --- /dev/null +++ b/test/fuzzer/only-some-bytes.test @@ -0,0 +1,38 @@ +# Tests the data flow tracer. +REQUIRES: linux +UNSUPPORTED: aarch64 + +# Build the tracer and the test. +RUN: %no_fuzzer_cpp_compiler -c -fno-sanitize=all -fsanitize=dataflow %S/../../lib/fuzzer/dataflow/DataFlow.cpp -o %t-DataFlow.o +RUN: %no_fuzzer_cpp_compiler -fno-sanitize=all -fsanitize=dataflow -fsanitize-coverage=trace-pc-guard,pc-table,func,trace-cmp %S/OnlySomeBytesTest.cpp %t-DataFlow.o -o %t-DFT +RUN: %cpp_compiler %S/OnlySomeBytesTest.cpp -o %t-Fuzz + +# Prepare the inputs. +RUN: rm -rf %t/* +RUN: mkdir -p %t/IN +RUN: echo -n 0123456789012345678901234567890123456789012345678901234567891234 > %t/IN/6 +RUN: cat %t/IN/6 %t/IN/6 %t/IN/6 %t/IN/6 > %t/IN/8 +RUN: cat %t/IN/8 %t/IN/8 %t/IN/8 %t/IN/8 > %t/IN/10 +RUN: cat %t/IN/10 %t/IN/10 %t/IN/10 %t/IN/10 > %t/IN/12 +# %t/IN/12 is 4096 bytes-long. + +RUN: %t-Fuzz -focus_function=f0 -runs=0 %t/IN 2>&1 | FileCheck %s --check-prefix=NO_FOCUSED_INPUT +NO_FOCUSED_INPUT: INFO: 0/2 inputs touch the focus function + +RUN: (echo -n ABC; cat %t/IN/12) > %t/IN/ABC +RUN: %t-Fuzz -focus_function=f0 -runs=0 %t/IN 2>&1 | FileCheck %s --check-prefix=ONE_FOCUSED_INPUT +ONE_FOCUSED_INPUT: INFO: 1/3 inputs touch the focus function + +RUN: rm -rf %t/IN_DFT +RUN: %libfuzzer_src/scripts/collect_data_flow.py %t-DFT %t/IN %t/IN_DFT > /dev/null 2>&1 + +# Repeat twice to make sure that the inputs with DFT are not removed from the corpus. +RUN: %t-Fuzz -focus_function=f0 -data_flow_trace=%t/IN_DFT -runs=100 %t/IN 2>&1 | FileCheck %s --check-prefix=HAVE_DFT +RUN: %t-Fuzz -focus_function=f0 -data_flow_trace=%t/IN_DFT -runs=100 %t/IN 2>&1 | FileCheck %s --check-prefix=HAVE_DFT +HAVE_DFT: INFO: 1/{{.*}} inputs have the Data Flow Trace + +# Collect DFT, then use it. +RUN: rm -rf %t/C && mkdir %t/C && cp %t/IN/* %t/C +RUN: rm -rf %t/C_DFT && %libfuzzer_src/scripts/collect_data_flow.py %t-DFT %t/C %t/C_DFT > /dev/null 2>&1 +RUN: not %t-Fuzz -focus_function=f0 -data_flow_trace=%t/C_DFT -seed=1 -runs=1000000 -use_value_profile=3 %t/C 2> %t/log +RUN: grep BINGO %t/log diff --git a/test/fuzzer/overwrite-input.test b/test/fuzzer/overwrite-input.test index 3695622d0352..e5ddd62cbdc7 100644 --- a/test/fuzzer/overwrite-input.test +++ b/test/fuzzer/overwrite-input.test @@ -1,3 +1,3 @@ RUN: %cpp_compiler %S/OverwriteInputTest.cpp -o %t-OverwriteInputTest -RUN: not %t-OverwriteInputTest 2>&1 | FileCheck %s +RUN: not %run %t-OverwriteInputTest 2>&1 | FileCheck %s CHECK: ERROR: libFuzzer: fuzz target overwrites it's const input diff --git a/test/fuzzer/print-func.test b/test/fuzzer/print-func.test index 930e9992a2f9..c74da218282e 100644 --- a/test/fuzzer/print-func.test +++ b/test/fuzzer/print-func.test @@ -1,6 +1,7 @@ +UNSUPPORTED: darwin, aarch64 RUN: %cpp_compiler %S/PrintFuncTest.cpp -o %t -RUN: %t -seed=1 -runs=100000 2>&1 | FileCheck %s -RUN: %t -seed=1 -runs=100000 -print_funcs=0 2>&1 | FileCheck %s --check-prefix=NO +RUN: %run %t -seed=1 -runs=100000 2>&1 | FileCheck %s +RUN: %run %t -seed=1 -runs=100000 -print_funcs=0 2>&1 | FileCheck %s --check-prefix=NO CHECK: NEW_FUNC{{.*}} FunctionA CHECK: NEW_FUNC{{.*}} FunctionB CHECK: NEW_FUNC{{.*}} FunctionC diff --git a/test/fuzzer/print_unstable_stats.test b/test/fuzzer/print_unstable_stats.test new file mode 100644 index 000000000000..bba99aecc838 --- /dev/null +++ b/test/fuzzer/print_unstable_stats.test @@ -0,0 +1,3 @@ +RUN: %cpp_compiler %S/PrintUnstableStatsTest.cpp -o %t-PrintUnstableStatsTest +RUN: %run %t-PrintUnstableStatsTest -print_unstable_stats=1 -runs=100000 2>&1 | FileCheck %s --check-prefix=LONG +LONG: stat::stability_rate: 27.59 diff --git a/test/fuzzer/recommended-dictionary.test b/test/fuzzer/recommended-dictionary.test index 41b62c924ceb..e1d58c96fa20 100644 --- a/test/fuzzer/recommended-dictionary.test +++ b/test/fuzzer/recommended-dictionary.test @@ -1,5 +1,6 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/RepeatedMemcmp.cpp -o %t-RepeatedMemcmp -RUN: %t-RepeatedMemcmp -seed=11 -runs=100000 -max_len=20 2>&1 | FileCheck %s --check-prefix=RECOMMENDED_DICT +RUN: %run %t-RepeatedMemcmp -seed=11 -runs=100000 -max_len=20 2>&1 | FileCheck %s --check-prefix=RECOMMENDED_DICT RECOMMENDED_DICT:###### Recommended dictionary. ###### RECOMMENDED_DICT-DAG: "foo" RECOMMENDED_DICT-DAG: "bar" diff --git a/test/fuzzer/reduce_inputs.test b/test/fuzzer/reduce_inputs.test index 94f8cc4f37a8..e65f57227729 100644 --- a/test/fuzzer/reduce_inputs.test +++ b/test/fuzzer/reduce_inputs.test @@ -4,13 +4,13 @@ RUN: rm -rf %t/C RUN: mkdir -p %t/C RUN: %cpp_compiler %S/ShrinkControlFlowSimpleTest.cpp -o %t-ShrinkControlFlowSimpleTest RUN: %cpp_compiler %S/ShrinkControlFlowTest.cpp -o %t-ShrinkControlFlowTest -RUN: %t-ShrinkControlFlowSimpleTest -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -runs=1000000 %t/C 2>&1 | FileCheck %s +RUN: %run %t-ShrinkControlFlowSimpleTest -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -runs=1000000 %t/C 2>&1 | FileCheck %s CHECK: INFO: found item with checksum '0eb8e4ed029b774d80f2b66408203801cb982a60' # Test that reduce_inputs deletes redundant files in the corpus. -RUN: %t-ShrinkControlFlowSimpleTest -runs=0 %t/C 2>&1 | FileCheck %s --check-prefix=COUNT +RUN: %run %t-ShrinkControlFlowSimpleTest -runs=0 %t/C 2>&1 | FileCheck %s --check-prefix=COUNT COUNT: seed corpus: files: 4 # a bit longer test -RUN: %t-ShrinkControlFlowTest -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -seed=1 -runs=1000000 2>&1 | FileCheck %s +RUN: %run %t-ShrinkControlFlowTest -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -seed=42 -runs=1000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/repeated-bytes.test b/test/fuzzer/repeated-bytes.test index 0bba2a91688f..e749a3e239a4 100644 --- a/test/fuzzer/repeated-bytes.test +++ b/test/fuzzer/repeated-bytes.test @@ -1,3 +1,3 @@ RUN: %cpp_compiler %S/RepeatedBytesTest.cpp -o %t-RepeatedBytesTest CHECK: BINGO -RUN: not %t-RepeatedBytesTest -seed=1 -runs=1000000 2>&1 | FileCheck %s +RUN: not %run %t-RepeatedBytesTest -seed=1 -runs=1000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/shrink.test b/test/fuzzer/shrink.test index 2988d4bbb043..5abbcc90b8c0 100644 --- a/test/fuzzer/shrink.test +++ b/test/fuzzer/shrink.test @@ -1,9 +1,9 @@ RUN: %cpp_compiler %S/ShrinkControlFlowTest.cpp -o %t-ShrinkControlFlowTest RUN: %cpp_compiler %S/ShrinkValueProfileTest.cpp -o %t-ShrinkValueProfileTest -RUN: %t-ShrinkControlFlowTest -seed=1 -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -runs=1000000 -shrink=1 -reduce_inputs=0 2>&1 | FileCheck %s --check-prefix=SHRINK1 +RUN: %run %t-ShrinkControlFlowTest -seed=1 -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -runs=1000000 -shrink=1 -reduce_inputs=0 2>&1 | FileCheck %s --check-prefix=SHRINK1 # Limit max_len to run this negative test faster. -RUN: %t-ShrinkControlFlowTest -seed=1 -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -runs=1000000 -shrink=0 -reduce_inputs=0 -max_len=64 2>&1 | FileCheck %s --check-prefix=SHRINK0 -RUN: %t-ShrinkValueProfileTest -seed=1 -exit_on_item=aea2e3923af219a8956f626558ef32f30a914ebc -runs=100000 -shrink=1 -reduce_inputs=0 -use_value_profile=1 2>&1 | FileCheck %s --check-prefix=SHRINK1_VP +RUN: %run %t-ShrinkControlFlowTest -seed=1 -exit_on_item=0eb8e4ed029b774d80f2b66408203801cb982a60 -runs=1000000 -shrink=0 -reduce_inputs=0 -max_len=64 2>&1 | FileCheck %s --check-prefix=SHRINK0 +RUN: %run %t-ShrinkValueProfileTest -seed=1 -exit_on_item=aea2e3923af219a8956f626558ef32f30a914ebc -runs=100000 -shrink=1 -reduce_inputs=0 -use_value_profile=1 2>&1 | FileCheck %s --check-prefix=SHRINK1_VP SHRINK0: Done 1000000 runs in SHRINK1: INFO: found item with checksum '0eb8e4ed029b774d80f2b66408203801cb982a60', exiting. diff --git a/test/fuzzer/sigusr.test b/test/fuzzer/sigusr.test index 12e3ac996c6c..0b3ddc72832d 100644 --- a/test/fuzzer/sigusr.test +++ b/test/fuzzer/sigusr.test @@ -1,9 +1,10 @@ +UNSUPPORTED: darwin # Check that libFuzzer honors SIGUSR1/SIGUSR2 RUN: rm -rf %t RUN: mkdir -p %t RUN: %cpp_compiler %S/SleepOneSecondTest.cpp -o %t/LFSIGUSR -RUN: %t/LFSIGUSR 2> %t/log & export PID=$! +RUN: %run %t/LFSIGUSR 2> %t/log & export PID=$! RUN: sleep 2 RUN: kill -SIGUSR1 $PID RUN: sleep 3 diff --git a/test/fuzzer/simple-cmp.test b/test/fuzzer/simple-cmp.test index 08123ed3ac47..e146379b2a5b 100644 --- a/test/fuzzer/simple-cmp.test +++ b/test/fuzzer/simple-cmp.test @@ -1,3 +1,7 @@ RUN: %cpp_compiler %S/SimpleCmpTest.cpp -o %t-SimpleCmpTest + +RUN: not %run %t-SimpleCmpTest -seed=1 -runs=100000000 2>&1 | FileCheck %s +RUN: %run %t-SimpleCmpTest -max_total_time=1 -use_cmp=0 2>&1 | FileCheck %s --check-prefix=MaxTotalTime +MaxTotalTime: Done {{.*}} runs in {{.}} second(s) + CHECK: BINGO -RUN: not %t-SimpleCmpTest -seed=1 -runs=100000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/simple.test b/test/fuzzer/simple.test new file mode 100644 index 000000000000..97a09be7cec9 --- /dev/null +++ b/test/fuzzer/simple.test @@ -0,0 +1,7 @@ +CHECK: BINGO +RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest + +RUN: not %run %t-SimpleTest 2>&1 | FileCheck %s + +# only_ascii mode. Will perform some minimal self-validation. +RUN: not %run %t-SimpleTest -only_ascii=1 2>&1 diff --git a/test/fuzzer/standalone.test b/test/fuzzer/standalone.test index e6483703f966..cd2422e4e683 100644 --- a/test/fuzzer/standalone.test +++ b/test/fuzzer/standalone.test @@ -2,7 +2,7 @@ RUN: %no_fuzzer_c_compiler %libfuzzer_src/standalone/StandaloneFuzzTargetMain.c RUN: %no_fuzzer_cpp_compiler %S/InitializeTest.cpp -c -o %t_2.o RUN: %no_fuzzer_cpp_compiler %t_1.o %t_2.o -o %t-StandaloneInitializeTest -RUN: %t-StandaloneInitializeTest %S/hi.txt %S/dict1.txt 2>&1 | FileCheck %s +RUN: %run %t-StandaloneInitializeTest %S/hi.txt %S/dict1.txt 2>&1 | FileCheck %s CHECK: StandaloneFuzzTargetMain: running 2 inputs CHECK: Done: {{.*}}hi.txt: (3 bytes) CHECK: Done: {{.*}}dict1.txt: (61 bytes) diff --git a/test/fuzzer/strcmp.test b/test/fuzzer/strcmp.test index 47ad8f9ba0f5..bd917bba6b69 100644 --- a/test/fuzzer/strcmp.test +++ b/test/fuzzer/strcmp.test @@ -1,4 +1,5 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/StrcmpTest.cpp -o %t-StrcmpTest -RUN: not %t-StrcmpTest -seed=1 -runs=2000000 2>&1 | FileCheck %s +RUN: not %run %t-StrcmpTest -seed=1 -runs=2000000 2>&1 | FileCheck %s CHECK: BINGO diff --git a/test/fuzzer/strncmp-oob.test b/test/fuzzer/strncmp-oob.test new file mode 100644 index 000000000000..a0365d961833 --- /dev/null +++ b/test/fuzzer/strncmp-oob.test @@ -0,0 +1,6 @@ +RUN: %cpp_compiler %S/StrncmpOOBTest.cpp -o %t-StrncmpOOBTest + +RUN: env ASAN_OPTIONS=strict_string_checks=1 not %run %t-StrncmpOOBTest -seed=1 -runs=1000000 2>&1 | FileCheck %s --check-prefix=STRNCMP +STRNCMP: AddressSanitizer: heap-buffer-overflow +STRNCMP-NOT: __sanitizer_weak_hook_strncmp +STRNCMP: in LLVMFuzzerTestOneInput diff --git a/test/fuzzer/strncmp.test b/test/fuzzer/strncmp.test index 49693c8de8f0..50189445b102 100644 --- a/test/fuzzer/strncmp.test +++ b/test/fuzzer/strncmp.test @@ -1,4 +1,5 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/StrncmpTest.cpp -o %t-StrncmpTest -RUN: not %t-StrncmpTest -seed=2 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-StrncmpTest -seed=2 -runs=10000000 2>&1 | FileCheck %s CHECK: BINGO diff --git a/test/fuzzer/strstr.test b/test/fuzzer/strstr.test index c39d5801acdb..f1fb210b47c7 100644 --- a/test/fuzzer/strstr.test +++ b/test/fuzzer/strstr.test @@ -1,4 +1,5 @@ +UNSUPPORTED: freebsd RUN: %cpp_compiler %S/StrstrTest.cpp -o %t-StrstrTest -RUN: not %t-StrstrTest -seed=1 -runs=2000000 2>&1 | FileCheck %s +RUN: not %run %t-StrstrTest -seed=1 -runs=2000000 2>&1 | FileCheck %s CHECK: BINGO diff --git a/test/fuzzer/swap-cmp.test b/test/fuzzer/swap-cmp.test index 5c2379cde4f6..7f7e2f60fa63 100644 --- a/test/fuzzer/swap-cmp.test +++ b/test/fuzzer/swap-cmp.test @@ -1,3 +1,3 @@ RUN: %cpp_compiler %S/SwapCmpTest.cpp -o %t-SwapCmpTest CHECK: BINGO -RUN: not %t-SwapCmpTest -seed=1 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-SwapCmpTest -seed=1 -runs=10000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/symbolize-deadlock.test b/test/fuzzer/symbolize-deadlock.test new file mode 100644 index 000000000000..25b519fd3fed --- /dev/null +++ b/test/fuzzer/symbolize-deadlock.test @@ -0,0 +1,2 @@ +RUN: %cpp_compiler %S/SymbolizeDeadlock.cpp -o %t +RUN: not %run %t -rss_limit_mb=20 2>&1 diff --git a/test/fuzzer/target-function.test b/test/fuzzer/target-function.test new file mode 100644 index 000000000000..afd29ab8a83f --- /dev/null +++ b/test/fuzzer/target-function.test @@ -0,0 +1,30 @@ +# Tests -focus_function +# +# TODO: don't require linux. +# REQUIRES: linux +UNSUPPORTED: aarch64 + +RUN: %cpp_compiler %S/OnlySomeBytesTest.cpp -o %t-exe + +RUN: %t-exe -runs=100 2>&1 | FileCheck %s --check-prefix=FOCUS_NONE +FOCUS_NONE-NOT: INFO: Focus function is set to +FOCUS_NONE-NOT: INFO: {{.*}} inputs touch the focus function + +RUN: %t-exe -runs=100 -focus_function=WRONG 2>&1 | FileCheck %s --check-prefix=FOCUS_WRONG +FOCUS_WRONG-NOT: INFO: Focus function is set to +FOCUS_WRONG: INFO: 0/1 inputs touch the focus function + +RUN: %t-exe -runs=100 -focus_function=f0 2>&1 | FileCheck %s --check-prefix=FOCUS_F0 +FOCUS_F0: INFO: Focus function is set to 'f0' +FOCUS_F0: INFO: 0/1 inputs touch the focus function + +RUN: rm -rf %t-corpus +RUN: mkdir %t-corpus +# ABC triggers the focus function, others don't. +RUN: echo ABC$(for((i=0;i<2048;i++)); do echo -n x; done) > %t-corpus/ABC +RUN: echo AXY$(for((i=0;i<2048;i++)); do echo -n x; done) > %t-corpus/AXY +RUN: echo ABX$(for((i=0;i<2048;i++)); do echo -n x; done) > %t-corpus/ABX + +RUN: %t-exe -runs=10000 -focus_function=f0 %t-corpus 2>&1 | FileCheck %s --check-prefix=CORPUS_1_3 +CORPUS_1_3: INFO: 1/3 inputs touch the focus function +CORPUS_1_3: DONE {{.*}} focus: diff --git a/test/fuzzer/three-bytes.test b/test/fuzzer/three-bytes.test new file mode 100644 index 000000000000..0b2187552cf5 --- /dev/null +++ b/test/fuzzer/three-bytes.test @@ -0,0 +1,8 @@ +Tests -use_value_profile=2 (alternative VP metric). +RUN: %cpp_compiler %S/ThreeBytes.cpp -o %t + +RUN: %run %t -seed=1 -runs=30000 +RUN: %run %t -seed=1 -runs=30000 -use_value_profile=1 +RUN: not %run %t -seed=1 -runs=1000000 -use_value_profile=2 2>&1 | FileCheck %s + +CHECK: Test unit written diff --git a/test/fuzzer/trace-malloc-2.test b/test/fuzzer/trace-malloc-2.test index 56f16d786012..2b32b95ed3e6 100644 --- a/test/fuzzer/trace-malloc-2.test +++ b/test/fuzzer/trace-malloc-2.test @@ -4,7 +4,7 @@ UNSUPPORTED: darwin RUN: %cpp_compiler %S/TraceMallocTest.cpp -o %t-TraceMallocTest -RUN: %t-TraceMallocTest -seed=1 -trace_malloc=2 -runs=1000 2>&1 | FileCheck %s --check-prefix=TRACE2 +RUN: %run %t-TraceMallocTest -seed=1 -trace_malloc=2 -runs=1000 2>&1 | FileCheck %s --check-prefix=TRACE2 TRACE2-DAG: FREE[0] TRACE2-DAG: MALLOC[0] TRACE2-DAG: in LLVMFuzzerTestOneInput diff --git a/test/fuzzer/trace-malloc-threaded.test b/test/fuzzer/trace-malloc-threaded.test index 11f3f049155f..8f972d61f5c6 100644 --- a/test/fuzzer/trace-malloc-threaded.test +++ b/test/fuzzer/trace-malloc-threaded.test @@ -1,10 +1,11 @@ // FIXME: This test infinite loops on darwin because it crashes // printing a stack trace repeatedly -UNSUPPORTED: darwin +UNSUPPORTED: darwin, aarch64 -RUN: %cpp_compiler %S/TraceMallocThreadedTest.cpp -o %t-TraceMallocThreadedTest +RUN: %cpp_compiler %S/TraceMallocThreadedTest.cpp -o \ +RUN: %t-TraceMallocThreadedTest -RUN: %t-TraceMallocThreadedTest -trace_malloc=2 -runs=1 2>&1 | FileCheck %s +RUN: %run %t-TraceMallocThreadedTest -trace_malloc=2 -runs=1 2>&1 | FileCheck %s CHECK: {{MALLOC\[[0-9]+] +0x[0-9]+ 5639}} CHECK-NEXT: {{ +\#0 +}} CHECK-NEXT: {{ +\#1 +}} diff --git a/test/fuzzer/trace-malloc-unbalanced.test b/test/fuzzer/trace-malloc-unbalanced.test index 8be5fab0ca43..193df01ddeff 100644 --- a/test/fuzzer/trace-malloc-unbalanced.test +++ b/test/fuzzer/trace-malloc-unbalanced.test @@ -6,10 +6,10 @@ UNSUPPORTED: darwin RUN: %cpp_compiler %S/TraceMallocTest.cpp -o %t-TraceMallocTest -RUN: %t-TraceMallocTest -seed=1 -trace_malloc=1 -runs=200 2>&1 | \ +RUN: %run %t-TraceMallocTest -seed=1 -trace_malloc=1 -runs=200 2>&1 | \ RUN: %libfuzzer_src/scripts/unbalanced_allocs.py --skip=5 | FileCheck %s -RUN: %t-TraceMallocTest -seed=1 -trace_malloc=2 -runs=200 2>&1 | \ +RUN: %run %t-TraceMallocTest -seed=1 -trace_malloc=2 -runs=200 2>&1 | \ RUN: %libfuzzer_src/scripts/unbalanced_allocs.py --skip=5 | FileCheck %s --check-prefixes=CHECK,CHECK2 CHECK: MallocFreeTracer: START diff --git a/test/fuzzer/trace-malloc.test b/test/fuzzer/trace-malloc.test index 979be99b7ac2..156d06a0c01e 100644 --- a/test/fuzzer/trace-malloc.test +++ b/test/fuzzer/trace-malloc.test @@ -1,6 +1,6 @@ RUN: %cpp_compiler %S/TraceMallocTest.cpp -o %t-TraceMallocTest -RUN: %t-TraceMallocTest -seed=1 -trace_malloc=1 -runs=10000 2>&1 | FileCheck %s +RUN: %run %t-TraceMallocTest -seed=1 -trace_malloc=1 -runs=10000 2>&1 | FileCheck %s CHECK-DAG: MallocFreeTracer: STOP 0 0 (same) CHECK-DAG: MallocFreeTracer: STOP 0 1 (DIFFERENT) CHECK-DAG: MallocFreeTracer: STOP 1 0 (DIFFERENT) diff --git a/test/fuzzer/trace-pc.test b/test/fuzzer/trace-pc.test index eaa0cb08afbe..30049331e360 100644 --- a/test/fuzzer/trace-pc.test +++ b/test/fuzzer/trace-pc.test @@ -1,3 +1,3 @@ -RUN: %cpp_compiler %S/SimpleTest.cpp -fno-sanitize-coverage=edge,trace-cmp,indirect-calls,8bit-counters,trace-pc-guard -fsanitize-coverage=trace-pc -o %t-SimpleTest-TracePC +RUN: %cpp_compiler %S/SimpleTest.cpp -fsanitize-coverage=0 -fsanitize-coverage=trace-pc -o %t-SimpleTest-TracePC CHECK: BINGO -RUN: not %t-SimpleTest-TracePC -runs=1000000 -seed=1 2>&1 | FileCheck %s +RUN: not %run %t-SimpleTest-TracePC -runs=1000000 -seed=1 2>&1 | FileCheck %s diff --git a/test/fuzzer/ulimit.test b/test/fuzzer/ulimit.test index 8772caa2d4c3..076866c50940 100644 --- a/test/fuzzer/ulimit.test +++ b/test/fuzzer/ulimit.test @@ -1,3 +1,3 @@ RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest RUN: ulimit -s 1000 -RUN: not %t-SimpleTest +RUN: not %run %t-SimpleTest diff --git a/test/fuzzer/value-profile-cmp.test b/test/fuzzer/value-profile-cmp.test index 64244297c64a..b927422d10ff 100644 --- a/test/fuzzer/value-profile-cmp.test +++ b/test/fuzzer/value-profile-cmp.test @@ -1,3 +1,3 @@ CHECK: BINGO RUN: %cpp_compiler %S/SimpleCmpTest.cpp -o %t-SimpleCmpTest -RUN: not %t-SimpleCmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s +RUN: not %run %t-SimpleCmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-cmp2.test b/test/fuzzer/value-profile-cmp2.test index a585c9317fab..4bf119fcb3df 100644 --- a/test/fuzzer/value-profile-cmp2.test +++ b/test/fuzzer/value-profile-cmp2.test @@ -1,3 +1,3 @@ CHECK: BINGO RUN: %cpp_compiler -fno-sanitize=address %S/SimpleHashTest.cpp -o %t-SimpleHashTest -RUN: not %t-SimpleHashTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 -max_len=64 2>&1 | FileCheck %s +RUN: not %run %t-SimpleHashTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 -max_len=64 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-cmp3.test b/test/fuzzer/value-profile-cmp3.test index d2284750b51e..58ba18b9001e 100644 --- a/test/fuzzer/value-profile-cmp3.test +++ b/test/fuzzer/value-profile-cmp3.test @@ -1,3 +1,3 @@ CHECK: BINGO RUN: %cpp_compiler %S/AbsNegAndConstantTest.cpp -o %t-AbsNegAndConstantTest -RUN: not %t-AbsNegAndConstantTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s +RUN: not %run %t-AbsNegAndConstantTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-cmp4.test b/test/fuzzer/value-profile-cmp4.test index bcbc67b1801f..05bc3f435912 100644 --- a/test/fuzzer/value-profile-cmp4.test +++ b/test/fuzzer/value-profile-cmp4.test @@ -1,3 +1,3 @@ CHECK: BINGO RUN: %cpp_compiler %S/AbsNegAndConstant64Test.cpp -o %t-AbsNegAndConstant64Test -RUN: not %t-AbsNegAndConstant64Test -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s +RUN: not %run %t-AbsNegAndConstant64Test -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-div.test b/test/fuzzer/value-profile-div.test index 8711a25466e5..59cc7c2f9552 100644 --- a/test/fuzzer/value-profile-div.test +++ b/test/fuzzer/value-profile-div.test @@ -1,4 +1,6 @@ +XFAIL: ios +UNSUPPORTED: aarch64 CHECK: AddressSanitizer: {{FPE|int-divide-by-zero}} RUN: %cpp_compiler %S/DivTest.cpp -fsanitize-coverage=trace-div -o %t-DivTest -RUN: not %t-DivTest -seed=1 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-DivTest -seed=1 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-load.test b/test/fuzzer/value-profile-load.test index 3bf2a658a5b2..607b81cd527f 100644 --- a/test/fuzzer/value-profile-load.test +++ b/test/fuzzer/value-profile-load.test @@ -1,3 +1,3 @@ CHECK: AddressSanitizer: global-buffer-overflow -RUN: %cpp_compiler %S/LoadTest.cpp -fsanitize-coverage=trace-pc-guard,indirect-calls,trace-gep,trace-div,trace-cmp -o %t-LoadTest -RUN: not %t-LoadTest -seed=2 -use_cmp=0 -use_value_profile=1 -runs=20000000 2>&1 | FileCheck %s +RUN: %cpp_compiler %S/LoadTest.cpp -fsanitize-coverage=trace-gep -o %t-LoadTest +RUN: not %run %t-LoadTest -seed=2 -use_cmp=0 -use_value_profile=1 -runs=20000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-mem.test b/test/fuzzer/value-profile-mem.test index 0b0c21d689ce..57c844e92261 100644 --- a/test/fuzzer/value-profile-mem.test +++ b/test/fuzzer/value-profile-mem.test @@ -1,3 +1,4 @@ +UNSUPPORTED: freebsd CHECK: BINGO RUN: %cpp_compiler %S/SingleMemcmpTest.cpp -o %t-SingleMemcmpTest -RUN: not %t-SingleMemcmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-SingleMemcmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-set.test b/test/fuzzer/value-profile-set.test index e2e3fb47f3ad..e55f1e4a853a 100644 --- a/test/fuzzer/value-profile-set.test +++ b/test/fuzzer/value-profile-set.test @@ -1,4 +1,4 @@ CHECK: BINGO RUN: %cpp_compiler %S/FourIndependentBranchesTest.cpp -o %t-FourIndependentBranchesTest -RUN: not %t-FourIndependentBranchesTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s +RUN: not %run %t-FourIndependentBranchesTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-strcmp.test b/test/fuzzer/value-profile-strcmp.test index f5c766a658f4..647121f22820 100644 --- a/test/fuzzer/value-profile-strcmp.test +++ b/test/fuzzer/value-profile-strcmp.test @@ -1,3 +1,4 @@ +UNSUPPORTED: freebsd CHECK: BINGO RUN: %cpp_compiler %S/SingleStrcmpTest.cpp -o %t-SingleStrcmpTest -RUN: not %t-SingleStrcmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s +RUN: not %run %t-SingleStrcmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-strncmp.test b/test/fuzzer/value-profile-strncmp.test index 2dfe43c4abc5..b60b97f86f3e 100644 --- a/test/fuzzer/value-profile-strncmp.test +++ b/test/fuzzer/value-profile-strncmp.test @@ -1,3 +1,4 @@ +UNSUPPORTED: freebsd CHECK: BINGO RUN: %cpp_compiler %S/SingleStrncmpTest.cpp -o %t-SingleStrncmpTest -RUN: not %t-SingleStrncmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s +RUN: not %run %t-SingleStrncmpTest -seed=1 -use_cmp=0 -use_value_profile=1 -runs=100000000 2>&1 | FileCheck %s diff --git a/test/fuzzer/value-profile-switch.test b/test/fuzzer/value-profile-switch.test index 7edb312a07b0..cc3d4944c0bf 100644 --- a/test/fuzzer/value-profile-switch.test +++ b/test/fuzzer/value-profile-switch.test @@ -1,5 +1,6 @@ +XFAIL: ios CHECK: BINGO RUN: %cpp_compiler %S/SwitchTest.cpp -o %t-SwitchTest RUN: %cpp_compiler %S/Switch2Test.cpp -o %t-Switch2Test -RUN: not %t-SwitchTest -use_cmp=0 -use_value_profile=1 -runs=100000000 -seed=1 2>&1 | FileCheck %s -RUN: not %t-Switch2Test -use_cmp=0 -use_value_profile=1 -runs=100000000 -seed=1 2>&1 | FileCheck %s +RUN: not %run %t-SwitchTest -use_cmp=0 -use_value_profile=1 -runs=100000000 -seed=1 2>&1 | FileCheck %s +RUN: not %run %t-Switch2Test -use_cmp=0 -use_value_profile=1 -runs=100000000 -seed=1 2>&1 | FileCheck %s |