Showing preview only (5,274K chars total). Download the full file or copy to clipboard to get everything.
Repository: delcypher/jfs
Branch: master
Commit: c45b12c5383e
Files: 979
Total size: 4.8 MB
Directory structure:
gitextract_qpsgp2_q/
├── .clang-format
├── .dockerignore
├── .gitignore
├── .idea/
│ └── codeStyleSettings.xml
├── CMakeLists.txt
├── LICENSE.txt
├── README.md
├── cmake/
│ ├── add_jfs_unit_test.cmake
│ ├── c_flags_override.cmake
│ ├── compiler_warnings.cmake
│ ├── cxx_flags_override.cmake
│ ├── git_utils.cmake
│ ├── jfs_add_component.cmake
│ ├── jfs_component_add_cxx_flag.cmake
│ ├── jfs_external_project_utils.cmake
│ └── jfs_get_llvm_components.cmake
├── docs/
│ └── tutorial/
│ ├── 0-basics-example.smt2
│ ├── 0-basics.md
│ ├── 1-setting-resource-limits.md
│ ├── 2-compilation-options-and-runtimes.md
│ ├── 3-resumming-fuzzing.md
│ ├── 4-getting-models.md
│ ├── 5-jfs-smt2cxx.md
│ └── 6-jfs-opt.md
├── include/
│ └── jfs/
│ ├── CXXFuzzingBackend/
│ │ ├── CXXFuzzingSolver.h
│ │ ├── CXXFuzzingSolverOptions.h
│ │ ├── CXXProgram.h
│ │ ├── CXXProgramBuilderOptions.h
│ │ ├── CXXProgramBuilderPass.h
│ │ ├── ClangInvocationManager.h
│ │ ├── ClangOptions.h
│ │ ├── CmdLine/
│ │ │ ├── CXXProgramBuilderOptionsBuilder.h
│ │ │ ├── ClangOptionsBuilder.h
│ │ │ └── CommandLineCategory.h
│ │ └── JFSCXXProgramStat.h
│ ├── Config/
│ │ ├── config.h.in
│ │ ├── depsVersion.h.in
│ │ └── version.h.in
│ ├── Core/
│ │ ├── IfVerbose.h
│ │ ├── JFSContext.h
│ │ ├── JFSTimerMacros.h
│ │ ├── Model.h
│ │ ├── ModelValidator.h
│ │ ├── Query.h
│ │ ├── RNG.h
│ │ ├── SMTLIB2Parser.h
│ │ ├── ScopedJFSContextErrorHandler.h
│ │ ├── SimpleModel.h
│ │ ├── Solver.h
│ │ ├── SolverOptions.h
│ │ ├── ToolErrorHandler.h
│ │ ├── Z3ASTCmp.h
│ │ ├── Z3ASTVisitor.h
│ │ ├── Z3Node.h
│ │ ├── Z3NodeMap.h
│ │ ├── Z3NodeSet.h
│ │ └── Z3NodeUtil.h
│ ├── FuzzingCommon/
│ │ ├── BufferAssignment.h
│ │ ├── BufferElement.h
│ │ ├── CmdLine/
│ │ │ ├── FreeVariableToBufferAssignmentPassOptionsBuilder.h
│ │ │ ├── LibFuzzerOptionsBuilder.h
│ │ │ └── SeedManagerOptionsBuilder.h
│ │ ├── CommandLineCategory.h
│ │ ├── DummyFuzzingSolver.h
│ │ ├── EqualityExtractionPass.h
│ │ ├── FileSerializableModel.h
│ │ ├── FreeVariableToBufferAssignmentPass.h
│ │ ├── FreeVariableToBufferAssignmentPassOptions.h
│ │ ├── FuzzingAnalysisInfo.h
│ │ ├── FuzzingSolver.h
│ │ ├── FuzzingSolverOptions.h
│ │ ├── JFSRuntimeFuzzingStat.h
│ │ ├── LibFuzzerInvocationManager.h
│ │ ├── LibFuzzerOptions.h
│ │ ├── SeedGenerator.h
│ │ ├── SeedManager.h
│ │ ├── SeedManagerOptions.h
│ │ ├── SeedManagerStat.h
│ │ ├── SortConformanceCheckPass.h
│ │ ├── SpecialConstantSeedGenerator.h
│ │ ├── SpecialConstantSeedGeneratorStat.h
│ │ └── WorkingDirectoryManager.h
│ ├── Support/
│ │ ├── CancellableProcess.h
│ │ ├── ErrorMessages.h
│ │ ├── FileUtils.h
│ │ ├── ICancellable.h
│ │ ├── JFSStat.h
│ │ ├── ScopedJFSTimerStatAppender.h
│ │ ├── ScopedTimer.h
│ │ ├── StatisticsManager.h
│ │ ├── Timer.h
│ │ └── version.h
│ ├── Transform/
│ │ ├── AndHoistingPass.h
│ │ ├── BitBlastPass.h
│ │ ├── BvBoundPropagationPass.h
│ │ ├── ConstantPropagationPass.h
│ │ ├── DIMACSOutputPass.h
│ │ ├── DuplicateConstraintEliminationPass.h
│ │ ├── FpToBvPass.h
│ │ ├── Passes.h
│ │ ├── QueryPass.h
│ │ ├── QueryPassManager.h
│ │ ├── SimpleContradictionsToFalsePass.h
│ │ ├── SimplificationPass.h
│ │ ├── StandardPasses.h
│ │ ├── TrueConstraintEliminationPass.h
│ │ └── Z3QueryPass.h
│ └── Z3Backend/
│ └── Z3Solver.h
├── lib/
│ ├── CMakeLists.txt
│ ├── CXXFuzzingBackend/
│ │ ├── CMakeLists.txt
│ │ ├── CXXFuzzingSolver.cpp
│ │ ├── CXXFuzzingSolverOptions.cpp
│ │ ├── CXXProgram.cpp
│ │ ├── CXXProgramBuilderOptions.cpp
│ │ ├── CXXProgramBuilderPass.cpp
│ │ ├── CXXProgramBuilderPassImpl.cpp
│ │ ├── CXXProgramBuilderPassImpl.h
│ │ ├── ClangInvocationManager.cpp
│ │ ├── ClangOptions.cpp
│ │ ├── CmdLine/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CXXProgramBuilderOptionsBuilder.cpp
│ │ │ ├── ClangOptionsBuilder.cpp
│ │ │ └── CommandLineCategory.cpp
│ │ └── JFSCXXProgramStat.cpp
│ ├── Core/
│ │ ├── CMakeLists.txt
│ │ ├── JFSContext.cpp
│ │ ├── Model.cpp
│ │ ├── ModelValidator.cpp
│ │ ├── Query.cpp
│ │ ├── RNG.cpp
│ │ ├── SMTLIB2Parser.cpp
│ │ ├── SimpleModel.cpp
│ │ ├── Solver.cpp
│ │ ├── ToolErrorHandler.cpp
│ │ ├── Z3ASTVisitor.cpp
│ │ ├── Z3Node.cpp
│ │ └── Z3NodeUtil.cpp
│ ├── FuzzingCommon/
│ │ ├── BufferAssignment.cpp
│ │ ├── BufferElement.cpp
│ │ ├── CMakeLists.txt
│ │ ├── CmdLine/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── FreeVariableToBufferAssignmentPassOptionsBuilder.cpp
│ │ │ ├── LibFuzzerOptionsBuilder.cpp
│ │ │ └── SeedManagerOptionsBuilder.cpp
│ │ ├── CommandLineCategory.cpp
│ │ ├── DummyFuzzingSolver.cpp
│ │ ├── EqualityExtractionPass.cpp
│ │ ├── FileSerializableModel.cpp
│ │ ├── FreeVariableToBufferAssignmentPass.cpp
│ │ ├── FreeVariableToBufferAssignmentPassOptions.cpp
│ │ ├── FuzzingAnalysisInfo.cpp
│ │ ├── FuzzingSolver.cpp
│ │ ├── FuzzingSolverOptions.cpp
│ │ ├── JFSRuntimeFuzzingStat.cpp
│ │ ├── LibFuzzerInvocationManager.cpp
│ │ ├── LibFuzzerOptions.cpp
│ │ ├── SMTLIBRuntimes.cpp.in
│ │ ├── SMTLIBRuntimes.h.in
│ │ ├── SeedGenerator.cpp
│ │ ├── SeedManager.cpp
│ │ ├── SeedManagerStat.cpp
│ │ ├── SortConformanceCheckPass.cpp
│ │ ├── SpecialConstantSeedGenerator.cpp
│ │ ├── SpecialConstantSeedGeneratorStat.cpp
│ │ └── WorkingDirectoryManager.cpp
│ ├── Support/
│ │ ├── CMakeLists.txt
│ │ ├── CancellableProcess.cpp
│ │ ├── ErrorMessages.cpp
│ │ ├── FileUtils.cpp
│ │ ├── ICancellable.cpp
│ │ ├── JFSStat.cpp
│ │ ├── ScopedTimer.cpp
│ │ ├── StatisticsManager.cpp
│ │ ├── Timer.cpp
│ │ └── version.cpp
│ ├── Transform/
│ │ ├── AndHoistingPass.cpp
│ │ ├── BitBlastPass.cpp
│ │ ├── BvBoundPropagationPass.cpp
│ │ ├── CMakeLists.txt
│ │ ├── ConstantPropagationPass.cpp
│ │ ├── DIMACSOutputPass.cpp
│ │ ├── DuplicateConstraintEliminationPass.cpp
│ │ ├── FpToBvPass.cpp
│ │ ├── QueryPassManager.cpp
│ │ ├── SimpleContradictionsToFalsePass.cpp
│ │ ├── SimplificationPass.cpp
│ │ ├── StandardPasses.cpp
│ │ ├── TrueConstraintEliminationPass.cpp
│ │ └── Z3QueryPass.cpp
│ └── Z3Backend/
│ ├── CMakeLists.txt
│ └── Z3Solver.cpp
├── runtime/
│ ├── CMakeLists.txt
│ ├── LibFuzzer/
│ │ ├── CMakeLists.txt
│ │ ├── Fuzzer/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── FuzzerClangCounters.cpp
│ │ │ ├── FuzzerCommand.h
│ │ │ ├── FuzzerCorpus.h
│ │ │ ├── FuzzerCrossOver.cpp
│ │ │ ├── FuzzerDefs.h
│ │ │ ├── FuzzerDictionary.h
│ │ │ ├── FuzzerDriver.cpp
│ │ │ ├── FuzzerExtFunctions.def
│ │ │ ├── FuzzerExtFunctions.h
│ │ │ ├── FuzzerExtFunctionsDlsym.cpp
│ │ │ ├── FuzzerExtFunctionsDlsymWin.cpp
│ │ │ ├── FuzzerExtFunctionsWeak.cpp
│ │ │ ├── FuzzerExtFunctionsWeakAlias.cpp
│ │ │ ├── FuzzerExtraCounters.cpp
│ │ │ ├── FuzzerFlags.def
│ │ │ ├── FuzzerIO.cpp
│ │ │ ├── FuzzerIO.h
│ │ │ ├── FuzzerIOPosix.cpp
│ │ │ ├── FuzzerIOWindows.cpp
│ │ │ ├── FuzzerInterface.h
│ │ │ ├── FuzzerInternal.h
│ │ │ ├── FuzzerLoop.cpp
│ │ │ ├── FuzzerMain.cpp
│ │ │ ├── FuzzerMerge.cpp
│ │ │ ├── FuzzerMerge.h
│ │ │ ├── FuzzerMutate.cpp
│ │ │ ├── FuzzerMutate.h
│ │ │ ├── FuzzerOptions.h
│ │ │ ├── FuzzerRandom.h
│ │ │ ├── FuzzerSHA1.cpp
│ │ │ ├── FuzzerSHA1.h
│ │ │ ├── FuzzerShmem.h
│ │ │ ├── FuzzerShmemFuchsia.cpp
│ │ │ ├── FuzzerShmemPosix.cpp
│ │ │ ├── FuzzerShmemWindows.cpp
│ │ │ ├── FuzzerTracePC.cpp
│ │ │ ├── FuzzerTracePC.h
│ │ │ ├── FuzzerUtil.cpp
│ │ │ ├── FuzzerUtil.h
│ │ │ ├── FuzzerUtilDarwin.cpp
│ │ │ ├── FuzzerUtilFuchsia.cpp
│ │ │ ├── FuzzerUtilLinux.cpp
│ │ │ ├── FuzzerUtilPosix.cpp
│ │ │ ├── FuzzerUtilWindows.cpp
│ │ │ ├── FuzzerValueBitMap.h
│ │ │ ├── README.txt
│ │ │ ├── afl/
│ │ │ │ └── afl_driver.cpp
│ │ │ ├── build.sh
│ │ │ ├── scripts/
│ │ │ │ └── unbalanced_allocs.py
│ │ │ ├── standalone/
│ │ │ │ └── StandaloneFuzzTargetMain.c
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ └── FuzzerUnittest.cpp
│ │ └── README-JFS.md
│ ├── LibPureRandomFuzzer/
│ │ ├── API.cpp
│ │ ├── API.h
│ │ ├── CMakeLists.txt
│ │ ├── Driver.cpp
│ │ ├── Driver.h
│ │ ├── Log.h
│ │ ├── Main.cpp
│ │ ├── Options.def
│ │ ├── README.md
│ │ ├── Signals.cpp
│ │ ├── Signals.h
│ │ ├── TestInput.cpp
│ │ ├── TestInput.h
│ │ └── Types.h
│ └── SMTLIB/
│ ├── CMakeLists.txt
│ ├── SMTLIB/
│ │ ├── BitVector.h
│ │ ├── BufferRef.h
│ │ ├── CMakeLists.txt
│ │ ├── Core.cpp
│ │ ├── Core.h
│ │ ├── Float.cpp
│ │ ├── Float.h
│ │ ├── Logger.cpp
│ │ ├── Logger.h
│ │ ├── Messages.cpp
│ │ ├── Messages.h
│ │ ├── NativeBitVector.cpp
│ │ ├── NativeBitVector.h
│ │ ├── NativeFloat.cpp
│ │ ├── NativeFloat.h
│ │ ├── jassert.h
│ │ └── unittests/
│ │ ├── BitVector/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Native/
│ │ │ │ ├── BvAShr.cpp
│ │ │ │ ├── BvAdd.cpp
│ │ │ │ ├── BvAlloc.cpp
│ │ │ │ ├── BvAnd.cpp
│ │ │ │ ├── BvComp.cpp
│ │ │ │ ├── BvLShr.cpp
│ │ │ │ ├── BvMul.cpp
│ │ │ │ ├── BvNand.cpp
│ │ │ │ ├── BvNeg.cpp
│ │ │ │ ├── BvNor.cpp
│ │ │ │ ├── BvNot.cpp
│ │ │ │ ├── BvOr.cpp
│ │ │ │ ├── BvSDiv.cpp
│ │ │ │ ├── BvSMod.cpp
│ │ │ │ ├── BvSRem.cpp
│ │ │ │ ├── BvSge.cpp
│ │ │ │ ├── BvSgt.cpp
│ │ │ │ ├── BvShl.cpp
│ │ │ │ ├── BvSle.cpp
│ │ │ │ ├── BvSlt.cpp
│ │ │ │ ├── BvSub.cpp
│ │ │ │ ├── BvUDiv.cpp
│ │ │ │ ├── BvURem.cpp
│ │ │ │ ├── BvUge.cpp
│ │ │ │ ├── BvUgt.cpp
│ │ │ │ ├── BvUle.cpp
│ │ │ │ ├── BvUlt.cpp
│ │ │ │ ├── BvXNor.cpp
│ │ │ │ ├── BvXor.cpp
│ │ │ │ ├── Concat.cpp
│ │ │ │ ├── Equal.cpp
│ │ │ │ ├── Extract.cpp
│ │ │ │ ├── MakeFromBuffer.cpp
│ │ │ │ ├── RotateLeft.cpp
│ │ │ │ ├── RotateRight.cpp
│ │ │ │ ├── SignExtend.cpp
│ │ │ │ ├── WriteToBuffer.cpp
│ │ │ │ └── ZeroExtend.cpp
│ │ │ └── NonNative/
│ │ │ ├── Concat.cpp
│ │ │ ├── SignExtend.cpp
│ │ │ └── ZeroExtend.cpp
│ │ ├── CMakeLists.txt
│ │ ├── Core/
│ │ │ ├── CMakeLists.txt
│ │ │ └── MakeFromBuffer.cpp
│ │ ├── Float/
│ │ │ ├── CMakeLists.txt
│ │ │ └── Native/
│ │ │ ├── Abs.cpp
│ │ │ ├── Add.cpp
│ │ │ ├── ConvertToFloatFromFloat.cpp
│ │ │ ├── ConvertToFloatFromSignedBV.cpp
│ │ │ ├── ConvertToFloatFromUnsignedBV.cpp
│ │ │ ├── ConvertToSignedBVFromFloat.cpp
│ │ │ ├── ConvertToUnsignedBVFromFloat.cpp
│ │ │ ├── Div.cpp
│ │ │ ├── FMA.cpp
│ │ │ ├── GreaterThan.cpp
│ │ │ ├── GreaterThanOrEqual.cpp
│ │ │ ├── IEEEEquals.cpp
│ │ │ ├── IsInfinite.cpp
│ │ │ ├── IsNaN.cpp
│ │ │ ├── IsNegative.cpp
│ │ │ ├── IsNormal.cpp
│ │ │ ├── IsPositive.cpp
│ │ │ ├── IsSubnormal.cpp
│ │ │ ├── IsZero.cpp
│ │ │ ├── LessThan.cpp
│ │ │ ├── LessThanOrEqual.cpp
│ │ │ ├── MakeFromBuffer.cpp
│ │ │ ├── MakeFromIEEEBitVector.cpp
│ │ │ ├── MakeFromTriple.cpp
│ │ │ ├── Max.cpp
│ │ │ ├── Min.cpp
│ │ │ ├── Mul.cpp
│ │ │ ├── Neg.cpp
│ │ │ ├── Rem.cpp
│ │ │ ├── RoundToIntegral.cpp
│ │ │ ├── SMTLIBEquals.cpp
│ │ │ ├── SpecialConstants.cpp
│ │ │ ├── Sqrt.cpp
│ │ │ └── Sub.cpp
│ │ ├── Logger/
│ │ │ ├── CMakeLists.txt
│ │ │ └── LoggerTests.cpp
│ │ ├── SMTLIBRuntimeTestUtil.cpp
│ │ ├── SMTLIBRuntimeTestUtil.h
│ │ ├── lit-unit-tests-common.cfg
│ │ └── lit-unit-tests-common.site.cfg.in
│ └── gtest/
│ └── CMakeLists.txt
├── scripts/
│ ├── Dockerfiles/
│ │ ├── build.sh
│ │ ├── jfs_base_ubuntu_16.04.Dockerfile
│ │ └── jfs_build_ubuntu_16.04.Dockerfile
│ └── dist/
│ ├── build_and_install_cmake.sh
│ ├── build_and_install_ninja.sh
│ ├── build_jfs.sh
│ ├── build_llvm.sh
│ ├── build_z3.sh
│ └── test_jfs.sh
├── tests/
│ ├── CMakeLists.txt
│ ├── system_tests/
│ │ ├── CMakeLists.txt
│ │ ├── CNF/
│ │ │ ├── 2017-09-02-float-constant-regression.smt2
│ │ │ ├── imperial_synthetic_sqrt_klee_bug.x86_64_query.05.smt2
│ │ │ └── less_variables_than_bits.smt2
│ │ ├── CXXFuzzingBackend/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CXXProgramBuilder/
│ │ │ │ ├── SingleConstantAssignment.smt2
│ │ │ │ ├── SingleUnconstraintedBool.smt2
│ │ │ │ ├── UsedConstantAssignment.smt2
│ │ │ │ ├── UsedConstantFloatingPointAssignment.smt2
│ │ │ │ ├── branch_encodings/
│ │ │ │ │ ├── fail_fast.smt2
│ │ │ │ │ ├── try_all.smt2
│ │ │ │ │ └── try_all_imncsf.smt2
│ │ │ │ ├── buffer_element_alignment/
│ │ │ │ │ ├── bv_bool_bv_bool.smt2
│ │ │ │ │ ├── bv_bool_bv_bool_float.smt2
│ │ │ │ │ └── three_bools.smt2
│ │ │ │ ├── inconsistent_equalities.smt2
│ │ │ │ ├── operations/
│ │ │ │ │ ├── bool/
│ │ │ │ │ │ ├── and.smt2
│ │ │ │ │ │ ├── distinct_bool.smt2
│ │ │ │ │ │ ├── equal_bool.smt2
│ │ │ │ │ │ ├── iff.smt2
│ │ │ │ │ │ ├── implies.smt2
│ │ │ │ │ │ ├── ite_bool.smt2
│ │ │ │ │ │ ├── not.smt2
│ │ │ │ │ │ ├── or.smt2
│ │ │ │ │ │ └── xor.smt2
│ │ │ │ │ ├── bv/
│ │ │ │ │ │ ├── bvadd.smt2
│ │ │ │ │ │ ├── bvadd_nary.smt2
│ │ │ │ │ │ ├── bvand.smt2
│ │ │ │ │ │ ├── bvand_nary.smt2
│ │ │ │ │ │ ├── bvashr.smt2
│ │ │ │ │ │ ├── bvcomp.smt2
│ │ │ │ │ │ ├── bvlshr.smt2
│ │ │ │ │ │ ├── bvmul.smt2
│ │ │ │ │ │ ├── bvmul_nary.smt2
│ │ │ │ │ │ ├── bvnand.smt2
│ │ │ │ │ │ ├── bvneg.smt2
│ │ │ │ │ │ ├── bvnor.smt2
│ │ │ │ │ │ ├── bvnot.smt2
│ │ │ │ │ │ ├── bvor.smt2
│ │ │ │ │ │ ├── bvor_nary.smt2
│ │ │ │ │ │ ├── bvsdiv.smt2
│ │ │ │ │ │ ├── bvsdiv0.smt2
│ │ │ │ │ │ ├── bvsdiv_i.smt2
│ │ │ │ │ │ ├── bvsge.smt2
│ │ │ │ │ │ ├── bvsgt.smt2
│ │ │ │ │ │ ├── bvshl.smt2
│ │ │ │ │ │ ├── bvsle.smt2
│ │ │ │ │ │ ├── bvslt.smt2
│ │ │ │ │ │ ├── bvsmod.smt2
│ │ │ │ │ │ ├── bvsmod_i.smt2
│ │ │ │ │ │ ├── bvsrem.smt2
│ │ │ │ │ │ ├── bvsrem_i.smt2
│ │ │ │ │ │ ├── bvsub.smt2
│ │ │ │ │ │ ├── bvudiv.smt2
│ │ │ │ │ │ ├── bvudiv0.smt2
│ │ │ │ │ │ ├── bvudiv_i.smt2
│ │ │ │ │ │ ├── bvuge.smt2
│ │ │ │ │ │ ├── bvugt.smt2
│ │ │ │ │ │ ├── bvule.smt2
│ │ │ │ │ │ ├── bvult.smt2
│ │ │ │ │ │ ├── bvurem.smt2
│ │ │ │ │ │ ├── bvurem_i.smt2
│ │ │ │ │ │ ├── bvxnor.smt2
│ │ │ │ │ │ ├── bvxor.smt2
│ │ │ │ │ │ ├── bvxor_nary.smt2
│ │ │ │ │ │ ├── concat.smt2
│ │ │ │ │ │ ├── concat_large.smt2
│ │ │ │ │ │ ├── distinct_bitvector.smt2
│ │ │ │ │ │ ├── equal_bitvector.smt2
│ │ │ │ │ │ ├── extract.smt2
│ │ │ │ │ │ ├── ite_bitvector.smt2
│ │ │ │ │ │ ├── rotate_left.smt2
│ │ │ │ │ │ ├── rotate_right.smt2
│ │ │ │ │ │ ├── sign_extend.smt2
│ │ │ │ │ │ └── zero_extend.smt2
│ │ │ │ │ └── fp/
│ │ │ │ │ ├── abs_float32.smt2
│ │ │ │ │ ├── abs_float64.smt2
│ │ │ │ │ ├── add_rna_float32.smt2
│ │ │ │ │ ├── add_rna_float64.smt2
│ │ │ │ │ ├── add_rne_float32.smt2
│ │ │ │ │ ├── add_rne_float64.smt2
│ │ │ │ │ ├── add_rtn_float32.smt2
│ │ │ │ │ ├── add_rtn_float64.smt2
│ │ │ │ │ ├── add_rtp_float32.smt2
│ │ │ │ │ ├── add_rtp_float64.smt2
│ │ │ │ │ ├── add_rtz_float32.smt2
│ │ │ │ │ ├── add_rtz_float64.smt2
│ │ │ │ │ ├── cast_bv32_to_float.smt2
│ │ │ │ │ ├── constant_nan_float32.smt2
│ │ │ │ │ ├── constant_nan_float64.smt2
│ │ │ │ │ ├── constant_negative_infinity_float32.smt2
│ │ │ │ │ ├── constant_negative_infinity_float64.smt2
│ │ │ │ │ ├── constant_negative_zero_float32.smt2
│ │ │ │ │ ├── constant_negative_zero_float64.smt2
│ │ │ │ │ ├── constant_plus_infinity_float32.smt2
│ │ │ │ │ ├── constant_plus_infinity_float64.smt2
│ │ │ │ │ ├── constant_plus_zero_float32.smt2
│ │ │ │ │ ├── constant_plus_zero_float64.smt2
│ │ │ │ │ ├── constants_from_triple.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rtz.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rtz.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rtz.smt2
│ │ │ │ │ ├── div_rna_float32.smt2
│ │ │ │ │ ├── div_rna_float64.smt2
│ │ │ │ │ ├── div_rne_float32.smt2
│ │ │ │ │ ├── div_rne_float64.smt2
│ │ │ │ │ ├── div_rtn_float32.smt2
│ │ │ │ │ ├── div_rtn_float64.smt2
│ │ │ │ │ ├── div_rtp_float32.smt2
│ │ │ │ │ ├── div_rtp_float64.smt2
│ │ │ │ │ ├── div_rtz_float32.smt2
│ │ │ │ │ ├── div_rtz_float64.smt2
│ │ │ │ │ ├── fma_rna_float32.smt2
│ │ │ │ │ ├── fma_rna_float64.smt2
│ │ │ │ │ ├── fma_rne_float32.smt2
│ │ │ │ │ ├── fma_rne_float64.smt2
│ │ │ │ │ ├── fma_rtn_float32.smt2
│ │ │ │ │ ├── fma_rtn_float64.smt2
│ │ │ │ │ ├── fma_rtp_float32.smt2
│ │ │ │ │ ├── fma_rtp_float64.smt2
│ │ │ │ │ ├── fma_rtz_float32.smt2
│ │ │ │ │ ├── fma_rtz_float64.smt2
│ │ │ │ │ ├── fpgeq_float32.smt2
│ │ │ │ │ ├── fpgeq_float64.smt2
│ │ │ │ │ ├── fpgt_float32.smt2
│ │ │ │ │ ├── fpgt_float64.smt2
│ │ │ │ │ ├── fpleq_float32.smt2
│ │ │ │ │ ├── fpleq_float64.smt2
│ │ │ │ │ ├── fplt_float32.smt2
│ │ │ │ │ ├── fplt_float64.smt2
│ │ │ │ │ ├── ieee_equals_float32.smt2
│ │ │ │ │ ├── ieee_equals_float64.smt2
│ │ │ │ │ ├── is_infinite_float32.smt2
│ │ │ │ │ ├── is_infinite_float64.smt2
│ │ │ │ │ ├── is_nan_float32.smt2
│ │ │ │ │ ├── is_nan_float64.smt2
│ │ │ │ │ ├── is_negative_float32.smt2
│ │ │ │ │ ├── is_negative_float64.smt2
│ │ │ │ │ ├── is_normal_float32.smt2
│ │ │ │ │ ├── is_normal_float64.smt2
│ │ │ │ │ ├── is_positive_float32.smt2
│ │ │ │ │ ├── is_positive_float64.smt2
│ │ │ │ │ ├── is_subnormal_float32.smt2
│ │ │ │ │ ├── is_subnormal_float64.smt2
│ │ │ │ │ ├── is_zero_float32.smt2
│ │ │ │ │ ├── is_zero_float64.smt2
│ │ │ │ │ ├── max_float32.smt2
│ │ │ │ │ ├── max_float64.smt2
│ │ │ │ │ ├── min_float32.smt2
│ │ │ │ │ ├── min_float64.smt2
│ │ │ │ │ ├── mul_rna_float32.smt2
│ │ │ │ │ ├── mul_rna_float64.smt2
│ │ │ │ │ ├── mul_rne_float32.smt2
│ │ │ │ │ ├── mul_rne_float64.smt2
│ │ │ │ │ ├── mul_rtn_float32.smt2
│ │ │ │ │ ├── mul_rtn_float64.smt2
│ │ │ │ │ ├── mul_rtp_float32.smt2
│ │ │ │ │ ├── mul_rtp_float64.smt2
│ │ │ │ │ ├── mul_rtz_float32.smt2
│ │ │ │ │ ├── mul_rtz_float64.smt2
│ │ │ │ │ ├── neg_float32.smt2
│ │ │ │ │ ├── neg_float64.smt2
│ │ │ │ │ ├── print_fp_const_minus_inf_float64.smt2
│ │ │ │ │ ├── print_fp_const_minus_zero_float64.smt2
│ │ │ │ │ ├── print_fp_const_nan_float64.smt2
│ │ │ │ │ ├── print_fp_const_plus_inf_float64.smt2
│ │ │ │ │ ├── print_fp_const_plus_zero_float64.smt2
│ │ │ │ │ ├── rem_float32.smt2
│ │ │ │ │ ├── rem_float64.smt2
│ │ │ │ │ ├── round_to_integral_rna_float32.smt2
│ │ │ │ │ ├── round_to_integral_rna_float64.smt2
│ │ │ │ │ ├── round_to_integral_rne_float32.smt2
│ │ │ │ │ ├── round_to_integral_rne_float64.smt2
│ │ │ │ │ ├── round_to_integral_rtn_float32.smt2
│ │ │ │ │ ├── round_to_integral_rtn_float64.smt2
│ │ │ │ │ ├── round_to_integral_rtp_float32.smt2
│ │ │ │ │ ├── round_to_integral_rtp_float64.smt2
│ │ │ │ │ ├── round_to_integral_rtz_float32.smt2
│ │ │ │ │ ├── round_to_integral_rtz_float64.smt2
│ │ │ │ │ ├── sqrt_rna_float32.smt2
│ │ │ │ │ ├── sqrt_rna_float64.smt2
│ │ │ │ │ ├── sqrt_rne_float32.smt2
│ │ │ │ │ ├── sqrt_rne_float64.smt2
│ │ │ │ │ ├── sqrt_rtn_float32.smt2
│ │ │ │ │ ├── sqrt_rtn_float64.smt2
│ │ │ │ │ ├── sqrt_rtp_float32.smt2
│ │ │ │ │ ├── sqrt_rtp_float64.smt2
│ │ │ │ │ ├── sqrt_rtz_float32.smt2
│ │ │ │ │ ├── sqrt_rtz_float64.smt2
│ │ │ │ │ ├── sub_rna_float32.smt2
│ │ │ │ │ ├── sub_rna_float64.smt2
│ │ │ │ │ ├── sub_rne_float32.smt2
│ │ │ │ │ ├── sub_rne_float64.smt2
│ │ │ │ │ ├── sub_rtn_float32.smt2
│ │ │ │ │ ├── sub_rtn_float64.smt2
│ │ │ │ │ ├── sub_rtp_float32.smt2
│ │ │ │ │ ├── sub_rtp_float64.smt2
│ │ │ │ │ ├── sub_rtz_float32.smt2
│ │ │ │ │ └── sub_rtz_float64.smt2
│ │ │ │ ├── symbol_names/
│ │ │ │ │ ├── quoted_symbol.smt2
│ │ │ │ │ ├── simple_alphanumeric.smt2
│ │ │ │ │ ├── simple_alphanumeric_ampersand.smt2
│ │ │ │ │ ├── simple_alphanumeric_asterisk.smt2
│ │ │ │ │ ├── simple_alphanumeric_at.smt2
│ │ │ │ │ ├── simple_alphanumeric_caret.smt2
│ │ │ │ │ ├── simple_alphanumeric_dollar_sign.smt2
│ │ │ │ │ ├── simple_alphanumeric_dot.smt2
│ │ │ │ │ ├── simple_alphanumeric_equal.smt2
│ │ │ │ │ ├── simple_alphanumeric_exclaimation_mark.smt2
│ │ │ │ │ ├── simple_alphanumeric_gt.smt2
│ │ │ │ │ ├── simple_alphanumeric_lt.smt2
│ │ │ │ │ ├── simple_alphanumeric_minus.smt2
│ │ │ │ │ ├── simple_alphanumeric_minus_clash.smt2
│ │ │ │ │ ├── simple_alphanumeric_percent.smt2
│ │ │ │ │ ├── simple_alphanumeric_plus.smt2
│ │ │ │ │ ├── simple_alphanumeric_question_foward_slash.smt2
│ │ │ │ │ ├── simple_alphanumeric_question_mark.smt2
│ │ │ │ │ ├── simple_alphanumeric_tilda.smt2
│ │ │ │ │ └── stress_test.smt2
│ │ │ │ ├── track_num_constraints/
│ │ │ │ │ ├── track_max_num_solved_fail_fast.smt2
│ │ │ │ │ ├── track_max_num_solved_try_all.smt2
│ │ │ │ │ └── track_max_num_solved_try_all_imncsf.smt2
│ │ │ │ └── track_num_inputs/
│ │ │ │ ├── track_num_inputs.smt2
│ │ │ │ └── track_num_wrong_size_inputs.smt2
│ │ │ ├── Fuzz/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── branch_encodings/
│ │ │ │ │ └── try_all_imncsf.smt2
│ │ │ │ ├── buffer_element_alignment/
│ │ │ │ │ └── bv_bool_bv_bool_float.smt2
│ │ │ │ ├── lit.local.cfg
│ │ │ │ ├── models/
│ │ │ │ │ ├── equality_extraction/
│ │ │ │ │ │ ├── all_assignments.smt2
│ │ │ │ │ │ ├── empty.smt2
│ │ │ │ │ │ ├── equalities_with_model_from_fuzzer.smt2
│ │ │ │ │ │ └── trivial_equalities.smt2
│ │ │ │ │ └── simple/
│ │ │ │ │ ├── 3_bv_const.smt2
│ │ │ │ │ ├── 3_true.smt2
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── empty.smt2
│ │ │ │ │ ├── float_nan.smt2
│ │ │ │ │ ├── float_neg_inf.smt2
│ │ │ │ │ ├── float_neg_one.smt2
│ │ │ │ │ ├── float_neg_zero.smt2
│ │ │ │ │ ├── float_pos_inf.smt2
│ │ │ │ │ ├── float_pos_one.smt2
│ │ │ │ │ └── float_pos_zero.smt2
│ │ │ │ ├── runtimes/
│ │ │ │ │ └── a629test0052.smt2
│ │ │ │ ├── sat/
│ │ │ │ │ ├── 2017-09-02-float-constant-regression.smt2
│ │ │ │ │ ├── a629test0052.smt2
│ │ │ │ │ ├── max-has-solution-12341.smt2
│ │ │ │ │ ├── min-has-solution-1235.smt2
│ │ │ │ │ ├── simple_bool.smt2
│ │ │ │ │ └── simplifer_makes_consts.smt2
│ │ │ │ ├── stats/
│ │ │ │ │ ├── can_write_to_stdout.smt2
│ │ │ │ │ └── valid_yaml.smt2
│ │ │ │ ├── test_format.py
│ │ │ │ ├── tracing/
│ │ │ │ │ ├── increase_in_max_num_constraints_sat.smt2
│ │ │ │ │ └── trace_wrong_sized_input.smt2
│ │ │ │ ├── track_all/
│ │ │ │ │ ├── sat_fail_fast_encoding.smt2
│ │ │ │ │ ├── sat_try_all_encodings.smt2
│ │ │ │ │ ├── unsat_fail_fast_encoding.smt2
│ │ │ │ │ └── unsat_try_all_encoding.smt2
│ │ │ │ ├── track_num_constraints/
│ │ │ │ │ ├── sat_fail_fast_encoding.smt2
│ │ │ │ │ ├── sat_try_all_encoding.smt2
│ │ │ │ │ ├── unsat_fail_fast_encoding.smt2
│ │ │ │ │ └── unsat_try_all_encoding.smt2
│ │ │ │ ├── unknown/
│ │ │ │ │ ├── bv_unsupported_size.smt2
│ │ │ │ │ └── float_unsupported_size.smt2
│ │ │ │ └── unsat/
│ │ │ │ ├── max-no-solution.smt2
│ │ │ │ └── min-no-solution.smt2
│ │ │ └── SeedGeneration/
│ │ │ ├── 3b_all_ones
│ │ │ ├── 3b_all_zeros
│ │ │ ├── all_zeros_and_all_ones.smt2
│ │ │ ├── bool_bv_float.smt2
│ │ │ ├── bool_bv_float_linux.smt2
│ │ │ ├── max_num_seeds_1.smt2
│ │ │ └── special_constants_stats.smt2
│ │ ├── CommandLine/
│ │ │ ├── NonExistentFile.smt2
│ │ │ └── version.smt2
│ │ ├── DummyFuzzingSolver/
│ │ │ ├── README.md
│ │ │ ├── sat/
│ │ │ │ ├── trivial_equalities.smt2
│ │ │ │ └── true_elim.smt2
│ │ │ ├── unknown/
│ │ │ │ ├── trivial_equality_with_non_trivial_constraint.smt2
│ │ │ │ └── unknown_ineq.smt2
│ │ │ └── unsat/
│ │ │ ├── bound_contradiction.smt2
│ │ │ ├── bound_contradiction2.smt2
│ │ │ └── true_elim.smt2
│ │ ├── Transforms/
│ │ │ ├── AndHoisting/
│ │ │ │ ├── nested_and.smt2
│ │ │ │ ├── non_constant_and.smt2
│ │ │ │ ├── single_and.smt2
│ │ │ │ └── single_and_ternary.smt2
│ │ │ ├── BvBoundPropagation/
│ │ │ │ └── bound_contradiction.smt2
│ │ │ ├── ConstantPropagation/
│ │ │ │ ├── constant_prop.smt2
│ │ │ │ ├── constant_prop_and.smt2
│ │ │ │ ├── duplicate_constraint.smt2
│ │ │ │ ├── modulus_true-unreach-call_true-no-overflow.i_242.smt2
│ │ │ │ ├── not_preverse_multiple_false.smt2
│ │ │ │ └── preserve_false.smt2
│ │ │ ├── DuplicateConstraintElimination/
│ │ │ │ └── duplicate_equals.smt2
│ │ │ ├── SimpleContradictionsToFalse/
│ │ │ │ └── e_not_e.smt2
│ │ │ ├── Simplify/
│ │ │ │ ├── constant_fold_bvadd.smt2
│ │ │ │ ├── constant_fold_ite_identity.smt2
│ │ │ │ ├── equal.smt2
│ │ │ │ └── not_equal.smt2
│ │ │ └── TrueConstraintElimination/
│ │ │ └── true_elim.smt2
│ │ ├── Z3Backend/
│ │ │ └── QF_FPBV/
│ │ │ ├── sat/
│ │ │ │ └── imperial_synthetic_sqrt_klee_bug.x86_64_query.05.smt2
│ │ │ └── unsat/
│ │ │ └── imperial_synthetic_sqrt_klee_bug.x86_64_query.06.smt2
│ │ ├── lit.cfg
│ │ └── lit.site.cfg.in
│ └── unit_tests/
│ ├── CMakeLists.txt
│ ├── Core/
│ │ ├── CMakeLists.txt
│ │ └── FloatSpecialConstants.cpp
│ ├── Dummy/
│ │ ├── CMakeLists.txt
│ │ └── Dummy.cpp
│ ├── FuzzingCommon/
│ │ ├── CMakeLists.txt
│ │ └── EqualityExtractionPass.cpp
│ ├── lit-unit-tests-common.cfg
│ └── lit-unit-tests-common.site.cfg.in
├── tools/
│ ├── CMakeLists.txt
│ ├── jfs/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ ├── jfs-opt/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ ├── jfs-smt2cnf/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ ├── jfs-smt2cxx/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ └── yaml-syntax-check/
│ ├── CMakeLists.txt
│ └── main.cpp
└── utils/
├── CMakeLists.txt
├── FileCheck/
│ ├── CMakeLists.txt
│ ├── FileCheck.cpp
│ └── LICENSE.TXT
├── SMT-COMP/
│ ├── StarExec-SMTCOMP2017.Dockerfile
│ ├── configs/
│ │ └── starexec_run_default
│ ├── mk_starexec_binary_dist.sh
│ └── starexec_description.txt
├── googletest/
│ ├── CMakeLists.txt
│ ├── README.md
│ └── googletest/
│ ├── .gitignore
│ ├── CHANGES
│ ├── CMakeLists.txt
│ ├── CONTRIBUTORS
│ ├── LICENSE
│ ├── Makefile.am
│ ├── README.md
│ ├── build-aux/
│ │ └── .keep
│ ├── cmake/
│ │ └── internal_utils.cmake
│ ├── codegear/
│ │ ├── gtest.cbproj
│ │ ├── gtest.groupproj
│ │ ├── gtest_all.cc
│ │ ├── gtest_link.cc
│ │ ├── gtest_main.cbproj
│ │ └── gtest_unittest.cbproj
│ ├── configure.ac
│ ├── docs/
│ │ ├── AdvancedGuide.md
│ │ ├── DevGuide.md
│ │ ├── Documentation.md
│ │ ├── FAQ.md
│ │ ├── Primer.md
│ │ ├── PumpManual.md
│ │ ├── Samples.md
│ │ ├── V1_5_AdvancedGuide.md
│ │ ├── V1_5_Documentation.md
│ │ ├── V1_5_FAQ.md
│ │ ├── V1_5_Primer.md
│ │ ├── V1_5_PumpManual.md
│ │ ├── V1_5_XcodeGuide.md
│ │ ├── V1_6_AdvancedGuide.md
│ │ ├── V1_6_Documentation.md
│ │ ├── V1_6_FAQ.md
│ │ ├── V1_6_Primer.md
│ │ ├── V1_6_PumpManual.md
│ │ ├── V1_6_Samples.md
│ │ ├── V1_6_XcodeGuide.md
│ │ ├── V1_7_AdvancedGuide.md
│ │ ├── V1_7_Documentation.md
│ │ ├── V1_7_FAQ.md
│ │ ├── V1_7_Primer.md
│ │ ├── V1_7_PumpManual.md
│ │ ├── V1_7_Samples.md
│ │ ├── V1_7_XcodeGuide.md
│ │ └── XcodeGuide.md
│ ├── include/
│ │ └── gtest/
│ │ ├── gtest-death-test.h
│ │ ├── gtest-message.h
│ │ ├── gtest-param-test.h
│ │ ├── gtest-param-test.h.pump
│ │ ├── gtest-printers.h
│ │ ├── gtest-spi.h
│ │ ├── gtest-test-part.h
│ │ ├── gtest-typed-test.h
│ │ ├── gtest.h
│ │ ├── gtest_pred_impl.h
│ │ ├── gtest_prod.h
│ │ └── internal/
│ │ ├── custom/
│ │ │ ├── gtest-port.h
│ │ │ ├── gtest-printers.h
│ │ │ └── gtest.h
│ │ ├── gtest-death-test-internal.h
│ │ ├── gtest-filepath.h
│ │ ├── gtest-internal.h
│ │ ├── gtest-linked_ptr.h
│ │ ├── gtest-param-util-generated.h
│ │ ├── gtest-param-util-generated.h.pump
│ │ ├── gtest-param-util.h
│ │ ├── gtest-port-arch.h
│ │ ├── gtest-port.h
│ │ ├── gtest-string.h
│ │ ├── gtest-tuple.h
│ │ ├── gtest-tuple.h.pump
│ │ ├── gtest-type-util.h
│ │ └── gtest-type-util.h.pump
│ ├── m4/
│ │ ├── acx_pthread.m4
│ │ └── gtest.m4
│ ├── make/
│ │ └── Makefile
│ ├── msvc/
│ │ ├── gtest-md.sln
│ │ ├── gtest-md.vcproj
│ │ ├── gtest.sln
│ │ ├── gtest.vcproj
│ │ ├── gtest_main-md.vcproj
│ │ ├── gtest_main.vcproj
│ │ ├── gtest_prod_test-md.vcproj
│ │ ├── gtest_prod_test.vcproj
│ │ ├── gtest_unittest-md.vcproj
│ │ └── gtest_unittest.vcproj
│ ├── samples/
│ │ ├── prime_tables.h
│ │ ├── sample1.cc
│ │ ├── sample1.h
│ │ ├── sample10_unittest.cc
│ │ ├── sample1_unittest.cc
│ │ ├── sample2.cc
│ │ ├── sample2.h
│ │ ├── sample2_unittest.cc
│ │ ├── sample3-inl.h
│ │ ├── sample3_unittest.cc
│ │ ├── sample4.cc
│ │ ├── sample4.h
│ │ ├── sample4_unittest.cc
│ │ ├── sample5_unittest.cc
│ │ ├── sample6_unittest.cc
│ │ ├── sample7_unittest.cc
│ │ ├── sample8_unittest.cc
│ │ └── sample9_unittest.cc
│ ├── scripts/
│ │ ├── common.py
│ │ ├── fuse_gtest_files.py
│ │ ├── gen_gtest_pred_impl.py
│ │ ├── gtest-config.in
│ │ ├── pump.py
│ │ ├── release_docs.py
│ │ ├── test/
│ │ │ └── Makefile
│ │ ├── upload.py
│ │ └── upload_gtest.py
│ ├── src/
│ │ ├── gtest-all.cc
│ │ ├── gtest-death-test.cc
│ │ ├── gtest-filepath.cc
│ │ ├── gtest-internal-inl.h
│ │ ├── gtest-port.cc
│ │ ├── gtest-printers.cc
│ │ ├── gtest-test-part.cc
│ │ ├── gtest-typed-test.cc
│ │ ├── gtest.cc
│ │ └── gtest_main.cc
│ ├── test/
│ │ ├── gtest-death-test_ex_test.cc
│ │ ├── gtest-death-test_test.cc
│ │ ├── gtest-filepath_test.cc
│ │ ├── gtest-linked_ptr_test.cc
│ │ ├── gtest-listener_test.cc
│ │ ├── gtest-message_test.cc
│ │ ├── gtest-options_test.cc
│ │ ├── gtest-param-test2_test.cc
│ │ ├── gtest-param-test_test.cc
│ │ ├── gtest-param-test_test.h
│ │ ├── gtest-port_test.cc
│ │ ├── gtest-printers_test.cc
│ │ ├── gtest-test-part_test.cc
│ │ ├── gtest-tuple_test.cc
│ │ ├── gtest-typed-test2_test.cc
│ │ ├── gtest-typed-test_test.cc
│ │ ├── gtest-typed-test_test.h
│ │ ├── gtest-unittest-api_test.cc
│ │ ├── gtest_all_test.cc
│ │ ├── gtest_break_on_failure_unittest.py
│ │ ├── gtest_break_on_failure_unittest_.cc
│ │ ├── gtest_catch_exceptions_test.py
│ │ ├── gtest_catch_exceptions_test_.cc
│ │ ├── gtest_color_test.py
│ │ ├── gtest_color_test_.cc
│ │ ├── gtest_env_var_test.py
│ │ ├── gtest_env_var_test_.cc
│ │ ├── gtest_environment_test.cc
│ │ ├── gtest_filter_unittest.py
│ │ ├── gtest_filter_unittest_.cc
│ │ ├── gtest_help_test.py
│ │ ├── gtest_help_test_.cc
│ │ ├── gtest_list_tests_unittest.py
│ │ ├── gtest_list_tests_unittest_.cc
│ │ ├── gtest_main_unittest.cc
│ │ ├── gtest_no_test_unittest.cc
│ │ ├── gtest_output_test.py
│ │ ├── gtest_output_test_.cc
│ │ ├── gtest_output_test_golden_lin.txt
│ │ ├── gtest_pred_impl_unittest.cc
│ │ ├── gtest_premature_exit_test.cc
│ │ ├── gtest_prod_test.cc
│ │ ├── gtest_repeat_test.cc
│ │ ├── gtest_shuffle_test.py
│ │ ├── gtest_shuffle_test_.cc
│ │ ├── gtest_sole_header_test.cc
│ │ ├── gtest_stress_test.cc
│ │ ├── gtest_test_utils.py
│ │ ├── gtest_throw_on_failure_ex_test.cc
│ │ ├── gtest_throw_on_failure_test.py
│ │ ├── gtest_throw_on_failure_test_.cc
│ │ ├── gtest_uninitialized_test.py
│ │ ├── gtest_uninitialized_test_.cc
│ │ ├── gtest_unittest.cc
│ │ ├── gtest_xml_outfile1_test_.cc
│ │ ├── gtest_xml_outfile2_test_.cc
│ │ ├── gtest_xml_outfiles_test.py
│ │ ├── gtest_xml_output_unittest.py
│ │ ├── gtest_xml_output_unittest_.cc
│ │ ├── gtest_xml_test_utils.py
│ │ ├── production.cc
│ │ └── production.h
│ └── xcode/
│ ├── Config/
│ │ ├── DebugProject.xcconfig
│ │ ├── FrameworkTarget.xcconfig
│ │ ├── General.xcconfig
│ │ ├── ReleaseProject.xcconfig
│ │ ├── StaticLibraryTarget.xcconfig
│ │ └── TestTarget.xcconfig
│ ├── Resources/
│ │ └── Info.plist
│ ├── Samples/
│ │ └── FrameworkSample/
│ │ ├── Info.plist
│ │ ├── WidgetFramework.xcodeproj/
│ │ │ └── project.pbxproj
│ │ ├── runtests.sh
│ │ ├── widget.cc
│ │ ├── widget.h
│ │ └── widget_test.cc
│ ├── Scripts/
│ │ ├── runtests.sh
│ │ └── versiongenerate.py
│ └── gtest.xcodeproj/
│ └── project.pbxproj
├── hacks/
│ └── query-run/
│ ├── query-filter.py
│ ├── query-info.py
│ └── run-queries.py
├── not/
│ ├── CMakeLists.txt
│ ├── LICENSE.TXT
│ └── not.cpp
└── suppressions/
├── lsan/
│ ├── README.md
│ └── lsan_sup.txt
├── supr_env.sh
└── ubsan/
├── README.md
└── ubsan_sup.txt
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
BasedOnStyle: LLVM
Standard: Cpp11
PointerAlignment: Left
...
================================================
FILE: .dockerignore
================================================
.dockerignore
# Pass `.git` directory so that
# `jfs --version` gives git hash.
#.git
**/.*.swp
**/*.Dockerfile
scripts/Dockerfiles/*.patched
scripts/Dockerfiles/build.sh
utils/SMT-COMP
================================================
FILE: .gitignore
================================================
# Vim swap files
*.swp
*.swo
scripts/Dockerfiles/*.patched
*.pyc
================================================
FILE: .idea/codeStyleSettings.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectCodeStyleSettingsManager">
<option name="PER_PROJECT_SETTINGS">
<value>
<Objective-C>
<option name="INDENT_NAMESPACE_MEMBERS" value="2" />
<option name="INDENT_C_STRUCT_MEMBERS" value="2" />
<option name="INDENT_CLASS_MEMBERS" value="2" />
<option name="INDENT_INSIDE_CODE_BLOCK" value="2" />
</Objective-C>
<Objective-C-extensions>
<file>
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Import" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Macro" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Typedef" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Enum" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Constant" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Global" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Struct" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="FunctionPredecl" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Function" />
</file>
<class>
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Property" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Synthesize" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InitMethod" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="StaticMethod" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InstanceMethod" />
<option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="DeallocMethod" />
</class>
<extensions>
<pair source="cpp" header="h" />
<pair source="c" header="h" />
</extensions>
</Objective-C-extensions>
<codeStyleSettings language="ObjectiveC">
<indentOptions>
<option name="INDENT_SIZE" value="2" />
<option name="CONTINUATION_INDENT_SIZE" value="2" />
<option name="TAB_SIZE" value="2" />
</indentOptions>
</codeStyleSettings>
</value>
</option>
<option name="USE_PER_PROJECT_SETTINGS" value="true" />
</component>
</project>
================================================
FILE: CMakeLists.txt
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
###############################################################################
# Minimum CMake version and policies
###############################################################################
cmake_minimum_required(VERSION 2.8.12)
if (POLICY CMP0054)
# FIXME: This is horrible. With the old behaviour,
# quoted strings like "MSVC" in if() conditionals
# get implicitly dereferenced. The NEW behaviour
# doesn't do this but CMP0054 was only introduced
# in CMake 3.1 and we support lower versions as the
# minimum. We could set NEW here but it would be very
# confusing to use NEW for some builds and OLD for others
# which could lead to some subtle bugs. Instead when the
# minimum version is 3.1 change this policy to NEW and remove
# the hacks in place to work around it.
cmake_policy(SET CMP0054 OLD)
endif()
if (POLICY CMP0042)
# Enable `MACOSX_RPATH` by default.
cmake_policy(SET CMP0042 NEW)
endif()
if (POLICY CMP0037)
# Disallow reserved target names
cmake_policy(SET CMP0037 NEW)
endif()
# This overrides the default flags for the different CMAKE_BUILD_TYPEs
set(CMAKE_USER_MAKE_RULES_OVERRIDE_C
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/c_flags_override.cmake")
set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cxx_flags_override.cmake")
project(JFS CXX C)
###############################################################################
# Project version
###############################################################################
set(JFS_VERSION_MAJOR 0)
set(JFS_VERSION_MINOR 0)
set(JFS_VERSION_PATCH 0)
set(JFS_VERSION_TWEAK 0)
set(JFS_VERSION "${JFS_VERSION_MAJOR}.${JFS_VERSION_MINOR}.${JFS_VERSION_PATCH}.${JFS_VERSION_TWEAK}")
message(STATUS "JFS version ${JFS_VERSION}")
################################################################################
# Set various useful variables depending on CMake version
################################################################################
if (("${CMAKE_VERSION}" VERSION_EQUAL "3.2") OR ("${CMAKE_VERSION}" VERSION_GREATER "3.2"))
# In CMake >= 3.2 add_custom_command() supports a ``USES_TERMINAL`` argument
set(ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG "USES_TERMINAL")
else()
set(ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG "")
endif()
if (("${CMAKE_VERSION}" VERSION_EQUAL "3.4") OR ("${CMAKE_VERSION}" VERSION_GREATER "3.4"))
# In CMake >= 3.4 ExternalProject_Add_Step() supports a `USES_TERMINAL` argument
set(EXTERNAL_PROJECT_ADD_STEP_USES_TERMINAL_ARG "USES_TERMINAL" "1")
else()
set(EXTERNAL_PROJECT_ADD_STEP_USES_TERMINAL_ARG "")
endif()
################################################################################
# Sanity check - Disallow building in source.
################################################################################
if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
message(FATAL_ERROR "In source builds are not allowed. You should invoke "
"CMake from a different directory.")
endif()
################################################################################
# Build type
################################################################################
message(STATUS "CMake generator: ${CMAKE_GENERATOR}")
if (DEFINED CMAKE_CONFIGURATION_TYPES)
# Multi-configuration build (e.g. Xcode). Here
# CMAKE_BUILD_TYPE doesn't matter
message(STATUS "Available configurations: ${CMAKE_CONFIGURATION_TYPES}")
else()
# Single configuration generator (e.g. Unix Makefiles, Ninja)
set(available_build_types Debug Release RelWithDebInfo MinSizeRel)
if(NOT CMAKE_BUILD_TYPE)
message(STATUS "CMAKE_BUILD_TYPE is not set. Setting default")
message(STATUS "The available build types are: ${available_build_types}")
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE String
"Options are ${available_build_types}"
FORCE)
# Provide drop down menu options in cmake-gui
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${available_build_types})
endif()
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
# Check the selected build type is valid
list(FIND available_build_types "${CMAKE_BUILD_TYPE}" _build_type_index)
if ("${_build_type_index}" EQUAL "-1")
message(FATAL_ERROR "\"${CMAKE_BUILD_TYPE}\" is an invalid build type.\n"
"Use one of the following build types ${available_build_types}")
endif()
endif()
################################################################################
# Add our CMake module directory to the list of module search directories
################################################################################
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
################################################################################
# Compiler flags for JFS components
# Subsequent commands will append to these. These are used instead of
# directly modifying CMAKE_CXX_FLAGS so that other code can be easily built with
# different flags.
################################################################################
set(JFS_COMPONENT_EXTRA_INCLUDE_DIRS "")
set(JFS_COMPONENT_CXX_DEFINES "")
set(JFS_COMPONENT_CXX_FLAGS "")
set(JFS_SOLVER_LIBRARIES "")
set(JFS_COMPONENT_EXTRA_LIBRARIES "")
include("${CMAKE_SOURCE_DIR}/cmake/jfs_component_add_cxx_flag.cmake")
################################################################################
# JFS include directories
################################################################################
list(APPEND JFS_COMPONENT_EXTRA_INCLUDE_DIRS
"${CMAKE_BINARY_DIR}/include"
"${CMAKE_SOURCE_DIR}/include"
)
################################################################################
# Assertions
################################################################################
option(ENABLE_JFS_ASSERTS "Enable JFS assertions" ON)
if (ENABLE_JFS_ASSERTS)
message(STATUS "JFS assertions enabled")
# Assume that -DNDEBUG isn't set.
else()
message(STATUS "JFS assertions disabled")
list(APPEND JFS_COMPONENT_CXX_DEFINES "NDEBUG")
endif()
################################################################################
# Find LLVM
################################################################################
find_package(LLVM 6.0.0
CONFIG
)
set(NEEDED_LLVM_VARS
LLVM_PACKAGE_VERSION
LLVM_VERSION_MAJOR
LLVM_VERSION_MINOR
LLVM_VERSION_PATCH
LLVM_DEFINITIONS
LLVM_ENABLE_ASSERTIONS
LLVM_ENABLE_EH
LLVM_ENABLE_RTTI
LLVM_INCLUDE_DIRS
LLVM_LIBRARY_DIRS
LLVM_TOOLS_BINARY_DIR
)
foreach (vname ${NEEDED_LLVM_VARS})
message(STATUS "${vname}: \"${${vname}}\"")
if (NOT (DEFINED "${vname}"))
message(FATAL_ERROR "${vname} was not defined")
endif()
endforeach()
message(STATUS "LLVM_DIR: \"${LLVM_DIR}\"")
# Find Clang
# FIXME: This won't work if LLVM was built with a multi-configuration generator.
set(LLVM_CLANG_CXX_TOOL "${LLVM_TOOLS_BINARY_DIR}/clang++")
if (NOT EXISTS "${LLVM_CLANG_CXX_TOOL}")
message(FATAL_ERROR "Failed to find clang++ at \"${LLVM_CLANG_CXX_TOOL}\"")
else()
message(STATUS "Found clang++ at \"${LLVM_CLANG_CXX_TOOL}\"")
endif()
if (LLVM_ENABLE_ASSERTIONS)
# Certain LLVM debugging macros only work when LLVM was built with asserts
set(ENABLE_JFS_DEBUG 1) # for config.h
else()
unset(ENABLE_JFS_DEBUG) # for config.h
endif()
# LLVM_DEFINITIONS aren't lists. Instead they are space separated
string(REPLACE " " ";" LLVM_DEFINITIONS_AS_LIST "${LLVM_DEFINITIONS}")
list(APPEND JFS_COMPONENT_CXX_DEFINES ${LLVM_DEFINITIONS_AS_LIST})
# LLVM_INCLUDE_DIRS aren't lists. Instead they are space separated
string(REPLACE " " ";" LLVM_INCLUDE_DIRS_AS_LIST "${LLVM_INCLUDE_DIRS}")
list(APPEND JFS_COMPONENT_EXTRA_INCLUDE_DIRS ${LLVM_INCLUDE_DIRS_AS_LIST})
if (NOT LLVM_ENABLE_EH)
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"))
jfs_component_add_cxx_flag("-fno-exceptions" REQUIRED)
else()
message(FATAL_ERROR "${CMAKE_CXX_COMPILER_ID} not supported")
endif()
endif()
if (NOT LLVM_ENABLE_RTTI)
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"))
jfs_component_add_cxx_flag("-fno-rtti" REQUIRED)
else()
message(FATAL_ERROR "${CMAKE_CXX_COMPILER_ID} not supported")
endif()
endif()
include("${CMAKE_SOURCE_DIR}/cmake/jfs_get_llvm_components.cmake")
################################################################################
# Find Z3
################################################################################
# FIXME: Specify version. Need to upstream support for config setting version.
find_package(Z3 CONFIG)
set(NEEDED_Z3_VARS
Z3_VERSION_MAJOR
Z3_VERSION_MINOR
Z3_VERSION_PATCH
Z3_VERSION_TWEAK
Z3_VERSION_STRING
Z3_C_INCLUDE_DIRS
Z3_LIBRARIES
)
foreach (vname ${NEEDED_Z3_VARS})
message(STATUS "${vname}: \"${${vname}}\"")
if (NOT (DEFINED "${vname}"))
message(FATAL_ERROR "${vname} was not defined")
endif()
endforeach()
if ("${Z3_VERSION_STRING}" VERSION_LESS "4.6")
message(FATAL_ERROR "Need Z3 4.6 or newer")
endif()
list(APPEND JFS_COMPONENT_EXTRA_INCLUDE_DIRS ${Z3_C_INCLUDE_DIRS})
################################################################################
# C++ version
################################################################################
# FIXME: Use CMake's support for this
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"))
set(JFS_USE_CXX_FLAG "-std=c++11")
jfs_component_add_cxx_flag("${JFS_USE_CXX_FLAG}" REQUIRED)
else()
set(JFS_USE_CXX_FLAG "")
endif()
################################################################################
# Warnings
################################################################################
include("${CMAKE_SOURCE_DIR}/cmake/compiler_warnings.cmake")
################################################################################
# Report flags
################################################################################
message(STATUS "JFS_COMPONENT_CXX_DEFINES: \"${JFS_COMPONENT_CXX_DEFINES}\"")
message(STATUS "JFS_COMPONENT_EXTRA_INCLUDE_DIRS: \"${JFS_COMPONENT_EXTRA_INCLUDE_DIRS}\"")
message(STATUS "JFS_COMPONENT_CXX_FLAGS: \"${JFS_COMPONENT_CXX_FLAGS}\"")
message(STATUS "JFS_COMPONENT_EXTRA_LIBRARIES: \"${JFS_COMPONENT_EXTRA_LIBRARIES}\"")
################################################################################
# Report default CMake flags
################################################################################
# This is mainly for debugging.
message(STATUS "CMAKE_CXX_FLAGS: \"${CMAKE_CXX_FLAGS}\"")
message(STATUS "CMAKE_EXE_LINKER_FLAGS: \"${CMAKE_EXE_LINKER_FLAGS}\"")
message(STATUS "CMAKE_STATIC_LINKER_FLAGS: \"${CMAKE_STATIC_LINKER_FLAGS}\"")
message(STATUS "CMAKE_SHARED_LINKER_FLAGS: \"${CMAKE_SHARED_LINKER_FLAGS}\"")
if (DEFINED CMAKE_CONFIGURATION_TYPES)
# Multi configuration generator
string(TOUPPER "${available_build_types}" build_types_to_report)
else()
# Single configuration generator
string(TOUPPER "${CMAKE_BUILD_TYPE}" build_types_to_report)
endif()
foreach (_build_type ${build_types_to_report})
message(STATUS "CMAKE_CXX_FLAGS_${_build_type}: \"${CMAKE_CXX_FLAGS_${_build_type}}\"")
message(STATUS "CMAKE_EXE_LINKER_FLAGS_${_build_type}: \"${CMAKE_EXE_LINKER_FLAGS_${_build_type}}\"")
message(STATUS "CMAKE_SHARED_LINKER_FLAGS_${_build_type}: \"${CMAKE_SHARED_LINKER_FLAGS_${_build_type}}\"")
message(STATUS "CMAKE_STATIC_LINKER_FLAGS_${_build_type}: \"${CMAKE_STATIC_LINKER_FLAGS_${_build_type}}\"")
endforeach()
################################################################################
# Handle git hash and description
################################################################################
include(${CMAKE_SOURCE_DIR}/cmake/git_utils.cmake)
macro(disable_git_describe)
message(WARNING "Disabling INCLUDE_GIT_DESCRIBE")
set(INCLUDE_GIT_DESCRIBE OFF CACHE BOOL "Include git describe output in version output" FORCE)
endmacro()
macro(disable_git_hash)
message(WARNING "Disabling INCLUDE_GIT_HASH")
set(INCLUDE_GIT_HASH OFF CACHE BOOL "Include git hash in version output" FORCE)
unset(Z3GITHASH) # Used in configure_file()
endmacro()
option(INCLUDE_GIT_HASH "Include git hash in version output" ON)
option(INCLUDE_GIT_DESCRIBE "Include git describe output in version output" ON)
set(GIT_DIR "${CMAKE_SOURCE_DIR}/.git")
if (EXISTS "${GIT_DIR}")
# Try to make CMake configure depend on the current git HEAD so that
# a re-configure is triggered when the HEAD changes.
add_git_dir_dependency("${GIT_DIR}" ADD_GIT_DEP_SUCCESS)
if (ADD_GIT_DEP_SUCCESS)
if (INCLUDE_GIT_HASH)
get_git_head_hash("${GIT_DIR}" JFS_GIT_HASH)
if (NOT JFS_GIT_HASH)
message(WARNING "Failed to get Git hash")
disable_git_hash()
endif()
message(STATUS "Using Git hash in version output: ${JFS_GIT_HASH}")
else()
message(STATUS "Not using Git hash in version output")
unset(JFS_GIT_HASH) # Used in configure_file()
endif()
if (INCLUDE_GIT_DESCRIBE)
get_git_head_describe("${GIT_DIR}" JFS_GIT_DESCRIPTION)
if (NOT Z3_GIT_DESCRIPTION)
message(WARNING "Failed to get Git description")
disable_git_describe()
endif()
message(STATUS "Using Git description in version output: ${JFS_GIT_DESCRIPTION}")
else()
message(STATUS "Not including git descrption in version")
endif()
else()
message(WARNING "Failed to add git dependency.")
disable_git_describe()
disable_git_hash()
endif()
else()
message(STATUS "Failed to find git directory.")
disable_git_describe()
disable_git_hash()
endif()
################################################################################
# Generate configuration header files
################################################################################
set(AUTO_GEN_MSG "Automatically generated. DO NOT EDIT")
set(configuration_files "version.h" "depsVersion.h" "config.h")
foreach (configuration_file ${configuration_files})
configure_file(
"${CMAKE_SOURCE_DIR}/include/jfs/Config/${configuration_file}.in"
"${CMAKE_BINARY_DIR}/include/jfs/Config/${configuration_file}"
)
endforeach()
################################################################################
# Set default location for targets in the build directory
################################################################################
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
################################################################################
# Top level unit test target
################################################################################
# This is top level because there are multiple unit test suites to run
add_custom_target(unittests)
################################################################################
# Detect lit tool
################################################################################
# This can't belong in `tests/` because `runtime/` needs to run its own tests.
option(ENABLE_SYSTEM_TESTS "Enable system tests" ON)
option(ENABLE_UNIT_TESTS "Enable unit tests" ON)
if (ENABLE_SYSTEM_TESTS OR ENABLE_UNIT_TESTS)
# Find lit
set(LIT_TOOL_NAMES "llvm-lit" "lit")
find_program(
LIT_TOOL
NAMES ${LIT_TOOL_NAMES}
HINTS "${LLVM_TOOLS_BINARY_DIR}"
DOC "Path to lit tool"
)
set(LIT_ARGS
"-v;-s"
CACHE
STRING
"Lit arguments"
)
if ((NOT LIT_TOOL) OR (NOT EXISTS "${LIT_TOOL}"))
message(FATAL_ERROR "The lit tool is required for testing.")
else()
message(STATUS "Using lit: ${LIT_TOOL}")
endif()
endif()
################################################################################
# Utilities
################################################################################
set(GTEST_SRC_DIR "${CMAKE_SOURCE_DIR}/utils/googletest/googletest")
add_subdirectory(utils)
################################################################################
# Runtime
################################################################################
add_subdirectory(runtime)
# Sanity checks
if ("${JFS_LLVM_CLANG_CXX_TOOL}" STREQUAL "")
message(FATAL_ERROR "JFS_LLVM_CLANG_CXX_TOOL not set")
endif()
if (NOT (EXISTS "${JFS_LLVM_CLANG_CXX_TOOL}"))
message(FATAL_ERROR "JFS_LLVM_CLANG_CXX_TOOL (\"${JFS_LLVM_CLANG_CXX_TOOL}\") doest not exist")
endif()
message(STATUS "JFS_LLVM_CLANG_CXX_TOOL: ${JFS_LLVM_CLANG_CXX_TOOL}")
################################################################################
# Libraries
################################################################################
include("${CMAKE_SOURCE_DIR}/cmake/jfs_add_component.cmake")
add_subdirectory(lib)
################################################################################
# Tools
################################################################################
add_subdirectory(tools)
################################################################################
# Tests
################################################################################
add_subdirectory(tests)
================================================
FILE: LICENSE.txt
================================================
Copyright 2017 Daniel Liew
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# JFS
JFS (Just Fuzz it Solver) (originally JIT Fuzzing Solver) is an experimental
constraint solver designed to investigate using __coverage guided fuzzing__ as
an incomplete strategy for solving boolean, BitVector, and floating-point
constraints.
JFS supports constraints in the [SMT-LIBv2][1] constraint langauge in the
`QF_BV`, `QF_BVFP`, and `QF_FP` logics. JFS's primary purpose however is
solve floating-point constraints.
JFS is built on top of the following projects
* [LLVM](https://llvm.org/)
* [Clang](http://clang.llvm.org/)
* [Z3](https://github.com/Z3Prover/z3)
* [LibFuzzer](https://llvm.org/docs/LibFuzzer.html)
[1]: http://smtlib.cs.uiowa.edu/
## FSE 2019 paper
[A paper on JFS](https://srg.doc.ic.ac.uk/files/papers/jfs-esecfse-19.pdf) was presented and published at ESEC/FSE 2019.
Additional resources:
* [artifact](https://github.com/mc-imperial/jfs-fse-2019-artifact)
* [slides](https://docs.google.com/presentation/d/1wPxNJ3rXVqLRCm9jRMZTsL5sEW5aW9WZ583TPpb2Ffo/edit?usp=sharing)
The [Docker image](https://cloud.docker.com/u/delcypher/repository/docker/delcypher/jfs_build) with the tag `fse_2019`
## Using JFS Docker image
If you want to get started with JFS with minimal effort the easiest thing to do
is download the latest Docker image for JFS. Note this image may not be up-to-date
so you might not the latest changes.
To obtain the image run (replace `fse_2019` with the tag you wish to use).
```
docker pull delcypher/jfs_build:fse_2019
```
The simplest invocation is something like this which will show JFS's help output.
```
docker run --user 1000 --rm -t delcypher/jfs_build:fse_2019 /home/user/jfs/build/bin/jfs --help
```
To run JFS on a SMT-LIBv2 file that exists outside the container (`/path/to/simple.smt2` in this example) run this command below.
```
docker run --rm -t -v /path/to/simple.smt2:/tmp/simple.smt2 delcypher/jfs_build:fse_2019 /home/user/jfs/build/bin/jfs /tmp/simple.smt2
```
Note that the `docker run` command creates a new container and destroys it
afterwards which has notable overhead. For better performance consider running
JFS outside of a docker container or creating a single container and spawning a
shell inside it and then launch JFS from there.
## Building JFS
JFS has been tested on Linux and macOS.
Windows support would likely require a lot more work and is dependent on getting
LibFuzzer to work on Windows.
### Using Docker (the easy way)
The easiest way is just to use our Dockerfile. To do this simply run
```
scripts/Dockerfiles/build.sh
```
once the script completes you will have a Docker image on your system
named `jfs_build:ubuntu1604`. In this image you will find the JFS binaries
in the `/home/user/jfs/build/bin` directory.
## From source (the hard way)
JFS has the following build dependencies:
* LLVM/Clang/compiler-rt 6.0
* Z3 4.6.0
* CMake
* Ninja
Here are the steps to build JFS.
1. Build Z3 4.6.0. Note you must build this using Z3's CMake build system
and not its legacy build system because JFS's build system depends on files
emitted by Z3's CMake build system.
A convenience script is provided for this
```bash
export Z3_SRC_DIR=/home/user/z3/src
export Z3_BUILD_DIR=/home/user/z3/build
export Z3_BUILD_TYPE=Release
scripts/dist/build_z3.sh
```
Set the `Z3_SRC_DIR`, `Z3_BUILD_DIR` to paths to empty or non-existant
directories. The `Z3_BUILD_TYPE` can be set to `Release`, `RelWithDebInfo`,
or `Debug`.
2. Build or install LLVM, Clang, and compiler-rt 6.0
A convenience script is provided to build LLVM.
```bash
export LLVM_SRC_DIR=/home/user/llvm/src
export LLVM_BUILD_DIR=/home/user/llvm/src
export LLVM_BUILD_TYPE=Release
scripts/dist/build_llvm.sh
```
Set the `LLVM_SRC_DIR`, `LLVM_BUILD_DIR` to paths to empty or non-existant
directories. The `LLVM_BUILD_TYPE` can be set to `Release`, `RelWithDebInfo`,
or `Debug`.
3. Build JFS
A convenience script is provided to build JFS.
```bash
export JFS_SRC_DIR=/home/user/jfs/src
export JFS_BUILD_DIR=/home/user/jfs/build
export JFS_BUILD_TYPE=Release
scripts/dist/build_jfs.sh
```
`JFS_SRC_DIR` should be the absolute path to an already cloned copy of the JFS
repo. `JFS_BUILD_DIR` should be a path to an empty or non-existant directory.
The `JFS_BUILD_TYPE` can be set to `Release`, `RelWithDebInfo`, or `Debug`.
Note that `Z3_BUILD_DIR` and `LLVM_BUILD_DIR` must also be set.
4. Test JFS
```
cd ${JFS_BUILD_DIR}
ninja check
```
## FAQs
### Aren't there already a bunch of search based floating-point constraint solvers?
Yes. However as far as we're aware, JFS is the first to try to use an
"off the shelf" coverage guided fuzzer as a search strategy.
Here's a non-exhaustive list:
* [coral][2] is a constraint solver that
supports various search strategies over floating point constraints. It uses
its own constraint language which is only partially overlaps with `QF_FP`
constraints in the SMT-LIBv2 language. The [smt2coral][3] tool provides a way
to run coral on SMT-LIBv2 constraints.
* [XSat][4] transform constraints into a mathematical global optimization
problem. Unfortunately this tool is not open source.
* [goSAT][5] takes the ideas behind XSat but
uses different optimization libraries and uses LLVM's JIT to generate code.
We are currently in the process of performing an evaluation of JFS against
these solvers and we will report these results in the not to distant future.
[2]: http://pan.cin.ufpe.br/coral/index.html
[3]: https://github.com/delcypher/smt2coral
[4]: https://www.researchgate.net/publication/305252908_XSat_A_Fast_Floating-Point_Satisfiability_Solver
[5]: https://github.com/abenkhadra/gosat
### How does JFS work?
To see how JFS works let's walk through a small example.
1. Parse SMT-LIB constraints using Z3.
```
(declare-fun a () (_ FloatingPoint 11 53))
(declare-fun b () (_ FloatingPoint 11 53))
(define-fun a_b_rne () (_ FloatingPoint 11 53) (fp.div RNE a b))
(define-fun a_b_rtp () (_ FloatingPoint 11 53) (fp.div RTP a b))
(assert (not (fp.isNaN a)))
(assert (not (fp.isNaN b)))
(assert (not (fp.eq a_b_rne a_b_rtp)))
(assert (not (fp.isNaN a_b_rne)))
(assert (not (fp.isNaN a_b_rtp)))
(check-sat)
```
2. Perform some simplifications on the constraints (e.g. constant folding).
**NOTE: You can use the jfs-opt tool to experiment with these simplifications.**
3. Generate a C++ program where the reachability of an `abort()` statement is
equivalent to finding a satisfying assignment to the constraints.
**NOTE: You can use the `jfs-smt2cxx` tool to convert SMT-LIBv2 constraints
into a program.**
```c++
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (size < 16) {
return 0;
}
BufferRef<const uint8_t> jfs_buffer_ref =
BufferRef<const uint8_t>(data, size);
const Float<11, 53> a = makeFloatFrom<11, 53>(jfs_buffer_ref, 0, 63);
const Float<11, 53> b = makeFloatFrom<11, 53>(jfs_buffer_ref, 64, 127);
const bool jfs_ssa_0 = a.isNaN();
const bool jfs_ssa_1 = !(jfs_ssa_0);
if (jfs_ssa_1) {
} else {
return 0;
}
const bool jfs_ssa_2 = b.isNaN();
const bool jfs_ssa_3 = !(jfs_ssa_2);
if (jfs_ssa_3) {
} else {
return 0;
}
const Float<11, 53> jfs_ssa_4 = a.div(JFS_RM_RNE, b);
const Float<11, 53> jfs_ssa_5 = a.div(JFS_RM_RTP, b);
const bool jfs_ssa_6 = jfs_ssa_4.ieeeEquals(jfs_ssa_5);
const bool jfs_ssa_7 = !(jfs_ssa_6);
if (jfs_ssa_7) {
} else {
return 0;
}
const bool jfs_ssa_8 = jfs_ssa_4.isNaN();
const bool jfs_ssa_9 = !(jfs_ssa_8);
if (jfs_ssa_9) {
} else {
return 0;
}
const bool jfs_ssa_10 = jfs_ssa_5.isNaN();
const bool jfs_ssa_11 = !(jfs_ssa_10);
if (jfs_ssa_11) {
} else {
return 0;
}
// Fuzzing target
abort();
}
```
4. This program is then compiled by Clang with coverage instrumentation
and linked against LibFuzzer and a small runtime library. The runtime
library implements the `Float` and `BitVector` SMT-LIBv2 types.
5. A set of seeds are generated for the fuzzer.
6. The compiled binary is invoked with the given seeds.
If the fuzzer generates an input that reaches the `abort()` a satisfying
assignment has been found and JFS terminates reporting `sat`.
Note this strategy will never find a satisfying assignment if one does not exist
(i.e. the constraints are unsatisfiable). This is why we say JFS is "incomplete"
because it cannot show that unsatisfiable constraints are unsatisfiable.
There is one exception to this. JFS can show unsatisfiable constraints to be
unsatisfiable if its simplications show one or more constraints to be `false`
(i.e. trivially unsatisfiable).
================================================
FILE: cmake/add_jfs_unit_test.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
if (NOT DEFINED GTEST_SRC_DIR)
message(FATAL_ERROR "GTEST_SRC_DIR must be defined")
endif()
if (NOT EXISTS "${GTEST_SRC_DIR}")
message(FATAL_ERROR "GTEST_SRC_DIR (${GTEST_SRC_DIR}) must exist")
endif()
# This keeps track of all the unit test
# targets so we can ensure they are built
# before trying to run them.
define_property(GLOBAL
PROPERTY JFS_UNIT_TEST_TARGETS
BRIEF_DOCS "JFS unit tests"
FULL_DOCS "JFS unit tests"
)
set(GTEST_INCLUDE_DIR "${GTEST_SRC_DIR}/include")
if (NOT IS_DIRECTORY "${GTEST_INCLUDE_DIR}")
message(FATAL_ERROR
"Cannot find GTest include directory \"${GTEST_INCLUDE_DIR}\"")
endif()
set (UNIT_TEST_EXE_SUFFIX "Test")
function(add_jfs_unit_test target_name)
add_executable(${target_name}${UNIT_TEST_EXE_SUFFIX} ${ARGN})
target_link_libraries(${target_name}${UNIT_TEST_EXE_SUFFIX} PRIVATE jfs_gtest_main)
target_include_directories(${target_name}${UNIT_TEST_EXE_SUFFIX} BEFORE PRIVATE "${GTEST_INCLUDE_DIR}")
set_target_properties(${target_name}${UNIT_TEST_EXE_SUFFIX}
PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
)
set_property(GLOBAL
APPEND
PROPERTY JFS_UNIT_TEST_TARGETS
${target_name}${UNIT_TEST_EXE_SUFFIX}
)
endfunction()
================================================
FILE: cmake/c_flags_override.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
#
# This file overrides the default compiler flags for CMake's built-in
# configurations (CMAKE_BUILD_TYPE). Most compiler flags should not be set
# here. The main purpose is to make sure ``-DNDEBUG`` is never set by default.
#
#===------------------------------------------------------------------------===#
if (("${CMAKE_C_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU"))
# Taken from Modules/Compiler/GNU.cmake but -DNDEBUG is removed
set(CMAKE_C_FLAGS_INIT "")
set(CMAKE_C_FLAGS_DEBUG_INIT "-O0 -g")
set(CMAKE_C_FLAGS_MINSIZEREL_INIT "-Os")
set(CMAKE_C_FLAGS_RELEASE_INIT "-O3")
set(CMAKE_C_FLAGS_RELWITHDEBINFO_INIT "-O2 -g")
else()
message(FATAL_ERROR "Overrides not set for compiler ${CMAKE_C_COMPILER_ID}")
endif()
================================================
FILE: cmake/compiler_warnings.cmake
================================================
set(GCC_AND_CLANG_WARNINGS
"-Wall"
)
set(GCC_ONLY_WARNINGS "")
set(CLANG_ONLY_WARNINGS "")
set(MSVC_WARNINGS "/W3")
set(WARNING_FLAGS_TO_CHECK "")
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
list(APPEND WARNING_FLAGS_TO_CHECK ${GCC_AND_CLANG_WARNINGS})
list(APPEND WARNING_FLAGS_TO_CHECK ${GCC_ONLY_WARNINGS})
elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
list(APPEND WARNING_FLAGS_TO_CHECK ${GCC_AND_CLANG_WARNINGS})
list(APPEND WARNING_FLAGS_TO_CHECK ${CLANG_ONLY_WARNINGS})
# FIXME: Remove "x.." when CMP0054 is set to NEW
elseif ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
list(APPEND WARNING_FLAGS_TO_CHECK ${MSVC_WARNINGS})
# CMake's default flags include /W3 already so remove them if
# they already exist.
if ("${CMAKE_CXX_FLAGS}" MATCHES "/W3")
string(REPLACE "/W3" "" _cmake_cxx_flags_remove_w3 "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${_cmake_cxx_flags_remove_w3}" CACHE STRING "" FORCE)
endif()
else()
message(AUTHOR_WARNING "Unknown compiler")
endif()
# Loop through flags and use the ones which the compiler supports
foreach (flag ${WARNING_FLAGS_TO_CHECK})
jfs_component_add_cxx_flag("${flag}")
endforeach()
================================================
FILE: cmake/cxx_flags_override.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
#
# This file overrides the default compiler flags for CMake's built-in
# configurations (CMAKE_BUILD_TYPE). Most compiler flags should not be set
# here. The main purpose is to make sure ``-DNDEBUG`` is never set by default.
#
#===------------------------------------------------------------------------===#
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"))
# Taken from Modules/Compiler/GNU.cmake but -DNDEBUG is removed
set(CMAKE_CXX_FLAGS_INIT "")
set(CMAKE_CXX_FLAGS_DEBUG_INIT "-O0 -g")
set(CMAKE_CXX_FLAGS_MINSIZEREL_INIT "-Os")
set(CMAKE_CXX_FLAGS_RELEASE_INIT "-O3")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT "-O2 -g")
else()
message(FATAL_ERROR "Overrides not set for compiler ${CMAKE_CXX_COMPILER_ID}")
endif()
================================================
FILE: cmake/git_utils.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
# add_git_dir_dependency(GIT_DIR SUCCESS_VAR)
#
# Adds a configure time dependency on the git directory such that if the HEAD
# of the git directory changes CMake will be forced to re-run. This useful
# for fetching the current git hash and including it in the build.
#
# `GIT_DIR` is the path to the git directory (i.e. the `.git` directory)
# `SUCCESS_VAR` is the name of the variable to set. It will be set to TRUE
# if the dependency was successfully added and FALSE otherwise.
function(add_git_dir_dependency GIT_DIR SUCCESS_VAR)
if (NOT "${ARGC}" EQUAL 2)
message(FATAL_ERROR "Invalid number (${ARGC}) of arguments")
endif()
if (NOT IS_ABSOLUTE "${GIT_DIR}")
message(FATAL_ERROR "GIT_DIR (\"${GIT_DIR}\") is not an absolute path")
endif()
if (NOT IS_DIRECTORY "${GIT_DIR}")
message(FATAL_ERROR "GIT_DIR (\"${GIT_DIR}\") is not a directory")
endif()
set(GIT_HEAD_FILE "${GIT_DIR}/HEAD")
if (NOT EXISTS "${GIT_HEAD_FILE}")
message(AUTHOR_WARNING "Git head file \"${GIT_HEAD_FILE}\" cannot be found")
set(${SUCCESS_VAR} FALSE PARENT_SCOPE)
return()
endif()
# List of files in the git tree that CMake configuration should depend on
set(GIT_FILE_DEPS "${GIT_HEAD_FILE}")
# Examine the HEAD and workout what additional dependencies there are.
file(READ "${GIT_HEAD_FILE}" GIT_HEAD_DATA LIMIT 128)
string(STRIP "${GIT_HEAD_DATA}" GIT_HEAD_DATA_STRIPPED)
if ("${GIT_HEAD_DATA_STRIPPED}" MATCHES "^ref:[ ]*(.+)$")
# HEAD points at a reference.
set(GIT_REF "${CMAKE_MATCH_1}")
if (EXISTS "${GIT_DIR}/${GIT_REF}")
# Unpacked reference. The file contains the commit hash
# so add a dependency on this file so that if we stay on this
# reference (i.e. branch) but change commit CMake will be forced
# to reconfigure.
list(APPEND GIT_FILE_DEPS "${GIT_DIR}/${GIT_REF}")
elseif(EXISTS "${GIT_DIR}/packed-refs")
# The ref must be packed (see `man git-pack-refs`).
list(APPEND GIT_FILE_DEPS "${GIT_DIR}/packed-refs")
else()
# Fail
message(AUTHOR_WARNING "Unhandled git reference")
set(${SUCCESS_VAR} FALSE PARENT_SCOPE)
return()
endif()
else()
# Detached HEAD.
# No other dependencies needed
endif()
# FIXME:
# This is the directory we will copy (via `configure_file()`) git files
# into. This is a hack. It would be better to use the
# `CMAKE_CONFIGURE_DEPENDS` directory property but that feature is not
# available in CMake 2.8.12. So we use `configure_file()` to effectively
# do the same thing. When the source file to `configure_file()` changes
# it will trigger a re-run of CMake.
set(GIT_CMAKE_FILES_DIR "${CMAKE_CURRENT_BINARY_DIR}/git_cmake_files")
file(MAKE_DIRECTORY "${GIT_CMAKE_FILES_DIR}")
foreach (git_dependency ${GIT_FILE_DEPS})
message(STATUS "Adding git dependency \"${git_dependency}\"")
configure_file(
"${git_dependency}"
"${GIT_CMAKE_FILES_DIR}"
COPYONLY
)
endforeach()
set(${SUCCESS_VAR} TRUE PARENT_SCOPE)
endfunction()
# get_git_head_hash(GIT_DIR OUTPUT_VAR)
#
# Retrieve the current commit hash for a git working directory where `GIT_DIR`
# is the `.git` directory in the root of the git working directory.
#
# `OUTPUT_VAR` should be the name of the variable to put the result in. If this
# function fails then either a fatal error will be raised or `OUTPUT_VAR` will
# contain a string with the suffix `NOTFOUND` which can be used in CMake `if()`
# commands.
function(get_git_head_hash GIT_DIR OUTPUT_VAR)
if (NOT "${ARGC}" EQUAL 2)
message(FATAL_ERROR "Invalid number of arguments")
endif()
if (NOT IS_DIRECTORY "${GIT_DIR}")
message(FATAL_ERROR "\"${GIT_DIR}\" is not a directory")
endif()
if (NOT IS_ABSOLUTE "${GIT_DIR}")
message(FATAL_ERROR \""${GIT_DIR}\" is not an absolute path")
endif()
find_package(Git)
if (NOT Git_FOUND)
set(${OUTPUT_VAR} "GIT-NOTFOUND" PARENT_SCOPE)
return()
endif()
get_filename_component(GIT_WORKING_DIR "${GIT_DIR}" DIRECTORY)
execute_process(
COMMAND
"${GIT_EXECUTABLE}"
"rev-parse"
"-q" # Quiet
"HEAD"
WORKING_DIRECTORY
"${GIT_WORKING_DIR}"
RESULT_VARIABLE
GIT_EXIT_CODE
OUTPUT_VARIABLE
Z3_GIT_HASH
OUTPUT_STRIP_TRAILING_WHITESPACE
)
if (NOT "${GIT_EXIT_CODE}" EQUAL 0)
message(WARNING "Failed to execute git")
set(${OUTPUT_VAR} NOTFOUND PARENT_SCOPE)
return()
endif()
set(${OUTPUT_VAR} "${Z3_GIT_HASH}" PARENT_SCOPE)
endfunction()
# get_git_head_describe(GIT_DIR OUTPUT_VAR)
#
# Retrieve the output of `git describe` for a git working directory where
# `GIT_DIR` is the `.git` directory in the root of the git working directory.
#
# `OUTPUT_VAR` should be the name of the variable to put the result in. If this
# function fails then either a fatal error will be raised or `OUTPUT_VAR` will
# contain a string with the suffix `NOTFOUND` which can be used in CMake `if()`
# commands.
function(get_git_head_describe GIT_DIR OUTPUT_VAR)
if (NOT "${ARGC}" EQUAL 2)
message(FATAL_ERROR "Invalid number of arguments")
endif()
if (NOT IS_DIRECTORY "${GIT_DIR}")
message(FATAL_ERROR "\"${GIT_DIR}\" is not a directory")
endif()
if (NOT IS_ABSOLUTE "${GIT_DIR}")
message(FATAL_ERROR \""${GIT_DIR}\" is not an absolute path")
endif()
find_package(Git)
if (NOT Git_FOUND)
set(${OUTPUT_VAR} "GIT-NOTFOUND" PARENT_SCOPE)
return()
endif()
get_filename_component(GIT_WORKING_DIR "${GIT_DIR}" DIRECTORY)
execute_process(
COMMAND
"${GIT_EXECUTABLE}"
"describe"
"--long"
WORKING_DIRECTORY
"${GIT_WORKING_DIR}"
RESULT_VARIABLE
GIT_EXIT_CODE
OUTPUT_VARIABLE
Z3_GIT_DESCRIPTION
OUTPUT_STRIP_TRAILING_WHITESPACE
)
if (NOT "${GIT_EXIT_CODE}" EQUAL 0)
message(WARNING "Failed to execute git")
set(${OUTPUT_VAR} NOTFOUND PARENT_SCOPE)
return()
endif()
set(${OUTPUT_VAR} "${Z3_GIT_DESCRIPTION}" PARENT_SCOPE)
endfunction()
================================================
FILE: cmake/jfs_add_component.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
function(jfs_add_component target_name)
# Components are explicitly STATIC because we don't support building them
# as shared libraries.
add_library(${target_name} STATIC ${ARGN})
# Use of `PUBLIC` means these will propagate to targets that use this component.
if (("${CMAKE_VERSION}" VERSION_EQUAL "3.3") OR ("${CMAKE_VERSION}" VERSION_GREATER "3.3"))
# In newer CMakes we can make sure that the flags are only used when compiling C++
target_compile_options(${target_name} PUBLIC
$<$<COMPILE_LANGUAGE:CXX>:${JFS_COMPONENT_CXX_FLAGS}>)
else()
# For older CMakes just live with the warnings we get for passing C++ only flags
# to the C compiler.
target_compile_options(${target_name} PUBLIC ${JFS_COMPONENT_CXX_FLAGS})
endif()
target_include_directories(${target_name} PUBLIC ${JFS_COMPONENT_EXTRA_INCLUDE_DIRS})
target_compile_definitions(${target_name} PUBLIC ${JFS_COMPONENT_CXX_DEFINES})
target_link_libraries(${target_name} PUBLIC ${JFS_COMPONENT_EXTRA_LIBRARIES})
endfunction()
================================================
FILE: cmake/jfs_component_add_cxx_flag.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
include(CheckCXXCompilerFlag)
include(CMakeParseArguments)
function(jfs_component_add_cxx_flag flag)
CMAKE_PARSE_ARGUMENTS(jfs_component_add_cxx_flag "REQUIRED" "" "" ${ARGN})
string(REPLACE "-" "_" SANITIZED_FLAG_NAME "${flag}")
string(REPLACE "/" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
string(REPLACE "=" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
string(REPLACE " " "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
string(REPLACE "+" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
unset(HAS_${SANITIZED_FLAG_NAME})
CHECK_CXX_COMPILER_FLAG("${flag}" HAS_${SANITIZED_FLAG_NAME})
if (jfs_component_add_cxx_flag_REQUIRED AND NOT HAS_${SANITIZED_FLAG_NAME})
message(FATAL_ERROR "The flag \"${flag}\" is required but your C++ compiler doesn't support it")
endif()
if (HAS_${SANITIZED_FLAG_NAME})
message(STATUS "C++ compiler supports ${flag}")
list(APPEND JFS_COMPONENT_CXX_FLAGS "${flag}")
set(JFS_COMPONENT_CXX_FLAGS ${JFS_COMPONENT_CXX_FLAGS} PARENT_SCOPE)
else()
message(STATUS "C++ compiler does not support ${flag}")
endif()
endfunction()
================================================
FILE: cmake/jfs_external_project_utils.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
function(jfs_get_external_project_build_command OUTPUT_VAR BUILD_DIR)
if ("${CMAKE_GENERATOR}" STREQUAL "Unix Makefiles")
# HACK: This hack means that if the build generator for JFS
# is Make then `-j` value will passed through to make run
# to build the external project.
# See
# http://cmake.3232098.n2.nabble.com/How-would-I-use-parallel-make-on-ExternalProjects-td5609078.html
#
set(JFS_EXTERNAL_PROJECT_BUILD_COMMAND "BUILD_COMMAND" "$(MAKE)")
else()
include(ProcessorCount)
ProcessorCount(NUM_CPUS)
message(STATUS "Detected ${NUM_CPUS} CPUS. Will run this many jobs when building runtime tests")
set(JFS_EXTERNAL_PROJECT_BUILD_COMMAND
"BUILD_COMMAND" "${CMAKE_COMMAND}" "--build" "${BUILD_DIR}" "--" "-j${NUM_CPUS}")
endif()
set(${OUTPUT_VAR} ${JFS_EXTERNAL_PROJECT_BUILD_COMMAND} PARENT_SCOPE)
endfunction()
================================================
FILE: cmake/jfs_get_llvm_components.cmake
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
function(jfs_get_llvm_components DESTVAR)
if (${ARGC} LESS 2)
message(FATAL_ERROR "Insufficent number of argument")
endif()
llvm_map_components_to_libnames(llvm_components ${ARGN})
set(${DESTVAR} ${llvm_components} PARENT_SCOPE)
endfunction()
================================================
FILE: docs/tutorial/0-basics-example.smt2
================================================
(declare-fun a () (_ FloatingPoint 11 53))
(declare-fun b () (_ FloatingPoint 11 53))
(define-fun a_b_rne () (_ FloatingPoint 11 53) (fp.div RNE a b))
(define-fun a_b_rtp () (_ FloatingPoint 11 53) (fp.div RTP a b))
(assert (not (fp.isNaN a)))
(assert (not (fp.isNaN b)))
(assert (not (fp.eq a_b_rne a_b_rtp)))
(assert (not (fp.isNaN a_b_rne)))
(assert (not (fp.isNaN a_b_rtp)))
(check-sat)
================================================
FILE: docs/tutorial/0-basics.md
================================================
# JFS basics
This tutorial will walk you through the basics of using JFS.
JFS is designed to solve constraints in the [SMT-LIBv2.6 format](http://smtlib.cs.uiowa.edu/).
More specifically it is designed to solve constraints that
use any combination of Booleans, BitVectors, and floating-point
types.
Let's walk through running JFS on the constraints in the [0-basics-example.smt2](0-basics-example.smt2) file.
Try running the following. **NOTE the $ symbol indicates a shell
prompt and it should not be typed.**
```
$ jfs 0-basics-example.smt2
sat
```
We can see that the tool responded with `sat` meaning that JFS found
a satisfying assignment to the constraints in `0-basics-example.smt2`.
## Verbose output
How do we see what happened? We can use the `-v=1` to see more information. The `-v` sets the verbosity level.
```
$ jfs -v=1 -keep-output-dir 0-basics-example.smt2
(WorkingDirectoryManager "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2", deleteOnDestruction: 1)
pathToBinary: "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/bin/clang++"
pathToRuntimeIncludeDir: "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/include"
pathToLibFuzzerLib: "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/LibFuzzer_RelWithDebInfo/Fuzzer/libLLVMFuzzer.a"
optimizationLevel: O0
debug symbols:false
useASan: false
useUBSan: false
sanitizerCoverageOptions: TRACE_PC_GUARD
(Parser starting)
(Parser finished)
(QueryPassManager starting)
(QueryPassManager "AndHoisting")
(QueryPassManager "Simplification")
(QueryPassManager "AndHoisting")
(QueryPassManager "Simplification")
(QueryPassManager "ConstantPropagation")
(QueryPassManager "AndHoisting")
(QueryPassManager "Simplification")
(QueryPassManager "ConstantPropagation")
(QueryPassManager "Simplification")
(QueryPassManager "AndHoisting")
(QueryPassManager "DuplicateConstraintElimination")
(QueryPassManager "TrueConstraintElimination")
(QueryPassManager "SimpleContradictionsToFalse")
(QueryPassManager "DuplicateConstraintElimination")
(QueryPassManager finished)
(using solver "CXXFuzzingSolver")
(QueryPassManager starting)
(QueryPassManager "EqualityExtractionPass")
(QueryPassManager "FreeVariableToBufferAssignmentPass")
(QueryPassManager finished)
(QueryPassManager starting)
(QueryPassManager "SortConformanceCheckPass")
(QueryPassManager finished)
(QueryPassManager starting)
(QueryPassManager "CXXProgramBuilder")
(QueryPassManager finished)
(ClangInvocationManager
["/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/bin/clang++", "-std=c++11", "-I", "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/include", "-O0", "-fno-omit-frame-pointer", "-fsanitize-coverage=trace-pc-guard", "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/program.cpp", "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/SMTLIB/SMTLIB__DebugSymbols_Optimized_TracePCGuard/libJFSSMTLIBRuntime.a", "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/LibFuzzer_RelWithDebInfo/Fuzzer/libLLVMFuzzer.a", "-o", "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/fuzzer", ]
)
(SeedManager effectiveBound:18446744073709551615)
(SeedManager creating seed "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus/zeros_0")
(SeedManager creating seed "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus/ones_0")
(SeedManager active generators exhausted)
(SeedManager wrote 2 seeds (16 bytes each))
(LibFuzzerInvocationManager
["/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/fuzzer", "-runs=-1", "-seed=1", "-mutate_depth=5", "-cross_over=1", "-max_len=16", "-use_cmp=0", "-print_final_stats=1", "-reduce_inputs=0", "-default_mutators_resize_input=0", "-handle_abrt=1", "-handle_bus=0", "-handle_fpe=0", "-handle_ill=0", "-handle_int=1", "-handle_segv=0", "-handle_term=1", "-handle_xfsz=1", "-artifact_prefix=/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/artifacts/", "-error_exitcode=77", "-timeout_exitcode=88", "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus", ]
)
INFO: Seed: 1
INFO: HACK: Mutators that resize input DISABLED!
INFO: Loaded 1 modules (443 guards): 443 [0x677fd0, 0x6786bc),
INFO: 2 files found in /home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus
JFS WARNING: Wrong sized input tried.
INFO: seed corpus: files: 2 min: 16b max: 16b total: 32b rss: 33Mb
#3 INITED cov: 23 ft: 23 corp: 2/32b exec/s: 0 rss: 33Mb
#6 NEW cov: 24 ft: 26 corp: 3/48b exec/s: 0 rss: 33Mb L: 16/16 MS: 3 CopyPart-CopyPart-ChangeBinInt-
#9 NEW cov: 25 ft: 27 corp: 4/64b exec/s: 0 rss: 33Mb L: 16/16 MS: 3 CrossOver-CopyPart-CrossOver-
==24758== ERROR: libFuzzer: deadly signal
#0 0x42bcd3 in __sanitizer_print_stack_trace /home/user/dev/jfs/llvm6/src/projects/compiler-rt/lib/ubsan/ubsan_diag_standalone.cc:29
#1 0x43e811 in fuzzer::Fuzzer::CrashCallback() /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp:233:5
#2 0x43e7df in fuzzer::Fuzzer::StaticCrashSignalCallback() /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp:206:6
#3 0x151b23c44b8f (/usr/lib/libpthread.so.0+0x11b8f)
#4 0x151b23289efa in __GI_raise (/usr/lib/libc.so.6+0x34efa)
#5 0x151b2328b2c0 in __GI_abort (/usr/lib/libc.so.6+0x362c0)
#6 0x42e4a5 in LLVMFuzzerTestOneInput (/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/fuzzer+0x42e4a5)
#7 0x43fa13 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp:524:13
#8 0x43f2ab in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp:449:3
#9 0x44043d in fuzzer::Fuzzer::MutateAndTestOne() /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp:657:19
#10 0x440c75 in fuzzer::Fuzzer::Loop(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, fuzzer::fuzzer_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&) /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp:784:5
#11 0x437a6b in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerDriver.cpp:755:6
#12 0x4331a0 in main /home/user/dev/jfs/jfs/src/runtime/LibFuzzer/Fuzzer/FuzzerMain.cpp:20:10
#13 0x151b232769a6 in __libc_start_main (/usr/lib/libc.so.6+0x219a6)
#14 0x406af9 in _start (/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/fuzzer+0x406af9)
NOTE: libFuzzer has rudimentary signal handlers.
Combine libFuzzer with AddressSanitizer or similar for better crash reports.
SUMMARY: libFuzzer: deadly signal
MS: 1 CopyPart-; base unit: 1519e74668a11df04e90de531274a5929990d1fa
0x0,0xff,0xff,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0x0,
\x00\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\xff\xff\xff\x00
artifact_prefix='/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/artifacts/'; Test unit written to /home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/artifacts/crash-26f92ccb5076c2b6534271d13d4ac70dc5c26f2f
Base64: AP///////wAAAAAA////AA==
stat::number_of_executed_units: 25
stat::average_exec_per_sec: 0
stat::new_units_added: 2
stat::slowest_unit_time_sec: 0
stat::peak_rss_mb: 38
sat
```
The verbose output shows a lot of internal implementation details of JFS.
We'll now highlight some of the important information.
The line below informs us where JFS's temporary working directory will be
located (note this can be set by using the `-output-dir` option).
Note that `deleteOnDestruction` is set to 1 which means the temporary working
directory will be deleted when JFS exits. To prevent this use the `-keep-output-dir` command line option.
```
(WorkingDirectoryManager "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2", deleteOnDestruction: 1)
```
The following lines indicate that the SMT-LIB parser is running.
```
(Parser starting)
(Parser finished)
```
After parsing the next step is to run a set of simplification passes
on the constraints. We can see this in the `(QueryPassManager ...)` lines.
After this we see the line `(using solver "CXXFuzzingSolver")`. This informs
us that the CXXFuzzingSolver back-end is being used. Note this can be changed
on the command line. See `--help`, e.g. `-z3` causes Z3 to be used to solve the simplified constraints.
After this we see the `QueryPassManager` running again. This is running
some passes that are specific to the CXXFuzzingSolver backend. Notice that
a pass named `CXXProgramBuilder` is executed. This pass reads the constraints
and constructs a C++ program that encodes the constraints as a path
reachability problem.
After this we see the following.
```
(ClangInvocationManager
["/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/bin/clang++", "-std=c++11", "-I", "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/include", "-O0", "-fno-omit-frame-pointer", "-fsanitize-coverage=trace-pc-guard", "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/program.cpp", "/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/SMTLIB/SMTLIB__DebugSymbols_Optimized_TracePCGuard/libJFSSMTLIBRuntime.a",
"/home/user/dev/jfs/jfs/builds/upgrades/gcc_rel/runtime/LibFuzzer_RelWithDebInfo/Fuzzer/libLLVMFuzzer.a", "-o", "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/fuzzer", ]
)
```
This shows us how the Clang compiler is invoked to take the generated C++ programs and generate native code that is linked with [LibFuzzer](https://llvm.org/docs/LibFuzzer.html).
After this we then see the following.
```
(SeedManager effectiveBound:18446744073709551615)
(SeedManager creating seed "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus/zeros_0")
(SeedManager creating seed "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus/ones_0")
(SeedManager active generators exhausted)
(SeedManager wrote 2 seeds (16 bytes each))
```
This is informing us that JFS has created two seeds to fuzz the generated
programs and that each seed is 16 bytes.
After this we see then the following.
```
(LibFuzzerInvocationManager
["/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/fuzzer", "-runs=-1", "-seed=1", "-mutate_depth=5", "-cross_over=1", "-max_len=16", "-use_cmp=0", "-print_final_stats=1", "-reduce_inputs=0", "-default_mutators_resize_input=0", "-handle_abrt=1", "-handle_bus=0", "-handle_fpe=0", "-handle_ill=0", "-handle_int=1", "-handle_segv=0", "-handle_term=1", "-handle_xfsz=1", "-artifact_prefix=/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/artifacts/", "-error_exitcode=77", "-timeout_exitcode=88", "/home/user/dev/jfs/jfs/src/0-basics-example.smt2-2/corpus", ]
)
```
This shows us how the generated binary is invoked to run LibFuzzer.
The output that follows this is [LibFuzzer's output](https://llvm.org/docs/LibFuzzer.html#output). Here we can see that
LibFuzzer catches a deadly signal.
```
==24758== ERROR: libFuzzer: deadly signal
```
Due to the way the generated program is constructed, this indicates that
a satisfying assignment to constraints has been found.
## Working directory
We can run the example again but this time keeping the working directory and
giving it a fixed name.
```
$ jfs -keep-output-dir -output-dir=wd 0-basics-example.smt2
sat
$ cd wd
$ ls
artifacts clang.stderr.txt clang.stdout.txt corpus fuzzer libfuzzer.stderr.txt libfuzzer.stdout.txt program.cpp
```
* `artifacts/` - Contains the input that is a satisfying assignment (if any).
* `clang.stderr.txt` - Contains any standard error output from the Clang invocation.
* `clang.stdout.txt` - Contains any standard output from the Clang invocation.
* `corpus/` - Contains the fuzzing corpus (seeds + found inputs).
* `fuzzer` - Is the fuzzing binary that is executed by JFS
* `libfuzzer.stderr.txt` - Contains any standard output from running the `fuzzer` binary.
* `libfuzzer.stderr.txt` - Contains any standard error output from running the `fuzzer` binary.
* `program.cpp` - The generated C++ program that is compiled using Clang.
Note that the `*.stdout.txt` and `*.stderr.txt` files will not be created
if JFS is used in verbose mode because the output goes to JFS's standard output and standard error output respectively. This behaviour can be changed
by using the `-redirect-clang-output` and `-redirect-libfuzzer-output` options.
================================================
FILE: docs/tutorial/1-setting-resource-limits.md
================================================
# Setting JFS resource limits
TODO
================================================
FILE: docs/tutorial/2-compilation-options-and-runtimes.md
================================================
# Compilation options and runtimes
TODO
================================================
FILE: docs/tutorial/3-resumming-fuzzing.md
================================================
# Resumming fuzzing
TODO
================================================
FILE: docs/tutorial/4-getting-models.md
================================================
# Getting a model from JFS
TODO
================================================
FILE: docs/tutorial/5-jfs-smt2cxx.md
================================================
# The `jfs-smt2cxx` tool
TODO
================================================
FILE: docs/tutorial/6-jfs-opt.md
================================================
# The `jfs-opt` tool
TODO
================================================
FILE: include/jfs/CXXFuzzingBackend/CXXFuzzingSolver.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_FUZZING_SOLVER_H
#define JFS_CXX_FUZZING_BACKEND_FUZZING_SOLVER_H
#include "jfs/FuzzingCommon/FuzzingSolver.h"
namespace jfs {
namespace cxxfb {
class CXXFuzzingSolverImpl;
class CXXFuzzingSolverOptions;
// This solver emits a CXX program and fuzzes it to find a satisfying
// assignment.
class CXXFuzzingSolver : public jfs::fuzzingCommon::FuzzingSolver {
private:
std::unique_ptr<CXXFuzzingSolverImpl> impl;
protected:
std::unique_ptr<jfs::core::SolverResponse>
fuzz(jfs::core::Query& q, bool produceModel,
std::shared_ptr<jfs::fuzzingCommon::FuzzingAnalysisInfo> info) override;
public:
CXXFuzzingSolver(
std::unique_ptr<CXXFuzzingSolverOptions> options,
std::unique_ptr<jfs::fuzzingCommon::WorkingDirectoryManager> wdm,
jfs::core::JFSContext& ctx);
~CXXFuzzingSolver();
llvm::StringRef getName() const override;
void cancel() override;
};
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CXXFuzzingSolverOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_FUZZING_SOLVER_OPTIONS_H
#define JFS_CXX_FUZZING_BACKEND_FUZZING_SOLVER_OPTIONS_H
#include "jfs/CXXFuzzingBackend/CXXProgramBuilderOptions.h"
#include "jfs/CXXFuzzingBackend/ClangOptions.h"
#include "jfs/Core/SolverOptions.h"
#include "jfs/FuzzingCommon/FuzzingSolverOptions.h"
#include "jfs/FuzzingCommon/LibFuzzerOptions.h"
#include "jfs/FuzzingCommon/SeedManagerOptions.h"
#include <memory>
namespace jfs {
namespace cxxfb {
class CXXFuzzingSolver;
class CXXFuzzingSolverImpl;
class CXXFuzzingSolverOptions
: public jfs::fuzzingCommon::FuzzingSolverOptions {
private:
// Options
std::unique_ptr<ClangOptions> clangOpt;
std::unique_ptr<jfs::fuzzingCommon::LibFuzzerOptions> libFuzzerOpt;
std::unique_ptr<CXXProgramBuilderOptions> cxxProgramBuilderOpt;
std::unique_ptr<jfs::fuzzingCommon::SeedManagerOptions> seedManagerOpt;
public:
CXXFuzzingSolverOptions(
std::unique_ptr<
jfs::fuzzingCommon::FreeVariableToBufferAssignmentPassOptions>
fvtbapOptions,
std::unique_ptr<ClangOptions> clangOpt,
std::unique_ptr<jfs::fuzzingCommon::LibFuzzerOptions> libFuzzerOpt,
std::unique_ptr<CXXProgramBuilderOptions> cxxProgramBuilderOpt,
std::unique_ptr<jfs::fuzzingCommon::SeedManagerOptions> seedManagerOpt,
bool debugSaveModel);
static bool classof(const SolverOptions* so) {
return so->getKind() == CXX_FUZZING_SOLVER_KIND;
}
const ClangOptions* getClangOptions() const { return clangOpt.get(); }
// FIXME: This needs rethinking. This isn't const because the options
// need to be populated with internal implementation details before being
// used.
jfs::fuzzingCommon::LibFuzzerOptions* getLibFuzzerOptions() {
return libFuzzerOpt.get();
}
const CXXProgramBuilderOptions* getCXXProgramBuilderOptions() const {
return cxxProgramBuilderOpt.get();
}
friend class CXXFuzzingSolver;
friend class CXXFuzzingSolverImpl;
// public for convenience.
bool redirectClangOutput;
bool redirectLibFuzzerOutput;
};
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CXXProgram.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CXX_PROGRAM
#define JFS_CXX_FUZZING_BACKEND_CXX_PROGRAM
#include "llvm/Support/raw_ostream.h"
#include <list>
#include <memory>
#include <string>
#include <vector>
namespace jfs {
namespace cxxfb {
class CXXDecl;
class CXXCodeBlock;
class CXXType;
class CXXFunctionArgument;
class CXXFunctionDecl;
class CXXStatement;
using CXXDeclRef = std::shared_ptr<CXXDecl>;
using CXXCodeBlockRef = std::shared_ptr<CXXCodeBlock>;
using CXXTypeRef = std::shared_ptr<CXXType>;
using CXXFunctionArgumentRef = std::shared_ptr<CXXFunctionArgument>;
using CXXStatementRef = std::shared_ptr<CXXStatement>;
using CXXFunctionDeclRef = std::shared_ptr<CXXFunctionDecl>;
// Base class for all declarations
class CXXDecl {
protected:
// CXXDecl's form a tree with parents owning the children.
// Therefore we don't need to partcipate in ownership (like
// CXXDeclRef would) and raw pointers are fine.
CXXDecl* parent;
public:
CXXDecl(CXXDecl* parent);
virtual ~CXXDecl();
virtual void print(llvm::raw_ostream&) const = 0;
CXXDecl* getParent() const;
void dump() const;
};
// Include
class CXXIncludeDecl : public CXXDecl {
private:
std::string path;
bool isSystemInclude;
public:
CXXIncludeDecl(CXXDecl* parent, llvm::StringRef path, bool systemHeader);
~CXXIncludeDecl() {}
void print(llvm::raw_ostream&) const override;
const std::string& getPath() const { return path; }
};
// Statement (for use inside code blocks)
class CXXStatement : public CXXDecl {
public:
CXXStatement(CXXDecl* parent) : CXXDecl(parent) {}
~CXXStatement();
};
// Comment block
class CXXCommentBlock : public CXXStatement {
private:
std::string comment;
public:
CXXCommentBlock(CXXDecl* parent, llvm::StringRef comment)
: CXXStatement(parent), comment(comment) {}
void print(llvm::raw_ostream&) const override;
const std::string& getComment() const { return comment; }
};
class CXXCodeBlock;
class CXXType;
class CXXFunctionArgument;
// Function definition
class CXXFunctionDecl : public CXXDecl {
private:
std::string name;
CXXTypeRef returnTy;
std::vector<CXXFunctionArgumentRef> arguments;
bool hasCVisibility;
public:
// FIXME: shouldn't be public
CXXCodeBlockRef defn;
// Declaration
CXXFunctionDecl(CXXDecl* parent, llvm::StringRef name, CXXTypeRef returnTy,
std::vector<CXXFunctionArgumentRef>& arguments,
bool hasCVisibility);
// Definition
~CXXFunctionDecl();
void print(llvm::raw_ostream&) const override;
bool isDecl() const { return defn.get() == nullptr; }
bool isDefn() const { return !isDecl(); }
};
// CXXType
class CXXType : public CXXDecl {
private:
std::string name;
bool isConst;
public:
CXXType(CXXDecl* parent, llvm::StringRef name, bool isConst);
CXXType(CXXDecl* parent, llvm::StringRef name);
~CXXType();
void print(llvm::raw_ostream&) const override;
llvm::StringRef getName() const { return name; }
};
// CXXFunctionArgument
class CXXFunctionArgument : public CXXDecl {
private:
std::string name;
CXXTypeRef argType;
public:
CXXFunctionArgument(CXXDecl* parent, llvm::StringRef name,
CXXTypeRef argType);
~CXXFunctionArgument();
void print(llvm::raw_ostream&) const override;
};
// CXXCodeBlock
class CXXCodeBlock : public CXXDecl {
public:
// FIXME: shouldn't be public but its easier to just write to this
std::list<CXXStatementRef> statements;
CXXCodeBlock(CXXDecl* parent);
~CXXCodeBlock();
void print(llvm::raw_ostream&) const override;
};
// CXXIfStatement
class CXXIfStatement : public CXXStatement {
private:
std::string condition;
public:
CXXIfStatement(CXXCodeBlock* parent, llvm::StringRef condition);
void print(llvm::raw_ostream&) const override;
// FIXME: shouldn't be public
CXXCodeBlockRef trueBlock;
CXXCodeBlockRef falseBlock;
};
// CXXReturnIntStatement
class CXXReturnIntStatement : public CXXStatement {
private:
int returnValue;
public:
CXXReturnIntStatement(CXXCodeBlock* parent, int returnValue);
void print(llvm::raw_ostream&) const override;
};
// CXXDeclAndDefnVarStatement
class CXXDeclAndDefnVarStatement : public CXXStatement {
private:
CXXTypeRef ty;
std::string name;
std::string valueExpr;
public:
CXXDeclAndDefnVarStatement(CXXDecl* parent, CXXTypeRef ty,
llvm::StringRef name, llvm::StringRef valueExpr);
llvm::StringRef getName() const { return valueExpr; }
void print(llvm::raw_ostream&) const override;
};
// This is a hack
// CXXGenericStatement
class CXXGenericStatement : public CXXStatement {
private:
std::string statement;
public:
CXXGenericStatement(CXXDecl* parent, llvm::StringRef statement);
void print(llvm::raw_ostream&) const override;
};
class CXXProgram : public CXXDecl {
private:
typedef std::vector<CXXDeclRef> declStorageTy;
declStorageTy decls;
// FIXME: This should really be a set but we want the order that libraries
// are requested to be preserved.
typedef std::vector<std::string> libNameStoreageTy;
libNameStoreageTy requiredLibs;
bool recordsRuntimeStats;
public:
CXXProgram() : CXXDecl(nullptr), recordsRuntimeStats(false) {}
void print(llvm::raw_ostream&) const override;
void appendDecl(CXXDeclRef);
void addRequiredLibrary(llvm::StringRef name); // FIXME: Remove unused feature
bool
libraryIsRequired(llvm::StringRef name) const; // FIXME: Remove unused feature
bool getRecordsRuntimeStats() const { return recordsRuntimeStats; }
void setRecordsRuntimeStats(bool v) { recordsRuntimeStats = v; }
// Iterators
declStorageTy::const_iterator cbegin() const { return decls.cbegin(); }
declStorageTy::const_iterator cend() const { return decls.cend(); }
};
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CXXProgramBuilderOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CXX_PROGRAM_BUILDER_OPTIONS_H
#define JFS_CXX_FUZZING_BACKEND_CXX_PROGRAM_BUILDER_OPTIONS_H
#include <memory>
namespace jfs {
namespace cxxfb {
class CXXProgramBuilderOptions {
private:
bool recordMaxNumSatisifiedConstraints = false;
bool recordNumberOfInputs = false;
bool recordNumberOfWrongSizedInputs = false;
bool traceIncreaseMaxNumSatisfiedConstraints = false;
bool traceWrongSizedInputs = false;
public:
CXXProgramBuilderOptions();
bool getRecordMaxNumSatisfiedConstraints() const {
return recordMaxNumSatisifiedConstraints;
}
void setRecordMaxNumSatisfiedConstraints(bool v) {
recordMaxNumSatisifiedConstraints = v;
}
bool getRecordNumberOfInputs() const { return recordNumberOfInputs; }
void setRecordNumberOfInputs(bool v) { recordNumberOfInputs = v; }
bool getRecordNumberOfWrongSizedInputs() const {
return recordNumberOfWrongSizedInputs;
}
void setRecordNumberOfWrongSizedInputs(bool v) {
recordNumberOfWrongSizedInputs = v;
}
bool getTraceIncreaseMaxNumSatisfiedConstraints() const {
return traceIncreaseMaxNumSatisfiedConstraints;
}
void setTraceIncreaseMaxNumSatisfiedConstraints(bool v) {
traceIncreaseMaxNumSatisfiedConstraints = v;
}
bool getTraceWrongSizedInputs() const { return traceWrongSizedInputs; }
void setTraceWrongSizedInputs(bool v) { traceWrongSizedInputs = v; }
enum class BranchEncodingTy {
// Fail fast encoding
//
// If a constraint is found to be unsatisfiable fuzzing
// the current input is immediately halted without checking
// the remaining constraints.
//
// There are several problems with this encoding.
//
// * It is sensitive to the order constraints are checked.
// * Potentially prevents partially satisfying inputs from
// being observed which then prevents the input corpus
// from growing.
//
// In essence the encoding forces constraints to be solved
// in particular order.
FAIL_FAST,
// Try all encoding
//
// This is the "Serebryany encoding", named after
// Kostya Serebryany who proposed this.
//
// This encoding evaluates all constraints. This encoding
// addresses problems from the `TRY_ALL` encoding because
// this approach means that the order that constraints are
// checked do not matter.
//
// However it introduces a new problem in that in some cases
// inputs that increase the number of satisfied constraints
// are not added to the input corpus.
//
// For example. Let's say there are three constraints C0, C1, C2, C3.
// Let's say that Input A satisfies {C0, C1} and Input B satisfies {C2}. So
// Inputs A and B get added to the corpus. Then we try Input C which
// satisfies {C0, C1, C2}. This input will not be added to the input corpus
// because the branches for C0, C1, and C2 were already covered.
TRY_ALL,
// Try all IMNCSF
//
// IMNCSF - Increase in Maximum Number of Constraints Solved is a Feature
//
// This is the "Cadar encoding", named after Cristian Cadar
// who proposed this.
//
// This is an enhancement to the `TRY_ALL` encoding that addresses
// the issue where some inputs that increase the number of solved
// constraints
// might not be added to the corpus.
//
// This relies on an experimental LibFuzzer feature to treat an increase in
// the number of solved constraints as a "feature".
//
// At the time of writing this feature on works on Linux.
//
// FIXME: We should guard this so it is only available on Linux.
TRY_ALL_IMNCSF,
};
private:
BranchEncodingTy branchEncoding = BranchEncodingTy::FAIL_FAST;
public:
BranchEncodingTy getBranchEncoding() const { return branchEncoding; }
void setBranchEncoding(BranchEncodingTy ty) { branchEncoding = ty; }
};
} // namespace cxxfb
} // namespace jfs
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CXXProgramBuilderPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CXX_PROGRAM_BUILDER_PASS_H
#define JFS_CXX_FUZZING_BACKEND_CXX_PROGRAM_BUILDER_PASS_H
#include "jfs/Core/JFSContext.h"
#include "jfs/FuzzingCommon/FuzzingAnalysisInfo.h"
#include "jfs/Transform/QueryPass.h"
namespace jfs {
namespace cxxfb {
class CXXProgram;
class CXXProgramBuilderPassImpl;
class CXXProgramBuilderOptions;
class CXXProgramBuilderPass : public jfs::transform::QueryPass {
private:
std::unique_ptr<CXXProgramBuilderPassImpl> impl;
public:
CXXProgramBuilderPass(
std::shared_ptr<jfs::fuzzingCommon::FuzzingAnalysisInfo> info,
const CXXProgramBuilderOptions* options, jfs::core::JFSContext& ctx);
~CXXProgramBuilderPass();
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
// FIXME: Should be a const CXXProgram
std::shared_ptr<CXXProgram> getProgram();
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/ClangInvocationManager.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CLANG_INVOCATION_MANAGER_H
#define JFS_CXX_FUZZING_BACKEND_CLANG_INVOCATION_MANAGER_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Support/ICancellable.h"
#include <memory>
namespace jfs {
namespace cxxfb {
// Forward declarations
struct ClangOptions;
class ClangInvocationManagerImpl;
class CXXProgram;
class ClangInvocationManager : public jfs::support::ICancellable {
private:
std::unique_ptr<ClangInvocationManagerImpl> impl;
public:
ClangInvocationManager(jfs::core::JFSContext& ctx);
virtual ~ClangInvocationManager();
// Compile `program`. If `sourceFile` is non-empty the source file
// will be written to disk before being read by Clang. If `sourceFile`
// is empty the implementation is allowed to pipe the program directly
// to Clang.
bool compile(const CXXProgram* program, llvm::StringRef sourceFile,
llvm::StringRef outputFile, const ClangOptions* options,
llvm::StringRef stdOutFile, llvm::StringRef stdErrFile);
void cancel() override;
};
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/ClangOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CLANG_OPTIONS_H
#define JFS_CXX_FUZZING_BACKEND_CLANG_OPTIONS_H
#include "jfs/Core/JFSContext.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
#include <string>
#include <vector>
namespace jfs {
namespace cxxfb {
struct ClangOptions {
// Paths should be absolute
std::string pathToBinary;
std::string pathToRuntimeDir;
std::string pathToRuntimeIncludeDir;
std::string pathToLibFuzzerLib;
enum class OptimizationLevel { O0, O1, O2, O3 };
OptimizationLevel optimizationLevel;
bool debugSymbols;
bool useASan;
bool useUBSan;
bool useJFSRuntimeAsserts;
enum class SanitizerCoverageTy {
TRACE_PC_GUARD,
TRACE_CMP,
// TODO: Add more
};
std::vector<SanitizerCoverageTy> sanitizerCoverageOptions;
// FIXME: We should populate this enum from the CMake
// runtime declarations.
enum class LibFuzzerBuildType {
REL_WITH_DEB_INFO,
};
bool pureRandomFuzzer;
// If `pathToExecutable` is not empty then paths will be
// inferred assuming that `pathToExecutable` is the absolute
// path to the `jfs` binary.
ClangOptions(llvm::StringRef pathToExecutable, LibFuzzerBuildType lfbt,
bool pureRandomFuzzer);
ClangOptions(bool pureRandomFuzzer);
void appendSanitizerCoverageOption(SanitizerCoverageTy opt);
void dump() const;
void print(llvm::raw_ostream& os) const;
bool checkPaths(jfs::core::JFSContext& ctx) const;
};
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CmdLine/CXXProgramBuilderOptionsBuilder.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CMDLINE_CXX_PROGRAM_BUILDER_OPTIONS_BUILDER
#define JFS_CXX_FUZZING_BACKEND_CMDLINE_CXX_PROGRAM_BUILDER_OPTIONS_BUILDER
#include "jfs/CXXFuzzingBackend/CXXProgramBuilderOptions.h"
#include "jfs/Core/JFSContext.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
namespace jfs {
namespace cxxfb {
namespace cl {
std::unique_ptr<jfs::cxxfb::CXXProgramBuilderOptions>
buildCXXProgramBuilderOptionsFromCmdLine();
}
} // namespace cxxfb
} // namespace jfs
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CmdLine/ClangOptionsBuilder.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CMDLINE_CLANG_OPTIONS_BUILDER_H
#define JFS_CXX_FUZZING_BACKEND_CMDLINE_CLANG_OPTIONS_BUILDER_H
#include "jfs/CXXFuzzingBackend/ClangOptions.h"
#include "jfs/Core/JFSContext.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
namespace jfs {
namespace cxxfb {
namespace cl {
std::unique_ptr<jfs::cxxfb::ClangOptions>
buildClangOptionsFromCmdLine(llvm::StringRef pathToExecutable);
}
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/CmdLine/CommandLineCategory.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_CMDLINE_COMMAND_LINE_CATEGORY_H
#define JFS_CXX_FUZZING_BACKEND_CMDLINE_COMMAND_LINE_CATEGORY_H
#include "llvm/Support/CommandLine.h"
namespace jfs {
namespace cxxfb {
namespace cl {
extern llvm::cl::OptionCategory CommandLineCategory;
}
}
}
#endif
================================================
FILE: include/jfs/CXXFuzzingBackend/JFSCXXProgramStat.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CXX_FUZZING_BACKEND_JFS_CXX_PROGRAM_STAT_H
#define JFS_CXX_FUZZING_BACKEND_JFS_CXX_PROGRAM_STAT_H
#endif
#include "jfs/Support/JFSStat.h"
namespace jfs {
namespace cxxfb {
class JFSCXXProgramStat : public jfs::support::JFSStat {
public:
JFSCXXProgramStat(llvm::StringRef name);
virtual ~JFSCXXProgramStat();
void printYAML(llvm::ScopedPrinter& os) const override;
static bool classof(const JFSStat* s) { return s->getKind() == CXX_PROGRAM; }
// FIMXE: Should not be public
uint64_t numConstraints = 0;
uint64_t numEntryFuncStatements = 0;
// FIXME: Doesn't really belong here. The FuzzingAnalysisInfo should have its
// own stat
uint64_t numFreeVars = 0;
uint64_t bufferStoredWidth = 0;
uint64_t bufferTypeWidth = 0; // Sum of the type widths of each BufferElement
uint64_t numEqualitySets = 0;
};
}
}
================================================
FILE: include/jfs/Config/config.h.in
================================================
#ifndef JFS_CONFIG_CONFIG_H
#define JFS_CONFIG_CONFIG_H
// TODO
#endif
================================================
FILE: include/jfs/Config/depsVersion.h.in
================================================
#ifndef JFS_CONFIG_DEPS_VERSION_H
#define JFS_CONFIG_DEPS_VERSION_H
/* LLVM major version number */
#define LLVM_VERSION_MAJOR @LLVM_VERSION_MAJOR@
/* LLVM minor version number */
#define LLVM_VERSION_MINOR @LLVM_VERSION_MINOR@
/* Z3 major version number */
#define Z3_VERSION_MAJOR @Z3_VERSION_MAJOR@
/* Z3 minor version number */
#define Z3_VERSION_MINOR @Z3_VERSION_MINOR@
/* Useful macro to compile code depending on LLVM version */
#define LLVM_VERSION(major, minor) (((major) << 8) | (minor))
#define LLVM_VERSION_CODE LLVM_VERSION(LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR)
#endif
================================================
FILE: include/jfs/Config/version.h.in
================================================
#ifndef JFS_CONFIG_VERSION_H
#define JFS_CONFIG_VERSION_H
/* JFS major version number */
#define JFS_VERSION_MAJOR @JFS_VERSION_MAJOR@
/* JFS minor version number */
#define JFS_VERSION_MINOR @JFS_VERSION_MINOR@
/* JFS patch version number */
#define JFS_VERSION_PATCH @JFS_VERSION_PATCH@
/* JFS tweak version number */
#define JFS_VERSION_TWEAK @JFS_VERSION_TWEAK@
/* JFS git description */
#cmakedefine JFS_GIT_DESCRIPTION @JFS_GIT_DESCRIPTION@
/* JFS git hash */
#cmakedefine JFS_GIT_HASH @JFS_GIT_HASH@
#endif
================================================
FILE: include/jfs/Core/IfVerbose.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_IF_VERBOSE_H
#define JFS_CORE_IF_VERBOSE_H
#define IF_VERB_GT(CTX, VALUE, ACTION) \
do { \
if (CTX.getVerbosity() > VALUE) { \
ACTION; \
} \
} while (0)
#define IF_VERB(CTX, ACTION) IF_VERB_GT(CTX, 0, ACTION)
#endif
================================================
FILE: include/jfs/Core/JFSContext.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_JFSCONTEXT_H
#define JFS_CORE_JFSCONTEXT_H
#include "z3.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
namespace jfs {
namespace support {
class StatisticsManager;
}
}
namespace jfs {
namespace core {
struct JFSContextConfig {
unsigned verbosity = 0;
bool gathericStatistics = false;
uint64_t seed = 1;
};
class JFSContext;
class JFSContextErrorHandler {
public:
enum ErrorAction { STOP, CONTINUE };
virtual ErrorAction handleZ3error(JFSContext& ctx, Z3_error_code ec) = 0;
virtual ErrorAction handleFatalError(JFSContext& ctx,
llvm::StringRef msg) = 0;
virtual ErrorAction handleGenericError(JFSContext& ctx,
llvm::StringRef msg) = 0;
JFSContextErrorHandler();
virtual ~JFSContextErrorHandler();
};
class JFSContextImpl;
class RNG;
class JFSContext {
private:
const std::unique_ptr<JFSContextImpl> impl;
public:
JFSContext(const JFSContextConfig& ctxCfg);
~JFSContext();
// Don't allow copying
JFSContext(const JFSContext&) = delete;
JFSContext(const JFSContext&&) = delete;
JFSContext& operator=(const JFSContext&) = delete;
bool operator==(const JFSContext& other) const;
bool registerErrorHandler(JFSContextErrorHandler* h);
bool unRegisterErrorHandler(JFSContextErrorHandler* h);
Z3_context getZ3Ctx() const;
// TODO: Rethink this API.
unsigned getVerbosity() const;
// Message streams
llvm::raw_ostream& getErrorStream();
llvm::raw_ostream& getWarningStream();
llvm::raw_ostream& getDebugStream();
// FIXME: Should check compiler supports attribute
// Unlike Z3 errors it is guaranteed that execution will
// not leave this function.
__attribute__((noreturn)) void raiseFatalError(llvm::StringRef msg);
void raiseError(llvm::StringRef msg);
jfs::support::StatisticsManager* getStats() const;
const JFSContextConfig& getConfig() const;
RNG& getRNG() const;
};
}
}
#endif // JFS_JFSCONTEXT_H
================================================
FILE: include/jfs/Core/JFSTimerMacros.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_JFS_TIMER_MACROS_H
#define JFS_CORE_JFS_TIMER_MACROS_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Support/JFSStat.h"
#include "jfs/Support/ScopedJFSTimerStatAppender.h"
#include "jfs/Support/StatisticsManager.h"
#define JFS_SM_TIMER(NAME, CTX) \
jfs::support::ScopedJFSTimerStatAppender<jfs::support::StatisticsManager> \
NAME##_timer(((CTX).getConfig().gathericStatistics) ? (CTX.getStats()) \
: nullptr, \
#NAME)
#define JFS_AG_TIMER(DECL_NAME, NAME, AG, CTX) \
jfs::support::ScopedJFSTimerStatAppender< \
jfs::support::JFSAggregateTimerStat> \
DECL_NAME##_timer( \
((CTX).getConfig().gathericStatistics) ? (AG.stats.get()) : nullptr, \
(NAME))
#define JFS_AG_COL(NAME, CTX) \
jfs::support::ScopedJFSAggregateTimerStatAppender< \
jfs::support::StatisticsManager> \
NAME(((CTX).getConfig().gathericStatistics) ? (CTX.getStats()) \
: nullptr, \
#NAME)
#endif
================================================
FILE: include/jfs/Core/Model.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_MODEL_H
#define JFS_CORE_MODEL_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Z3Node.h"
#include <string>
namespace jfs {
namespace core {
struct ModelPrintOptions {
bool sortDecls = false;
bool useModelKeyword = false;
};
class Model {
protected:
jfs::core::Z3ModelHandle z3Model;
JFSContext& ctx;
Model(JFSContext& ctx);
public:
// The idea behind this interface is to allow implementations
// to defer working with Z3ModelHandle and only forcing use when
// `getRepr()` is called. At the time of writing no implementations
// actually do this so perhaps we should remove this complexity?
virtual Z3ASTHandle getAssignmentFor(Z3FuncDeclHandle);
virtual bool addAssignmentFor(Z3FuncDeclHandle decl, Z3ASTHandle e,
bool allowOverwrite = false);
virtual std::string getSMTLIBString(ModelPrintOptions* opts = nullptr);
virtual bool hasAssignmentFor(Z3FuncDeclHandle decl);
virtual Z3ModelHandle getRepr() { return z3Model; }
virtual bool replaceRepr(Z3ModelHandle replacement);
virtual Z3ASTHandle evaluate(Z3ASTHandle e, bool modelCompletion);
JFSContext& getContext();
virtual ~Model();
static Z3ASTHandle getDefaultValueFor(Z3SortHandle sort);
};
} // namespace core
} // namespace jfs
#endif
================================================
FILE: include/jfs/Core/ModelValidator.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Alastair Donaldson
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_MODEL_VALIDATOR_H
#define JFS_CORE_MODEL_VALIDATOR_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Model.h"
#include "jfs/Core/Query.h"
#include "jfs/Core/Z3Node.h"
#include <string>
namespace jfs {
namespace core {
class ValidationFailureInfo {
public:
enum ReasonTy {
NO_REASON,
EVALUATED_TO_FALSE,
EVALUATED_TO_NON_CONSTANT,
EVALUATED_TO_NON_BOOL_SORT,
};
ReasonTy reason;
uint64_t index;
Z3ASTHandle constraint;
Model* model;
// TODO: Add methods to allow further debugging.
// It would be useful to recursively walk the AST
// to find which assignments are responsible and
// which part of the subtree is causing the constraint
// to evaluate to false.
ValidationFailureInfo(ReasonTy reason, uint64_t index, Z3ASTHandle constraint,
Model* model);
ValidationFailureInfo();
static const char* reasonAsString(ReasonTy reason);
};
class ModelValidationOptions {
public:
bool warnOnVariablesMissingAssignment = true;
};
class ModelValidator {
public:
using VFIContainerTy = std::vector<ValidationFailureInfo>;
private:
VFIContainerTy failures;
public:
ModelValidator();
~ModelValidator();
VFIContainerTy::const_iterator cbegin() const { return failures.cbegin(); }
VFIContainerTy::const_iterator cend() const { return failures.cend(); }
VFIContainerTy::iterator begin() { return failures.begin(); }
VFIContainerTy::iterator end() { return failures.end(); }
uint64_t getNumberOfFailures() const { return failures.size(); }
void reset();
bool validate(const Query& q, Model* m,
const ModelValidationOptions* options = nullptr);
std::string toStr() const;
};
} // namespace core
} // namespace jfs
#endif
================================================
FILE: include/jfs/Core/Query.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_QUERY_H
#define JFS_CORE_QUERY_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeSet.h"
#include "llvm/Support/raw_ostream.h"
#include <vector>
namespace jfs {
namespace core {
class Query {
private:
JFSContext& ctx;
public:
std::vector<Z3ASTHandle> constraints;
Query(JFSContext& ctx);
~Query();
Query(const Query& other);
// In principle there's no reason we can't have these deleted methods.
// However we don't need them yet and I don't want the implicit declarations
// to accidently be called.
Query(const Query&&) = delete;
Query& operator=(const Query&) = delete;
Query& operator=(const Query&&) = delete;
void dump() const;
void collectFuncDecls(Z3FuncDeclSet& variables) const;
void print(llvm::raw_ostream& os) const;
JFSContext& getContext() const { return ctx; }
static bool areSame(std::vector<Z3ASTHandle>& a, std::vector<Z3ASTHandle>& b,
bool ignoreOrder = false);
};
// Operator overload for easy printing of queries
llvm::raw_ostream& operator<<(llvm::raw_ostream& os, const Query& q);
}
}
#endif
================================================
FILE: include/jfs/Core/RNG.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2018 J. Ryan Stinnett
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_RNG_H
#define JFS_CORE_RNG_H
#include <cstdint>
#include <random>
namespace jfs {
namespace core {
class RNG {
private:
std::mt19937_64 generator;
public:
RNG(uint64_t seed)
: generator(seed ? seed : std::mt19937_64::default_seed) {}
// Produce an integer in the range [0, limit).
uint64_t generate(uint64_t limit);
};
} // jfs
} // core
#endif // JFS_CORE_RNG_H
================================================
FILE: include/jfs/Core/SMTLIB2Parser.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_SMTLIB2PARSER_H
#define JFS_CORE_SMTLIB2PARSER_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Query.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
namespace llvm {
class MemoryBuffer;
}
namespace jfs {
namespace core {
class SMTLIB2Parser : public JFSContextErrorHandler {
public:
SMTLIB2Parser(JFSContext& ctx);
~SMTLIB2Parser();
std::shared_ptr<Query> parseFile(llvm::StringRef fileName);
std::shared_ptr<Query> parseStr(llvm::StringRef str);
std::shared_ptr<Query>
parseMemoryBuffer(std::unique_ptr<llvm::MemoryBuffer> buffer);
ErrorAction handleZ3error(JFSContext& ctx, Z3_error_code ec) override;
ErrorAction handleFatalError(JFSContext& ctx, llvm::StringRef msg) override;
ErrorAction handleGenericError(JFSContext& ctx, llvm::StringRef msg) override;
unsigned getErrorCount() const;
void resetErrorCount();
private:
JFSContext& ctx;
unsigned errorCount;
};
}
}
#endif
================================================
FILE: include/jfs/Core/ScopedJFSContextErrorHandler.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_SCOPED_JFS_CONTEXT_ERROR_HANDLER_H
#define JFS_CORE_SCOPED_JFS_CONTEXT_ERROR_HANDLER_H
#include "jfs/Core/JFSContext.h"
namespace jfs {
namespace core {
class ScopedJFSContextErrorHandler {
private:
JFSContext& ctx;
JFSContextErrorHandler* handler;
public:
ScopedJFSContextErrorHandler(JFSContext& ctx, JFSContextErrorHandler* h)
: ctx(ctx), handler(h) {
ctx.registerErrorHandler(handler);
}
~ScopedJFSContextErrorHandler() { ctx.unRegisterErrorHandler(handler); }
};
}
}
#endif
================================================
FILE: include/jfs/Core/SimpleModel.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Alastair Donaldson
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_SIMPLE_MODEL_H
#define JFS_CORE_SIMPLE_MODEL_H
#include "jfs/Core/Model.h"
namespace jfs {
namespace core {
// A model that on creation is empty
class SimpleModel : public Model {
public:
SimpleModel(JFSContext& ctx);
};
} // namespace core
} // namespace jfs
#endif
================================================
FILE: include/jfs/Core/Solver.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_SOLVER_H
#define JFS_CORE_SOLVER_H
#include "jfs/Core/Query.h"
#include "jfs/Core/SolverOptions.h"
#include "jfs/Support/ICancellable.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
#include <stdint.h>
namespace jfs {
namespace core {
class Model;
class SolverResponse {
public:
enum SolverSatisfiability { SAT, UNSAT, UNKNOWN };
SolverResponse(SolverSatisfiability sat);
virtual ~SolverResponse();
const SolverSatisfiability sat;
virtual Model* getModel() = 0;
static llvm::StringRef getSatString(SolverSatisfiability);
};
class Solver : public jfs::support::ICancellable {
protected:
std::unique_ptr<SolverOptions> options;
JFSContext& ctx;
public:
Solver(std::unique_ptr<SolverOptions> options, JFSContext& ctx);
virtual ~Solver();
Solver(const Solver&) = delete;
Solver(const Solver&&) = delete;
Solver& operator=(const Solver&) = delete;
// Determine the satisfiability of the query.
// Iff `produceModel` is false then only satisfiability will
// be available.
virtual std::unique_ptr<SolverResponse> solve(const Query& q,
bool produceModel) = 0;
const SolverOptions* getOptions() const;
virtual llvm::StringRef getName() const = 0;
JFSContext& getContext() { return ctx; }
};
}
}
#endif
================================================
FILE: include/jfs/Core/SolverOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_SOLVER_OPTIONS_H
#define JFS_CORE_SOLVER_OPTIONS_H
#include "llvm/Support/Casting.h"
#include <stdint.h>
namespace jfs {
namespace core {
class SolverOptions {
// START: LLVM RTTI boilerplate code
public:
// NOTE: When updating this enum make sure you update all implementations
// of `classof(const SolverOptions* so)`.
enum SolverOptionKind {
SOLVER_OPTIONS_KIND,
FUZZING_SOLVER_KIND,
CXX_FUZZING_SOLVER_KIND,
LAST_FUZZING_SOLVER_KIND // This is a dummy entry
};
private:
const SolverOptionKind kind;
protected:
SolverOptions(SolverOptionKind kind) : kind(kind) {}
public:
SolverOptions() : SolverOptions(SOLVER_OPTIONS_KIND) {}
virtual ~SolverOptions() {}
SolverOptionKind getKind() const { return kind; }
static bool classof(const SolverOptions* so) {
return so->getKind() == SOLVER_OPTIONS_KIND;
}
// END: LLVM RTTI boilerplate code
// Options common to all solvers
};
}
}
#endif
================================================
FILE: include/jfs/Core/ToolErrorHandler.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_TOOL_ERROR_HANDLER_H
#define JFS_CORE_TOOL_ERROR_HANDLER_H
#include "jfs/Core/JFSContext.h"
namespace jfs {
namespace core {
class ToolErrorHandler : public JFSContextErrorHandler {
private:
bool ignoreCanceled;
public:
ToolErrorHandler(bool ignoreCanceled) : ignoreCanceled(ignoreCanceled) {}
JFSContextErrorHandler::ErrorAction handleZ3error(JFSContext& ctx,
Z3_error_code ec) override;
ErrorAction handleFatalError(JFSContext& ctx, llvm::StringRef msg) override;
ErrorAction handleGenericError(JFSContext& ctx, llvm::StringRef msg) override;
};
}
}
#endif
================================================
FILE: include/jfs/Core/Z3ASTCmp.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_Z3_AST_CMP
#define JFS_CORE_Z3_AST_CMP
#include "jfs/Core/Z3Node.h"
#include <z3.h>
namespace jfs {
namespace core {
struct Z3ASTHashGet {
size_t operator()(const Z3ASTHandle& h) const {
return ::Z3_get_ast_hash(h.getContext(), h);
}
};
struct Z3ASTCmp {
bool operator()(const Z3ASTHandle& a, const Z3ASTHandle b) const {
assert(a.getContext() == b.getContext() && "Contexts must be equal");
return ::Z3_is_eq_ast(a.getContext(), a, b);
}
};
struct Z3SortHashGet {
size_t operator()(const Z3SortHandle& h) const {
return ::Z3_get_ast_hash(h.getContext(), h.asAST());
}
};
struct Z3SortCmp {
bool operator()(const Z3SortHandle& a, const Z3SortHandle b) const {
assert(a.getContext() == b.getContext() && "Contexts must be equal");
return ::Z3_is_eq_ast(a.getContext(), a.asAST(), b.asAST());
}
};
struct Z3FuncDeclHashGet {
size_t operator()(const Z3FuncDeclHandle& h) const {
return ::Z3_get_ast_hash(h.getContext(),
::Z3_func_decl_to_ast(h.getContext(), h));
}
};
struct Z3FuncDeclCmp {
bool operator()(const Z3FuncDeclHandle& a, const Z3FuncDeclHandle b) const {
assert(a.getContext() == b.getContext() && "Contexts must be equal");
return ::Z3_is_eq_ast(a.getContext(),
::Z3_func_decl_to_ast(a.getContext(), a),
::Z3_func_decl_to_ast(b.getContext(), b));
}
};
}
}
#endif
================================================
FILE: include/jfs/Core/Z3ASTVisitor.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_Z3_AST_VISITOR_H
#define JFS_CORE_Z3_AST_VISITOR_H
#include "jfs/Core/Z3Node.h"
namespace jfs {
namespace core {
// FIXME: This design only works for
// read only traversal. It needs rethinking
// for Z3AST modification and traversal order
class Z3ASTVisitor {
public:
Z3ASTVisitor();
virtual ~Z3ASTVisitor();
void visit(Z3ASTHandle e);
protected:
// TODO: Add more methods for different Z3 application kinds
// Uninterpreted function
virtual void visitUninterpretedFunc(Z3AppHandle e) = 0;
// Constants
virtual void visitBoolConstant(Z3AppHandle e) = 0;
virtual void visitBitVector(Z3AppHandle e) = 0;
virtual void visitFloatingPointConstant(Z3AppHandle e) = 0;
// Overloaded operations
virtual void visitEqual(Z3AppHandle e) = 0;
virtual void visitDistinct(Z3AppHandle e) = 0;
virtual void visitIfThenElse(Z3AppHandle e) = 0;
virtual void visitImplies(Z3AppHandle e) = 0;
// This isn't part of the core SMT-LIBv2 theory. Is this a Z3 extension?
virtual void visitIff(Z3AppHandle e) = 0;
// Boolean operations
virtual void visitAnd(Z3AppHandle e) = 0;
virtual void visitOr(Z3AppHandle e) = 0;
virtual void visitXor(Z3AppHandle e) = 0;
virtual void visitNot(Z3AppHandle e) = 0;
// Arithmetic BitVector operations
virtual void visitBvNeg(Z3AppHandle e) = 0;
virtual void visitBvAdd(Z3AppHandle e) = 0;
virtual void visitBvSub(Z3AppHandle e) = 0;
virtual void visitBvMul(Z3AppHandle e) = 0;
virtual void visitBvSDiv(Z3AppHandle e) = 0;
virtual void visitBvUDiv(Z3AppHandle e) = 0;
virtual void visitBvSRem(Z3AppHandle e) = 0;
virtual void visitBvURem(Z3AppHandle e) = 0;
virtual void visitBvSMod(Z3AppHandle e) = 0;
// Comparison BitVector operations
virtual void visitBvULE(Z3AppHandle e) = 0;
virtual void visitBvSLE(Z3AppHandle e) = 0;
virtual void visitBvUGE(Z3AppHandle e) = 0;
virtual void visitBvSGE(Z3AppHandle e) = 0;
virtual void visitBvULT(Z3AppHandle e) = 0;
virtual void visitBvSLT(Z3AppHandle e) = 0;
virtual void visitBvUGT(Z3AppHandle e) = 0;
virtual void visitBvSGT(Z3AppHandle e) = 0;
virtual void visitBvComp(Z3AppHandle e) = 0;
// Bitwise BitVector operations
virtual void visitBvAnd(Z3AppHandle e) = 0;
virtual void visitBvOr(Z3AppHandle e) = 0;
virtual void visitBvNot(Z3AppHandle e) = 0;
virtual void visitBvXor(Z3AppHandle e) = 0;
virtual void visitBvNand(Z3AppHandle e) = 0;
virtual void visitBvNor(Z3AppHandle e) = 0;
virtual void visitBvXnor(Z3AppHandle e) = 0;
// Shift and rotation BitVector operations
virtual void visitBvShl(Z3AppHandle e) = 0;
virtual void visitBvLShr(Z3AppHandle e) = 0;
virtual void visitBvAShr(Z3AppHandle e) = 0;
virtual void visitBvRotateLeft(Z3AppHandle e) = 0;
virtual void visitBvRotateRight(Z3AppHandle e) = 0;
// Sort changing BitVector operations
virtual void visitBvConcat(Z3AppHandle e) = 0;
virtual void visitBvSignExtend(Z3AppHandle e) = 0;
virtual void visitBvZeroExtend(Z3AppHandle e) = 0;
virtual void visitBvExtract(Z3AppHandle e) = 0;
// Floating point operations
virtual void visitFloatingPointFromTriple(Z3AppHandle e) = 0;
virtual void visitFloatingPointFromIEEEBitVector(Z3AppHandle e) = 0;
virtual void visitFloatIsNaN(Z3AppHandle e) = 0;
virtual void visitFloatIsNormal(Z3AppHandle e) = 0;
virtual void visitFloatIsSubnormal(Z3AppHandle e) = 0;
virtual void visitFloatIsZero(Z3AppHandle e) = 0;
virtual void visitFloatIsPositive(Z3AppHandle e) = 0;
virtual void visitFloatIsNegative(Z3AppHandle e) = 0;
virtual void visitFloatIsInfinite(Z3AppHandle e) = 0;
virtual void visitFloatIEEEEquals(Z3AppHandle e) = 0;
virtual void visitFloatLessThan(Z3AppHandle e) = 0;
virtual void visitFloatLessThanOrEqual(Z3AppHandle e) = 0;
virtual void visitFloatGreaterThan(Z3AppHandle e) = 0;
virtual void visitFloatGreaterThanOrEqual(Z3AppHandle e) = 0;
virtual void visitFloatPositiveZero(Z3AppHandle e) = 0;
virtual void visitFloatNegativeZero(Z3AppHandle e) = 0;
virtual void visitFloatPositiveInfinity(Z3AppHandle e) = 0;
virtual void visitFloatNegativeInfinity(Z3AppHandle e) = 0;
virtual void visitFloatNaN(Z3AppHandle e) = 0;
virtual void visitFloatAbs(Z3AppHandle e) = 0;
virtual void visitFloatNeg(Z3AppHandle e) = 0;
virtual void visitFloatMin(Z3AppHandle e) = 0;
virtual void visitFloatMax(Z3AppHandle e) = 0;
virtual void visitFloatAdd(Z3AppHandle e) = 0;
virtual void visitFloatSub(Z3AppHandle e) = 0;
virtual void visitFloatMul(Z3AppHandle e) = 0;
virtual void visitFloatDiv(Z3AppHandle e) = 0;
virtual void visitFloatFMA(Z3AppHandle e) = 0;
virtual void visitFloatSqrt(Z3AppHandle e) = 0;
virtual void visitFloatRem(Z3AppHandle e) = 0;
virtual void visitFloatRoundToIntegral(Z3AppHandle e) = 0;
virtual void visitConvertToFloatFromFloat(Z3AppHandle e) = 0;
virtual void visitConvertToFloatFromUnsignedBitVector(Z3AppHandle e) = 0;
virtual void visitConvertToFloatFromSignedBitVector(Z3AppHandle e) = 0;
virtual void visitConvertToUnsignedBitVectorFromFloat(Z3AppHandle e) = 0;
virtual void visitConvertToSignedBitVectorFromFloat(Z3AppHandle e) = 0;
};
}
}
#endif
================================================
FILE: include/jfs/Core/Z3Node.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_Z3NODE_H
#define JFS_CORE_Z3NODE_H
#include "z3.h"
#include <assert.h>
#include <string>
#include <vector>
namespace jfs {
namespace core {
template <typename T> class Z3NodeHandle {
// Internally these Z3 types are pointers
// so storing these should be cheap.
// It would be nice if we could infer the Z3_context from the node
// but I can't see a way to do this from Z3's API.
protected:
T node;
::Z3_context context;
private:
// To be specialised
inline void inc_ref(T node);
inline void dec_ref(T node);
public:
Z3NodeHandle() : node(NULL), context(NULL) {}
Z3NodeHandle(const T _node, const ::Z3_context _context)
: node(_node), context(_context) {
if (node && context) {
inc_ref(node);
}
};
~Z3NodeHandle() {
if (node && context) {
dec_ref(node);
}
}
Z3NodeHandle(const Z3NodeHandle& b) : node(b.node), context(b.context) {
if (node && context) {
inc_ref(node);
}
}
Z3NodeHandle& operator=(const Z3NodeHandle& b) {
if (node == NULL && context == NULL) {
// Special case for when this object was constructed
// using the default constructor. Try to inherit a non null
// context.
context = b.context;
}
assert(context == b.context && "Mismatched Z3 contexts!");
// node != nullptr ==> context != NULL
assert((node == NULL || context) &&
"Can't have non nullptr node with nullptr context");
if (node && context) {
dec_ref(node);
}
node = b.node;
if (node && context) {
inc_ref(node);
}
return *this;
}
// To be specialised
void dump() const;
std::string toStr() const;
operator T() const { return node; }
Z3_context getContext() const { return context; }
bool isNull() const { return node == nullptr; }
};
// Instantiate templates
// Specialise for Z3_sort
template <> inline void Z3NodeHandle<Z3_sort>::inc_ref(Z3_sort node) {
// In Z3 internally this call is just a cast. We could just do that
// instead to simplify our implementation but this seems cleaner.
::Z3_inc_ref(context, ::Z3_sort_to_ast(context, node));
}
template <> inline void Z3NodeHandle<Z3_sort>::dec_ref(Z3_sort node) {
// In Z3 internally this call is just a cast. We could just do that
// instead to simplify our implementation but this seems cleaner.
::Z3_dec_ref(context, ::Z3_sort_to_ast(context, node));
}
template <> void Z3NodeHandle<Z3_sort>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_sort>::toStr() const __attribute__((used));
class Z3ASTHandle;
class Z3SortHandle : public Z3NodeHandle<Z3_sort> {
public:
// Inherit constructors
using Z3NodeHandle<Z3_sort>::Z3NodeHandle;
// Helper methods
Z3_sort_kind getKind() const;
bool isBoolTy() const;
bool isBitVectorTy() const;
bool isFloatingPointTy() const;
// Return 0 if not bitvector, floating point, or bool
unsigned getWidth() const;
// Return 0 if not a bitvector
unsigned getBitVectorWidth() const;
// Return 0 if not floating point
unsigned getFloatingPointBitWidth() const;
unsigned getFloatingPointExponentBitWidth() const;
unsigned getFloatingPointSignificandBitWidth() const; // Includes implicit bit
Z3ASTHandle asAST() const;
static Z3SortHandle getBoolTy(Z3_context ctx);
static Z3SortHandle getBitVectorTy(Z3_context, unsigned bitWidth);
static Z3SortHandle getFloat32Ty(Z3_context ctx);
static Z3SortHandle getFloat64Ty(Z3_context ctx);
};
// Specialise for Z3_ast
template <> inline void Z3NodeHandle<Z3_ast>::inc_ref(Z3_ast node) {
::Z3_inc_ref(context, node);
}
template <> inline void Z3NodeHandle<Z3_ast>::dec_ref(Z3_ast node) {
::Z3_dec_ref(context, node);
}
template <> void Z3NodeHandle<Z3_ast>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_ast>::toStr() const __attribute__((used));
class Z3AppHandle;
class Z3FuncDeclHandle;
// Provide a class rather than a typedef so we can add
// additional helper methods.
class Z3ASTHandle : public Z3NodeHandle<Z3_ast> {
public:
// Inherit constructors
using Z3NodeHandle<Z3_ast>::Z3NodeHandle;
// Helper methods
Z3_ast_kind getKind() const;
bool isApp() const;
bool isFuncDecl() const;
bool isSort() const;
bool isNumeral() const;
bool isTrue() const;
bool isFalse() const;
bool isConstant() const;
// FIXME: Should be renamed isAppOfFreeVariable
bool isFreeVariable() const;
bool isAppOf(Z3_decl_kind) const;
bool isStructurallyEqualTo(Z3ASTHandle other) const;
Z3SortHandle getSort() const;
Z3AppHandle asApp() const;
Z3FuncDeclHandle asFuncDecl() const;
static Z3ASTHandle getTrue(Z3_context ctx);
static Z3ASTHandle getFalse(Z3_context ctx);
static Z3ASTHandle getBVZero(Z3_context, unsigned width);
static Z3ASTHandle getBVZero(Z3SortHandle sort);
static Z3ASTHandle getBV(Z3SortHandle sort, uint64_t value);
static Z3ASTHandle getFloatAbsoluteSmallestSubnormal(Z3SortHandle sort,
bool positive);
static Z3ASTHandle getFloatAbsoluteLargestSubnormal(Z3SortHandle sort,
bool positive);
static Z3ASTHandle getFloatAbsoluteSmallestNormal(Z3SortHandle sort,
bool positive);
static Z3ASTHandle getFloatAbsoluteLargestNormal(Z3SortHandle sort,
bool positive);
static Z3ASTHandle getFloatZero(Z3SortHandle sort, bool positive = true);
static Z3ASTHandle getFloatInfinity(Z3SortHandle sort, bool positive = true);
static Z3ASTHandle getFloatNAN(Z3SortHandle sort);
static Z3ASTHandle getFloatFromInt(Z3SortHandle sort, signed value);
};
// Specialise for Z3_app
template <> inline void Z3NodeHandle<Z3_app>::inc_ref(Z3_app node) {
::Z3_inc_ref(context, ::Z3_app_to_ast(context, node));
}
template <> inline void Z3NodeHandle<Z3_app>::dec_ref(Z3_app node) {
::Z3_dec_ref(context, ::Z3_app_to_ast(context, node));
}
template <> void Z3NodeHandle<Z3_app>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_app>::toStr() const __attribute__((used));
// FIXME: It's silly that Z3AppHandle does not inherit from Z3ASTHandle
// to reflect the hierarchy in Z3.
// Provide a class rather than a typedef so we can add
// additional helper methods.
class Z3AppHandle : public Z3NodeHandle<Z3_app> {
public:
// Inherit constructors
using Z3NodeHandle<Z3_app>::Z3NodeHandle;
// Helper methods
Z3FuncDeclHandle getFuncDecl() const;
Z3_decl_kind getKind() const;
unsigned getNumKids() const;
Z3ASTHandle getKid(unsigned) const;
bool isConstant() const;
// FIXME: Should be renamed isAppOfFreeVariable
bool isFreeVariable() const;
bool isSpecialFPConstant() const;
Z3ASTHandle asAST() const;
Z3SortHandle getSort() const;
bool getConstantAsUInt64(uint64_t* out) const;
};
// Specialise for Z3_func_decl
template <> inline void Z3NodeHandle<Z3_func_decl>::inc_ref(Z3_func_decl node) {
::Z3_inc_ref(context, ::Z3_func_decl_to_ast(context, node));
}
template <> inline void Z3NodeHandle<Z3_func_decl>::dec_ref(Z3_func_decl node) {
::Z3_dec_ref(context, ::Z3_func_decl_to_ast(context, node));
}
template <> void Z3NodeHandle<Z3_func_decl>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_func_decl>::toStr() const __attribute__((used));
// FIXME: It's silly that Z3FuncDeclHandle does not inherit from Z3ASTHandle
// to reflect the hierarchy in Z3.
// Provide a class rather than a typedef so we can add
// additional helper methods.
class Z3FuncDeclHandle : public Z3NodeHandle<Z3_func_decl> {
// Inherit constructors
public:
using Z3NodeHandle<Z3_func_decl>::Z3NodeHandle;
Z3_decl_kind getKind() const;
Z3SortHandle getSort() const;
std::string getName() const;
Z3ASTHandle asAST() const;
// Parameters
unsigned getNumParams() const;
Z3_parameter_kind getParamKind(unsigned index) const;
int getIntParam(unsigned index) const;
};
// Specialise for Z3_solver
template <> inline void Z3NodeHandle<Z3_solver>::inc_ref(Z3_solver node) {
::Z3_solver_inc_ref(context, node);
}
template <> inline void Z3NodeHandle<Z3_solver>::dec_ref(Z3_solver node) {
::Z3_solver_dec_ref(context, node);
}
typedef Z3NodeHandle<Z3_solver> Z3SolverHandle;
template <> void Z3NodeHandle<Z3_solver>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_solver>::toStr() const __attribute__((used));
// Specialise for Z3_params
template <> inline void Z3NodeHandle<Z3_params>::inc_ref(Z3_params node) {
::Z3_params_inc_ref(context, node);
}
template <> inline void Z3NodeHandle<Z3_params>::dec_ref(Z3_params node) {
::Z3_params_dec_ref(context, node);
}
typedef Z3NodeHandle<Z3_params> Z3ParamsHandle;
template <> void Z3NodeHandle<Z3_params>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_params>::toStr() const __attribute__((used));
// Specialise for Z3_model
template <> inline void Z3NodeHandle<Z3_model>::inc_ref(Z3_model node) {
::Z3_model_inc_ref(context, node);
}
template <> inline void Z3NodeHandle<Z3_model>::dec_ref(Z3_model node) {
::Z3_model_dec_ref(context, node);
}
template <> void Z3NodeHandle<Z3_model>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_model>::toStr() const __attribute__((used));
class Z3ModelHandle : public Z3NodeHandle<Z3_model> {
// Inherit constructors
public:
using Z3NodeHandle<Z3_model>::Z3NodeHandle;
Z3ASTHandle getAssignmentFor(Z3FuncDeclHandle);
bool hasAssignmentFor(Z3FuncDeclHandle d) const;
bool addAssignmentFor(Z3FuncDeclHandle decl, Z3ASTHandle e,
bool allowOverwrite = false);
uint64_t getNumAssignments() const;
Z3FuncDeclHandle getVariableDeclForIndex(uint64_t index);
Z3ASTHandle evaluate(Z3ASTHandle e, bool modelCompletion);
bool isEmpty() const;
};
// Specialise for Z3_goal
template <> inline void Z3NodeHandle<Z3_goal>::inc_ref(Z3_goal node) {
::Z3_goal_inc_ref(context, node);
}
template <> inline void Z3NodeHandle<Z3_goal>::dec_ref(Z3_goal node) {
::Z3_goal_dec_ref(context, node);
}
template <> void Z3NodeHandle<Z3_goal>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_goal>::toStr() const __attribute__((used));
class Z3GoalHandle : public Z3NodeHandle<Z3_goal> {
// Inherit constructors
public:
using Z3NodeHandle<Z3_goal>::Z3NodeHandle;
void addFormula(Z3ASTHandle);
unsigned getNumFormulas() const;
Z3ASTHandle getFormula(unsigned index) const;
};
class Z3ApplyResultHandle;
// Specialise for Z3_tactic
template <> inline void Z3NodeHandle<Z3_tactic>::inc_ref(Z3_tactic node) {
::Z3_tactic_inc_ref(context, node);
}
template <> inline void Z3NodeHandle<Z3_tactic>::dec_ref(Z3_tactic node) {
::Z3_tactic_dec_ref(context, node);
}
template <> void Z3NodeHandle<Z3_tactic>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_tactic>::toStr() const __attribute__((used));
class Z3TacticHandle : public Z3NodeHandle<Z3_tactic> {
// Inherit constructors
public:
using Z3NodeHandle<Z3_tactic>::Z3NodeHandle;
Z3ApplyResultHandle apply(Z3GoalHandle goal);
Z3ApplyResultHandle applyWithParams(Z3GoalHandle goal, Z3ParamsHandle params);
};
// Specialise for Z3_apply_result
template <>
inline void Z3NodeHandle<Z3_apply_result>::inc_ref(Z3_apply_result node) {
::Z3_apply_result_inc_ref(context, node);
}
template <>
inline void Z3NodeHandle<Z3_apply_result>::dec_ref(Z3_apply_result node) {
::Z3_apply_result_dec_ref(context, node);
}
template <>
void Z3NodeHandle<Z3_apply_result>::dump() const __attribute__((used));
template <>
std::string Z3NodeHandle<Z3_apply_result>::toStr() const __attribute__((used));
class Z3ApplyResultHandle : public Z3NodeHandle<Z3_apply_result> {
// Inherit constructors
public:
using Z3NodeHandle<Z3_apply_result>::Z3NodeHandle;
unsigned getNumGoals() const;
Z3GoalHandle getGoal(unsigned index) const;
void collectAllFormulas(std::vector<Z3ASTHandle>&) const;
Z3ModelHandle convertModelForGoal(unsigned index, Z3ModelHandle toConvert);
};
}
}
#endif
================================================
FILE: include/jfs/Core/Z3NodeMap.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_Z3_NODE_MAP_H
#define JFS_CORE_Z3_NODE_MAP_H
#include "jfs/Core/Z3ASTCmp.h"
#include <unordered_map>
namespace jfs {
namespace core {
template <typename T>
using Z3ASTMap = std::unordered_map<Z3ASTHandle, T, Z3ASTHashGet, Z3ASTCmp>;
template <typename T>
using Z3SortMap = std::unordered_map<Z3SortHandle, T, Z3SortHashGet, Z3SortCmp>;
template <typename T>
using Z3FuncDeclMap =
std::unordered_map<Z3FuncDeclHandle, T, Z3FuncDeclHashGet, Z3FuncDeclCmp>;
}
}
#endif
================================================
FILE: include/jfs/Core/Z3NodeSet.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_Z3_AST_SET_H
#define JFS_CORE_Z3_AST_SET_H
#include "jfs/Core/Z3ASTCmp.h"
#include "jfs/Core/Z3Node.h"
#include <assert.h>
#include <unordered_set>
namespace jfs {
namespace core {
// We don't provide a templated Z3NodeSet because not all Z3Node's are ASTs.
// For now doing these aliases is simpler.
using Z3ASTSet = std::unordered_set<Z3ASTHandle, Z3ASTHashGet, Z3ASTCmp>;
using Z3FuncDeclSet =
std::unordered_set<Z3FuncDeclHandle, Z3FuncDeclHashGet, Z3FuncDeclCmp>;
using Z3SortSet = std::unordered_set<Z3SortHandle, Z3SortHashGet, Z3SortCmp>;
}
}
#endif
================================================
FILE: include/jfs/Core/Z3NodeUtil.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Alastair Donaldson
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_CORE_Z3NODE_UTIL_H
#define JFS_CORE_Z3NODE_UTIL_H
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeSet.h"
#include <list>
namespace jfs {
namespace core {
class Z3NodeUtil {
public:
static void collectFuncDecls(Z3FuncDeclSet& addTo,
std::list<Z3ASTHandle>& workList);
static void collectFuncDecls(Z3FuncDeclSet& addTo, Z3ASTHandle e);
template <typename IteratorTy>
static void collectFuncDecls(Z3FuncDeclSet& addTo, IteratorTy begin,
IteratorTy end) {
std::list<Z3ASTHandle> workList;
for (IteratorTy b = begin, e = end; b != e; ++b) {
workList.push_back(*b);
}
collectFuncDecls(addTo, workList);
}
};
} // namespace core
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/BufferAssignment.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_BUFFER_ASSIGNMENT
#define JFS_FUZZING_COMMON_BUFFER_ASSIGNMENT
#include "jfs/Core/Query.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeMap.h"
#include "jfs/Core/Z3NodeSet.h"
#include "jfs/FuzzingCommon/BufferElement.h"
#include <vector>
namespace jfs {
namespace fuzzingCommon {
class BufferAssignment {
private:
typedef std::vector<BufferElement> ChunksTy;
ChunksTy chunks;
uint64_t cachedTypeBitWidth;
uint64_t cachedStoreBitWidth;
uint64_t computeTypeBitWidth() const;
uint64_t computeStoreBitWidth() const;
public:
BufferAssignment() : cachedTypeBitWidth(0), cachedStoreBitWidth(0) {}
~BufferAssignment() {}
void appendElement(BufferElement&);
uint64_t getTypeBitWidth() const { return cachedTypeBitWidth; }
uint64_t getStoreBitWidth() const { return cachedStoreBitWidth; }
uint64_t getRequiredStoreBytes() const {
return (getStoreBitWidth() + 7) / 8;
}
ChunksTy::const_iterator cbegin() const { return chunks.begin(); }
ChunksTy::const_iterator cend() const { return chunks.end(); }
ChunksTy::const_iterator begin() const { return cbegin(); }
ChunksTy::const_iterator end() const { return cend(); }
size_t size() const { return chunks.size(); }
void print(llvm::raw_ostream&) const;
void dump() const;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/BufferElement.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_BUFFER_ELEMENT
#define JFS_FUZZING_COMMON_BUFFER_ELEMENT
#include "jfs/Core/Query.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeMap.h"
#include "jfs/Core/Z3NodeSet.h"
#include <vector>
namespace jfs {
namespace fuzzingCommon {
class BufferElement {
private:
size_t storeBitAlignment;
public:
const jfs::core::Z3ASTHandle declApp;
BufferElement(const jfs::core::Z3ASTHandle declApp,
size_t storeBitAlignment = 1);
unsigned getTypeBitWidth() const; // Does not include padding
unsigned getStoreBitWidth() const; // Includes any required padding
size_t getStoreBitAlignment() const { return storeBitAlignment; }
// FIXME: put this behind an interface once we know the requirements
std::vector<jfs::core::Z3ASTHandle> equalities;
void print(llvm::raw_ostream&) const;
void dump() const;
jfs::core::Z3FuncDeclHandle getDecl() const;
std::string getName() const;
jfs::core::Z3SortHandle getSort() const;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/CmdLine/FreeVariableToBufferAssignmentPassOptionsBuilder.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_CMDLINE_FVTBAPOB_H
#define JFS_FUZZING_COMMON_CMDLINE_FVTBAPOB_H
#include "jfs/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
namespace cl {
std::unique_ptr<jfs::fuzzingCommon::FreeVariableToBufferAssignmentPassOptions>
buildFVTBAPOptionsFromCmdLine();
}
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/CmdLine/LibFuzzerOptionsBuilder.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_CMDLINE_LIBFUZZER_OPTIONS_BUILDER_H
#define JFS_FUZZING_COMMON_CMDLINE_LIBFUZZER_OPTIONS_BUILDER_H
#include "jfs/FuzzingCommon/LibFuzzerOptions.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
namespace cl {
std::unique_ptr<jfs::fuzzingCommon::LibFuzzerOptions>
buildLibFuzzerOptionsFromCmdLine();
}
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/CmdLine/SeedManagerOptionsBuilder.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_CMDLINE_SEED_MANAGER_OPTIONS_BUILDER_H
#define JFS_FUZZING_COMMON_CMDLINE_SEED_MANAGER_OPTIONS_BUILDER_H
#include "jfs/FuzzingCommon/SeedManager.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
namespace cl {
std::unique_ptr<jfs::fuzzingCommon::SeedManagerOptions>
buildSeedManagerOptionsFromCmdLine();
}
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/CommandLineCategory.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_COMMAND_LINE_CATEGORY_H
#define JFS_FUZZING_COMMON_COMMAND_LINE_CATEGORY_H
#include "llvm/Support/CommandLine.h"
namespace jfs {
namespace fuzzingCommon {
extern llvm::cl::OptionCategory CommandLineCategory;
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/DummyFuzzingSolver.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_DUMMY_FUZZING_SOLVER
#define JFS_FUZZING_COMMON_DUMMY_FUZZING_SOLVER
#include "jfs/FuzzingCommon/FuzzingSolver.h"
namespace jfs {
namespace fuzzingCommon {
// This solver doesn't do any fuzzing so in effect
// it can only solve trivial constraints
class DummyFuzzingSolver : public FuzzingSolver {
protected:
std::unique_ptr<jfs::core::SolverResponse>
fuzz(jfs::core::Query& q, bool produceModel,
std::shared_ptr<FuzzingAnalysisInfo> info) override;
public:
DummyFuzzingSolver(std::unique_ptr<jfs::core::SolverOptions> options,
std::unique_ptr<WorkingDirectoryManager> wdm,
jfs::core::JFSContext& ctx);
~DummyFuzzingSolver();
llvm::StringRef getName() const override;
void cancel() override;
};
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/EqualityExtractionPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_EQUALITY_EXTRACTION_PASS_H
#define JFS_FUZZING_COMMON_EQUALITY_EXTRACTION_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeMap.h"
#include "jfs/Core/Z3NodeSet.h"
#include "jfs/Transform/QueryPass.h"
#include <vector>
namespace jfs {
namespace fuzzingCommon {
// This pass looks for simple equalities (e.g. `(= a b)`), removes them from
// the query and adds them to the known set of equalites. The motivation is
// that the fuzzer is very unlikely to guess at random to make two expressions
// equal. Instead of enforcing them as branch conditions we can construct the
// input program such the equality always holds in some simple cases.
class EqualityExtractionPass : public jfs::transform::QueryPass {
private:
void cleanUp();
public:
// TODO: Put this behind an interface once we know what the requirements
// are.
jfs::core::Z3ASTMap<std::shared_ptr<jfs::core::Z3ASTSet>> mapping;
std::unordered_set<std::shared_ptr<jfs::core::Z3ASTSet>> equalities;
EqualityExtractionPass();
~EqualityExtractionPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/FileSerializableModel.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Alastair Donaldson
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_FILE_SERIALIZABLE_MODEL_H
#define JFS_FUZZING_COMMON_FILE_SERIALIZABLE_MODEL_H
#include "jfs/Core/Model.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/FuzzingCommon/BufferAssignment.h"
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/Support/MemoryBuffer.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
class FileSerializableModel : public jfs::core::Model {
public:
// Empty model
FileSerializableModel(jfs::core::JFSContext& ctx);
static std::unique_ptr<FileSerializableModel>
loadFrom(const llvm::MemoryBuffer* buf, const BufferAssignment* ba,
jfs::core::JFSContext& ctx);
bool saveTo(llvm::FileOutputBuffer* buf, const BufferAssignment* ba,
jfs::core::JFSContext& ctx);
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/FreeVariableToBufferAssignmentPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_FREE_VARIABLE_TO_BUFFER_ASSIGNMENT_PASS_H
#define JFS_FUZZING_COMMON_FREE_VARIABLE_TO_BUFFER_ASSIGNMENT_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeMap.h"
#include "jfs/Core/Z3NodeSet.h"
#include "jfs/FuzzingCommon/BufferAssignment.h"
#include "jfs/FuzzingCommon/EqualityExtractionPass.h"
#include "jfs/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.h"
#include "jfs/Transform/QueryPass.h"
#include <vector>
namespace jfs {
namespace fuzzingCommon {
class ConstantAssignment {
public:
// TODO: Put this behind an interface
jfs::core::Z3ASTMap<jfs::core::Z3ASTHandle> assignments;
void print(llvm::raw_ostream&) const;
void dump() const;
};
class FreeVariableToBufferAssignmentPass : public jfs::transform::QueryPass {
private:
const EqualityExtractionPass& eep;
// raw ptr because we don't own storage
FreeVariableToBufferAssignmentPassOptions* options;
std::unique_ptr<FreeVariableToBufferAssignmentPassOptions> defaultOptions;
public:
FreeVariableToBufferAssignmentPass(
const EqualityExtractionPass&,
FreeVariableToBufferAssignmentPassOptions* options);
~FreeVariableToBufferAssignmentPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
// TODO: Put these behind an interface
std::shared_ptr<BufferAssignment> bufferAssignment;
// FIXME: It's debatable whether we actually need this. The
// ConstantPropagation pass
// means that equalities like this will already be expanded in constraints.
// This means
// the free variables that have constant assignments will never be used once
// the
// EqualityExtractionPass has run and so constantAssignment is always empty.
std::shared_ptr<ConstantAssignment> constantAssignments;
virtual bool convertModel(jfs::core::Model* m) override;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_FREE_VARIABLE_TO_BUFFER_ASSIGNMENT_PASS_OPTIONS_H
#define JFS_FUZZING_COMMON_FREE_VARIABLE_TO_BUFFER_ASSIGNMENT_PASS_OPTIONS_H
#include <cstddef>
namespace jfs {
namespace fuzzingCommon {
class FreeVariableToBufferAssignmentPassOptions {
public:
enum class FreeVariableSortStrategyTy {
ALPHABETICAL,
FIRST_OBSERVED,
NONE, // Warning: Will likely be non-deterministic
};
size_t bufferElementBitAlignment = 1;
FreeVariableSortStrategyTy sortStrategy =
FreeVariableSortStrategyTy::FIRST_OBSERVED;
FreeVariableToBufferAssignmentPassOptions();
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/FuzzingAnalysisInfo.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_FUZZING_ANALYSIS_INFO_H
#define JFS_FUZZING_COMMON_FUZZING_ANALYSIS_INFO_H
#include "jfs/FuzzingCommon/EqualityExtractionPass.h"
#include "jfs/FuzzingCommon/FreeVariableToBufferAssignmentPass.h"
#include "jfs/Transform/QueryPassManager.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
// This contains the necessary analysis info
// that a fuzzing solver needs.
class FuzzingAnalysisInfo {
public:
std::shared_ptr<EqualityExtractionPass> equalityExtraction;
std::shared_ptr<FreeVariableToBufferAssignmentPass> freeVariableAssignment;
void addTo(jfs::transform::QueryPassManager& pm);
FuzzingAnalysisInfo(FreeVariableToBufferAssignmentPassOptions* fvtbapOptions);
~FuzzingAnalysisInfo();
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/FuzzingSolver.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_FUZZING_SOLVER_H
#define JFS_FUZZING_COMMON_FUZZING_SOLVER_H
#include "jfs/Core/Solver.h"
#include "jfs/FuzzingCommon/WorkingDirectoryManager.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
class FuzzingAnalysisInfo;
class FuzzingSolverImpl;
class FuzzingSolver : public jfs::core::Solver {
private:
std::unique_ptr<FuzzingSolverImpl> impl;
protected:
virtual std::unique_ptr<jfs::core::SolverResponse>
fuzz(jfs::core::Query& q, bool produceModel,
std::shared_ptr<FuzzingAnalysisInfo> info) = 0;
std::unique_ptr<WorkingDirectoryManager> wdm;
public:
FuzzingSolver(std::unique_ptr<jfs::core::SolverOptions> options,
std::unique_ptr<WorkingDirectoryManager> wdm,
jfs::core::JFSContext& ctx);
~FuzzingSolver();
std::unique_ptr<jfs::core::SolverResponse> solve(const jfs::core::Query& q,
bool produceModel) override;
void cancel() override;
friend class FuzzingSolverImpl;
};
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/FuzzingSolverOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_FUZZING_SOLVER_OPTIONS_H
#define JFS_FUZZING_COMMON_FUZZING_SOLVER_OPTIONS_H
#include "jfs/Core/SolverOptions.h"
#include "jfs/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
class FuzzingSolverOptions : public jfs::core::SolverOptions {
private:
std::unique_ptr<FreeVariableToBufferAssignmentPassOptions> fvtbapOptions;
protected:
// For subclasses
FuzzingSolverOptions(
std::unique_ptr<FreeVariableToBufferAssignmentPassOptions> fvtbapOptions,
bool debugSaveModel,
jfs::core::SolverOptions::SolverOptionKind thisKind);
public:
bool debugSaveModel;
FuzzingSolverOptions(
std::unique_ptr<FreeVariableToBufferAssignmentPassOptions> fvtbapOptions,
bool debugSaveModel);
static bool classof(const SolverOptions* so) {
return so->getKind() >= jfs::core::SolverOptions::FUZZING_SOLVER_KIND &&
so->getKind() < jfs::core::SolverOptions::LAST_FUZZING_SOLVER_KIND;
}
FreeVariableToBufferAssignmentPassOptions*
getFreeVariableToBufferAssignmentOptions() const;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/JFSRuntimeFuzzingStat.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_JFS_RUNTIME_FUZZING_STAT
#define JFS_FUZZING_COMMON_JFS_RUNTIME_FUZZING_STAT
#include "jfs/Core/JFSContext.h"
#include "jfs/FuzzingCommon/FuzzingSolver.h"
#include "jfs/Support/JFSStat.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
struct JFSRuntimeFuzzingStat : public jfs::support::JFSStat {
uint64_t maxNumConstraintsSatisfied;
static const char* maxNumConstraintsSatisfiedKeyName;
uint64_t numberOfInputsTried;
static const char* numberOfInputsTriedKeyName;
uint64_t numberOfWrongSizedInputsTried;
static const char* numberOfWrongSizedInputsTriedKeyName;
JFSRuntimeFuzzingStat(llvm::StringRef name);
virtual ~JFSRuntimeFuzzingStat();
void printYAML(llvm::ScopedPrinter& os) const override;
static bool classof(const JFSStat* s) { return s->getKind() == RUNTIME; }
static std::unique_ptr<JFSRuntimeFuzzingStat>
LoadFromYAML(llvm::StringRef filePath, llvm::StringRef name,
jfs::core::JFSContext& ctx);
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/LibFuzzerInvocationManager.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_LIBFUZZER_INVOCATION_MANAGER_H
#define JFS_FUZZING_COMMON_LIBFUZZER_INVOCATION_MANAGER_H
#include "jfs/Core/JFSContext.h"
#include "jfs/FuzzingCommon/LibFuzzerOptions.h"
#include "jfs/Support/ICancellable.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/MemoryBuffer.h"
#include <memory>
#include <string>
namespace jfs {
namespace fuzzingCommon {
struct LibFuzzerResponse {
enum class ResponseTy {
TARGET_FOUND,
SINGLE_RUN_TARGET_NOT_FOUND,
RUN_BOUND_REACHED,
CANCELLED,
UNKNOWN,
};
ResponseTy outcome;
std::string pathToInput;
LibFuzzerResponse();
~LibFuzzerResponse();
// Returns nullptr if outcome was not `TARGET_FOUND`.
std::unique_ptr<llvm::MemoryBuffer> getInputForTarget() const;
};
class LibFuzzerInvocationManagerImpl;
class LibFuzzerInvocationManager : public jfs::support::ICancellable {
private:
const std::unique_ptr<LibFuzzerInvocationManagerImpl> impl;
public:
LibFuzzerInvocationManager(jfs::core::JFSContext& ctx);
~LibFuzzerInvocationManager();
void cancel();
std::unique_ptr<LibFuzzerResponse> fuzz(const LibFuzzerOptions* options,
llvm::StringRef stdOutFile,
llvm::StringRef stdErrFile);
};
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/LibFuzzerOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_LIBFUZZER_OPTIONS_H
#define JFS_FUZZING_COMMON_LIBFUZZER_OPTIONS_H
#include <stdint.h>
#include <string>
namespace jfs {
namespace fuzzingCommon {
// FIXME: This design is broken. Some of these options are used internally and
// will get overwritten and others are public and can be changed. We need
// to separate these two concerns.
struct LibFuzzerOptions {
// NOTE: `runs` value of `0` means an infinite number of runs.
size_t runs; // Approximately corresponds to `-runs=<N>` option.
uint64_t mutationDepth; // Corresponds to `-mutate_depth=<N>`
bool crossOver; // Corresponds to `-cross_over` option
uint64_t maxLength; // Corresponds to `-max_len=<N>` option (bytes).
bool useCmp; // Corresponds to `-use_cmp` option
bool printFinalStats; // Corresponds to `-print_final_stats=1`
bool reduceInputs; // Corresponds to `-reduce_inputs=1`
bool defaultMutationsResizeInput; // Corresponds to `default_mutators_resize_input=1`
bool handleSIGABRT;
bool handleSIGBUS;
bool handleSIGFPE;
bool handleSIGILL;
bool handleSIGINT;
bool handleSIGSEGV;
bool handleSIGTERM;
bool handleSIGXFSZ;
std::string targetBinary;
std::string artifactDir;
std::string corpusDir;
std::string jfsRuntimeLogFile;
// TODO: We should support LibFuzzer jobs/workers. This
// will require a vector of seeds rather than a single seed
LibFuzzerOptions();
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/SeedGenerator.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SEED_GENERATOR_H
#define JFS_FUZZING_COMMON_SEED_GENERATOR_H
#include "llvm/ADT/StringRef.h"
#include <string>
namespace jfs {
namespace fuzzingCommon {
class FuzzingAnalysisInfo;
class SeedManager;
class SeedGenerator {
private:
std::string name;
public:
SeedGenerator(llvm::StringRef name);
virtual ~SeedGenerator();
// Called once by the SeedManager before any seeds are requested
virtual void preGenerationCallBack(SeedManager& sm);
// Called once by the SeedManager after all seeds are requested
virtual void postGenerationCallBack(SeedManager& sm);
// Returns true on success
virtual bool writeSeed(SeedManager& sm) = 0;
virtual llvm::StringRef getName() const { return name; }
virtual bool empty() const = 0;
};
// A generator that emits a single seed with all bytes set to
// the supplied byte value.
class AllBytesEqualGenerator : public SeedGenerator {
private:
uint8_t byteValue;
bool seedWritten;
public:
AllBytesEqualGenerator(llvm::StringRef name, uint8_t byteValue);
void preGenerationCallBack(SeedManager& sm) override {}
void postGenerationCallBack(SeedManager& sm) override {}
bool writeSeed(SeedManager& sm) override;
bool empty() const override;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/SeedManager.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SEED_MANAGER_H
#define JFS_FUZZING_COMMON_SEED_MANAGER_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Query.h"
#include "jfs/Support/ICancellable.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/FileOutputBuffer.h"
#include <list>
#include <memory>
namespace jfs {
namespace fuzzingCommon {
class SeedGenerator;
class SeedManagerImpl;
class FuzzingAnalysisInfo;
class SeedManagerOptions;
class SeedManager : jfs::support::ICancellable {
private:
std::unique_ptr<SeedManagerImpl> impl;
public:
SeedManager(llvm::StringRef seedDir, jfs::core::JFSContext& ctx);
SeedManager(const SeedManager&) = delete;
~SeedManager();
void cancel() override;
void configureFrom(std::unique_ptr<SeedManagerOptions> options);
void addSeedGenerator(std::unique_ptr<SeedGenerator> sg);
// Returns number of written seeds.
uint64_t writeSeeds(const FuzzingAnalysisInfo* info,
const jfs::core::Query* q);
void setSpaceLimit(uint64_t maxSeedSpaceInBytes);
uint64_t getSpaceLimit() const;
void setMaxNumSeeds(uint64_t maxNumSeeds);
uint64_t getMaxNumSeeds() const;
// Create a FileOutputBuffer with the appropriate size and filename for the
// seed. The caller is responsible for calling commit.
//
// This is the preferred method writing a seed
std::unique_ptr<llvm::FileOutputBuffer>
getBufferForSeed(llvm::StringRef prefix);
// Get and reserve a seed ID but don't actually create it.
std::string getAndReserveSeedID(llvm::StringRef prefix);
std::string getAndReserveSeedID();
jfs::core::JFSContext& getContext() const;
const FuzzingAnalysisInfo* getCurrentFuzzingAnalysisInfo() const;
const jfs::core::Query* getCurrentQuery() const;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/SeedManagerOptions.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SEED_MANAGER_OPTIONS_H
#define JFS_FUZZING_COMMON_SEED_MANAGER_OPTIONS_H
#include "jfs/FuzzingCommon/SeedGenerator.h"
#include <list>
#include <memory>
namespace jfs {
namespace fuzzingCommon {
class SeedGenerator;
class SeedManagerOptions {
public:
uint64_t maxSeedSpaceInBytes;
uint64_t maxNumSeeds;
std::list<std::unique_ptr<SeedGenerator>> generators;
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/SeedManagerStat.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SEED_MANAGER_STAT_H
#define JFS_FUZZING_COMMON_SEED_MANAGER_STAT_H
#include "jfs/Core/JFSContext.h"
#include "jfs/FuzzingCommon/FuzzingSolver.h"
#include "jfs/Support/JFSStat.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
namespace jfs {
namespace fuzzingCommon {
struct SeedManagerStat : public jfs::support::JFSStat {
uint64_t numSeedsGenerated = 0;
SeedManagerStat(llvm::StringRef name);
virtual ~SeedManagerStat();
void printYAML(llvm::ScopedPrinter& os) const override;
static bool classof(const JFSStat* s) { return s->getKind() == SEED_MANAGER; }
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/SortConformanceCheckPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SORT_CONFORMANCE_PASS_H
#define JFS_FUZZING_COMMON_SORT_CONFORMANCE_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/QueryPass.h"
#include <functional>
namespace jfs {
namespace fuzzingCommon {
class SortConformanceCheckPass : public jfs::transform::QueryPass {
bool predicateHeld;
std::function<bool(jfs::core::Z3SortHandle)> predicate;
public:
SortConformanceCheckPass(
std::function<bool(jfs::core::Z3SortHandle)> predicate);
~SortConformanceCheckPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
bool predicateAlwaysHeld() const { return predicateHeld; }
void reset() { predicateHeld = false; }
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/FuzzingCommon/SpecialConstantSeedGenerator.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2018 J. Ryan Stinnett
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SPECIAL_CONSTANT_SEED_GENERATOR_H
#define JFS_FUZZING_COMMON_SPECIAL_CONSTANT_SEED_GENERATOR_H
#include "jfs/Core/Z3Node.h"
#include "jfs/Core/Z3NodeMap.h"
#include "jfs/FuzzingCommon/SeedGenerator.h"
#include "jfs/FuzzingCommon/SpecialConstantSeedGeneratorStat.h"
#include <vector>
namespace jfs {
namespace core {
class JFSContext;
class Model;
}
}
namespace jfs {
namespace fuzzingCommon {
class BufferElement;
class SeedManager;
// A seed generator that emits special constants based on the sorts used in the
// constraints of the query.
class SpecialConstantSeedGenerator : public SeedGenerator {
// Inherit constructor
using SeedGenerator::SeedGenerator;
void preGenerationCallBack(SeedManager& sm) override;
void postGenerationCallBack(SeedManager& sm) override;
bool writeSeed(SeedManager& sm) override;
bool empty() const override;
private:
// Track vectors of constants found in constraints by sort.
jfs::core::Z3SortMap<std::vector<jfs::core::Z3ASTHandle>>
sortToConstraintConstantMap;
std::unique_ptr<SpecialConstantSeedGeneratorStat> stats;
bool chooseBool(core::JFSContext& ctx, const BufferElement& be,
core::Model& model);
bool chooseBitVector(core::JFSContext& ctx, const BufferElement& be,
core::Model& model);
bool chooseFloatingPoint(core::JFSContext& ctx, const BufferElement& be,
core::Model& model);
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/SpecialConstantSeedGeneratorStat.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Alastair Donaldson
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_SEED_GENERATOR_STAT_H
#define JFS_FUZZING_COMMON_SEED_GENERATOR_STAT_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Z3NodeMap.h"
#include "jfs/Support/JFSStat.h"
namespace jfs {
namespace fuzzingCommon {
struct SpecialConstantSeedGeneratorStat : public jfs::support::JFSStat {
jfs::core::Z3SortMap<uint64_t> foundConstantsCount;
uint64_t totalNumBuiltInBVConstants = 0;
uint64_t numCoveredBVConstants = 0;
uint64_t totalNumBuiltInFPConstants = 0;
uint64_t numCoveredFPConstants = 0;
uint64_t totalNumBuiltInBoolConstants = 0;
uint64_t numCoveredBoolConstants = 0;
SpecialConstantSeedGeneratorStat(llvm::StringRef name);
virtual ~SpecialConstantSeedGeneratorStat();
void printYAML(llvm::ScopedPrinter& os) const override;
static bool classof(const JFSStat* s) {
return s->getKind() == SEED_GENERATOR;
}
};
} // namespace fuzzingCommon
} // namespace jfs
#endif
================================================
FILE: include/jfs/FuzzingCommon/WorkingDirectoryManager.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_FUZZING_COMMON_WORKING_DIRECTORY_MANAGER_H
#define JFS_FUZZING_COMMON_WORKING_DIRECTORY_MANAGER_H
#include "jfs/Core/JFSContext.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
#include <string>
namespace jfs {
namespace fuzzingCommon {
class WorkingDirectoryManager {
private:
const std::string path;
jfs::core::JFSContext& ctx;
const bool deleteOnDestruction;
WorkingDirectoryManager(llvm::StringRef path, jfs::core::JFSContext& ctx,
bool deleteOnDestruction);
public:
// Don't allow copying
~WorkingDirectoryManager();
WorkingDirectoryManager(const WorkingDirectoryManager&) = delete;
WorkingDirectoryManager(const WorkingDirectoryManager&&) = delete;
WorkingDirectoryManager& operator=(const WorkingDirectoryManager&) = delete;
llvm::StringRef getPath() const { return path; }
std::string getPathToFileInDirectory(llvm::StringRef fileName) const;
std::string makeNewDirectoryInDirectory(llvm::StringRef dirName);
// Make at `path`. `path` should not already exist, but its
// parent directory should.
// If the fails a nullptr will be returned.
static std::unique_ptr<WorkingDirectoryManager>
makeAtPath(llvm::StringRef path, jfs::core::JFSContext& ctx,
bool deleteOnDestruction);
// Make at `<directory>/<prefix>-N` where `N` is an integer.
// This function will start with `N == 0` an keep incrementing
// `N` until a directory is successfully created `N == maxN`.
// If the fails a nullptr will be returned.
static std::unique_ptr<WorkingDirectoryManager>
makeInDirectory(llvm::StringRef directory, llvm::StringRef prefix,
jfs::core::JFSContext& ctx, bool deleteOnDestruction,
uint16_t maxN = 100);
};
}
}
#endif
================================================
FILE: include/jfs/Support/CancellableProcess.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_CANCELLABLE_PROCESS_H
#define JFS_SUPPORT_CANCELLABLE_PROCESS_H
#include "jfs/Support/ICancellable.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
#include <string>
#include <vector>
namespace jfs {
namespace support {
class CancellableProcessImpl;
// This is a thin wrapper around LLVM's
// `llvm::sys::ExecuteAndWait()` that supports
// cancellation.
class CancellableProcess : public ICancellable {
private:
const std::unique_ptr<CancellableProcessImpl> impl;
public:
CancellableProcess();
~CancellableProcess();
void cancel() override;
// Return values >= 0 is program exit code.
// Negative value indicates failure.
int execute(llvm::StringRef program, std::vector<const char*>& args,
std::vector<llvm::StringRef>& redirects,
const char** envp = nullptr);
};
} // namespace support
} // namespace jfs
#endif
================================================
FILE: include/jfs/Support/ErrorMessages.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_ERROR_MESSAGES_H
#define JFS_SUPPORT_ERROR_MESSAGES_H
#include "llvm/ADT/StringRef.h"
#include <string>
#include <system_error>
namespace jfs {
namespace support {
std::string getMessageForFailedOpenFileOrSTDIN(llvm::StringRef inputFileName,
std::error_code ec);
std::string
getMessageForFailedOpenFileForWriting(llvm::StringRef outputFileName,
std::error_code ec);
}
}
#endif
================================================
FILE: include/jfs/Support/FileUtils.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_ERROR_MESSAGES_H
#define JFS_SUPPORT_ERROR_MESSAGES_H
#include "llvm/ADT/StringRef.h"
#include <string>
#include <system_error>
namespace jfs {
namespace support {
std::error_code recursive_remove(llvm::StringRef path, bool IgnoreNonExisting);
}
}
#endif
================================================
FILE: include/jfs/Support/ICancellable.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_ICANCELLABLE_H
#define JFS_SUPPORT_ICANCELLABLE_H
namespace jfs {
namespace support {
// This is a simple interface that classes can implement to cancel their
// currently assigned work. It is not defined what the state of the instance
// will be after making this call.
class ICancellable {
public:
virtual void cancel() = 0;
virtual ~ICancellable();
};
}
}
#endif
================================================
FILE: include/jfs/Support/JFSStat.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_JFS_STAT_H
#define JFS_SUPPORT_JFS_STAT_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/Timer.h"
#include "llvm/Support/raw_ostream.h"
#include <list>
#include <memory>
#include <string>
namespace jfs {
namespace support {
class JFSStat {
public:
enum JFSStatKind {
SINGLE_TIMER,
AGGREGATE_TIMER,
CXX_PROGRAM,
RUNTIME,
SEED_MANAGER,
SEED_GENERATOR
};
private:
const JFSStatKind kind;
std::string name;
protected:
JFSStat(JFSStatKind kind, llvm::StringRef name);
public:
virtual ~JFSStat();
JFSStatKind getKind() const { return kind; }
// FIXME: We should switch to llvm::yaml API.
virtual void printYAML(llvm::ScopedPrinter& os) const = 0;
void dump() const;
llvm::StringRef getName() const;
};
class JFSAggregateTimerStat;
class JFSTimerStat : public JFSStat {
private:
using RecordTy = llvm::TimeRecord;
RecordTy record;
public:
friend class JFSAggregateTimerStat;
JFSTimerStat(RecordTy record, llvm::StringRef name);
~JFSTimerStat();
void printYAML(llvm::ScopedPrinter& os) const override;
static bool classof(const JFSStat* s) { return s->getKind() == SINGLE_TIMER; }
};
class JFSAggregateTimerStat : public JFSStat {
private:
std::list<std::unique_ptr<const JFSTimerStat>> timers;
public:
JFSAggregateTimerStat(llvm::StringRef name);
~JFSAggregateTimerStat();
void append(std::unique_ptr<JFSTimerStat> t);
void clear();
void printYAML(llvm::ScopedPrinter& os) const override;
static bool classof(const JFSStat* s) {
return s->getKind() == AGGREGATE_TIMER;
}
};
}
}
#endif
================================================
FILE: include/jfs/Support/ScopedJFSTimerStatAppender.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_SCOPED_JFS_TIMER_STAT_APPENDER_H
#define JFS_SUPPORT_SCOPED_JFS_TIMER_STAT_APPENDER_H
#include "jfs/Support/JFSStat.h"
#include "jfs/Support/Timer.h"
#include <memory>
namespace jfs {
namespace support {
template <typename T> class ScopedJFSTimerStatAppender {
public:
T* receiver;
Timer timer;
llvm::StringRef name;
std::unique_ptr<JFSTimerStat> result;
ScopedJFSTimerStatAppender(T* receiver, llvm::StringRef name)
: receiver(receiver), timer(), name(name), result(nullptr) {
if (receiver == nullptr)
return;
// Start timer
timer.startTimer();
}
~ScopedJFSTimerStatAppender() {
if (receiver == nullptr)
return;
timer.stopTimer();
result.reset(new JFSTimerStat(timer.getTotalTime(), name));
receiver->append(std::move(result));
}
};
template <typename T> class ScopedJFSAggregateTimerStatAppender {
public:
T* receiver;
std::unique_ptr<JFSAggregateTimerStat> stats;
ScopedJFSAggregateTimerStatAppender(T* receiver, llvm::StringRef name)
: receiver(receiver), stats(nullptr) {
if (receiver == nullptr)
return;
stats.reset(new JFSAggregateTimerStat(name));
}
~ScopedJFSAggregateTimerStatAppender() {
if (receiver == nullptr)
return;
receiver->append(std::move(stats));
}
};
}
}
#endif
================================================
FILE: include/jfs/Support/ScopedTimer.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_SCOPED_TIMER_H
#define JFS_SUPPORT_SCOPED_TIMER_H
#include <functional>
#include <memory>
#include <stdint.h>
namespace jfs {
namespace support {
class ScopedTimerImpl;
class ScopedTimer {
private:
std::unique_ptr<ScopedTimerImpl> impl;
public:
typedef std::function<void(void)> CallBackTy;
// Will call `callBack` if wall clock time exceeds
// `maxTime`. If `maxTime` is == 0 then `callBack`
// will never be called.
ScopedTimer(uint64_t maxTime, CallBackTy callBack);
~ScopedTimer();
uint64_t getRemainingTime() const;
uint64_t getMaxTime() const;
};
}
}
#endif
================================================
FILE: include/jfs/Support/StatisticsManager.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_STATISTICS_MANAGER_H
#define JFS_SUPPORT_STATISTICS_MANAGER_H
#include "llvm/Support/raw_ostream.h"
#include <memory>
namespace jfs {
namespace support {
class JFSStat;
class StatisticsManagerImpl;
class StatisticsManager {
private:
const std::unique_ptr<StatisticsManagerImpl> impl;
public:
// FIXME: Figure out how to add iterators without leaking
// implementation details
StatisticsManager();
~StatisticsManager();
void append(std::unique_ptr<JFSStat> stat);
void clear();
size_t size() const;
void printYAML(llvm::raw_ostream& os) const;
void dump() const;
};
}
}
#endif
================================================
FILE: include/jfs/Support/Timer.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_TIMER_H
#define JFS_SUPPORT_TIMER_H
#include "llvm/Support/Timer.h" // For llvm::TimeRecord
namespace jfs {
namespace support {
// This is timer inspired by `llvm::Timer`. Unfortunately `llvm::Timer` is a
// bit cumbersome to use due to the way it's tied to `TimerGroup`. We could
// potentially create `TimerGroup` for `StatisticsManager` and for each
// `JFSAggregateTimerStat` but we would need to keep all the `llvm::Timer`s
// alive so that the implicit dumping of stats to stderr happens properly.
// This seems wasteful so implementing our own seems simpler.
class Timer {
public:
typedef llvm::TimeRecord RecordTy;
private:
RecordTy Time; ///< The total time captured.
RecordTy StartTime; ///< The time startTimer() was last called.
bool Running; ///< Is the timer currently running?
bool Triggered; ///< Has the timer ever been triggered?
public:
Timer();
~Timer();
Timer(const Timer& RHS) = delete;
/// Check if the timer is currently running.
bool isRunning() const { return Running; }
/// Check if startTimer() has ever been called on this timer.
bool hasTriggered() const { return Triggered; }
/// Start the timer running. Time between calls to startTimer/stopTimer is
/// counted by the Timer class. Note that these calls must be correctly
/// paired.
void startTimer();
/// Stop the timer.
void stopTimer();
/// Clear the timer state.
void clear();
/// Return the duration for which this timer has been running.
RecordTy getTotalTime() const { return Time; }
};
}
}
#endif
================================================
FILE: include/jfs/Support/version.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_SUPPORT_VERSION_H
#define JFS_SUPPORT_VERSION_H
namespace jfs {
namespace support {
const char* getVersionString();
}
}
#endif
================================================
FILE: include/jfs/Transform/AndHoistingPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_AND_HOISTING_PASS_H
#define JFS_TRANSFORM_AND_HOISTING_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/QueryPass.h"
namespace jfs {
namespace transform {
class AndHoistingPass : public QueryPass {
public:
AndHoistingPass() {}
~AndHoistingPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/BitBlastPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2018 J. Ryan Stinnett
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_BIT_BLAST_PASS_H
#define JFS_TRANSFORM_BIT_BLAST_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/Z3QueryPass.h"
namespace jfs {
namespace transform {
class BitBlastPass : public Z3QueryPass {
public:
BitBlastPass() {}
~BitBlastPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/BvBoundPropagationPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_BV_BOUND_PROPAGATION_PASS_H
#define JFS_TRANSFORM_BV_BOUND_PROPAGATION_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/Z3QueryPass.h"
namespace jfs {
namespace transform {
// NOTE: This pass only supports bvule and bvsle
// currently so simplifier must be run first.
class BvBoundPropagationPass : public Z3QueryPass {
public:
BvBoundPropagationPass() {}
~BvBoundPropagationPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/ConstantPropagationPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_CONSTANT_PROPAGATION_PASS_H
#define JFS_TRANSFORM_CONSTANT_PROPAGATION_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/Z3QueryPass.h"
namespace jfs {
namespace transform {
class ConstantPropagationPass : public Z3QueryPass {
public:
ConstantPropagationPass() {}
~ConstantPropagationPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/DIMACSOutputPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2018 J. Ryan Stinnett
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_DIMACS_OUTPUT_PASS_H
#define JFS_TRANSFORM_DIMACS_OUTPUT_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/Z3QueryPass.h"
namespace jfs {
namespace transform {
class DIMACSOutputPass : public Z3QueryPass {
public:
DIMACSOutputPass() {}
~DIMACSOutputPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/DuplicateConstraintEliminationPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_DUPLICATE_CONSTRAINT_ELIMINATION_PASS_H
#define JFS_TRANSFORM_DUPLICATE_CONSTRAINT_ELIMINATION_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/QueryPass.h"
namespace jfs {
namespace transform {
class DuplicateConstraintEliminationPass : public QueryPass {
public:
DuplicateConstraintEliminationPass() {}
~DuplicateConstraintEliminationPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/FpToBvPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2018 J. Ryan Stinnett
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_FP_TO_BV_PASS_H
#define JFS_TRANSFORM_FP_TO_BV_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/Z3QueryPass.h"
namespace jfs {
namespace transform {
class FpToBvPass : public Z3QueryPass {
public:
FpToBvPass() {}
~FpToBvPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/Passes.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#include "jfs/Transform/AndHoistingPass.h"
#include "jfs/Transform/BitBlastPass.h"
#include "jfs/Transform/BvBoundPropagationPass.h"
#include "jfs/Transform/ConstantPropagationPass.h"
#include "jfs/Transform/DIMACSOutputPass.h"
#include "jfs/Transform/DuplicateConstraintEliminationPass.h"
#include "jfs/Transform/FpToBvPass.h"
#include "jfs/Transform/SimpleContradictionsToFalsePass.h"
#include "jfs/Transform/SimplificationPass.h"
#include "jfs/Transform/TrueConstraintEliminationPass.h"
================================================
FILE: include/jfs/Transform/QueryPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_QUERY_PASS_H
#define JFS_TRANSFORM_QUERY_PASS_H
#include "jfs/Core/Model.h"
#include "jfs/Core/Query.h"
#include "jfs/Support/ICancellable.h"
#include "llvm/ADT/StringRef.h"
#include <atomic>
namespace jfs {
namespace transform {
class QueryPass : jfs::support::ICancellable {
protected:
std::atomic<bool> cancelled;
public:
QueryPass() : cancelled(false) {}
virtual ~QueryPass() {}
// returns `true` if changed, `false` otherwise.
virtual bool run(jfs::core::Query&) = 0;
virtual llvm::StringRef getName() = 0;
void cancel() override { cancelled = true; }
virtual bool convertModel(jfs::core::Model* m) = 0;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/QueryPassManager.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_QUERY_PASS_MANAGER_H
#define JFS_TRANSFORM_QUERY_PASS_MANAGER_H
#include "jfs/Core/Model.h"
#include "jfs/Support/ICancellable.h"
#include "jfs/Transform/QueryPass.h"
#include <memory>
namespace jfs {
namespace transform {
class QueryPassManagerImpl;
class QueryPassManager : public jfs::support::ICancellable {
private:
std::unique_ptr<QueryPassManagerImpl> impl;
public:
QueryPassManager();
virtual ~QueryPassManager();
// This not a std::unique_ptr<QueryPass> because some passes just collect
// information so clients will need to hold on to a pointer to those
// passes. This means we can't have unique ownership (otherwise clients
// would have to hold on to raw pointers which is dangerous).
void add(std::shared_ptr<QueryPass> pass);
void run(jfs::core::Query& q);
void cancel() override;
void clear();
// Modify (in-place) the provided model so that it is a solution to the Query
// passed to the last call to `run()` before it was modified. It is assumed
// that the provided model already satisfies the modified query.
bool convertModel(jfs::core::Model* m);
};
}
}
#endif
================================================
FILE: include/jfs/Transform/SimpleContradictionsToFalsePass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_SIMPLE_CONTRADICTIONS_TO_FALSE_H
#define JFS_TRANSFORM_SIMPLE_CONTRADICTIONS_TO_FALSE_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/QueryPass.h"
namespace jfs {
namespace transform {
class SimpleContradictionsToFalsePass : public QueryPass {
public:
SimpleContradictionsToFalsePass() {}
~SimpleContradictionsToFalsePass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/SimplificationPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_SIMPLIFICATION_PASS_H
#define JFS_TRANSFORM_SIMPLIFICATION_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/Z3QueryPass.h"
namespace jfs {
namespace transform {
class SimplificationPass : public Z3QueryPass {
public:
SimplificationPass() {}
~SimplificationPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/StandardPasses.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_STANDARD_PASSES_H
#define JFS_TRANSFORM_STANDARD_PASSES_H
#include "jfs/Transform/QueryPassManager.h"
namespace jfs {
namespace transform {
void AddStandardPasses(QueryPassManager& pm);
}
}
#endif
================================================
FILE: include/jfs/Transform/TrueConstraintEliminationPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_TRUE_CONSTRAINT_ELIMINATION_PASS_H
#define JFS_TRANSFORM_TRUE_CONSTRAINT_ELIMINATION_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Transform/QueryPass.h"
namespace jfs {
namespace transform {
class TrueConstraintEliminationPass : public QueryPass {
public:
TrueConstraintEliminationPass() {}
~TrueConstraintEliminationPass() {}
bool run(jfs::core::Query& q) override;
virtual llvm::StringRef getName() override;
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/Transform/Z3QueryPass.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_TRANSFORM_Z3_QUERY_PASS_H
#define JFS_TRANSFORM_Z3_QUERY_PASS_H
#include "jfs/Core/Query.h"
#include "jfs/Core/Z3Node.h"
#include "jfs/Transform/QueryPass.h"
namespace jfs {
namespace transform {
class Z3QueryPass : public QueryPass {
protected:
Z3_context z3Ctx;
jfs::core::Z3ApplyResultHandle result;
public:
Z3QueryPass() : z3Ctx(nullptr) {}
~Z3QueryPass() {}
void cancel() override;
virtual bool convertModel(jfs::core::Model* m) override;
};
}
}
#endif
================================================
FILE: include/jfs/Z3Backend/Z3Solver.h
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#ifndef JFS_Z3BACKEND_Z3_SOLVER_H
#define JFS_Z3BACKEND_Z3_SOLVER_H
#include "jfs/Core/JFSContext.h"
#include "jfs/Core/Solver.h"
#include <memory>
namespace jfs {
namespace z3Backend {
class Z3Solver : public jfs::core::Solver {
private:
Z3_context z3Ctx;
bool cancelled;
public:
Z3Solver(std::unique_ptr<jfs::core::SolverOptions> options,
jfs::core::JFSContext& ctx);
~Z3Solver();
std::unique_ptr<jfs::core::SolverResponse> solve(const jfs::core::Query& q,
bool produceModel) override;
llvm::StringRef getName() const override;
void cancel() override;
};
}
}
#endif
================================================
FILE: lib/CMakeLists.txt
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
add_subdirectory(Support)
add_subdirectory(Core)
add_subdirectory(Transform)
add_subdirectory(Z3Backend)
add_subdirectory(FuzzingCommon)
add_subdirectory(CXXFuzzingBackend)
================================================
FILE: lib/CXXFuzzingBackend/CMakeLists.txt
================================================
#===------------------------------------------------------------------------===#
#
# JFS
#
# Copyright 2017-2018 Daniel Liew
#
# This file is distributed under the MIT license.
# See LICENSE.txt for details.
#
#===------------------------------------------------------------------------===#
jfs_add_component(JFSCXXFuzzingBackend
ClangInvocationManager.cpp
ClangOptions.cpp
CXXFuzzingSolver.cpp
CXXFuzzingSolverOptions.cpp
CXXProgram.cpp
CXXProgramBuilderPass.cpp
CXXProgramBuilderPassImpl.cpp
CXXProgramBuilderOptions.cpp
JFSCXXProgramStat.cpp
)
target_link_libraries(JFSCXXFuzzingBackend PUBLIC JFSFuzzingCommon)
jfs_get_llvm_components(llvm_components support)
target_link_libraries(JFSCXXFuzzingBackend PUBLIC ${llvm_components})
add_subdirectory(CmdLine)
================================================
FILE: lib/CXXFuzzingBackend/CXXFuzzingSolver.cpp
================================================
//===----------------------------------------------------------------------===//
//
// JFS
//
// Copyright 2017-2018 Daniel Liew
//
// This file is distributed under the MIT license.
// See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
#include "jfs/CXXFuzzingBackend/CXXFuzzingSolver.h"
#include "jfs/CXXFuzzingBackend/CXXFuzzingSolverOptions.h"
#include "jfs/CXXFuzzingBackend/CXXProgram.h"
#include "jfs/CXXFuzzingBackend/CXXProgramBuilderPass.h"
#include "jfs/CXXFuzzingBackend/ClangInvocationManager.h"
#include "jfs/CXXFuzzingBackend/ClangOptions.h"
#include "jfs/Core/IfVerbose.h"
#include "jfs/Core/JFSTimerMacros.h"
#include "jfs/FuzzingCommon/FileSerializableModel.h"
#include "jfs/FuzzingCommon/JFSRuntimeFuzzingStat.h"
#include "jfs/FuzzingCommon/LibFuzzerInvocationManager.h"
#include "jfs/FuzzingCommon/SeedManager.h"
#include "jfs/FuzzingCommon/SortConformanceCheckPass.h"
#include "jfs/FuzzingCommon/WorkingDirectoryManager.h"
#include "jfs/Transform/QueryPass.h"
#include "jfs/Transform/QueryPassManager.h"
#include "llvm/Support/CommandLine.h"
#include <algorithm>
#include <atomic>
#include <mutex>
#include <unordered_set>
using namespace jfs::core;
using namespace jfs::fuzzingCommon;
using namespace jfs::transform;
namespace {
// FIXME: Should use an OptionCategory but
// we shouldn't pull in `jfs::cxxfb::cl::CommandLineCategory` because
// that defeats the purpose of having the separate libraries. So instead
// just hide the option by default. It's only meant for internal testing
// anyway.
llvm::cl::opt<bool> DebugStopAfterCompilation(
"debug-stop-after-compile", llvm::cl::init(false),
llvm::cl::desc("Stop CXXFuzzingSolver after clang compilation"),
llvm::c
gitextract_qpsgp2_q/
├── .clang-format
├── .dockerignore
├── .gitignore
├── .idea/
│ └── codeStyleSettings.xml
├── CMakeLists.txt
├── LICENSE.txt
├── README.md
├── cmake/
│ ├── add_jfs_unit_test.cmake
│ ├── c_flags_override.cmake
│ ├── compiler_warnings.cmake
│ ├── cxx_flags_override.cmake
│ ├── git_utils.cmake
│ ├── jfs_add_component.cmake
│ ├── jfs_component_add_cxx_flag.cmake
│ ├── jfs_external_project_utils.cmake
│ └── jfs_get_llvm_components.cmake
├── docs/
│ └── tutorial/
│ ├── 0-basics-example.smt2
│ ├── 0-basics.md
│ ├── 1-setting-resource-limits.md
│ ├── 2-compilation-options-and-runtimes.md
│ ├── 3-resumming-fuzzing.md
│ ├── 4-getting-models.md
│ ├── 5-jfs-smt2cxx.md
│ └── 6-jfs-opt.md
├── include/
│ └── jfs/
│ ├── CXXFuzzingBackend/
│ │ ├── CXXFuzzingSolver.h
│ │ ├── CXXFuzzingSolverOptions.h
│ │ ├── CXXProgram.h
│ │ ├── CXXProgramBuilderOptions.h
│ │ ├── CXXProgramBuilderPass.h
│ │ ├── ClangInvocationManager.h
│ │ ├── ClangOptions.h
│ │ ├── CmdLine/
│ │ │ ├── CXXProgramBuilderOptionsBuilder.h
│ │ │ ├── ClangOptionsBuilder.h
│ │ │ └── CommandLineCategory.h
│ │ └── JFSCXXProgramStat.h
│ ├── Config/
│ │ ├── config.h.in
│ │ ├── depsVersion.h.in
│ │ └── version.h.in
│ ├── Core/
│ │ ├── IfVerbose.h
│ │ ├── JFSContext.h
│ │ ├── JFSTimerMacros.h
│ │ ├── Model.h
│ │ ├── ModelValidator.h
│ │ ├── Query.h
│ │ ├── RNG.h
│ │ ├── SMTLIB2Parser.h
│ │ ├── ScopedJFSContextErrorHandler.h
│ │ ├── SimpleModel.h
│ │ ├── Solver.h
│ │ ├── SolverOptions.h
│ │ ├── ToolErrorHandler.h
│ │ ├── Z3ASTCmp.h
│ │ ├── Z3ASTVisitor.h
│ │ ├── Z3Node.h
│ │ ├── Z3NodeMap.h
│ │ ├── Z3NodeSet.h
│ │ └── Z3NodeUtil.h
│ ├── FuzzingCommon/
│ │ ├── BufferAssignment.h
│ │ ├── BufferElement.h
│ │ ├── CmdLine/
│ │ │ ├── FreeVariableToBufferAssignmentPassOptionsBuilder.h
│ │ │ ├── LibFuzzerOptionsBuilder.h
│ │ │ └── SeedManagerOptionsBuilder.h
│ │ ├── CommandLineCategory.h
│ │ ├── DummyFuzzingSolver.h
│ │ ├── EqualityExtractionPass.h
│ │ ├── FileSerializableModel.h
│ │ ├── FreeVariableToBufferAssignmentPass.h
│ │ ├── FreeVariableToBufferAssignmentPassOptions.h
│ │ ├── FuzzingAnalysisInfo.h
│ │ ├── FuzzingSolver.h
│ │ ├── FuzzingSolverOptions.h
│ │ ├── JFSRuntimeFuzzingStat.h
│ │ ├── LibFuzzerInvocationManager.h
│ │ ├── LibFuzzerOptions.h
│ │ ├── SeedGenerator.h
│ │ ├── SeedManager.h
│ │ ├── SeedManagerOptions.h
│ │ ├── SeedManagerStat.h
│ │ ├── SortConformanceCheckPass.h
│ │ ├── SpecialConstantSeedGenerator.h
│ │ ├── SpecialConstantSeedGeneratorStat.h
│ │ └── WorkingDirectoryManager.h
│ ├── Support/
│ │ ├── CancellableProcess.h
│ │ ├── ErrorMessages.h
│ │ ├── FileUtils.h
│ │ ├── ICancellable.h
│ │ ├── JFSStat.h
│ │ ├── ScopedJFSTimerStatAppender.h
│ │ ├── ScopedTimer.h
│ │ ├── StatisticsManager.h
│ │ ├── Timer.h
│ │ └── version.h
│ ├── Transform/
│ │ ├── AndHoistingPass.h
│ │ ├── BitBlastPass.h
│ │ ├── BvBoundPropagationPass.h
│ │ ├── ConstantPropagationPass.h
│ │ ├── DIMACSOutputPass.h
│ │ ├── DuplicateConstraintEliminationPass.h
│ │ ├── FpToBvPass.h
│ │ ├── Passes.h
│ │ ├── QueryPass.h
│ │ ├── QueryPassManager.h
│ │ ├── SimpleContradictionsToFalsePass.h
│ │ ├── SimplificationPass.h
│ │ ├── StandardPasses.h
│ │ ├── TrueConstraintEliminationPass.h
│ │ └── Z3QueryPass.h
│ └── Z3Backend/
│ └── Z3Solver.h
├── lib/
│ ├── CMakeLists.txt
│ ├── CXXFuzzingBackend/
│ │ ├── CMakeLists.txt
│ │ ├── CXXFuzzingSolver.cpp
│ │ ├── CXXFuzzingSolverOptions.cpp
│ │ ├── CXXProgram.cpp
│ │ ├── CXXProgramBuilderOptions.cpp
│ │ ├── CXXProgramBuilderPass.cpp
│ │ ├── CXXProgramBuilderPassImpl.cpp
│ │ ├── CXXProgramBuilderPassImpl.h
│ │ ├── ClangInvocationManager.cpp
│ │ ├── ClangOptions.cpp
│ │ ├── CmdLine/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CXXProgramBuilderOptionsBuilder.cpp
│ │ │ ├── ClangOptionsBuilder.cpp
│ │ │ └── CommandLineCategory.cpp
│ │ └── JFSCXXProgramStat.cpp
│ ├── Core/
│ │ ├── CMakeLists.txt
│ │ ├── JFSContext.cpp
│ │ ├── Model.cpp
│ │ ├── ModelValidator.cpp
│ │ ├── Query.cpp
│ │ ├── RNG.cpp
│ │ ├── SMTLIB2Parser.cpp
│ │ ├── SimpleModel.cpp
│ │ ├── Solver.cpp
│ │ ├── ToolErrorHandler.cpp
│ │ ├── Z3ASTVisitor.cpp
│ │ ├── Z3Node.cpp
│ │ └── Z3NodeUtil.cpp
│ ├── FuzzingCommon/
│ │ ├── BufferAssignment.cpp
│ │ ├── BufferElement.cpp
│ │ ├── CMakeLists.txt
│ │ ├── CmdLine/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── FreeVariableToBufferAssignmentPassOptionsBuilder.cpp
│ │ │ ├── LibFuzzerOptionsBuilder.cpp
│ │ │ └── SeedManagerOptionsBuilder.cpp
│ │ ├── CommandLineCategory.cpp
│ │ ├── DummyFuzzingSolver.cpp
│ │ ├── EqualityExtractionPass.cpp
│ │ ├── FileSerializableModel.cpp
│ │ ├── FreeVariableToBufferAssignmentPass.cpp
│ │ ├── FreeVariableToBufferAssignmentPassOptions.cpp
│ │ ├── FuzzingAnalysisInfo.cpp
│ │ ├── FuzzingSolver.cpp
│ │ ├── FuzzingSolverOptions.cpp
│ │ ├── JFSRuntimeFuzzingStat.cpp
│ │ ├── LibFuzzerInvocationManager.cpp
│ │ ├── LibFuzzerOptions.cpp
│ │ ├── SMTLIBRuntimes.cpp.in
│ │ ├── SMTLIBRuntimes.h.in
│ │ ├── SeedGenerator.cpp
│ │ ├── SeedManager.cpp
│ │ ├── SeedManagerStat.cpp
│ │ ├── SortConformanceCheckPass.cpp
│ │ ├── SpecialConstantSeedGenerator.cpp
│ │ ├── SpecialConstantSeedGeneratorStat.cpp
│ │ └── WorkingDirectoryManager.cpp
│ ├── Support/
│ │ ├── CMakeLists.txt
│ │ ├── CancellableProcess.cpp
│ │ ├── ErrorMessages.cpp
│ │ ├── FileUtils.cpp
│ │ ├── ICancellable.cpp
│ │ ├── JFSStat.cpp
│ │ ├── ScopedTimer.cpp
│ │ ├── StatisticsManager.cpp
│ │ ├── Timer.cpp
│ │ └── version.cpp
│ ├── Transform/
│ │ ├── AndHoistingPass.cpp
│ │ ├── BitBlastPass.cpp
│ │ ├── BvBoundPropagationPass.cpp
│ │ ├── CMakeLists.txt
│ │ ├── ConstantPropagationPass.cpp
│ │ ├── DIMACSOutputPass.cpp
│ │ ├── DuplicateConstraintEliminationPass.cpp
│ │ ├── FpToBvPass.cpp
│ │ ├── QueryPassManager.cpp
│ │ ├── SimpleContradictionsToFalsePass.cpp
│ │ ├── SimplificationPass.cpp
│ │ ├── StandardPasses.cpp
│ │ ├── TrueConstraintEliminationPass.cpp
│ │ └── Z3QueryPass.cpp
│ └── Z3Backend/
│ ├── CMakeLists.txt
│ └── Z3Solver.cpp
├── runtime/
│ ├── CMakeLists.txt
│ ├── LibFuzzer/
│ │ ├── CMakeLists.txt
│ │ ├── Fuzzer/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── FuzzerClangCounters.cpp
│ │ │ ├── FuzzerCommand.h
│ │ │ ├── FuzzerCorpus.h
│ │ │ ├── FuzzerCrossOver.cpp
│ │ │ ├── FuzzerDefs.h
│ │ │ ├── FuzzerDictionary.h
│ │ │ ├── FuzzerDriver.cpp
│ │ │ ├── FuzzerExtFunctions.def
│ │ │ ├── FuzzerExtFunctions.h
│ │ │ ├── FuzzerExtFunctionsDlsym.cpp
│ │ │ ├── FuzzerExtFunctionsDlsymWin.cpp
│ │ │ ├── FuzzerExtFunctionsWeak.cpp
│ │ │ ├── FuzzerExtFunctionsWeakAlias.cpp
│ │ │ ├── FuzzerExtraCounters.cpp
│ │ │ ├── FuzzerFlags.def
│ │ │ ├── FuzzerIO.cpp
│ │ │ ├── FuzzerIO.h
│ │ │ ├── FuzzerIOPosix.cpp
│ │ │ ├── FuzzerIOWindows.cpp
│ │ │ ├── FuzzerInterface.h
│ │ │ ├── FuzzerInternal.h
│ │ │ ├── FuzzerLoop.cpp
│ │ │ ├── FuzzerMain.cpp
│ │ │ ├── FuzzerMerge.cpp
│ │ │ ├── FuzzerMerge.h
│ │ │ ├── FuzzerMutate.cpp
│ │ │ ├── FuzzerMutate.h
│ │ │ ├── FuzzerOptions.h
│ │ │ ├── FuzzerRandom.h
│ │ │ ├── FuzzerSHA1.cpp
│ │ │ ├── FuzzerSHA1.h
│ │ │ ├── FuzzerShmem.h
│ │ │ ├── FuzzerShmemFuchsia.cpp
│ │ │ ├── FuzzerShmemPosix.cpp
│ │ │ ├── FuzzerShmemWindows.cpp
│ │ │ ├── FuzzerTracePC.cpp
│ │ │ ├── FuzzerTracePC.h
│ │ │ ├── FuzzerUtil.cpp
│ │ │ ├── FuzzerUtil.h
│ │ │ ├── FuzzerUtilDarwin.cpp
│ │ │ ├── FuzzerUtilFuchsia.cpp
│ │ │ ├── FuzzerUtilLinux.cpp
│ │ │ ├── FuzzerUtilPosix.cpp
│ │ │ ├── FuzzerUtilWindows.cpp
│ │ │ ├── FuzzerValueBitMap.h
│ │ │ ├── README.txt
│ │ │ ├── afl/
│ │ │ │ └── afl_driver.cpp
│ │ │ ├── build.sh
│ │ │ ├── scripts/
│ │ │ │ └── unbalanced_allocs.py
│ │ │ ├── standalone/
│ │ │ │ └── StandaloneFuzzTargetMain.c
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ └── FuzzerUnittest.cpp
│ │ └── README-JFS.md
│ ├── LibPureRandomFuzzer/
│ │ ├── API.cpp
│ │ ├── API.h
│ │ ├── CMakeLists.txt
│ │ ├── Driver.cpp
│ │ ├── Driver.h
│ │ ├── Log.h
│ │ ├── Main.cpp
│ │ ├── Options.def
│ │ ├── README.md
│ │ ├── Signals.cpp
│ │ ├── Signals.h
│ │ ├── TestInput.cpp
│ │ ├── TestInput.h
│ │ └── Types.h
│ └── SMTLIB/
│ ├── CMakeLists.txt
│ ├── SMTLIB/
│ │ ├── BitVector.h
│ │ ├── BufferRef.h
│ │ ├── CMakeLists.txt
│ │ ├── Core.cpp
│ │ ├── Core.h
│ │ ├── Float.cpp
│ │ ├── Float.h
│ │ ├── Logger.cpp
│ │ ├── Logger.h
│ │ ├── Messages.cpp
│ │ ├── Messages.h
│ │ ├── NativeBitVector.cpp
│ │ ├── NativeBitVector.h
│ │ ├── NativeFloat.cpp
│ │ ├── NativeFloat.h
│ │ ├── jassert.h
│ │ └── unittests/
│ │ ├── BitVector/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Native/
│ │ │ │ ├── BvAShr.cpp
│ │ │ │ ├── BvAdd.cpp
│ │ │ │ ├── BvAlloc.cpp
│ │ │ │ ├── BvAnd.cpp
│ │ │ │ ├── BvComp.cpp
│ │ │ │ ├── BvLShr.cpp
│ │ │ │ ├── BvMul.cpp
│ │ │ │ ├── BvNand.cpp
│ │ │ │ ├── BvNeg.cpp
│ │ │ │ ├── BvNor.cpp
│ │ │ │ ├── BvNot.cpp
│ │ │ │ ├── BvOr.cpp
│ │ │ │ ├── BvSDiv.cpp
│ │ │ │ ├── BvSMod.cpp
│ │ │ │ ├── BvSRem.cpp
│ │ │ │ ├── BvSge.cpp
│ │ │ │ ├── BvSgt.cpp
│ │ │ │ ├── BvShl.cpp
│ │ │ │ ├── BvSle.cpp
│ │ │ │ ├── BvSlt.cpp
│ │ │ │ ├── BvSub.cpp
│ │ │ │ ├── BvUDiv.cpp
│ │ │ │ ├── BvURem.cpp
│ │ │ │ ├── BvUge.cpp
│ │ │ │ ├── BvUgt.cpp
│ │ │ │ ├── BvUle.cpp
│ │ │ │ ├── BvUlt.cpp
│ │ │ │ ├── BvXNor.cpp
│ │ │ │ ├── BvXor.cpp
│ │ │ │ ├── Concat.cpp
│ │ │ │ ├── Equal.cpp
│ │ │ │ ├── Extract.cpp
│ │ │ │ ├── MakeFromBuffer.cpp
│ │ │ │ ├── RotateLeft.cpp
│ │ │ │ ├── RotateRight.cpp
│ │ │ │ ├── SignExtend.cpp
│ │ │ │ ├── WriteToBuffer.cpp
│ │ │ │ └── ZeroExtend.cpp
│ │ │ └── NonNative/
│ │ │ ├── Concat.cpp
│ │ │ ├── SignExtend.cpp
│ │ │ └── ZeroExtend.cpp
│ │ ├── CMakeLists.txt
│ │ ├── Core/
│ │ │ ├── CMakeLists.txt
│ │ │ └── MakeFromBuffer.cpp
│ │ ├── Float/
│ │ │ ├── CMakeLists.txt
│ │ │ └── Native/
│ │ │ ├── Abs.cpp
│ │ │ ├── Add.cpp
│ │ │ ├── ConvertToFloatFromFloat.cpp
│ │ │ ├── ConvertToFloatFromSignedBV.cpp
│ │ │ ├── ConvertToFloatFromUnsignedBV.cpp
│ │ │ ├── ConvertToSignedBVFromFloat.cpp
│ │ │ ├── ConvertToUnsignedBVFromFloat.cpp
│ │ │ ├── Div.cpp
│ │ │ ├── FMA.cpp
│ │ │ ├── GreaterThan.cpp
│ │ │ ├── GreaterThanOrEqual.cpp
│ │ │ ├── IEEEEquals.cpp
│ │ │ ├── IsInfinite.cpp
│ │ │ ├── IsNaN.cpp
│ │ │ ├── IsNegative.cpp
│ │ │ ├── IsNormal.cpp
│ │ │ ├── IsPositive.cpp
│ │ │ ├── IsSubnormal.cpp
│ │ │ ├── IsZero.cpp
│ │ │ ├── LessThan.cpp
│ │ │ ├── LessThanOrEqual.cpp
│ │ │ ├── MakeFromBuffer.cpp
│ │ │ ├── MakeFromIEEEBitVector.cpp
│ │ │ ├── MakeFromTriple.cpp
│ │ │ ├── Max.cpp
│ │ │ ├── Min.cpp
│ │ │ ├── Mul.cpp
│ │ │ ├── Neg.cpp
│ │ │ ├── Rem.cpp
│ │ │ ├── RoundToIntegral.cpp
│ │ │ ├── SMTLIBEquals.cpp
│ │ │ ├── SpecialConstants.cpp
│ │ │ ├── Sqrt.cpp
│ │ │ └── Sub.cpp
│ │ ├── Logger/
│ │ │ ├── CMakeLists.txt
│ │ │ └── LoggerTests.cpp
│ │ ├── SMTLIBRuntimeTestUtil.cpp
│ │ ├── SMTLIBRuntimeTestUtil.h
│ │ ├── lit-unit-tests-common.cfg
│ │ └── lit-unit-tests-common.site.cfg.in
│ └── gtest/
│ └── CMakeLists.txt
├── scripts/
│ ├── Dockerfiles/
│ │ ├── build.sh
│ │ ├── jfs_base_ubuntu_16.04.Dockerfile
│ │ └── jfs_build_ubuntu_16.04.Dockerfile
│ └── dist/
│ ├── build_and_install_cmake.sh
│ ├── build_and_install_ninja.sh
│ ├── build_jfs.sh
│ ├── build_llvm.sh
│ ├── build_z3.sh
│ └── test_jfs.sh
├── tests/
│ ├── CMakeLists.txt
│ ├── system_tests/
│ │ ├── CMakeLists.txt
│ │ ├── CNF/
│ │ │ ├── 2017-09-02-float-constant-regression.smt2
│ │ │ ├── imperial_synthetic_sqrt_klee_bug.x86_64_query.05.smt2
│ │ │ └── less_variables_than_bits.smt2
│ │ ├── CXXFuzzingBackend/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CXXProgramBuilder/
│ │ │ │ ├── SingleConstantAssignment.smt2
│ │ │ │ ├── SingleUnconstraintedBool.smt2
│ │ │ │ ├── UsedConstantAssignment.smt2
│ │ │ │ ├── UsedConstantFloatingPointAssignment.smt2
│ │ │ │ ├── branch_encodings/
│ │ │ │ │ ├── fail_fast.smt2
│ │ │ │ │ ├── try_all.smt2
│ │ │ │ │ └── try_all_imncsf.smt2
│ │ │ │ ├── buffer_element_alignment/
│ │ │ │ │ ├── bv_bool_bv_bool.smt2
│ │ │ │ │ ├── bv_bool_bv_bool_float.smt2
│ │ │ │ │ └── three_bools.smt2
│ │ │ │ ├── inconsistent_equalities.smt2
│ │ │ │ ├── operations/
│ │ │ │ │ ├── bool/
│ │ │ │ │ │ ├── and.smt2
│ │ │ │ │ │ ├── distinct_bool.smt2
│ │ │ │ │ │ ├── equal_bool.smt2
│ │ │ │ │ │ ├── iff.smt2
│ │ │ │ │ │ ├── implies.smt2
│ │ │ │ │ │ ├── ite_bool.smt2
│ │ │ │ │ │ ├── not.smt2
│ │ │ │ │ │ ├── or.smt2
│ │ │ │ │ │ └── xor.smt2
│ │ │ │ │ ├── bv/
│ │ │ │ │ │ ├── bvadd.smt2
│ │ │ │ │ │ ├── bvadd_nary.smt2
│ │ │ │ │ │ ├── bvand.smt2
│ │ │ │ │ │ ├── bvand_nary.smt2
│ │ │ │ │ │ ├── bvashr.smt2
│ │ │ │ │ │ ├── bvcomp.smt2
│ │ │ │ │ │ ├── bvlshr.smt2
│ │ │ │ │ │ ├── bvmul.smt2
│ │ │ │ │ │ ├── bvmul_nary.smt2
│ │ │ │ │ │ ├── bvnand.smt2
│ │ │ │ │ │ ├── bvneg.smt2
│ │ │ │ │ │ ├── bvnor.smt2
│ │ │ │ │ │ ├── bvnot.smt2
│ │ │ │ │ │ ├── bvor.smt2
│ │ │ │ │ │ ├── bvor_nary.smt2
│ │ │ │ │ │ ├── bvsdiv.smt2
│ │ │ │ │ │ ├── bvsdiv0.smt2
│ │ │ │ │ │ ├── bvsdiv_i.smt2
│ │ │ │ │ │ ├── bvsge.smt2
│ │ │ │ │ │ ├── bvsgt.smt2
│ │ │ │ │ │ ├── bvshl.smt2
│ │ │ │ │ │ ├── bvsle.smt2
│ │ │ │ │ │ ├── bvslt.smt2
│ │ │ │ │ │ ├── bvsmod.smt2
│ │ │ │ │ │ ├── bvsmod_i.smt2
│ │ │ │ │ │ ├── bvsrem.smt2
│ │ │ │ │ │ ├── bvsrem_i.smt2
│ │ │ │ │ │ ├── bvsub.smt2
│ │ │ │ │ │ ├── bvudiv.smt2
│ │ │ │ │ │ ├── bvudiv0.smt2
│ │ │ │ │ │ ├── bvudiv_i.smt2
│ │ │ │ │ │ ├── bvuge.smt2
│ │ │ │ │ │ ├── bvugt.smt2
│ │ │ │ │ │ ├── bvule.smt2
│ │ │ │ │ │ ├── bvult.smt2
│ │ │ │ │ │ ├── bvurem.smt2
│ │ │ │ │ │ ├── bvurem_i.smt2
│ │ │ │ │ │ ├── bvxnor.smt2
│ │ │ │ │ │ ├── bvxor.smt2
│ │ │ │ │ │ ├── bvxor_nary.smt2
│ │ │ │ │ │ ├── concat.smt2
│ │ │ │ │ │ ├── concat_large.smt2
│ │ │ │ │ │ ├── distinct_bitvector.smt2
│ │ │ │ │ │ ├── equal_bitvector.smt2
│ │ │ │ │ │ ├── extract.smt2
│ │ │ │ │ │ ├── ite_bitvector.smt2
│ │ │ │ │ │ ├── rotate_left.smt2
│ │ │ │ │ │ ├── rotate_right.smt2
│ │ │ │ │ │ ├── sign_extend.smt2
│ │ │ │ │ │ └── zero_extend.smt2
│ │ │ │ │ └── fp/
│ │ │ │ │ ├── abs_float32.smt2
│ │ │ │ │ ├── abs_float64.smt2
│ │ │ │ │ ├── add_rna_float32.smt2
│ │ │ │ │ ├── add_rna_float64.smt2
│ │ │ │ │ ├── add_rne_float32.smt2
│ │ │ │ │ ├── add_rne_float64.smt2
│ │ │ │ │ ├── add_rtn_float32.smt2
│ │ │ │ │ ├── add_rtn_float64.smt2
│ │ │ │ │ ├── add_rtp_float32.smt2
│ │ │ │ │ ├── add_rtp_float64.smt2
│ │ │ │ │ ├── add_rtz_float32.smt2
│ │ │ │ │ ├── add_rtz_float64.smt2
│ │ │ │ │ ├── cast_bv32_to_float.smt2
│ │ │ │ │ ├── constant_nan_float32.smt2
│ │ │ │ │ ├── constant_nan_float64.smt2
│ │ │ │ │ ├── constant_negative_infinity_float32.smt2
│ │ │ │ │ ├── constant_negative_infinity_float64.smt2
│ │ │ │ │ ├── constant_negative_zero_float32.smt2
│ │ │ │ │ ├── constant_negative_zero_float64.smt2
│ │ │ │ │ ├── constant_plus_infinity_float32.smt2
│ │ │ │ │ ├── constant_plus_infinity_float64.smt2
│ │ │ │ │ ├── constant_plus_zero_float32.smt2
│ │ │ │ │ ├── constant_plus_zero_float64.smt2
│ │ │ │ │ ├── constants_from_triple.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_float64_rtz.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_signed_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float32_from_unsigned_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_float64_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_signed_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rna.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rne.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rtn.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rtp.smt2
│ │ │ │ │ ├── convert_to_float64_from_unsigned_bv_rtz.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_signed_bv_from_float64_rtz.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rna.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rne.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rtn.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rtp.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float32_rtz.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rna.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rne.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rtn.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rtp.smt2
│ │ │ │ │ ├── convert_to_unsigned_bv_from_float64_rtz.smt2
│ │ │ │ │ ├── div_rna_float32.smt2
│ │ │ │ │ ├── div_rna_float64.smt2
│ │ │ │ │ ├── div_rne_float32.smt2
│ │ │ │ │ ├── div_rne_float64.smt2
│ │ │ │ │ ├── div_rtn_float32.smt2
│ │ │ │ │ ├── div_rtn_float64.smt2
│ │ │ │ │ ├── div_rtp_float32.smt2
│ │ │ │ │ ├── div_rtp_float64.smt2
│ │ │ │ │ ├── div_rtz_float32.smt2
│ │ │ │ │ ├── div_rtz_float64.smt2
│ │ │ │ │ ├── fma_rna_float32.smt2
│ │ │ │ │ ├── fma_rna_float64.smt2
│ │ │ │ │ ├── fma_rne_float32.smt2
│ │ │ │ │ ├── fma_rne_float64.smt2
│ │ │ │ │ ├── fma_rtn_float32.smt2
│ │ │ │ │ ├── fma_rtn_float64.smt2
│ │ │ │ │ ├── fma_rtp_float32.smt2
│ │ │ │ │ ├── fma_rtp_float64.smt2
│ │ │ │ │ ├── fma_rtz_float32.smt2
│ │ │ │ │ ├── fma_rtz_float64.smt2
│ │ │ │ │ ├── fpgeq_float32.smt2
│ │ │ │ │ ├── fpgeq_float64.smt2
│ │ │ │ │ ├── fpgt_float32.smt2
│ │ │ │ │ ├── fpgt_float64.smt2
│ │ │ │ │ ├── fpleq_float32.smt2
│ │ │ │ │ ├── fpleq_float64.smt2
│ │ │ │ │ ├── fplt_float32.smt2
│ │ │ │ │ ├── fplt_float64.smt2
│ │ │ │ │ ├── ieee_equals_float32.smt2
│ │ │ │ │ ├── ieee_equals_float64.smt2
│ │ │ │ │ ├── is_infinite_float32.smt2
│ │ │ │ │ ├── is_infinite_float64.smt2
│ │ │ │ │ ├── is_nan_float32.smt2
│ │ │ │ │ ├── is_nan_float64.smt2
│ │ │ │ │ ├── is_negative_float32.smt2
│ │ │ │ │ ├── is_negative_float64.smt2
│ │ │ │ │ ├── is_normal_float32.smt2
│ │ │ │ │ ├── is_normal_float64.smt2
│ │ │ │ │ ├── is_positive_float32.smt2
│ │ │ │ │ ├── is_positive_float64.smt2
│ │ │ │ │ ├── is_subnormal_float32.smt2
│ │ │ │ │ ├── is_subnormal_float64.smt2
│ │ │ │ │ ├── is_zero_float32.smt2
│ │ │ │ │ ├── is_zero_float64.smt2
│ │ │ │ │ ├── max_float32.smt2
│ │ │ │ │ ├── max_float64.smt2
│ │ │ │ │ ├── min_float32.smt2
│ │ │ │ │ ├── min_float64.smt2
│ │ │ │ │ ├── mul_rna_float32.smt2
│ │ │ │ │ ├── mul_rna_float64.smt2
│ │ │ │ │ ├── mul_rne_float32.smt2
│ │ │ │ │ ├── mul_rne_float64.smt2
│ │ │ │ │ ├── mul_rtn_float32.smt2
│ │ │ │ │ ├── mul_rtn_float64.smt2
│ │ │ │ │ ├── mul_rtp_float32.smt2
│ │ │ │ │ ├── mul_rtp_float64.smt2
│ │ │ │ │ ├── mul_rtz_float32.smt2
│ │ │ │ │ ├── mul_rtz_float64.smt2
│ │ │ │ │ ├── neg_float32.smt2
│ │ │ │ │ ├── neg_float64.smt2
│ │ │ │ │ ├── print_fp_const_minus_inf_float64.smt2
│ │ │ │ │ ├── print_fp_const_minus_zero_float64.smt2
│ │ │ │ │ ├── print_fp_const_nan_float64.smt2
│ │ │ │ │ ├── print_fp_const_plus_inf_float64.smt2
│ │ │ │ │ ├── print_fp_const_plus_zero_float64.smt2
│ │ │ │ │ ├── rem_float32.smt2
│ │ │ │ │ ├── rem_float64.smt2
│ │ │ │ │ ├── round_to_integral_rna_float32.smt2
│ │ │ │ │ ├── round_to_integral_rna_float64.smt2
│ │ │ │ │ ├── round_to_integral_rne_float32.smt2
│ │ │ │ │ ├── round_to_integral_rne_float64.smt2
│ │ │ │ │ ├── round_to_integral_rtn_float32.smt2
│ │ │ │ │ ├── round_to_integral_rtn_float64.smt2
│ │ │ │ │ ├── round_to_integral_rtp_float32.smt2
│ │ │ │ │ ├── round_to_integral_rtp_float64.smt2
│ │ │ │ │ ├── round_to_integral_rtz_float32.smt2
│ │ │ │ │ ├── round_to_integral_rtz_float64.smt2
│ │ │ │ │ ├── sqrt_rna_float32.smt2
│ │ │ │ │ ├── sqrt_rna_float64.smt2
│ │ │ │ │ ├── sqrt_rne_float32.smt2
│ │ │ │ │ ├── sqrt_rne_float64.smt2
│ │ │ │ │ ├── sqrt_rtn_float32.smt2
│ │ │ │ │ ├── sqrt_rtn_float64.smt2
│ │ │ │ │ ├── sqrt_rtp_float32.smt2
│ │ │ │ │ ├── sqrt_rtp_float64.smt2
│ │ │ │ │ ├── sqrt_rtz_float32.smt2
│ │ │ │ │ ├── sqrt_rtz_float64.smt2
│ │ │ │ │ ├── sub_rna_float32.smt2
│ │ │ │ │ ├── sub_rna_float64.smt2
│ │ │ │ │ ├── sub_rne_float32.smt2
│ │ │ │ │ ├── sub_rne_float64.smt2
│ │ │ │ │ ├── sub_rtn_float32.smt2
│ │ │ │ │ ├── sub_rtn_float64.smt2
│ │ │ │ │ ├── sub_rtp_float32.smt2
│ │ │ │ │ ├── sub_rtp_float64.smt2
│ │ │ │ │ ├── sub_rtz_float32.smt2
│ │ │ │ │ └── sub_rtz_float64.smt2
│ │ │ │ ├── symbol_names/
│ │ │ │ │ ├── quoted_symbol.smt2
│ │ │ │ │ ├── simple_alphanumeric.smt2
│ │ │ │ │ ├── simple_alphanumeric_ampersand.smt2
│ │ │ │ │ ├── simple_alphanumeric_asterisk.smt2
│ │ │ │ │ ├── simple_alphanumeric_at.smt2
│ │ │ │ │ ├── simple_alphanumeric_caret.smt2
│ │ │ │ │ ├── simple_alphanumeric_dollar_sign.smt2
│ │ │ │ │ ├── simple_alphanumeric_dot.smt2
│ │ │ │ │ ├── simple_alphanumeric_equal.smt2
│ │ │ │ │ ├── simple_alphanumeric_exclaimation_mark.smt2
│ │ │ │ │ ├── simple_alphanumeric_gt.smt2
│ │ │ │ │ ├── simple_alphanumeric_lt.smt2
│ │ │ │ │ ├── simple_alphanumeric_minus.smt2
│ │ │ │ │ ├── simple_alphanumeric_minus_clash.smt2
│ │ │ │ │ ├── simple_alphanumeric_percent.smt2
│ │ │ │ │ ├── simple_alphanumeric_plus.smt2
│ │ │ │ │ ├── simple_alphanumeric_question_foward_slash.smt2
│ │ │ │ │ ├── simple_alphanumeric_question_mark.smt2
│ │ │ │ │ ├── simple_alphanumeric_tilda.smt2
│ │ │ │ │ └── stress_test.smt2
│ │ │ │ ├── track_num_constraints/
│ │ │ │ │ ├── track_max_num_solved_fail_fast.smt2
│ │ │ │ │ ├── track_max_num_solved_try_all.smt2
│ │ │ │ │ └── track_max_num_solved_try_all_imncsf.smt2
│ │ │ │ └── track_num_inputs/
│ │ │ │ ├── track_num_inputs.smt2
│ │ │ │ └── track_num_wrong_size_inputs.smt2
│ │ │ ├── Fuzz/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── branch_encodings/
│ │ │ │ │ └── try_all_imncsf.smt2
│ │ │ │ ├── buffer_element_alignment/
│ │ │ │ │ └── bv_bool_bv_bool_float.smt2
│ │ │ │ ├── lit.local.cfg
│ │ │ │ ├── models/
│ │ │ │ │ ├── equality_extraction/
│ │ │ │ │ │ ├── all_assignments.smt2
│ │ │ │ │ │ ├── empty.smt2
│ │ │ │ │ │ ├── equalities_with_model_from_fuzzer.smt2
│ │ │ │ │ │ └── trivial_equalities.smt2
│ │ │ │ │ └── simple/
│ │ │ │ │ ├── 3_bv_const.smt2
│ │ │ │ │ ├── 3_true.smt2
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── empty.smt2
│ │ │ │ │ ├── float_nan.smt2
│ │ │ │ │ ├── float_neg_inf.smt2
│ │ │ │ │ ├── float_neg_one.smt2
│ │ │ │ │ ├── float_neg_zero.smt2
│ │ │ │ │ ├── float_pos_inf.smt2
│ │ │ │ │ ├── float_pos_one.smt2
│ │ │ │ │ └── float_pos_zero.smt2
│ │ │ │ ├── runtimes/
│ │ │ │ │ └── a629test0052.smt2
│ │ │ │ ├── sat/
│ │ │ │ │ ├── 2017-09-02-float-constant-regression.smt2
│ │ │ │ │ ├── a629test0052.smt2
│ │ │ │ │ ├── max-has-solution-12341.smt2
│ │ │ │ │ ├── min-has-solution-1235.smt2
│ │ │ │ │ ├── simple_bool.smt2
│ │ │ │ │ └── simplifer_makes_consts.smt2
│ │ │ │ ├── stats/
│ │ │ │ │ ├── can_write_to_stdout.smt2
│ │ │ │ │ └── valid_yaml.smt2
│ │ │ │ ├── test_format.py
│ │ │ │ ├── tracing/
│ │ │ │ │ ├── increase_in_max_num_constraints_sat.smt2
│ │ │ │ │ └── trace_wrong_sized_input.smt2
│ │ │ │ ├── track_all/
│ │ │ │ │ ├── sat_fail_fast_encoding.smt2
│ │ │ │ │ ├── sat_try_all_encodings.smt2
│ │ │ │ │ ├── unsat_fail_fast_encoding.smt2
│ │ │ │ │ └── unsat_try_all_encoding.smt2
│ │ │ │ ├── track_num_constraints/
│ │ │ │ │ ├── sat_fail_fast_encoding.smt2
│ │ │ │ │ ├── sat_try_all_encoding.smt2
│ │ │ │ │ ├── unsat_fail_fast_encoding.smt2
│ │ │ │ │ └── unsat_try_all_encoding.smt2
│ │ │ │ ├── unknown/
│ │ │ │ │ ├── bv_unsupported_size.smt2
│ │ │ │ │ └── float_unsupported_size.smt2
│ │ │ │ └── unsat/
│ │ │ │ ├── max-no-solution.smt2
│ │ │ │ └── min-no-solution.smt2
│ │ │ └── SeedGeneration/
│ │ │ ├── 3b_all_ones
│ │ │ ├── 3b_all_zeros
│ │ │ ├── all_zeros_and_all_ones.smt2
│ │ │ ├── bool_bv_float.smt2
│ │ │ ├── bool_bv_float_linux.smt2
│ │ │ ├── max_num_seeds_1.smt2
│ │ │ └── special_constants_stats.smt2
│ │ ├── CommandLine/
│ │ │ ├── NonExistentFile.smt2
│ │ │ └── version.smt2
│ │ ├── DummyFuzzingSolver/
│ │ │ ├── README.md
│ │ │ ├── sat/
│ │ │ │ ├── trivial_equalities.smt2
│ │ │ │ └── true_elim.smt2
│ │ │ ├── unknown/
│ │ │ │ ├── trivial_equality_with_non_trivial_constraint.smt2
│ │ │ │ └── unknown_ineq.smt2
│ │ │ └── unsat/
│ │ │ ├── bound_contradiction.smt2
│ │ │ ├── bound_contradiction2.smt2
│ │ │ └── true_elim.smt2
│ │ ├── Transforms/
│ │ │ ├── AndHoisting/
│ │ │ │ ├── nested_and.smt2
│ │ │ │ ├── non_constant_and.smt2
│ │ │ │ ├── single_and.smt2
│ │ │ │ └── single_and_ternary.smt2
│ │ │ ├── BvBoundPropagation/
│ │ │ │ └── bound_contradiction.smt2
│ │ │ ├── ConstantPropagation/
│ │ │ │ ├── constant_prop.smt2
│ │ │ │ ├── constant_prop_and.smt2
│ │ │ │ ├── duplicate_constraint.smt2
│ │ │ │ ├── modulus_true-unreach-call_true-no-overflow.i_242.smt2
│ │ │ │ ├── not_preverse_multiple_false.smt2
│ │ │ │ └── preserve_false.smt2
│ │ │ ├── DuplicateConstraintElimination/
│ │ │ │ └── duplicate_equals.smt2
│ │ │ ├── SimpleContradictionsToFalse/
│ │ │ │ └── e_not_e.smt2
│ │ │ ├── Simplify/
│ │ │ │ ├── constant_fold_bvadd.smt2
│ │ │ │ ├── constant_fold_ite_identity.smt2
│ │ │ │ ├── equal.smt2
│ │ │ │ └── not_equal.smt2
│ │ │ └── TrueConstraintElimination/
│ │ │ └── true_elim.smt2
│ │ ├── Z3Backend/
│ │ │ └── QF_FPBV/
│ │ │ ├── sat/
│ │ │ │ └── imperial_synthetic_sqrt_klee_bug.x86_64_query.05.smt2
│ │ │ └── unsat/
│ │ │ └── imperial_synthetic_sqrt_klee_bug.x86_64_query.06.smt2
│ │ ├── lit.cfg
│ │ └── lit.site.cfg.in
│ └── unit_tests/
│ ├── CMakeLists.txt
│ ├── Core/
│ │ ├── CMakeLists.txt
│ │ └── FloatSpecialConstants.cpp
│ ├── Dummy/
│ │ ├── CMakeLists.txt
│ │ └── Dummy.cpp
│ ├── FuzzingCommon/
│ │ ├── CMakeLists.txt
│ │ └── EqualityExtractionPass.cpp
│ ├── lit-unit-tests-common.cfg
│ └── lit-unit-tests-common.site.cfg.in
├── tools/
│ ├── CMakeLists.txt
│ ├── jfs/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ ├── jfs-opt/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ ├── jfs-smt2cnf/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ ├── jfs-smt2cxx/
│ │ ├── CMakeLists.txt
│ │ └── main.cpp
│ └── yaml-syntax-check/
│ ├── CMakeLists.txt
│ └── main.cpp
└── utils/
├── CMakeLists.txt
├── FileCheck/
│ ├── CMakeLists.txt
│ ├── FileCheck.cpp
│ └── LICENSE.TXT
├── SMT-COMP/
│ ├── StarExec-SMTCOMP2017.Dockerfile
│ ├── configs/
│ │ └── starexec_run_default
│ ├── mk_starexec_binary_dist.sh
│ └── starexec_description.txt
├── googletest/
│ ├── CMakeLists.txt
│ ├── README.md
│ └── googletest/
│ ├── .gitignore
│ ├── CHANGES
│ ├── CMakeLists.txt
│ ├── CONTRIBUTORS
│ ├── LICENSE
│ ├── Makefile.am
│ ├── README.md
│ ├── build-aux/
│ │ └── .keep
│ ├── cmake/
│ │ └── internal_utils.cmake
│ ├── codegear/
│ │ ├── gtest.cbproj
│ │ ├── gtest.groupproj
│ │ ├── gtest_all.cc
│ │ ├── gtest_link.cc
│ │ ├── gtest_main.cbproj
│ │ └── gtest_unittest.cbproj
│ ├── configure.ac
│ ├── docs/
│ │ ├── AdvancedGuide.md
│ │ ├── DevGuide.md
│ │ ├── Documentation.md
│ │ ├── FAQ.md
│ │ ├── Primer.md
│ │ ├── PumpManual.md
│ │ ├── Samples.md
│ │ ├── V1_5_AdvancedGuide.md
│ │ ├── V1_5_Documentation.md
│ │ ├── V1_5_FAQ.md
│ │ ├── V1_5_Primer.md
│ │ ├── V1_5_PumpManual.md
│ │ ├── V1_5_XcodeGuide.md
│ │ ├── V1_6_AdvancedGuide.md
│ │ ├── V1_6_Documentation.md
│ │ ├── V1_6_FAQ.md
│ │ ├── V1_6_Primer.md
│ │ ├── V1_6_PumpManual.md
│ │ ├── V1_6_Samples.md
│ │ ├── V1_6_XcodeGuide.md
│ │ ├── V1_7_AdvancedGuide.md
│ │ ├── V1_7_Documentation.md
│ │ ├── V1_7_FAQ.md
│ │ ├── V1_7_Primer.md
│ │ ├── V1_7_PumpManual.md
│ │ ├── V1_7_Samples.md
│ │ ├── V1_7_XcodeGuide.md
│ │ └── XcodeGuide.md
│ ├── include/
│ │ └── gtest/
│ │ ├── gtest-death-test.h
│ │ ├── gtest-message.h
│ │ ├── gtest-param-test.h
│ │ ├── gtest-param-test.h.pump
│ │ ├── gtest-printers.h
│ │ ├── gtest-spi.h
│ │ ├── gtest-test-part.h
│ │ ├── gtest-typed-test.h
│ │ ├── gtest.h
│ │ ├── gtest_pred_impl.h
│ │ ├── gtest_prod.h
│ │ └── internal/
│ │ ├── custom/
│ │ │ ├── gtest-port.h
│ │ │ ├── gtest-printers.h
│ │ │ └── gtest.h
│ │ ├── gtest-death-test-internal.h
│ │ ├── gtest-filepath.h
│ │ ├── gtest-internal.h
│ │ ├── gtest-linked_ptr.h
│ │ ├── gtest-param-util-generated.h
│ │ ├── gtest-param-util-generated.h.pump
│ │ ├── gtest-param-util.h
│ │ ├── gtest-port-arch.h
│ │ ├── gtest-port.h
│ │ ├── gtest-string.h
│ │ ├── gtest-tuple.h
│ │ ├── gtest-tuple.h.pump
│ │ ├── gtest-type-util.h
│ │ └── gtest-type-util.h.pump
│ ├── m4/
│ │ ├── acx_pthread.m4
│ │ └── gtest.m4
│ ├── make/
│ │ └── Makefile
│ ├── msvc/
│ │ ├── gtest-md.sln
│ │ ├── gtest-md.vcproj
│ │ ├── gtest.sln
│ │ ├── gtest.vcproj
│ │ ├── gtest_main-md.vcproj
│ │ ├── gtest_main.vcproj
│ │ ├── gtest_prod_test-md.vcproj
│ │ ├── gtest_prod_test.vcproj
│ │ ├── gtest_unittest-md.vcproj
│ │ └── gtest_unittest.vcproj
│ ├── samples/
│ │ ├── prime_tables.h
│ │ ├── sample1.cc
│ │ ├── sample1.h
│ │ ├── sample10_unittest.cc
│ │ ├── sample1_unittest.cc
│ │ ├── sample2.cc
│ │ ├── sample2.h
│ │ ├── sample2_unittest.cc
│ │ ├── sample3-inl.h
│ │ ├── sample3_unittest.cc
│ │ ├── sample4.cc
│ │ ├── sample4.h
│ │ ├── sample4_unittest.cc
│ │ ├── sample5_unittest.cc
│ │ ├── sample6_unittest.cc
│ │ ├── sample7_unittest.cc
│ │ ├── sample8_unittest.cc
│ │ └── sample9_unittest.cc
│ ├── scripts/
│ │ ├── common.py
│ │ ├── fuse_gtest_files.py
│ │ ├── gen_gtest_pred_impl.py
│ │ ├── gtest-config.in
│ │ ├── pump.py
│ │ ├── release_docs.py
│ │ ├── test/
│ │ │ └── Makefile
│ │ ├── upload.py
│ │ └── upload_gtest.py
│ ├── src/
│ │ ├── gtest-all.cc
│ │ ├── gtest-death-test.cc
│ │ ├── gtest-filepath.cc
│ │ ├── gtest-internal-inl.h
│ │ ├── gtest-port.cc
│ │ ├── gtest-printers.cc
│ │ ├── gtest-test-part.cc
│ │ ├── gtest-typed-test.cc
│ │ ├── gtest.cc
│ │ └── gtest_main.cc
│ ├── test/
│ │ ├── gtest-death-test_ex_test.cc
│ │ ├── gtest-death-test_test.cc
│ │ ├── gtest-filepath_test.cc
│ │ ├── gtest-linked_ptr_test.cc
│ │ ├── gtest-listener_test.cc
│ │ ├── gtest-message_test.cc
│ │ ├── gtest-options_test.cc
│ │ ├── gtest-param-test2_test.cc
│ │ ├── gtest-param-test_test.cc
│ │ ├── gtest-param-test_test.h
│ │ ├── gtest-port_test.cc
│ │ ├── gtest-printers_test.cc
│ │ ├── gtest-test-part_test.cc
│ │ ├── gtest-tuple_test.cc
│ │ ├── gtest-typed-test2_test.cc
│ │ ├── gtest-typed-test_test.cc
│ │ ├── gtest-typed-test_test.h
│ │ ├── gtest-unittest-api_test.cc
│ │ ├── gtest_all_test.cc
│ │ ├── gtest_break_on_failure_unittest.py
│ │ ├── gtest_break_on_failure_unittest_.cc
│ │ ├── gtest_catch_exceptions_test.py
│ │ ├── gtest_catch_exceptions_test_.cc
│ │ ├── gtest_color_test.py
│ │ ├── gtest_color_test_.cc
│ │ ├── gtest_env_var_test.py
│ │ ├── gtest_env_var_test_.cc
│ │ ├── gtest_environment_test.cc
│ │ ├── gtest_filter_unittest.py
│ │ ├── gtest_filter_unittest_.cc
│ │ ├── gtest_help_test.py
│ │ ├── gtest_help_test_.cc
│ │ ├── gtest_list_tests_unittest.py
│ │ ├── gtest_list_tests_unittest_.cc
│ │ ├── gtest_main_unittest.cc
│ │ ├── gtest_no_test_unittest.cc
│ │ ├── gtest_output_test.py
│ │ ├── gtest_output_test_.cc
│ │ ├── gtest_output_test_golden_lin.txt
│ │ ├── gtest_pred_impl_unittest.cc
│ │ ├── gtest_premature_exit_test.cc
│ │ ├── gtest_prod_test.cc
│ │ ├── gtest_repeat_test.cc
│ │ ├── gtest_shuffle_test.py
│ │ ├── gtest_shuffle_test_.cc
│ │ ├── gtest_sole_header_test.cc
│ │ ├── gtest_stress_test.cc
│ │ ├── gtest_test_utils.py
│ │ ├── gtest_throw_on_failure_ex_test.cc
│ │ ├── gtest_throw_on_failure_test.py
│ │ ├── gtest_throw_on_failure_test_.cc
│ │ ├── gtest_uninitialized_test.py
│ │ ├── gtest_uninitialized_test_.cc
│ │ ├── gtest_unittest.cc
│ │ ├── gtest_xml_outfile1_test_.cc
│ │ ├── gtest_xml_outfile2_test_.cc
│ │ ├── gtest_xml_outfiles_test.py
│ │ ├── gtest_xml_output_unittest.py
│ │ ├── gtest_xml_output_unittest_.cc
│ │ ├── gtest_xml_test_utils.py
│ │ ├── production.cc
│ │ └── production.h
│ └── xcode/
│ ├── Config/
│ │ ├── DebugProject.xcconfig
│ │ ├── FrameworkTarget.xcconfig
│ │ ├── General.xcconfig
│ │ ├── ReleaseProject.xcconfig
│ │ ├── StaticLibraryTarget.xcconfig
│ │ └── TestTarget.xcconfig
│ ├── Resources/
│ │ └── Info.plist
│ ├── Samples/
│ │ └── FrameworkSample/
│ │ ├── Info.plist
│ │ ├── WidgetFramework.xcodeproj/
│ │ │ └── project.pbxproj
│ │ ├── runtests.sh
│ │ ├── widget.cc
│ │ ├── widget.h
│ │ └── widget_test.cc
│ ├── Scripts/
│ │ ├── runtests.sh
│ │ └── versiongenerate.py
│ └── gtest.xcodeproj/
│ └── project.pbxproj
├── hacks/
│ └── query-run/
│ ├── query-filter.py
│ ├── query-info.py
│ └── run-queries.py
├── not/
│ ├── CMakeLists.txt
│ ├── LICENSE.TXT
│ └── not.cpp
└── suppressions/
├── lsan/
│ ├── README.md
│ └── lsan_sup.txt
├── supr_env.sh
└── ubsan/
├── README.md
└── ubsan_sup.txt
Showing preview only (462K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4367 symbols across 385 files)
FILE: include/jfs/CXXFuzzingBackend/CXXFuzzingSolver.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/CXXFuzzingSolverOptions.h
function namespace (line 21) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/CXXProgram.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/CXXProgramBuilderOptions.h
function namespace (line 16) | namespace cxxfb {
FILE: include/jfs/CXXFuzzingBackend/CXXProgramBuilderPass.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/ClangInvocationManager.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/ClangOptions.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/CmdLine/CXXProgramBuilderOptionsBuilder.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/CmdLine/ClangOptionsBuilder.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/CmdLine/CommandLineCategory.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/CXXFuzzingBackend/JFSCXXProgramStat.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Core/JFSContext.h
function namespace (line 17) | namespace jfs {
function namespace (line 23) | namespace jfs {
FILE: include/jfs/Core/Model.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/Core/ModelValidator.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/Core/Query.h
function namespace (line 20) | namespace core {
FILE: include/jfs/Core/RNG.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/Core/SMTLIB2Parser.h
function namespace (line 18) | namespace llvm {
function namespace (line 22) | namespace jfs {
FILE: include/jfs/Core/ScopedJFSContextErrorHandler.h
function namespace (line 14) | namespace jfs {
FILE: include/jfs/Core/SimpleModel.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/Core/Solver.h
function namespace (line 20) | namespace jfs {
FILE: include/jfs/Core/SolverOptions.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Core/ToolErrorHandler.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/Core/Z3ASTCmp.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Core/Z3ASTVisitor.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/Core/Z3Node.h
function namespace (line 18) | namespace jfs {
function inc_ref (line 87) | inline void Z3NodeHandle<Z3_sort>::inc_ref(Z3_sort node) {
function dec_ref (line 92) | inline void Z3NodeHandle<Z3_sort>::dec_ref(Z3_sort node) {
function class (line 103) | class Z3SortHandle : public Z3NodeHandle<Z3_sort> {
FILE: include/jfs/Core/Z3NodeMap.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Core/Z3NodeSet.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/Core/Z3NodeUtil.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/FuzzingCommon/BufferAssignment.h
function namespace (line 20) | namespace jfs {
FILE: include/jfs/FuzzingCommon/BufferElement.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/FuzzingCommon/CmdLine/FreeVariableToBufferAssignmentPassOptionsBuilder.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/FuzzingCommon/CmdLine/LibFuzzerOptionsBuilder.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/FuzzingCommon/CmdLine/SeedManagerOptionsBuilder.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/FuzzingCommon/CommandLineCategory.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/FuzzingCommon/DummyFuzzingSolver.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/FuzzingCommon/EqualityExtractionPass.h
function namespace (line 20) | namespace jfs {
FILE: include/jfs/FuzzingCommon/FileSerializableModel.h
function namespace (line 20) | namespace jfs {
FILE: include/jfs/FuzzingCommon/FreeVariableToBufferAssignmentPass.h
function namespace (line 23) | namespace jfs {
FILE: include/jfs/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/FuzzingCommon/FuzzingAnalysisInfo.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/FuzzingCommon/FuzzingSolver.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/FuzzingCommon/FuzzingSolverOptions.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/FuzzingCommon/JFSRuntimeFuzzingStat.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/FuzzingCommon/LibFuzzerInvocationManager.h
function namespace (line 21) | namespace jfs {
FILE: include/jfs/FuzzingCommon/LibFuzzerOptions.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SeedGenerator.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SeedManager.h
function namespace (line 21) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SeedManagerOptions.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SeedManagerStat.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SortConformanceCheckPass.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SpecialConstantSeedGenerator.h
function namespace (line 20) | namespace jfs {
function namespace (line 27) | namespace jfs {
FILE: include/jfs/FuzzingCommon/SpecialConstantSeedGeneratorStat.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/FuzzingCommon/WorkingDirectoryManager.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/Support/CancellableProcess.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/Support/ErrorMessages.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/Support/FileUtils.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/Support/ICancellable.h
function namespace (line 14) | namespace jfs {
FILE: include/jfs/Support/JFSStat.h
function namespace (line 22) | namespace jfs {
FILE: include/jfs/Support/ScopedJFSTimerStatAppender.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/Support/ScopedTimer.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/Support/StatisticsManager.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Support/Timer.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/Support/version.h
function namespace (line 14) | namespace jfs {
FILE: include/jfs/Transform/AndHoistingPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/BitBlastPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/BvBoundPropagationPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/ConstantPropagationPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/DIMACSOutputPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/DuplicateConstraintEliminationPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/FpToBvPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/QueryPass.h
function namespace (line 19) | namespace jfs {
FILE: include/jfs/Transform/QueryPassManager.h
function namespace (line 18) | namespace jfs {
FILE: include/jfs/Transform/SimpleContradictionsToFalsePass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/SimplificationPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/StandardPasses.h
function namespace (line 15) | namespace jfs {
FILE: include/jfs/Transform/TrueConstraintEliminationPass.h
function namespace (line 16) | namespace jfs {
FILE: include/jfs/Transform/Z3QueryPass.h
function namespace (line 17) | namespace jfs {
FILE: include/jfs/Z3Backend/Z3Solver.h
function namespace (line 17) | namespace jfs {
FILE: lib/CXXFuzzingBackend/CXXFuzzingSolver.cpp
type jfs (line 54) | namespace jfs {
type cxxfb (line 55) | namespace cxxfb {
class CXXFuzzingSolverImpl (line 57) | class CXXFuzzingSolverImpl
method CXXFuzzingSolverImpl (line 84) | CXXFuzzingSolverImpl(JFSContext& ctx, CXXFuzzingSolverOptions* opt...
method getName (line 98) | llvm::StringRef getName() { return "CXXFuzzingSolver"; }
method cancel (line 99) | void cancel() {
method sortsAreSupported (line 119) | bool sortsAreSupported(Query& q) {
method fuzz (line 182) | std::unique_ptr<jfs::core::SolverResponse>
class CXXFuzzingSolverResponse (line 59) | class CXXFuzzingSolverResponse : public SolverResponse {
method CXXFuzzingSolverResponse (line 64) | CXXFuzzingSolverResponse(SolverResponse::SolverSatisfiability sat)
method Model (line 66) | Model* getModel() override { return model.get(); }
class CXXFuzzingSolverImpl (line 70) | class CXXFuzzingSolverImpl {
method CXXFuzzingSolverImpl (line 84) | CXXFuzzingSolverImpl(JFSContext& ctx, CXXFuzzingSolverOptions* opt...
method getName (line 98) | llvm::StringRef getName() { return "CXXFuzzingSolver"; }
method cancel (line 99) | void cancel() {
method sortsAreSupported (line 119) | bool sortsAreSupported(Query& q) {
method fuzz (line 182) | std::unique_ptr<jfs::core::SolverResponse>
FILE: lib/CXXFuzzingBackend/CXXFuzzingSolverOptions.cpp
type jfs (line 18) | namespace jfs {
type cxxfb (line 19) | namespace cxxfb {
FILE: lib/CXXFuzzingBackend/CXXProgram.cpp
type jfs (line 13) | namespace jfs {
type cxxfb (line 14) | namespace cxxfb {
function CXXDecl (line 19) | CXXDecl* CXXDecl::getParent() const { return parent; }
FILE: lib/CXXFuzzingBackend/CXXProgramBuilderOptions.cpp
type jfs (line 13) | namespace jfs {
type cxxfb (line 14) | namespace cxxfb {
FILE: lib/CXXFuzzingBackend/CXXProgramBuilderPass.cpp
type jfs (line 20) | namespace jfs {
type cxxfb (line 21) | namespace cxxfb {
FILE: lib/CXXFuzzingBackend/CXXProgramBuilderPassImpl.cpp
type jfs (line 24) | namespace jfs {
type cxxfb (line 25) | namespace cxxfb {
function CXXCodeBlockRef (line 68) | CXXCodeBlockRef CXXProgramBuilderPassImpl::getConstraintIsFalseBlock...
function CXXCodeBlockRef (line 77) | CXXCodeBlockRef CXXProgramBuilderPassImpl::getConstraintIsTrueBlock() {
function CXXTypeRef (line 201) | CXXTypeRef CXXProgramBuilderPassImpl::getCounterTy() {
function CXXTypeRef (line 209) | CXXTypeRef CXXProgramBuilderPassImpl::getOrInsertTy(Z3SortHandle sor...
function CXXFunctionDeclRef (line 284) | CXXFunctionDeclRef CXXProgramBuilderPassImpl::buildEntryPoint() {
FILE: lib/CXXFuzzingBackend/CXXProgramBuilderPassImpl.h
function namespace (line 20) | namespace jfs {
FILE: lib/CXXFuzzingBackend/ClangInvocationManager.cpp
type jfs (line 25) | namespace jfs {
type cxxfb (line 26) | namespace cxxfb {
class ClangInvocationManagerImpl (line 31) | class ClangInvocationManagerImpl : public jfs::support::ICancellable {
method ClangInvocationManagerImpl (line 38) | ClangInvocationManagerImpl(JFSContext& ctx) : ctx(ctx), cancelled(...
method cancel (line 40) | void cancel() override {
method computeSMTLIBRuntime (line 49) | jfs::fuzzingCommon::SMTLIBRuntimeTy
method computeSMTLIBRuntimePath (line 98) | std::string computeSMTLIBRuntimePath(const ClangOptions* options) ...
method compile (line 109) | bool compile(const CXXProgram* program, llvm::StringRef sourceFile,
FILE: lib/CXXFuzzingBackend/ClangOptions.cpp
type jfs (line 17) | namespace jfs {
type cxxfb (line 18) | namespace cxxfb {
FILE: lib/CXXFuzzingBackend/CmdLine/CXXProgramBuilderOptionsBuilder.cpp
type jfs (line 72) | namespace jfs {
type cxxfb (line 73) | namespace cxxfb {
type cl (line 74) | namespace cl {
function buildCXXProgramBuilderOptionsFromCmdLine (line 76) | std::unique_ptr<CXXProgramBuilderOptions>
FILE: lib/CXXFuzzingBackend/CmdLine/ClangOptionsBuilder.cpp
type jfs (line 76) | namespace jfs {
type cxxfb (line 77) | namespace cxxfb {
type cl (line 78) | namespace cl {
function buildClangOptionsFromCmdLine (line 80) | std::unique_ptr<ClangOptions>
FILE: lib/CXXFuzzingBackend/CmdLine/CommandLineCategory.cpp
type jfs (line 13) | namespace jfs {
type cxxfb (line 14) | namespace cxxfb {
type cl (line 15) | namespace cl {
FILE: lib/CXXFuzzingBackend/JFSCXXProgramStat.cpp
type jfs (line 13) | namespace jfs {
type cxxfb (line 14) | namespace cxxfb {
FILE: lib/Core/JFSContext.cpp
type jfs (line 25) | namespace jfs {
type core (line 26) | namespace core {
class JFSContextImpl (line 31) | class JFSContextImpl {
method JFSContextImpl (line 46) | JFSContextImpl(JFSContext* ctx, const JFSContextConfig& ctxCfg)
method JFSContextImpl (line 82) | JFSContextImpl(const JFSContextImpl&) = delete;
method JFSContextImpl (line 83) | JFSContextImpl(const JFSContextImpl&&) = delete;
method JFSContextImpl (line 84) | JFSContextImpl& operator=(const JFSContextImpl&) = delete;
method registerErrorHandler (line 86) | bool registerErrorHandler(JFSContextErrorHandler* h) {
method unRegisterErrorHandler (line 91) | bool unRegisterErrorHandler(JFSContextErrorHandler* h) {
method z3ErrorHandler (line 103) | void z3ErrorHandler(Z3_error_code ec) {
method getVerbosity (line 121) | unsigned getVerbosity() const { return config.verbosity; }
method raiseFatalError (line 131) | __attribute__((noreturn)) void raiseFatalError(llvm::StringRef msg) {
method raiseError (line 143) | void raiseError(llvm::StringRef msg) {
method JFSContextConfig (line 154) | const JFSContextConfig& getConfig() const { return config; }
function Z3_context (line 210) | Z3_context JFSContext::getZ3Ctx() const { return impl->z3Ctx; }
function JFSContextConfig (line 230) | const JFSContextConfig& JFSContext::getConfig() const {
function RNG (line 234) | RNG& JFSContext::getRNG() const { return impl->rng; }
type core (line 180) | namespace core {
class JFSContextImpl (line 31) | class JFSContextImpl {
method JFSContextImpl (line 46) | JFSContextImpl(JFSContext* ctx, const JFSContextConfig& ctxCfg)
method JFSContextImpl (line 82) | JFSContextImpl(const JFSContextImpl&) = delete;
method JFSContextImpl (line 83) | JFSContextImpl(const JFSContextImpl&&) = delete;
method JFSContextImpl (line 84) | JFSContextImpl& operator=(const JFSContextImpl&) = delete;
method registerErrorHandler (line 86) | bool registerErrorHandler(JFSContextErrorHandler* h) {
method unRegisterErrorHandler (line 91) | bool unRegisterErrorHandler(JFSContextErrorHandler* h) {
method z3ErrorHandler (line 103) | void z3ErrorHandler(Z3_error_code ec) {
method getVerbosity (line 121) | unsigned getVerbosity() const { return config.verbosity; }
method raiseFatalError (line 131) | __attribute__((noreturn)) void raiseFatalError(llvm::StringRef msg) {
method raiseError (line 143) | void raiseError(llvm::StringRef msg) {
method JFSContextConfig (line 154) | const JFSContextConfig& getConfig() const { return config; }
function Z3_context (line 210) | Z3_context JFSContext::getZ3Ctx() const { return impl->z3Ctx; }
function JFSContextConfig (line 230) | const JFSContextConfig& JFSContext::getConfig() const {
function RNG (line 234) | RNG& JFSContext::getRNG() const { return impl->rng; }
function z3_error_handler (line 166) | void z3_error_handler(Z3_context ctx, Z3_error_code ec) {
type jfs (line 179) | namespace jfs {
type core (line 26) | namespace core {
class JFSContextImpl (line 31) | class JFSContextImpl {
method JFSContextImpl (line 46) | JFSContextImpl(JFSContext* ctx, const JFSContextConfig& ctxCfg)
method JFSContextImpl (line 82) | JFSContextImpl(const JFSContextImpl&) = delete;
method JFSContextImpl (line 83) | JFSContextImpl(const JFSContextImpl&&) = delete;
method JFSContextImpl (line 84) | JFSContextImpl& operator=(const JFSContextImpl&) = delete;
method registerErrorHandler (line 86) | bool registerErrorHandler(JFSContextErrorHandler* h) {
method unRegisterErrorHandler (line 91) | bool unRegisterErrorHandler(JFSContextErrorHandler* h) {
method z3ErrorHandler (line 103) | void z3ErrorHandler(Z3_error_code ec) {
method getVerbosity (line 121) | unsigned getVerbosity() const { return config.verbosity; }
method raiseFatalError (line 131) | __attribute__((noreturn)) void raiseFatalError(llvm::StringRef msg) {
method raiseError (line 143) | void raiseError(llvm::StringRef msg) {
method JFSContextConfig (line 154) | const JFSContextConfig& getConfig() const { return config; }
function Z3_context (line 210) | Z3_context JFSContext::getZ3Ctx() const { return impl->z3Ctx; }
function JFSContextConfig (line 230) | const JFSContextConfig& JFSContext::getConfig() const {
function RNG (line 234) | RNG& JFSContext::getRNG() const { return impl->rng; }
type core (line 180) | namespace core {
class JFSContextImpl (line 31) | class JFSContextImpl {
method JFSContextImpl (line 46) | JFSContextImpl(JFSContext* ctx, const JFSContextConfig& ctxCfg)
method JFSContextImpl (line 82) | JFSContextImpl(const JFSContextImpl&) = delete;
method JFSContextImpl (line 83) | JFSContextImpl(const JFSContextImpl&&) = delete;
method JFSContextImpl (line 84) | JFSContextImpl& operator=(const JFSContextImpl&) = delete;
method registerErrorHandler (line 86) | bool registerErrorHandler(JFSContextErrorHandler* h) {
method unRegisterErrorHandler (line 91) | bool unRegisterErrorHandler(JFSContextErrorHandler* h) {
method z3ErrorHandler (line 103) | void z3ErrorHandler(Z3_error_code ec) {
method getVerbosity (line 121) | unsigned getVerbosity() const { return config.verbosity; }
method raiseFatalError (line 131) | __attribute__((noreturn)) void raiseFatalError(llvm::StringRef msg) {
method raiseError (line 143) | void raiseError(llvm::StringRef msg) {
method JFSContextConfig (line 154) | const JFSContextConfig& getConfig() const { return config; }
function Z3_context (line 210) | Z3_context JFSContext::getZ3Ctx() const { return impl->z3Ctx; }
function JFSContextConfig (line 230) | const JFSContextConfig& JFSContext::getConfig() const {
function RNG (line 234) | RNG& JFSContext::getRNG() const { return impl->rng; }
FILE: lib/Core/Model.cpp
type jfs (line 19) | namespace jfs {
type core (line 20) | namespace core {
function JFSContext (line 25) | JFSContext& Model::getContext() { return ctx; }
function Z3ASTHandle (line 27) | Z3ASTHandle Model::getAssignmentFor(Z3FuncDeclHandle funcDecl) {
function Z3ASTHandle (line 40) | Z3ASTHandle Model::evaluate(Z3ASTHandle e, bool modelCompletion) {
function Z3ASTHandle (line 104) | Z3ASTHandle Model::getDefaultValueFor(Z3SortHandle sort) {
FILE: lib/Core/ModelValidator.cpp
type jfs (line 21) | namespace jfs {
type core (line 22) | namespace core {
FILE: lib/Core/Query.cpp
type jfs (line 18) | namespace jfs {
type core (line 19) | namespace core {
FILE: lib/Core/RNG.cpp
type jfs (line 15) | namespace jfs {
type core (line 16) | namespace core {
FILE: lib/Core/SMTLIB2Parser.cpp
function addConstraints (line 21) | void addConstraints(std::shared_ptr<Query> q, Z3ASTHandle constraint) {
type jfs (line 37) | namespace jfs {
type core (line 38) | namespace core {
FILE: lib/Core/SimpleModel.cpp
type jfs (line 13) | namespace jfs {
type core (line 14) | namespace core {
FILE: lib/Core/Solver.cpp
type jfs (line 13) | namespace jfs {
type core (line 14) | namespace core {
function SolverOptions (line 24) | const SolverOptions* Solver::getOptions() const { return options.get...
FILE: lib/Core/ToolErrorHandler.cpp
type jfs (line 14) | namespace jfs {
type core (line 15) | namespace core {
FILE: lib/Core/Z3ASTVisitor.cpp
type jfs (line 15) | namespace jfs {
type core (line 16) | namespace core {
FILE: lib/Core/Z3Node.cpp
type jfs (line 16) | namespace jfs {
type core (line 17) | namespace core {
function Z3ASTHandle (line 83) | Z3ASTHandle Z3ModelHandle::getAssignmentFor(Z3FuncDeclHandle funcDec...
function Z3FuncDeclHandle (line 124) | Z3FuncDeclHandle Z3ModelHandle::getVariableDeclForIndex(uint64_t ind...
function Z3ASTHandle (line 130) | Z3ASTHandle Z3ModelHandle::evaluate(Z3ASTHandle e, bool modelComplet...
function Z3_sort_kind (line 147) | Z3_sort_kind Z3SortHandle::getKind() const {
function Z3ASTHandle (line 198) | Z3ASTHandle Z3SortHandle::asAST() const {
function Z3SortHandle (line 202) | Z3SortHandle Z3SortHandle::getBoolTy(Z3_context ctx) {
function Z3SortHandle (line 206) | Z3SortHandle Z3SortHandle::getBitVectorTy(Z3_context ctx, unsigned b...
function Z3SortHandle (line 210) | Z3SortHandle Z3SortHandle::getFloat32Ty(Z3_context ctx) {
function Z3SortHandle (line 214) | Z3SortHandle Z3SortHandle::getFloat64Ty(Z3_context ctx) {
function Z3_ast_kind (line 219) | Z3_ast_kind Z3ASTHandle::getKind() const {
function Z3SortHandle (line 296) | Z3SortHandle Z3ASTHandle::getSort() const {
function Z3AppHandle (line 304) | Z3AppHandle Z3ASTHandle::asApp() const {
function Z3FuncDeclHandle (line 310) | Z3FuncDeclHandle Z3ASTHandle::asFuncDecl() const {
function Z3ASTHandle (line 316) | Z3ASTHandle Z3ASTHandle::getTrue(Z3_context ctx) {
function Z3ASTHandle (line 320) | Z3ASTHandle Z3ASTHandle::getFalse(Z3_context ctx) {
function Z3ASTHandle (line 324) | Z3ASTHandle Z3ASTHandle::getBVZero(Z3_context ctx, unsigned width) {
function Z3ASTHandle (line 329) | Z3ASTHandle Z3ASTHandle::getBVZero(Z3SortHandle sort) {
function Z3ASTHandle (line 333) | Z3ASTHandle Z3ASTHandle::getBV(Z3SortHandle sort, uint64_t value) {
function Z3ASTHandle (line 341) | Z3ASTHandle Z3ASTHandle::getFloatZero(Z3SortHandle sort, bool positi...
function Z3ASTHandle (line 348) | Z3ASTHandle Z3ASTHandle::getFloatInfinity(Z3SortHandle sort, bool po...
function Z3ASTHandle (line 355) | Z3ASTHandle Z3ASTHandle::getFloatNAN(Z3SortHandle sort) {
function Z3ASTHandle (line 361) | Z3ASTHandle Z3ASTHandle::getFloatFromInt(Z3SortHandle sort, signed v...
function getEMax (line 367) | static size_t getEMax(Z3SortHandle fpSort) {
function getEMin (line 376) | static size_t getEMin(Z3SortHandle fpSort) {
function Z3ASTHandle (line 384) | Z3ASTHandle Z3ASTHandle::getFloatAbsoluteSmallestSubnormal(Z3SortHan...
function Z3ASTHandle (line 421) | Z3ASTHandle Z3ASTHandle::getFloatAbsoluteLargestSubnormal(Z3SortHand...
function Z3ASTHandle (line 438) | Z3ASTHandle Z3ASTHandle::getFloatAbsoluteSmallestNormal(Z3SortHandle...
function Z3ASTHandle (line 453) | Z3ASTHandle Z3ASTHandle::getFloatAbsoluteLargestNormal(Z3SortHandle ...
function Z3FuncDeclHandle (line 471) | Z3FuncDeclHandle Z3AppHandle::getFuncDecl() const {
function Z3_decl_kind (line 475) | Z3_decl_kind Z3AppHandle::getKind() const { return getFuncDecl().get...
function Z3ASTHandle (line 481) | Z3ASTHandle Z3AppHandle::getKid(unsigned index) const {
function Z3ASTHandle (line 528) | Z3ASTHandle Z3AppHandle::asAST() const {
function Z3SortHandle (line 532) | Z3SortHandle Z3AppHandle::getSort() const { return asAST().getSort(); }
function Z3_decl_kind (line 549) | Z3_decl_kind Z3FuncDeclHandle::getKind() const {
function Z3SortHandle (line 553) | Z3SortHandle Z3FuncDeclHandle::getSort() const {
function Z3ASTHandle (line 565) | Z3ASTHandle Z3FuncDeclHandle::asAST() const {
function Z3_parameter_kind (line 573) | Z3_parameter_kind Z3FuncDeclHandle::getParamKind(unsigned index) con...
function Z3ASTHandle (line 602) | Z3ASTHandle Z3GoalHandle::getFormula(unsigned index) const {
function Z3ApplyResultHandle (line 616) | Z3ApplyResultHandle Z3TacticHandle::apply(Z3GoalHandle goal) {
function Z3ApplyResultHandle (line 620) | Z3ApplyResultHandle Z3TacticHandle::applyWithParams(Z3GoalHandle goal,
function Z3GoalHandle (line 639) | Z3GoalHandle Z3ApplyResultHandle::getGoal(unsigned index) const {
function Z3ModelHandle (line 657) | Z3ModelHandle
FILE: lib/Core/Z3NodeUtil.cpp
type jfs (line 12) | namespace jfs {
type core (line 13) | namespace core {
FILE: lib/FuzzingCommon/BufferAssignment.cpp
type jfs (line 22) | namespace jfs {
type fuzzingCommon (line 23) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/BufferElement.cpp
type jfs (line 22) | namespace jfs {
type fuzzingCommon (line 23) | namespace fuzzingCommon {
function Z3FuncDeclHandle (line 56) | Z3FuncDeclHandle BufferElement::getDecl() const {
function Z3SortHandle (line 62) | Z3SortHandle BufferElement::getSort() const { return declApp.getSort...
FILE: lib/FuzzingCommon/CmdLine/FreeVariableToBufferAssignmentPassOptionsBuilder.cpp
type jfs (line 51) | namespace jfs {
type fuzzingCommon (line 52) | namespace fuzzingCommon {
type cl (line 53) | namespace cl {
function buildFVTBAPOptionsFromCmdLine (line 55) | std::unique_ptr<jfs::fuzzingCommon::FreeVariableToBufferAssignment...
FILE: lib/FuzzingCommon/CmdLine/LibFuzzerOptionsBuilder.cpp
type jfs (line 51) | namespace jfs {
type fuzzingCommon (line 52) | namespace fuzzingCommon {
type cl (line 53) | namespace cl {
function buildLibFuzzerOptionsFromCmdLine (line 55) | std::unique_ptr<jfs::fuzzingCommon::LibFuzzerOptions>
FILE: lib/FuzzingCommon/CmdLine/SeedManagerOptionsBuilder.cpp
type jfs (line 52) | namespace jfs {
type fuzzingCommon (line 53) | namespace fuzzingCommon {
type cl (line 54) | namespace cl {
function buildSeedManagerOptionsFromCmdLine (line 56) | std::unique_ptr<jfs::fuzzingCommon::SeedManagerOptions>
FILE: lib/FuzzingCommon/CommandLineCategory.cpp
type jfs (line 13) | namespace jfs {
type fuzzingCommon (line 14) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/DummyFuzzingSolver.cpp
type jfs (line 15) | namespace jfs {
type fuzzingCommon (line 16) | namespace fuzzingCommon {
class DummyFuzzingSolverResponse (line 32) | class DummyFuzzingSolverResponse : public SolverResponse {
method DummyFuzzingSolverResponse (line 34) | DummyFuzzingSolverResponse() : SolverResponse(SolverResponse::UNKN...
method Model (line 35) | Model* getModel() override {
FILE: lib/FuzzingCommon/EqualityExtractionPass.cpp
type jfs (line 18) | namespace jfs {
type fuzzingCommon (line 19) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/FileSerializableModel.cpp
function accessInRange (line 21) | bool accessInRange(size_t bufferSize, unsigned startBit, unsigned endBit) {
function accessInRange (line 27) | bool accessInRange(const llvm::MemoryBuffer* mb, unsigned startBit,
function accessInRange (line 32) | bool accessInRange(const llvm::FileOutputBuffer* buf, unsigned startBit,
function Z3ASTHandle (line 38) | Z3ASTHandle loadBool(JFSContext& ctx, const llvm::MemoryBuffer* mb,
function saveBool (line 58) | bool saveBool(JFSContext& ctx, llvm::FileOutputBuffer* buf, Z3SortHandle...
function Z3ASTHandle (line 80) | Z3ASTHandle loadBitVector(JFSContext& ctx, const llvm::MemoryBuffer* mb,
function saveBitVector (line 106) | bool saveBitVector(JFSContext& ctx, llvm::FileOutputBuffer* buf,
function Z3ASTHandle (line 136) | Z3ASTHandle loadFloatingPoint(JFSContext& ctx, const llvm::MemoryBuffer*...
function saveFloatingPointSpecial32 (line 172) | bool saveFloatingPointSpecial32(JFSContext& ctx, llvm::FileOutputBuffer*...
function saveFloatingPointSpecial64 (line 206) | bool saveFloatingPointSpecial64(JFSContext& ctx, llvm::FileOutputBuffer*...
function saveFloatingPoint (line 240) | bool saveFloatingPoint(JFSContext& ctx, llvm::FileOutputBuffer* buf,
type jfs (line 279) | namespace jfs {
type fuzzingCommon (line 280) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/FreeVariableToBufferAssignmentPass.cpp
type jfs (line 22) | namespace jfs {
type fuzzingCommon (line 23) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.cpp
type jfs (line 13) | namespace jfs {
type fuzzingCommon (line 14) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/FuzzingAnalysisInfo.cpp
type jfs (line 22) | namespace jfs {
type fuzzingCommon (line 23) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/FuzzingSolver.cpp
type jfs (line 24) | namespace jfs {
type fuzzingCommon (line 25) | namespace fuzzingCommon {
class FuzzingSolverImpl (line 27) | class FuzzingSolverImpl
method getName (line 54) | llvm::StringRef getName() const { return "FuzzingSolver"; }
method FuzzingSolverImpl (line 57) | FuzzingSolverImpl(FuzzingSolver* interF)
method cancel (line 59) | void cancel() {
method solve (line 67) | std::unique_ptr<SolverResponse> solve(const jfs::core::Query& q,
class TrivialFuzzingSolverResponse (line 31) | class TrivialFuzzingSolverResponse : public jfs::core::SolverResponse {
method setModel (line 35) | void setModel(std::unique_ptr<jfs::core::Model> m) { model = std::...
method TrivialFuzzingSolverResponse (line 38) | TrivialFuzzingSolverResponse(SolverResponse::SolverSatisfiability ...
method Model (line 40) | Model* getModel() override {
class FuzzingSolverImpl (line 49) | class FuzzingSolverImpl {
method getName (line 54) | llvm::StringRef getName() const { return "FuzzingSolver"; }
method FuzzingSolverImpl (line 57) | FuzzingSolverImpl(FuzzingSolver* interF)
method cancel (line 59) | void cancel() {
method solve (line 67) | std::unique_ptr<SolverResponse> solve(const jfs::core::Query& q,
FILE: lib/FuzzingCommon/FuzzingSolverOptions.cpp
type jfs (line 15) | namespace jfs {
type fuzzingCommon (line 16) | namespace fuzzingCommon {
function FreeVariableToBufferAssignmentPassOptions (line 31) | FreeVariableToBufferAssignmentPassOptions*
FILE: lib/FuzzingCommon/JFSRuntimeFuzzingStat.cpp
type llvm (line 16) | namespace llvm {
type yaml (line 17) | namespace yaml {
type MappingTraits<jfs::fuzzingCommon::JFSRuntimeFuzzingStat> (line 19) | struct MappingTraits<jfs::fuzzingCommon::JFSRuntimeFuzzingStat> {
method mapping (line 20) | static void mapping(IO& io,
type jfs (line 38) | namespace jfs {
type fuzzingCommon (line 39) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/LibFuzzerInvocationManager.cpp
type jfs (line 24) | namespace jfs {
type fuzzingCommon (line 25) | namespace fuzzingCommon {
class LibFuzzerInvocationManagerImpl (line 30) | class LibFuzzerInvocationManagerImpl {
method LibFuzzerInvocationManagerImpl (line 41) | LibFuzzerInvocationManagerImpl(JFSContext& ctx)
method cancel (line 44) | void cancel() {
method fuzz (line 51) | std::unique_ptr<LibFuzzerResponse> fuzz(const LibFuzzerOptions* op...
FILE: lib/FuzzingCommon/LibFuzzerOptions.cpp
type jfs (line 13) | namespace jfs {
type fuzzingCommon (line 14) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/SeedGenerator.cpp
type jfs (line 14) | namespace jfs {
type fuzzingCommon (line 15) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/SeedManager.cpp
type jfs (line 22) | namespace jfs {
type fuzzingCommon (line 23) | namespace fuzzingCommon {
class SeedManagerImpl (line 27) | class SeedManagerImpl {
method SeedManagerImpl (line 48) | SeedManagerImpl(SeedManager* wrapper, llvm::StringRef seedDir,
method cancel (line 58) | void cancel() { cancelled = true; }
method configureFrom (line 60) | void configureFrom(std::unique_ptr<SeedManagerOptions> options) {
method addSeedGenerator (line 72) | void addSeedGenerator(std::unique_ptr<SeedGenerator> sg) {
method writeSeeds (line 77) | uint64_t writeSeeds(const FuzzingAnalysisInfo* info,
method setSpaceLimit (line 164) | void setSpaceLimit(uint64_t maxSeedSpaceInBytes) {
method getSpaceLimit (line 167) | uint64_t getSpaceLimit() const { return maxSeedSpaceInBytes; }
method setMaxNumSeeds (line 168) | void setMaxNumSeeds(uint64_t maxNumSeeds) { this->maxNumSeeds = ma...
method getMaxNumSeeds (line 169) | uint64_t getMaxNumSeeds() const { return maxNumSeeds; }
method getBufferForSeed (line 171) | std::unique_ptr<llvm::FileOutputBuffer>
method getAndReserveSeedID (line 195) | std::string getAndReserveSeedID(llvm::StringRef prefix) {
method FuzzingAnalysisInfo (line 215) | const FuzzingAnalysisInfo* getCurrentFuzzingAnalysisInfo() const {
function FuzzingAnalysisInfo (line 268) | const FuzzingAnalysisInfo* SeedManager::getCurrentFuzzingAnalysisInf...
FILE: lib/FuzzingCommon/SeedManagerStat.cpp
type jfs (line 13) | namespace jfs {
type fuzzingCommon (line 14) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/SortConformanceCheckPass.cpp
type jfs (line 18) | namespace jfs {
type fuzzingCommon (line 19) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/SpecialConstantSeedGenerator.cpp
type SpecialConstantBitVector (line 28) | enum class SpecialConstantBitVector : size_t {
type SpecialConstantFloatingPoint (line 36) | enum class SpecialConstantFloatingPoint : size_t {
function getMask (line 55) | uint64_t getMask(const unsigned bitWidth) {
type jfs (line 61) | namespace jfs {
type fuzzingCommon (line 62) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/SpecialConstantSeedGeneratorStat.cpp
type jfs (line 13) | namespace jfs {
type fuzzingCommon (line 14) | namespace fuzzingCommon {
FILE: lib/FuzzingCommon/WorkingDirectoryManager.cpp
type jfs (line 20) | namespace jfs {
type fuzzingCommon (line 21) | namespace fuzzingCommon {
FILE: lib/Support/CancellableProcess.cpp
type jfs (line 20) | namespace jfs {
type support (line 21) | namespace support {
class CancellableProcessImpl (line 23) | class CancellableProcessImpl {
method CancellableProcessImpl (line 30) | CancellableProcessImpl() : cancelled(false) {
method cleanUp (line 37) | void cleanUp() { processInfo.Pid = llvm::sys::ProcessInfo::Invalid...
method cancel (line 39) | void cancel() {
method kill (line 45) | void kill() {
method execute (line 86) | int execute(llvm::StringRef program, std::vector<const char*>& args,
FILE: lib/Support/ErrorMessages.cpp
type jfs (line 14) | namespace jfs {
type support (line 15) | namespace support {
function getMessageForFailedOpenFileOrSTDIN (line 17) | std::string getMessageForFailedOpenFileOrSTDIN(llvm::StringRef input...
function getMessageForFailedOpenFileForWriting (line 26) | std::string
FILE: lib/Support/FileUtils.cpp
function recursive_remove_impl (line 18) | std::error_code recursive_remove_impl(llvm::StringRef path,
type jfs (line 46) | namespace jfs {
type support (line 47) | namespace support {
function recursive_remove (line 51) | std::error_code recursive_remove(llvm::StringRef path, bool IgnoreNo...
FILE: lib/Support/ICancellable.cpp
type jfs (line 13) | namespace jfs {
type support (line 14) | namespace support {
FILE: lib/Support/JFSStat.cpp
type jfs (line 14) | namespace jfs {
type support (line 15) | namespace support {
FILE: lib/Support/ScopedTimer.cpp
type jfs (line 16) | namespace jfs {
type support (line 17) | namespace support {
class ScopedTimerImpl (line 19) | class ScopedTimerImpl {
method waiterFunction (line 32) | void waiterFunction() {
method ScopedTimerImpl (line 48) | ScopedTimerImpl(uint64_t maxTime, ScopedTimer::CallBackTy callBack)
method getRemainingTime (line 84) | uint64_t getRemainingTime() const {
method getMaxTime (line 96) | uint64_t getMaxTime() const { return maxTime; }
FILE: lib/Support/StatisticsManager.cpp
type jfs (line 17) | namespace jfs {
type support (line 18) | namespace support {
class StatisticsManagerImpl (line 20) | class StatisticsManagerImpl {
method StatisticsManagerImpl (line 25) | StatisticsManagerImpl() {}
method append (line 27) | void append(std::unique_ptr<JFSStat> stat) {
method clear (line 31) | void clear() { stats.clear(); }
method size (line 32) | size_t size() const { return stats.size(); }
method printYAML (line 33) | void printYAML(llvm::raw_ostream& os) const {
method dump (line 51) | void dump() const { printYAML(llvm::errs()); }
FILE: lib/Support/Timer.cpp
type jfs (line 15) | namespace jfs {
type support (line 16) | namespace support {
FILE: lib/Support/version.cpp
type jfs (line 17) | namespace jfs {
type support (line 18) | namespace support {
FILE: lib/Transform/AndHoistingPass.cpp
type jfs (line 18) | namespace jfs {
type transform (line 19) | namespace transform {
FILE: lib/Transform/BitBlastPass.cpp
type jfs (line 18) | namespace jfs {
type transform (line 19) | namespace transform {
FILE: lib/Transform/BvBoundPropagationPass.cpp
type jfs (line 21) | namespace jfs {
type transform (line 22) | namespace transform {
FILE: lib/Transform/ConstantPropagationPass.cpp
type jfs (line 20) | namespace jfs {
type transform (line 21) | namespace transform {
FILE: lib/Transform/DIMACSOutputPass.cpp
type jfs (line 18) | namespace jfs {
type transform (line 19) | namespace transform {
FILE: lib/Transform/DuplicateConstraintEliminationPass.cpp
type jfs (line 18) | namespace jfs {
type transform (line 19) | namespace transform {
FILE: lib/Transform/FpToBvPass.cpp
type jfs (line 18) | namespace jfs {
type transform (line 19) | namespace transform {
FILE: lib/Transform/QueryPassManager.cpp
type jfs (line 20) | namespace jfs {
type transform (line 21) | namespace transform {
class QueryPassManagerImpl (line 22) | class QueryPassManagerImpl : public jfs::support::ICancellable {
method QueryPassManagerImpl (line 33) | QueryPassManagerImpl() : cancelled(false) {}
method add (line 35) | void add(std::shared_ptr<QueryPass> pass) {
method clear (line 41) | void clear() {
method cancel (line 45) | void cancel() {
method run (line 52) | void run(Query &q) {
method convertModel (line 84) | bool convertModel(jfs::core::Model* m) {
FILE: lib/Transform/SimpleContradictionsToFalsePass.cpp
function simplifyTopLevelNot (line 20) | bool simplifyTopLevelNot(Query& q, std::atomic<bool>* cancelled) {
type jfs (line 89) | namespace jfs {
type transform (line 90) | namespace transform {
FILE: lib/Transform/SimplificationPass.cpp
type jfs (line 18) | namespace jfs {
type transform (line 19) | namespace transform {
FILE: lib/Transform/StandardPasses.cpp
type jfs (line 14) | namespace jfs {
type transform (line 15) | namespace transform {
function AddStandardPasses (line 16) | void AddStandardPasses(QueryPassManager &pm) {
FILE: lib/Transform/TrueConstraintEliminationPass.cpp
type jfs (line 17) | namespace jfs {
type transform (line 18) | namespace transform {
FILE: lib/Transform/Z3QueryPass.cpp
type jfs (line 15) | namespace jfs {
type transform (line 16) | namespace transform {
FILE: lib/Z3Backend/Z3Solver.cpp
type jfs (line 17) | namespace jfs {
type z3Backend (line 18) | namespace z3Backend {
class Z3Model (line 27) | class Z3Model : public jfs::core::Model {
method Z3Model (line 29) | Z3Model(JFSContext& ctx, Z3ModelHandle m) : Model(ctx) { z3Model =...
class Z3SolverResponse (line 33) | class Z3SolverResponse : public SolverResponse {
method Z3SolverResponse (line 38) | Z3SolverResponse(SolverSatisfiability sat) : SolverResponse(sat), ...
method Model (line 40) | Model* getModel() override { return model.get(); }
method setModel (line 43) | void setModel(JFSContext& ctx, Z3ModelHandle m) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerClangCounters.cpp
type fuzzer (line 27) | namespace fuzzer {
function ATTRIBUTE_NO_SANITIZE_ALL (line 44) | ATTRIBUTE_NO_SANITIZE_ALL
type fuzzer (line 37) | namespace fuzzer {
function ATTRIBUTE_NO_SANITIZE_ALL (line 44) | ATTRIBUTE_NO_SANITIZE_ALL
type fuzzer (line 43) | namespace fuzzer {
function ATTRIBUTE_NO_SANITIZE_ALL (line 44) | ATTRIBUTE_NO_SANITIZE_ALL
FILE: runtime/LibFuzzer/Fuzzer/FuzzerCommand.h
function namespace (line 24) | namespace fuzzer {
function addFlag (line 111) | void addFlag(const std::string &Flag, const std::string &Value) {
function removeFlag (line 116) | void removeFlag(const std::string &Flag) {
function setOutputFile (line 132) | void setOutputFile(const std::string &FileName) { OutputFile = FileName; }
FILE: runtime/LibFuzzer/Fuzzer/FuzzerCorpus.h
type InputInfo (line 27) | struct InputInfo {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerCrossOver.cpp
type fuzzer (line 17) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerDefs.h
function namespace (line 108) | namespace fuzzer {
type Vector (line 140) | typedef Vector<uint8_t> Unit;
type Vector (line 141) | typedef Vector<Unit> UnitVector;
type ScopedDoingMyOwnMemOrStr (line 146) | struct ScopedDoingMyOwnMemOrStr {
function Bswap (line 152) | inline uint8_t Bswap(uint8_t x) { return x; }
function Bswap (line 153) | inline uint16_t Bswap(uint16_t x) { return __builtin_bswap16(x); }
function Bswap (line 154) | inline uint32_t Bswap(uint32_t x) { return __builtin_bswap32(x); }
function Bswap (line 155) | inline uint64_t Bswap(uint64_t x) { return __builtin_bswap64(x); }
FILE: runtime/LibFuzzer/Fuzzer/FuzzerDictionary.h
function namespace (line 21) | namespace fuzzer {
type FixedWord (line 56) | typedef FixedWord<64> Word;
function class (line 58) | class DictionaryEntry {
function GetPositionHint (line 66) | size_t GetPositionHint() const {
function IncSuccessCount (line 71) | void IncSuccessCount() { SuccessCount++; }
function class (line 89) | class Dictionary {
function clear (line 108) | void clear() { Size = 0; }
FILE: runtime/LibFuzzer/Fuzzer/FuzzerDriver.cpp
function __libfuzzer_is_present (line 32) | __attribute__((used)) void __libfuzzer_is_present() {}
type fuzzer (line 34) | namespace fuzzer {
type FlagDescription (line 37) | struct FlagDescription {
function FlagDescription (line 58) | static const FlagDescription FlagDescriptions [] {
function PrintHelp (line 81) | static void PrintHelp() {
function MyStol (line 117) | static long MyStol(const char *Str) {
function ParseOneFlag (line 133) | static bool ParseOneFlag(const char *Param) {
function ParseFlags (line 179) | static void ParseFlags(const Vector<std::string> &Args) {
function PulseThread (line 202) | static void PulseThread() {
function WorkerThread (line 210) | static void WorkerThread(const Command &BaseCmd, std::atomic<unsigned>...
function CloneArgsWithoutX (line 233) | std::string CloneArgsWithoutX(const Vector<std::string> &Args,
function RunInMultipleProcesses (line 244) | static int RunInMultipleProcesses(const Vector<std::string> &Args,
function RssThread (line 261) | static void RssThread(Fuzzer *F, size_t RssLimitMb) {
function StartRssThread (line 270) | static void StartRssThread(Fuzzer *F, size_t RssLimitMb) {
function RunOneTest (line 276) | int RunOneTest(Fuzzer *F, const char *InputFilePath, size_t MaxLen) {
function AllInputsAreFiles (line 285) | static bool AllInputsAreFiles() {
function GetDedupTokenFromFile (line 293) | static std::string GetDedupTokenFromFile(const std::string &Path) {
function CleanseCrashInput (line 304) | int CleanseCrashInput(const Vector<std::string> &Args,
function MinimizeCrashInput (line 363) | int MinimizeCrashInput(const Vector<std::string> &Args,
function MinimizeCrashInputInternalStep (line 450) | int MinimizeCrashInputInternalStep(Fuzzer *F, InputCorpus *Corpus) {
function AnalyzeDictionary (line 467) | int AnalyzeDictionary(Fuzzer *F, const Vector<Unit>& Dict,
function FuzzerDriver (line 533) | int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerExtFunctions.h
function namespace (line 18) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerExtFunctionsDlsym.cpp
function T (line 24) | static T GetFnPtr(const char *FnName, bool WarnIfMissing) {
type fuzzer (line 39) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerExtFunctionsDlsymWin.cpp
type fuzzer (line 21) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerExtFunctionsWeak.cpp
function CheckFnPtr (line 33) | static void CheckFnPtr(void *FnPtr, const char *FnName, bool WarnIfMissi...
type fuzzer (line 39) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp
function T (line 34) | static T *GetFnPtr(T *Fun, T *FunDef, const char *FnName, bool WarnIfMis...
type fuzzer (line 43) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerExtraCounters.cpp
type fuzzer (line 18) | namespace fuzzer {
function ATTRIBUTE_NO_SANITIZE_ALL (line 21) | ATTRIBUTE_NO_SANITIZE_ALL
function ClearExtraCounters (line 38) | void ClearExtraCounters() {}
type fuzzer (line 35) | namespace fuzzer {
function ATTRIBUTE_NO_SANITIZE_ALL (line 21) | ATTRIBUTE_NO_SANITIZE_ALL
function ClearExtraCounters (line 38) | void ClearExtraCounters() {}
FILE: runtime/LibFuzzer/Fuzzer/FuzzerIO.cpp
type fuzzer (line 22) | namespace fuzzer {
function GetEpoch (line 26) | long GetEpoch(const std::string &Path) {
function Unit (line 33) | Unit FileToVector(const std::string &Path, size_t MaxSize, bool ExitOn...
function FileToString (line 53) | std::string FileToString(const std::string &Path) {
function CopyFileToErr (line 59) | void CopyFileToErr(const std::string &Path) {
function WriteToFile (line 63) | void WriteToFile(const Unit &U, const std::string &Path) {
function ReadDirToVectorOfUnits (line 71) | void ReadDirToVectorOfUnits(const char *Path, Vector<Unit> *V,
function GetSizedFilesFromDir (line 90) | void GetSizedFilesFromDir(const std::string &Dir, Vector<SizedFile> *V) {
function DirPlusFile (line 98) | std::string DirPlusFile(const std::string &DirPath,
function DupAndCloseStderr (line 103) | void DupAndCloseStderr() {
function CloseStdout (line 117) | void CloseStdout() {
function Printf (line 121) | void Printf(const char *Fmt, ...) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerIO.h
function namespace (line 17) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerIOPosix.cpp
type fuzzer (line 26) | namespace fuzzer {
function IsFile (line 28) | bool IsFile(const std::string &Path) {
function IsDirectory (line 35) | static bool IsDirectory(const std::string &Path) {
function FileSize (line 42) | size_t FileSize(const std::string &Path) {
function ListFilesInDirRecursive (line 49) | void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
function GetSeparator (line 75) | char GetSeparator() {
function FILE (line 79) | FILE* OpenFile(int Fd, const char* Mode) {
function CloseFile (line 83) | int CloseFile(int fd) {
function DuplicateFile (line 87) | int DuplicateFile(int Fd) {
function RemoveFile (line 91) | void RemoveFile(const std::string &Path) {
function DiscardOutput (line 95) | void DiscardOutput(int Fd) {
function GetHandleFromFd (line 103) | intptr_t GetHandleFromFd(int fd) {
function DirName (line 107) | std::string DirName(const std::string &FileName) {
function TmpDir (line 115) | std::string TmpDir() {
function IsInterestingCoverageFile (line 121) | bool IsInterestingCoverageFile(const std::string &FileName) {
function RawPrint (line 134) | void RawPrint(const char *Str) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerIOWindows.cpp
type fuzzer (line 25) | namespace fuzzer {
function IsFile (line 27) | static bool IsFile(const std::string &Path, const DWORD &FileAttribute...
function IsFile (line 63) | bool IsFile(const std::string &Path) {
function ListFilesInDirRecursive (line 75) | void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
function GetSeparator (line 124) | char GetSeparator() {
function FILE (line 128) | FILE* OpenFile(int Fd, const char* Mode) {
function CloseFile (line 132) | int CloseFile(int Fd) {
function DuplicateFile (line 136) | int DuplicateFile(int Fd) {
function RemoveFile (line 140) | void RemoveFile(const std::string &Path) {
function DiscardOutput (line 144) | void DiscardOutput(int Fd) {
function GetHandleFromFd (line 152) | intptr_t GetHandleFromFd(int fd) {
function IsSeparator (line 156) | static bool IsSeparator(char C) {
function ParseDrive (line 162) | static size_t ParseDrive(const std::string &FileName, const size_t Off...
function ParseFileName (line 177) | static size_t ParseFileName(const std::string &FileName, const size_t ...
function ParseDir (line 187) | static size_t ParseDir(const std::string &FileName, const size_t Offse...
function ParseServerAndShare (line 202) | static size_t ParseServerAndShare(const std::string &FileName,
function ParseCustomString (line 217) | static size_t ParseCustomString(const std::string &Ref, size_t Offset,
function ParseLocation (line 228) | static size_t ParseLocation(const std::string &FileName) {
function DirName (line 261) | std::string DirName(const std::string &FileName) {
function TmpDir (line 294) | std::string TmpDir() {
function IsInterestingCoverageFile (line 306) | bool IsInterestingCoverageFile(const std::string &FileName) {
function RawPrint (line 316) | void RawPrint(const char *Str) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerInternal.h
function namespace (line 28) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerLoop.cpp
type fuzzer (line 39) | namespace fuzzer {
type MallocFreeTracer (line 51) | struct MallocFreeTracer {
method Start (line 52) | void Start(int TraceLevel) {
method Stop (line 60) | bool Stop() {
class TraceLock (line 82) | class TraceLock {
method TraceLock (line 84) | TraceLock() : Lock(AllocTracer.TraceMutex) {
method IsDisabled (line 89) | bool IsDisabled() const {
function ATTRIBUTE_NO_SANITIZE_MEMORY (line 98) | ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_NO_SANITIZE_MEMORY (line 112) | ATTRIBUTE_NO_SANITIZE_MEMORY
function NO_SANITIZE_MEMORY (line 193) | NO_SANITIZE_MEMORY
function NO_SANITIZE_MEMORY (line 277) | NO_SANITIZE_MEMORY
function LooseMemeq (line 498) | static bool LooseMemeq(const uint8_t *A, const uint8_t *B, size_t Size) {
function LLVMFuzzerMutate (line 838) | size_t LLVMFuzzerMutate(uint8_t *Data, size_t Size, size_t MaxSize) {
function LLVMFuzzerAnnounceOutput (line 844) | void LLVMFuzzerAnnounceOutput(const uint8_t *Data, size_t Size) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerMain.cpp
function main (line 19) | int main(int argc, char **argv) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerMerge.cpp
type fuzzer (line 24) | namespace fuzzer {
function WriteNewControlFile (line 262) | static void WriteNewControlFile(const std::string &CFPath,
FILE: runtime/LibFuzzer/Fuzzer/FuzzerMerge.h
function namespace (line 50) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerMutate.cpp
type fuzzer (line 19) | namespace fuzzer {
function PrintASCII (line 23) | static void PrintASCII(const Word &W, const char *PrintAfter) {
function RandCh (line 76) | static char RandCh(Random &Rand) {
function DictionaryEntry (line 206) | DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
function DictionaryEntry (line 240) | DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
function DictionaryEntry (line 250) | DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
function ChangeBinaryInteger (line 398) | size_t ChangeBinaryInteger(uint8_t *Data, size_t Size, Random &Rand) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerMutate.h
function namespace (line 20) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerOptions.h
function namespace (line 16) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerRandom.h
function namespace (line 17) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerSHA1.cpp
type sha1nfo (line 54) | struct sha1nfo {
function sha1_init (line 85) | void sha1_init(sha1nfo *s) {
function sha1_rol32 (line 95) | uint32_t sha1_rol32(uint32_t number, uint8_t bits) {
function sha1_hashBlock (line 99) | void sha1_hashBlock(sha1nfo *s) {
function sha1_addUncounted (line 136) | void sha1_addUncounted(sha1nfo *s, uint8_t data) {
function sha1_writebyte (line 150) | void sha1_writebyte(sha1nfo *s, uint8_t data) {
function sha1_write (line 155) | void sha1_write(sha1nfo *s, const char *data, size_t len) {
function sha1_pad (line 159) | void sha1_pad(sha1nfo *s) {
type fuzzer (line 199) | namespace fuzzer {
function ComputeSHA1 (line 202) | void ComputeSHA1(const uint8_t *Data, size_t Len, uint8_t *Out) {
function Sha1ToString (line 209) | std::string Sha1ToString(const uint8_t Sha1[kSHA1NumBytes]) {
function Hash (line 216) | std::string Hash(const Unit &U) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerSHA1.h
function namespace (line 19) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerShmem.h
function namespace (line 21) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerShmemFuchsia.cpp
type fuzzer (line 18) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerShmemPosix.cpp
type fuzzer (line 27) | namespace fuzzer {
type stat (line 65) | struct stat
FILE: runtime/LibFuzzer/Fuzzer/FuzzerShmemWindows.cpp
type fuzzer (line 22) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerTracePC.cpp
type fuzzer (line 38) | namespace fuzzer {
function ATTRIBUTE_NO_SANITIZE_ALL (line 143) | ATTRIBUTE_NO_SANITIZE_ALL
function ALWAYS_INLINE (line 203) | inline ALWAYS_INLINE uintptr_t GetPreviousInstructionPc(uintptr_t PC) {
function ALWAYS_INLINE (line 209) | inline ALWAYS_INLINE uintptr_t GetNextInstructionPc(uintptr_t PC) {
function GetModuleName (line 215) | static std::string GetModuleName(uintptr_t PC) {
function ATTRIBUTE_NO_SANITIZE_ALL (line 302) | ATTRIBUTE_NO_SANITIZE_ALL
function ATTRIBUTE_TARGET_POPCNT (line 331) | ATTRIBUTE_TARGET_POPCNT ALWAYS_INLINE
function InternalStrnlen (line 344) | static size_t InternalStrnlen(const char *S, size_t MaxLen) {
function InternalStrnlen2 (line 352) | static size_t InternalStrnlen2(const char *S1, const char *S2) {
function ATTRIBUTE_NO_SANITIZE_ALL (line 366) | ATTRIBUTE_NO_SANITIZE_ALL
function ATTRIBUTE_INTERFACE (line 379) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 390) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 399) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 404) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 409) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 415) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 422) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 430) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 441) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 449) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 457) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 465) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 473) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 481) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 489) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 516) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 524) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 532) | ATTRIBUTE_INTERFACE
function ATTRIBUTE_INTERFACE (line 540) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 549) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 562) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 572) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 579) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 586) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 593) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
function ATTRIBUTE_INTERFACE (line 600) | ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
FILE: runtime/LibFuzzer/Fuzzer/FuzzerTracePC.h
function namespace (line 21) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtil.cpp
type fuzzer (line 25) | namespace fuzzer {
function PrintHexArray (line 27) | void PrintHexArray(const uint8_t *Data, size_t Size,
function Print (line 34) | void Print(const Unit &v, const char *PrintAfter) {
function PrintASCIIByte (line 38) | void PrintASCIIByte(uint8_t Byte) {
function PrintASCII (line 49) | void PrintASCII(const uint8_t *Data, size_t Size, const char *PrintAft...
function PrintASCII (line 55) | void PrintASCII(const Unit &U, const char *PrintAfter) {
function ToASCII (line 59) | bool ToASCII(uint8_t *Data, size_t Size) {
function IsASCII (line 73) | bool IsASCII(const Unit &U) { return IsASCII(U.data(), U.size()); }
function IsASCII (line 75) | bool IsASCII(const uint8_t *Data, size_t Size) {
function ParseOneDictionaryEntry (line 81) | bool ParseOneDictionaryEntry(const std::string &Str, Unit *U) {
function ParseDictionaryFile (line 127) | bool ParseDictionaryFile(const std::string &Text, Vector<Unit> *Units) {
function Base64 (line 154) | std::string Base64(const Unit &U) {
function DescribePC (line 182) | std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC) {
function PrintPC (line 191) | void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintp...
function NumberOfCpuCores (line 198) | unsigned NumberOfCpuCores() {
function SimpleFastHash (line 208) | size_t SimpleFastHash(const uint8_t *Data, size_t Size) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtil.h
function namespace (line 18) | namespace fuzzer {
function Log (line 83) | inline uint32_t Log(uint32_t X) { return 32 - __builtin_clz(X) - 1; }
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtilDarwin.cpp
type fuzzer (line 25) | namespace fuzzer {
type sigaction (line 31) | struct sigaction
type sigaction (line 32) | struct sigaction
function ExecuteCommand (line 41) | int ExecuteCommand(const Command &Cmd) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtilFuchsia.cpp
type fuzzer (line 35) | namespace fuzzer {
function AlarmHandler (line 43) | void AlarmHandler(int Seconds) {
function InterruptHandler (line 50) | void InterruptHandler() {
function CrashHandler (line 56) | void CrashHandler(zx::port *Port) {
function SetSignalHandler (line 79) | void SetSignalHandler(const FuzzingOptions &Options) {
function SleepSeconds (line 119) | void SleepSeconds(int Seconds) {
function GetPid (line 123) | unsigned long GetPid() {
function GetPeakRSSMb (line 135) | size_t GetPeakRSSMb() {
function ExecuteCommand (line 147) | int ExecuteCommand(const Command &Cmd) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtilLinux.cpp
type fuzzer (line 17) | namespace fuzzer {
function ExecuteCommand (line 19) | int ExecuteCommand(const Command &Cmd) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtilPosix.cpp
type fuzzer (line 29) | namespace fuzzer {
function AlarmHandler (line 31) | static void AlarmHandler(int, siginfo_t *, void *) {
function CrashHandler (line 35) | static void CrashHandler(int, siginfo_t *, void *) {
function InterruptHandler (line 39) | static void InterruptHandler(int, siginfo_t *, void *) {
function GracefulExitHandler (line 43) | static void GracefulExitHandler(int, siginfo_t *, void *) {
function FileSizeExceedHandler (line 47) | static void FileSizeExceedHandler(int, siginfo_t *, void *) {
function SetSigaction (line 51) | static void SetSigaction(int signum,
function SetTimer (line 75) | void SetTimer(int Seconds) {
function SetSignalHandler (line 86) | void SetSignalHandler(const FuzzingOptions& Options) {
function SleepSeconds (line 111) | void SleepSeconds(int Seconds) {
function GetPid (line 115) | unsigned long GetPid() { return (unsigned long)getpid(); }
function GetPeakRSSMb (line 117) | size_t GetPeakRSSMb() {
function FILE (line 132) | FILE *OpenProcessPipe(const char *Command, const char *Mode) {
function DisassembleCmd (line 141) | std::string DisassembleCmd(const std::string &FileName) {
function SearchRegexCmd (line 145) | std::string SearchRegexCmd(const std::string &Regex) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerUtilWindows.cpp
type fuzzer (line 29) | namespace fuzzer {
function LONG (line 33) | static LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInf...
function BOOL (line 68) | BOOL WINAPI CtrlHandler(DWORD dwCtrlType) {
function AlarmHandler (line 82) | void CALLBACK AlarmHandler(PVOID, BOOLEAN) {
class TimerQ (line 86) | class TimerQ {
method TimerQ (line 89) | TimerQ() : TimerQueue(NULL) {}
method SetTimer (line 94) | void SetTimer(int Seconds) {
function CrashHandler (line 113) | static void CrashHandler(int) { Fuzzer::StaticCrashSignalCallback(); }
function SetSignalHandler (line 115) | void SetSignalHandler(const FuzzingOptions& Options) {
function SleepSeconds (line 140) | void SleepSeconds(int Seconds) { Sleep(Seconds * 1000); }
function GetPid (line 142) | unsigned long GetPid() { return GetCurrentProcessId(); }
function GetPeakRSSMb (line 144) | size_t GetPeakRSSMb() {
function FILE (line 151) | FILE *OpenProcessPipe(const char *Command, const char *Mode) {
function ExecuteCommand (line 155) | int ExecuteCommand(const Command &Cmd) {
function DisassembleCmd (line 181) | std::string DisassembleCmd(const std::string &FileName) {
function SearchRegexCmd (line 188) | std::string SearchRegexCmd(const std::string &Regex) {
FILE: runtime/LibFuzzer/Fuzzer/FuzzerValueBitMap.h
function namespace (line 17) | namespace fuzzer {
FILE: runtime/LibFuzzer/Fuzzer/afl/afl_driver.cpp
function GetPeakRSSMb (line 124) | size_t GetPeakRSSMb() {
function SetSigaction (line 140) | static void SetSigaction(int signum,
function write_extra_stats (line 153) | static void write_extra_stats() {
function crash_handler (line 169) | static void crash_handler(int, siginfo_t *, void *) {
function maybe_initialize_extra_stats (line 187) | static void maybe_initialize_extra_stats() {
function maybe_duplicate_stderr (line 234) | static void maybe_duplicate_stderr() {
function LLVMFuzzerMutate (line 254) | size_t LLVMFuzzerMutate(uint8_t *Data, size_t Size, size_t MaxSize) {
function ExecuteFilesOnyByOne (line 260) | int ExecuteFilesOnyByOne(int argc, char **argv) {
function main (line 278) | int main(int argc, char **argv) {
FILE: runtime/LibFuzzer/Fuzzer/scripts/unbalanced_allocs.py
function PrintStack (line 23) | def PrintStack(line, stack):
function ProcessStack (line 31) | def ProcessStack(line, f):
function ProcessFree (line 38) | def ProcessFree(line, f, allocs):
function ProcessMalloc (line 50) | def ProcessMalloc(line, f, allocs):
function ProcessRun (line 61) | def ProcessRun(line, f):
function ProcessFile (line 79) | def ProcessFile(f):
function main (line 84) | def main(argv):
FILE: runtime/LibFuzzer/Fuzzer/standalone/StandaloneFuzzTargetMain.c
function main (line 23) | int main(int argc, char **argv) {
FILE: runtime/LibFuzzer/Fuzzer/tests/FuzzerUnittest.cpp
function LLVMFuzzerTestOneInput (line 27) | int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
function TEST (line 31) | TEST(Fuzzer, CrossOver) {
function TEST (line 90) | TEST(Fuzzer, Hash) {
function TestEraseBytes (line 101) | void TestEraseBytes(Mutator M, int NumIter) {
function TEST (line 148) | TEST(FuzzerMutate, EraseBytes1) {
function TEST (line 151) | TEST(FuzzerMutate, EraseBytes2) {
function TestInsertByte (line 155) | void TestInsertByte(Mutator M, int NumIter) {
function TEST (line 184) | TEST(FuzzerMutate, InsertByte1) {
function TEST (line 187) | TEST(FuzzerMutate, InsertByte2) {
function TestInsertRepeatedBytes (line 191) | void TestInsertRepeatedBytes(Mutator M, int NumIter) {
function TEST (line 228) | TEST(FuzzerMutate, InsertRepeatedBytes1) {
function TEST (line 231) | TEST(FuzzerMutate, InsertRepeatedBytes2) {
function TestChangeByte (line 235) | void TestChangeByte(Mutator M, int NumIter) {
function TEST (line 264) | TEST(FuzzerMutate, ChangeByte1) {
function TEST (line 267) | TEST(FuzzerMutate, ChangeByte2) {
function TestChangeBit (line 271) | void TestChangeBit(Mutator M, int NumIter) {
function TEST (line 300) | TEST(FuzzerMutate, ChangeBit1) {
function TEST (line 303) | TEST(FuzzerMutate, ChangeBit2) {
function TestShuffleBytes (line 307) | void TestShuffleBytes(Mutator M, int NumIter) {
function TEST (line 330) | TEST(FuzzerMutate, ShuffleBytes1) {
function TEST (line 333) | TEST(FuzzerMutate, ShuffleBytes2) {
function TestCopyPart (line 337) | void TestCopyPart(Mutator M, int NumIter) {
function TEST (line 378) | TEST(FuzzerMutate, CopyPart1) {
function TEST (line 381) | TEST(FuzzerMutate, CopyPart2) {
function TestAddWordFromDictionary (line 385) | void TestAddWordFromDictionary(Mutator M, int NumIter) {
function TEST (line 418) | TEST(FuzzerMutate, AddWordFromDictionary1) {
function TEST (line 423) | TEST(FuzzerMutate, AddWordFromDictionary2) {
function TestChangeASCIIInteger (line 427) | void TestChangeASCIIInteger(Mutator M, int NumIter) {
function TEST (line 450) | TEST(FuzzerMutate, ChangeASCIIInteger1) {
function TEST (line 455) | TEST(FuzzerMutate, ChangeASCIIInteger2) {
function TestChangeBinaryInteger (line 459) | void TestChangeBinaryInteger(Mutator M, int NumIter) {
function TEST (line 490) | TEST(FuzzerMutate, ChangeBinaryInteger1) {
function TEST (line 495) | TEST(FuzzerMutate, ChangeBinaryInteger2) {
function TEST (line 500) | TEST(FuzzerDictionary, ParseOneDictionaryEntry) {
function TEST (line 528) | TEST(FuzzerDictionary, ParseDictionaryFile) {
function TEST (line 548) | TEST(FuzzerUtil, Base64) {
function TEST (line 561) | TEST(Corpus, Distribution) {
function TEST (line 579) | TEST(Merge, Bad) {
function EQ (line 599) | void EQ(const Vector<uint32_t> &A, const Vector<uint32_t> &B) {
function EQ (line 603) | void EQ(const Vector<std::string> &A, const Vector<std::string> &B) {
function Merge (line 609) | static void Merge(const std::string &Input,
function TEST (line 622) | TEST(Merge, Good) {
function TEST (line 704) | TEST(Merge, Merge) {
function TEST (line 733) | TEST(Fuzzer, ForEachNonZeroByte) {
function makeCommandArgs (line 771) | static void makeCommandArgs(Vector<std::string> *ArgsToAdd) {
function makeCmdLine (line 782) | static std::string makeCmdLine(const char *separator, const char *suffix) {
function TEST (line 797) | TEST(FuzzerCommand, Create) {
function TEST (line 838) | TEST(FuzzerCommand, ModifyArguments) {
function TEST (line 861) | TEST(FuzzerCommand, ModifyFlags) {
function TEST (line 893) | TEST(FuzzerCommand, SetOutput) {
function main (line 929) | int main(int argc, char **argv) {
FILE: runtime/LibPureRandomFuzzer/API.cpp
type prf (line 17) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/API.h
function namespace (line 45) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/Driver.cpp
type prf (line 27) | namespace prf {
type Fuzzer (line 31) | struct Fuzzer {
function Driver (line 41) | int Driver(int& argc, char**& argv) {
function PrintFinalStats (line 79) | void PrintFinalStats() {
function Options (line 89) | Options BuildOptions(int& argc, char**& argv) {
function WriteArtifact (line 145) | void WriteArtifact(const char* artifactType) {
function AbortHandler (line 158) | void AbortHandler(int sig) {
function TimeoutHandler (line 167) | void TimeoutHandler(int sig) {
FILE: runtime/LibPureRandomFuzzer/Driver.h
function namespace (line 19) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/Log.h
function namespace (line 17) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/Main.cpp
function main (line 14) | int main(int argc, char** argv) {
FILE: runtime/LibPureRandomFuzzer/Signals.cpp
type prf (line 18) | namespace prf {
type sigaction (line 41) | struct sigaction
FILE: runtime/LibPureRandomFuzzer/Signals.h
function namespace (line 18) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/TestInput.cpp
type prf (line 17) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/TestInput.h
function namespace (line 19) | namespace prf {
FILE: runtime/LibPureRandomFuzzer/Types.h
function namespace (line 15) | namespace prf {
FILE: runtime/SMTLIB/SMTLIB/BitVector.h
function dataTy (line 41) | dataTy doMod(dataTy value) const {
function dataTy (line 51) | constexpr dataTy computeSignExtendMask(uint64_t bits) const {
function bvult (line 333) | bool bvult(const BitVector<N>& rhs) const {
function bvule (line 336) | bool bvule(const BitVector<N>& rhs) const {
function bvugt (line 339) | bool bvugt(const BitVector<N>& rhs) const {
function bvuge (line 342) | bool bvuge(const BitVector<N>& rhs) const {
function bvslt (line 346) | bool bvslt(const BitVector<N>& rhs) const {
function bvsle (line 350) | bool bvsle(const BitVector<N>& rhs) const {
function bvsgt (line 354) | bool bvsgt(const BitVector<N>& rhs) const {
function bvsge (line 358) | bool bvsge(const BitVector<N>& rhs) const {
function numBytesRequired (line 388) | constexpr size_t numBytesRequired(size_t bits) const {
function BitVector (line 410) | BitVector(uint64_t value) : BitVector() {
FILE: runtime/SMTLIB/SMTLIB/BufferRef.h
function T (line 22) | T* get() const { return data; }
function operator (line 23) | operator T*() const { return get(); }
FILE: runtime/SMTLIB/SMTLIB/Core.cpp
function makeBoolFrom (line 16) | bool makeBoolFrom(BufferRef<const uint8_t> buffer, const uint64_t lowBit,
FILE: runtime/SMTLIB/SMTLIB/Float.cpp
function Float32 (line 14) | Float32 makeFloatFrom(BufferRef<const uint8_t> buffer, uint64_t lowBit,
function Float64 (line 22) | Float64 makeFloatFrom(BufferRef<const uint8_t> buffer, uint64_t lowBit,
function Float64 (line 29) | Float64 Float32::convertToFloat<11, 53>(JFS_NR_RM rm) const {
function Float32 (line 34) | Float32 Float32::convertToFloat<8, 24>(JFS_NR_RM rm) const {
function Float32 (line 39) | Float32 Float64::convertToFloat<8, 24>(JFS_NR_RM rm) const {
function Float64 (line 43) | Float64 Float64::convertToFloat<11, 53>(JFS_NR_RM rm) const {
FILE: runtime/SMTLIB/SMTLIB/Float.h
function Float32 (line 53) | Float32 convertFromUnsignedBV(JFS_NR_RM rm,
function Float32 (line 61) | Float32 convertFromSignedBV(JFS_NR_RM rm,
function Float32 (line 81) | static Float32 getPositiveInfinity() {
function Float32 (line 84) | static Float32 getNegativeInfinity() {
function Float32 (line 87) | static Float32 getPositiveZero() { return jfs_nr_float32_get_zero(true); }
function Float32 (line 88) | static Float32 getNegativeZero() { return jfs_nr_float32_get_zero(false); }
function Float32 (line 89) | static Float32 getNaN() { return jfs_nr_float32_get_nan(true); }
function operator (line 92) | bool operator==(const Float32& other) const {
function ieeeEquals (line 96) | bool ieeeEquals(const Float32& other) const {
function fplt (line 100) | bool fplt(const Float32& other) const {
function fpleq (line 103) | bool fpleq(const Float32& other) const {
function fpgt (line 106) | bool fpgt(const Float32& other) const {
function fpgeq (line 109) | bool fpgeq(const Float32& other) const {
function Float32 (line 116) | Float32 add(JFS_NR_RM rm, const Float32& other) const {
function Float32 (line 119) | Float32 sub(JFS_NR_RM rm, const Float32& other) const {
function Float32 (line 122) | Float32 mul(JFS_NR_RM rm, const Float32& other) const {
function Float32 (line 125) | Float32 div(JFS_NR_RM rm, const Float32& other) const {
function Float32 (line 128) | Float32 fma(JFS_NR_RM rm, const Float32& b, const Float32& c) const {
function Float32 (line 131) | Float32 sqrt(JFS_NR_RM rm) const { return jfs_nr_float32_sqrt(rm, data); }
function Float32 (line 132) | Float32 rem(const Float32& other) const {
function Float32 (line 135) | Float32 roundToIntegral(JFS_NR_RM rm) const {
function Float32 (line 138) | Float32 min(const Float32& other) const {
function Float32 (line 141) | Float32 max(const Float32& other) const {
function Float64 (line 182) | Float64 convertFromUnsignedBV(JFS_NR_RM rm,
function Float64 (line 190) | Float64 convertFromSignedBV(JFS_NR_RM rm,
function Float64 (line 210) | static Float64 getPositiveInfinity() {
function Float64 (line 213) | static Float64 getNegativeInfinity() {
function Float64 (line 216) | static Float64 getPositiveZero() { return jfs_nr_float64_get_zero(true); }
function Float64 (line 217) | static Float64 getNegativeZero() { return jfs_nr_float64_get_zero(false); }
function Float64 (line 218) | static Float64 getNaN() { return jfs_nr_float64_get_nan(true); }
function operator (line 221) | bool operator==(const Float64& other) const {
function ieeeEquals (line 225) | bool ieeeEquals(const Float64& other) const {
function fplt (line 229) | bool fplt(const Float64& other) const {
function fpleq (line 232) | bool fpleq(const Float64& other) const {
function fpgt (line 235) | bool fpgt(const Float64& other) const {
function fpgeq (line 238) | bool fpgeq(const Float64& other) const {
function Float64 (line 245) | Float64 add(JFS_NR_RM rm, const Float64& other) const {
function Float64 (line 248) | Float64 sub(JFS_NR_RM rm, const Float64& other) const {
function Float64 (line 251) | Float64 mul(JFS_NR_RM rm, const Float64& other) const {
function Float64 (line 254) | Float64 div(JFS_NR_RM rm, const Float64& other) const {
function Float64 (line 257) | Float64 fma(JFS_NR_RM rm, const Float64& b, const Float64& c) const {
function Float64 (line 260) | Float64 sqrt(JFS_NR_RM rm) const { return jfs_nr_float64_sqrt(rm, data); }
function Float64 (line 261) | Float64 rem(const Float64& other) const {
function Float64 (line 264) | Float64 roundToIntegral(JFS_NR_RM rm) const {
function Float64 (line 267) | Float64 min(const Float64& other) const {
function Float64 (line 270) | Float64 max(const Float64& other) const {
FILE: runtime/SMTLIB/SMTLIB/Logger.cpp
class LoggerImpl (line 21) | class LoggerImpl {
method LoggerImpl (line 27) | LoggerImpl(const char* path) : logPath(path) {}
method log_uint64 (line 40) | void log_uint64(const char* name, uint64_t value) {
function jfs_nr_logger_ty (line 49) | jfs_nr_logger_ty jfs_nr_mk_logger(const char* path) {
function jfs_nr_logger_ty (line 54) | jfs_nr_logger_ty jfs_nr_mk_logger_from_env() {
function jfs_nr_log_uint64 (line 64) | void jfs_nr_log_uint64(jfs_nr_logger_ty logger, const char* name,
function jfs_nr_del_logger (line 70) | void jfs_nr_del_logger(jfs_nr_logger_ty logger) {
FILE: runtime/SMTLIB/SMTLIB/Messages.cpp
function jfs_info (line 22) | void jfs_info(const char* fmt, ...) {
function jfs_warning (line 30) | void jfs_warning(const char* fmt, ...) {
FILE: runtime/SMTLIB/SMTLIB/NativeBitVector.cpp
function jfs_nr_bitvector_ty (line 24) | jfs_nr_bitvector_ty jfs_nr_get_bitvector_mask(const jfs_nr_width_ty bitW...
function jfs_nr_bitvector_ty (line 33) | jfs_nr_bitvector_ty
function jfs_nr_bitvector_ty (line 47) | jfs_nr_bitvector_ty jfs_nr_get_bitvector_mod(const jfs_nr_bitvector_ty v...
function jfs_nr_is_valid (line 57) | bool jfs_nr_is_valid(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 62) | jfs_nr_bitvector_ty jfs_nr_concat(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 76) | jfs_nr_bitvector_ty jfs_nr_extract(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 99) | jfs_nr_bitvector_ty jfs_nr_zero_extend(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 109) | jfs_nr_bitvector_ty jfs_nr_sign_extend(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 127) | jfs_nr_bitvector_ty jfs_nr_bvneg(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 140) | jfs_nr_bitvector_ty jfs_nr_bvadd(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 149) | jfs_nr_bitvector_ty jfs_nr_bvsub(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 160) | jfs_nr_bitvector_ty jfs_nr_bvmul(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 169) | jfs_nr_bitvector_ty jfs_nr_bvudiv(const jfs_nr_bitvector_ty dividend,
function jfs_nr_bitvector_ty (line 185) | jfs_nr_bitvector_ty jfs_nr_bvurem(const jfs_nr_bitvector_ty dividend,
function jfs_nr_bitvector_ty (line 203) | jfs_nr_bitvector_ty jfs_nr_bvsdiv(const jfs_nr_bitvector_ty dividend,
function jfs_nr_bitvector_ty (line 246) | jfs_nr_bitvector_ty jfs_nr_bvsrem(const jfs_nr_bitvector_ty dividend,
function jfs_nr_bitvector_ty (line 290) | jfs_nr_bitvector_ty jfs_nr_bvsmod(const jfs_nr_bitvector_ty dividend,
function jfs_nr_bitvector_ty (line 340) | jfs_nr_bitvector_ty jfs_nr_bvshl(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 357) | jfs_nr_bitvector_ty jfs_nr_bvlshr(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 374) | jfs_nr_bitvector_ty jfs_nr_bvashr(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 397) | jfs_nr_bitvector_ty jfs_nr_rotate_left(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 419) | jfs_nr_bitvector_ty jfs_nr_rotate_right(const jfs_nr_bitvector_ty value,
function jfs_nr_bitvector_ty (line 441) | jfs_nr_bitvector_ty jfs_nr_bvand(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 451) | jfs_nr_bitvector_ty jfs_nr_bvor(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 461) | jfs_nr_bitvector_ty jfs_nr_bvnand(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 472) | jfs_nr_bitvector_ty jfs_nr_bvnor(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 483) | jfs_nr_bitvector_ty jfs_nr_bvxor(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 494) | jfs_nr_bitvector_ty jfs_nr_bvxnor(const jfs_nr_bitvector_ty lhs,
function jfs_nr_bitvector_ty (line 505) | jfs_nr_bitvector_ty jfs_nr_bvnot(const jfs_nr_bitvector_ty value,
function jfs_nr_bvult (line 513) | bool jfs_nr_bvult(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvule (line 520) | bool jfs_nr_bvule(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvugt (line 527) | bool jfs_nr_bvugt(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvuge (line 534) | bool jfs_nr_bvuge(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvslt (line 541) | bool jfs_nr_bvslt(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvsle (line 558) | bool jfs_nr_bvsle(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvsgt (line 575) | bool jfs_nr_bvsgt(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bvsge (line 581) | bool jfs_nr_bvsge(const jfs_nr_bitvector_ty lhs, const jfs_nr_bitvector_...
function jfs_nr_bitvector_ty (line 592) | jfs_nr_bitvector_ty jfs_nr_make_bitvector(const uint8_t* bufferData,
function jfs_nr_write_bitvector (line 636) | void jfs_nr_write_bitvector(const jfs_nr_bitvector_ty bv,
FILE: runtime/SMTLIB/SMTLIB/NativeBitVector.h
type jfs_nr_bitvector_ty (line 19) | typedef uint64_t jfs_nr_bitvector_ty;
type jfs_nr_width_ty (line 20) | typedef uint64_t jfs_nr_width_ty;
FILE: runtime/SMTLIB/SMTLIB/NativeFloat.cpp
function T (line 26) | T jfs_nr_internal_make_float_from_buffer(const uint8_t* bufferData,
function RetTy (line 44) | RetTy jfs_nr_internal_float_get_raw_bits(const ArgTy value) {
function jfs_nr_float32_get_raw_bits (line 56) | uint32_t jfs_nr_float32_get_raw_bits(const jfs_nr_float32 value) {
function jfs_nr_float64_get_raw_bits (line 60) | uint64_t jfs_nr_float64_get_raw_bits(const jfs_nr_float64 value) {
function jfs_nr_float32 (line 64) | jfs_nr_float32 jfs_nr_float32_get_infinity(bool positive) {
function jfs_nr_float64 (line 70) | jfs_nr_float64 jfs_nr_float64_get_infinity(bool positive) {
function jfs_nr_float32 (line 76) | jfs_nr_float32 jfs_nr_float32_get_zero(bool positive) {
function jfs_nr_float64 (line 82) | jfs_nr_float64 jfs_nr_float64_get_zero(bool positive) {
function jfs_nr_float32 (line 88) | jfs_nr_float32 jfs_nr_float32_get_nan(bool quiet) {
function jfs_nr_float64 (line 94) | jfs_nr_float64 jfs_nr_float64_get_nan(bool quiet) {
function jfs_nr_float32_is_normal (line 100) | bool jfs_nr_float32_is_normal(const jfs_nr_float32 value) {
function jfs_nr_float64_is_normal (line 103) | bool jfs_nr_float64_is_normal(const jfs_nr_float64 value) {
function jfs_nr_float32_is_subnormal (line 107) | bool jfs_nr_float32_is_subnormal(const jfs_nr_float32 value) {
function jfs_nr_float64_is_subnormal (line 111) | bool jfs_nr_float64_is_subnormal(const jfs_nr_float64 value) {
function jfs_nr_float32_is_zero (line 115) | bool jfs_nr_float32_is_zero(const jfs_nr_float32 value) {
function jfs_nr_float64_is_zero (line 119) | bool jfs_nr_float64_is_zero(const jfs_nr_float64 value) {
function jfs_nr_float32_is_infinite (line 123) | bool jfs_nr_float32_is_infinite(const jfs_nr_float32 value) {
function jfs_nr_float64_is_infinite (line 127) | bool jfs_nr_float64_is_infinite(const jfs_nr_float64 value) {
function jfs_nr_float32_is_positive (line 131) | bool jfs_nr_float32_is_positive(const jfs_nr_float32 value) {
function jfs_nr_float64_is_positive (line 138) | bool jfs_nr_float64_is_positive(const jfs_nr_float64 value) {
function jfs_nr_float32_is_negative (line 145) | bool jfs_nr_float32_is_negative(const jfs_nr_float32 value) {
function jfs_nr_float64_is_negative (line 152) | bool jfs_nr_float64_is_negative(const jfs_nr_float64 value) {
function jfs_nr_float32_is_nan (line 159) | bool jfs_nr_float32_is_nan(const jfs_nr_float32 value) { return isnan(va...
function jfs_nr_float64_is_nan (line 161) | bool jfs_nr_float64_is_nan(const jfs_nr_float64 value) { return isnan(va...
function jfs_nr_float32_ieee_equals (line 163) | bool jfs_nr_float32_ieee_equals(const jfs_nr_float32 lhs,
function jfs_nr_float64_ieee_equals (line 168) | bool jfs_nr_float64_ieee_equals(const jfs_nr_float64 lhs,
function jfs_nr_float32_smtlib_equals (line 173) | bool jfs_nr_float32_smtlib_equals(const jfs_nr_float32 lhs,
function jfs_nr_float64_smtlib_equals (line 204) | bool jfs_nr_float64_smtlib_equals(const jfs_nr_float64 lhs,
function jfs_nr_float32 (line 217) | jfs_nr_float32 jfs_nr_float32_abs(const jfs_nr_float32 value) {
function jfs_nr_float64 (line 221) | jfs_nr_float64 jfs_nr_float64_abs(const jfs_nr_float64 value) {
function jfs_nr_float32 (line 225) | jfs_nr_float32 jfs_nr_float32_neg(const jfs_nr_float32 value) {
function NO_OPT (line 298) | NO_OPT jfs_nr_float32 jfs_nr_float32_add(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 306) | NO_OPT jfs_nr_float64 jfs_nr_float64_add(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 314) | NO_OPT jfs_nr_float32 jfs_nr_float32_sub(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 322) | NO_OPT jfs_nr_float64 jfs_nr_float64_sub(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 330) | NO_OPT jfs_nr_float32 jfs_nr_float32_mul(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 338) | NO_OPT jfs_nr_float64 jfs_nr_float64_mul(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 349) | NO_OPT ALLOW_DIV_BY_ZERO jfs_nr_float32 jfs_nr_float32_div(
function NO_OPT (line 357) | NO_OPT ALLOW_DIV_BY_ZERO jfs_nr_float64 jfs_nr_float64_div(
function NO_OPT (line 366) | NO_OPT jfs_nr_float32 jfs_nr_float32_fma(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 375) | NO_OPT jfs_nr_float64 jfs_nr_float64_fma(JFS_NR_RM rm, const jfs_nr_floa...
function NO_OPT (line 384) | NO_OPT jfs_nr_float32 jfs_nr_float32_sqrt(JFS_NR_RM rm,
function NO_OPT (line 392) | NO_OPT jfs_nr_float64 jfs_nr_float64_sqrt(JFS_NR_RM rm,
function NO_OPT (line 400) | NO_OPT jfs_nr_float32
function NO_OPT (line 410) | NO_OPT jfs_nr_float64
function NO_OPT (line 424) | NO_OPT ALLOW_OVERFLOW jfs_nr_float32
function jfs_nr_float64 (line 432) | jfs_nr_float64 jfs_nr_convert_float32_to_float64(const jfs_nr_float32 va...
function NO_OPT (line 438) | NO_OPT jfs_nr_float32 jfs_nr_convert_from_unsigned_bv_to_float32(
function NO_OPT (line 448) | NO_OPT jfs_nr_float64 jfs_nr_convert_from_unsigned_bv_to_float64(
function NO_OPT (line 458) | NO_OPT jfs_nr_float32 jfs_nr_convert_from_signed_bv_to_float32(
function NO_OPT (line 480) | NO_OPT jfs_nr_float64 jfs_nr_convert_from_signed_bv_to_float64(
function NO_OPT (line 504) | NO_OPT ALLOW_OVERFLOW jfs_nr_bitvector_ty jfs_nr_float32_convert_to_unsi...
function NO_OPT (line 517) | NO_OPT ALLOW_OVERFLOW jfs_nr_bitvector_ty jfs_nr_float64_convert_to_unsi...
function NO_OPT (line 530) | NO_OPT ALLOW_OVERFLOW jfs_nr_bitvector_ty jfs_nr_float32_convert_to_sign...
function NO_OPT (line 555) | NO_OPT ALLOW_OVERFLOW jfs_nr_bitvector_ty jfs_nr_float64_convert_to_sign...
function jfs_nr_float32 (line 582) | jfs_nr_float32 jfs_nr_float32_rem(const jfs_nr_float32 lhs,
function jfs_nr_float64 (line 587) | jfs_nr_float64 jfs_nr_float64_rem(const jfs_nr_float64 lhs,
function jfs_nr_float64 (line 592) | jfs_nr_float64 jfs_nr_float64_neg(const jfs_nr_float64 value) {
function jfs_nr_float32 (line 599) | jfs_nr_float32 jfs_nr_float32_min(const jfs_nr_float32 lhs,
function jfs_nr_float64 (line 604) | jfs_nr_float64 jfs_nr_float64_min(const jfs_nr_float64 lhs,
function jfs_nr_float32 (line 609) | jfs_nr_float32 jfs_nr_float32_max(const jfs_nr_float32 lhs,
function jfs_nr_float64 (line 614) | jfs_nr_float64 jfs_nr_float64_max(const jfs_nr_float64 lhs,
function jfs_nr_float32_leq (line 619) | bool jfs_nr_float32_leq(const jfs_nr_float32 lhs, const jfs_nr_float32 r...
function jfs_nr_float64_leq (line 623) | bool jfs_nr_float64_leq(const jfs_nr_float64 lhs, const jfs_nr_float64 r...
function jfs_nr_float32_lt (line 627) | bool jfs_nr_float32_lt(const jfs_nr_float32 lhs, const jfs_nr_float32 rh...
function jfs_nr_float64_lt (line 631) | bool jfs_nr_float64_lt(const jfs_nr_float64 lhs, const jfs_nr_float64 rh...
function jfs_nr_float32_gt (line 635) | bool jfs_nr_float32_gt(const jfs_nr_float32 lhs, const jfs_nr_float32 rh...
function jfs_nr_float64_gt (line 639) | bool jfs_nr_float64_gt(const jfs_nr_float64 lhs, const jfs_nr_float64 rh...
function jfs_nr_float32_geq (line 643) | bool jfs_nr_float32_geq(const jfs_nr_float32 lhs, const jfs_nr_float32 r...
function jfs_nr_float64_geq (line 647) | bool jfs_nr_float64_geq(const jfs_nr_float64 lhs, const jfs_nr_float64 r...
function jfs_nr_float32 (line 651) | jfs_nr_float32 jfs_nr_bitcast_bv_to_float32(const jfs_nr_bitvector_ty va...
function jfs_nr_float64 (line 658) | jfs_nr_float64 jfs_nr_bitcast_bv_to_float64(const jfs_nr_bitvector_ty va...
function jfs_nr_float32 (line 665) | jfs_nr_float32
function jfs_nr_float64 (line 679) | jfs_nr_float64
function jfs_nr_float32 (line 695) | jfs_nr_float32 jfs_nr_make_float32_from_buffer(const uint8_t* bufferData,
function jfs_nr_float64 (line 702) | jfs_nr_float64 jfs_nr_make_float64_from_buffer(const uint8_t* bufferData,
FILE: runtime/SMTLIB/SMTLIB/NativeFloat.h
type jfs_nr_float32 (line 20) | typedef float jfs_nr_float32;
type jfs_nr_float64 (line 21) | typedef double jfs_nr_float64;
type JFS_NR_RM (line 23) | enum JFS_NR_RM {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/Native/BvAlloc.cpp
function TEST (line 15) | TEST(bvalloc, defaultZero8) {
function TEST (line 20) | TEST(bvalloc, maxValue8) {
function TEST (line 25) | TEST(bvalloc, defaultZero64) {
function TEST (line 30) | TEST(bvalloc, maxValue64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/Native/BvSDiv.cpp
function getNegBits (line 15) | uint64_t getNegBits(uint64_t v, uint64_t N) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/Native/Extract.cpp
function TEST (line 34) | TEST(bvextract, simple) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/Native/MakeFromBuffer.cpp
function TEST (line 16) | TEST(MakeFromBuffer, WholeBuffer64) {
function TEST (line 25) | TEST(MakeFromBuffer, HalfBuffer64) {
function TEST (line 36) | TEST(MakeFromBuffer, IndividualBits) {
function TEST (line 54) | TEST(MakeFromBuffer, NonByteAlignedOffset) {
function TEST (line 69) | TEST(MakeFromBuffer, LargeBuffer) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/Native/WriteToBuffer.cpp
function TEST (line 16) | TEST(WriteToBuffer, ByteAligned) {
function TEST (line 39) | TEST(WriteToBuffer, SplitBytes) {
function TEST (line 62) | TEST(WriteToBuffer, MiddleOfBuffer) {
function TEST (line 87) | TEST(WriteToBuffer, SeveralVectors) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/NonNative/Concat.cpp
function TEST (line 14) | TEST(BvConcat, simpleBig) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/NonNative/SignExtend.cpp
function TEST (line 14) | TEST(bvsignextend, simpleZeroExt) {
function TEST (line 25) | TEST(bvsignextend, simpleSignExt) {
FILE: runtime/SMTLIB/SMTLIB/unittests/BitVector/NonNative/ZeroExtend.cpp
function TEST (line 14) | TEST(bvzeroexend, simpleNonNative) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Core/MakeFromBuffer.cpp
function TEST (line 14) | TEST(MakeFromBuffer, singleBitFromUniformBuffer) {
function TEST (line 102) | TEST(MakeFromBuffer, IndividualBits) {
function TEST (line 120) | TEST(MakeFromBuffer, AcrossByteBoundaryFalse) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Abs.cpp
function TEST (line 17) | TEST(Abs, NaN) {
function TEST (line 22) | TEST(Abs, NegativeZero) {
function TEST (line 31) | TEST(Abs, PositiveZero) {
function TEST (line 40) | TEST(Abs, NegativeInfinity) {
function TEST (line 49) | TEST(Abs, PositiveInfinity) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Add.cpp
function TEST (line 14) | TEST(Add, NaN) {
function TEST (line 19) | TEST(Add, Simple) {
function TEST (line 23) | TEST(Add, DiffResultRNE_RTP_Float32) {
function TEST (line 50) | TEST(Add, DiffResultRNE_RTP_Float64) {
function TEST (line 74) | TEST(Add, DiffResultRNE_RTN_Float32) {
function TEST (line 100) | TEST(Add, DiffResultRNE_RTN_Float64) {
function TEST (line 124) | TEST(Add, DiffResultRNE_RTZ_Float32) {
function TEST (line 150) | TEST(Add, DiffResultRNE_RTZ_Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/ConvertToFloatFromFloat.cpp
function TEST (line 14) | TEST(ConvertToFloatFromFloat, NaN) {
function TEST (line 24) | TEST(ConvertToFloatFromFloat, Float64ToFloat32_Diff_RNE_RTP) {
function TEST (line 53) | TEST(ConvertToFloatFromFloat, Float64ToFloat32_Diff_RNE_RTN) {
function TEST (line 82) | TEST(ConvertToFloatFromFloat, Float64ToFloat32_Diff_RNE_RTZ) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/ConvertToFloatFromSignedBV.cpp
function TEST (line 14) | TEST(ConvertToFloatFromSignedBV, zero) {
function TEST (line 21) | TEST(ConvertToFloatFromSignedBV, TwoFiveSix) {
function TEST (line 28) | TEST(ConvertToFloatFromSignedBV, MinusOne) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/ConvertToFloatFromUnsignedBV.cpp
function TEST (line 14) | TEST(ConvertToFloatFromUnsignedBV, zero) {
function TEST (line 21) | TEST(ConvertToFloatFromUnsignedBV, TwoFiveSix) {
function TEST (line 30) | TEST(ConvertToFloatFromUnsignedBV, Float32RoundedRTE) {
function TEST (line 49) | TEST(ConvertToFloatFromUnsignedBV, Float64RoundedRTE) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/ConvertToSignedBVFromFloat.cpp
function TEST (line 14) | TEST(ConvertToSignedBVFromFloat, positiveZero) {
function TEST (line 21) | TEST(ConvertToSignedBVFromFloat, negativeZero) {
function TEST (line 28) | TEST(ConvertToSignedBVFromFloat, TwoFiveSixPointTwo) {
function TEST (line 35) | TEST(ConvertToSignedBVFromFloat, MinusOne) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/ConvertToUnsignedBVFromFloat.cpp
function TEST (line 14) | TEST(ConvertToUnsignedBVFromFloat, zero) {
function TEST (line 21) | TEST(ConvertToUnsignedBVFromFloat, TwoFiveSixPointTwo) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Div.cpp
function TEST (line 14) | TEST(Div, NaN) {
function TEST (line 19) | TEST(Div, DivByZero) {
function TEST (line 28) | TEST(Div, Simple) {
function TEST (line 33) | TEST(Div, DiffResultRNE_RTP_Float32) {
function TEST (line 60) | TEST(Div, DiffResultRNE_RTP_Float64) {
function TEST (line 84) | TEST(Div, DiffResultRNE_RTN_Float32) {
function TEST (line 114) | TEST(Div, DiffResultRNE_RTN_Float64) {
function TEST (line 138) | TEST(Div, DiffResultRNE_RTZ_Float32) {
function TEST (line 164) | TEST(Div, DiffResultRNE_RTZ_Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/FMA.cpp
function TEST (line 14) | TEST(FMA, NaN) {
function TEST (line 21) | TEST(FMA, Simple) {
function TEST (line 30) | TEST(FMA, DiffResultRNE_RTP_Float32) {
function TEST (line 64) | TEST(FMA, DiffResultRNE_RTP_Float64) {
function TEST (line 98) | TEST(FMA, DiffResultRNE_RTN_Float32) {
function TEST (line 132) | TEST(FMA, DiffResultRNE_RTN_Float64) {
function TEST (line 166) | TEST(FMA, DiffResultRNE_RTZ_Float32) {
function TEST (line 200) | TEST(FMA, DiffResultRNE_RTZ_Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/GreaterThan.cpp
function TEST (line 14) | TEST(GreaterThan, NaNCmpNaN) {
function TEST (line 19) | TEST(GreaterThan, SameValues) {
function TEST (line 24) | TEST(GreaterThan, SmallLessBig) {
function TEST (line 29) | TEST(GreaterThan, BigLessSmall) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/GreaterThanOrEqual.cpp
function TEST (line 14) | TEST(GreaterThanOrEqual, NaNCmpNaN) {
function TEST (line 19) | TEST(GreaterThanOrEqual, SameValues) {
function TEST (line 24) | TEST(GreaterThanOrEqual, SmallLessBig) {
function TEST (line 29) | TEST(GreaterThanOrEqual, BigLessSmall) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IEEEEquals.cpp
function checkCommonConstants (line 16) | void checkCommonConstants() {
function TEST (line 33) | TEST(IEEEEquals, DisjointConstantsDisjointFloat32) {
function TEST (line 37) | TEST(IEEEEquals, DisjointConstantsDisjointFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsInfinite.cpp
function TEST (line 15) | TEST(IsInfinite, Float32) {
function TEST (line 35) | TEST(IsInfinite, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsNaN.cpp
function TEST (line 15) | TEST(IsNaN, fromFloat32API) {
function TEST (line 20) | TEST(IsNaN, fromFloat64API) {
function TEST (line 25) | TEST(IsNaN, onZeroFloat32) {
function TEST (line 30) | TEST(IsNaN, onZeroFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsNegative.cpp
function TEST (line 15) | TEST(IsNegative, Float32) {
function TEST (line 35) | TEST(IsNegative, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsNormal.cpp
function TEST (line 15) | TEST(IsNormal, Float32) {
function TEST (line 27) | TEST(IsNormal, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsPositive.cpp
function TEST (line 15) | TEST(IsPositive, Float32) {
function TEST (line 34) | TEST(IsPositive, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsSubnormal.cpp
function TEST (line 15) | TEST(IsSubnormal, Float32) {
function TEST (line 27) | TEST(IsSubnormal, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/IsZero.cpp
function TEST (line 15) | TEST(IsZero, Float32) {
function TEST (line 27) | TEST(IsZero, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/LessThan.cpp
function TEST (line 14) | TEST(LessThan, NaNCmpNaN) {
function TEST (line 19) | TEST(LessThan, SameValues) {
function TEST (line 24) | TEST(LessThan, SmallLessBig) {
function TEST (line 29) | TEST(LessThan, BigLessSmall) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/LessThanOrEqual.cpp
function TEST (line 14) | TEST(LessThanOrEqual, NaNCmpNaN) {
function TEST (line 19) | TEST(LessThanOrEqual, SameValues) {
function TEST (line 24) | TEST(LessThanOrEqual, SmallLessBig) {
function TEST (line 29) | TEST(LessThanOrEqual, BigLessSmall) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/MakeFromBuffer.cpp
function testFloat32Bits (line 18) | void testFloat32Bits(jfs_nr_float32 initialValue, uint32_t expectedBits) {
function testFloat32Value (line 27) | void testFloat32Value(jfs_nr_float32 initialValue) {
function testFloat64Bits (line 36) | void testFloat64Bits(jfs_nr_float64 initialValue, uint64_t expectedBits) {
function testFloat64Value (line 45) | void testFloat64Value(jfs_nr_float64 initialValue) {
function TEST (line 55) | TEST(MakeFromBuffer, PositiveZero) {
function TEST (line 60) | TEST(MakeFromBuffer, NegativeZero) {
function TEST (line 65) | TEST(MakeFromBuffer, PositiveInf) {
function TEST (line 70) | TEST(MakeFromBuffer, NegativeInf) {
function TEST (line 75) | TEST(MakeFromBuffer, PositiveOnes) {
function TEST (line 80) | TEST(MakeFromBuffer, NegativeOnes) {
function TEST (line 85) | TEST(MakeFromBuffer, NaN) {
function TEST (line 90) | TEST(MakeFromBuffer, simpleValuesFloat32) {
function TEST (line 108) | TEST(MakeFromBuffer, simpleValuesFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/MakeFromIEEEBitVector.cpp
function TEST (line 15) | TEST(MakeFromIEEEBitVector, PositiveZeroFloat32) {
function TEST (line 23) | TEST(MakeFromIEEEBitVector, PositiveZeroFloat64) {
function TEST (line 31) | TEST(MakeFromIEEEBitVector, NegativeZeroFloat32) {
function TEST (line 39) | TEST(MakeFromIEEEBitVector, NegativeZeroFloat64) {
function TEST (line 47) | TEST(MakeFromIEEEBitVector, PositiveInfinityFloat32) {
function TEST (line 55) | TEST(MakeFromIEEEBitVector, PositiveInfinityFloat64) {
function TEST (line 63) | TEST(MakeFromIEEEBitVector, NegativeInfinityFloat32) {
function TEST (line 71) | TEST(MakeFromIEEEBitVector, NegativeInfinityFloat64) {
function TEST (line 79) | TEST(MakeFromIEEEBitVector, NaNFloat32) {
function TEST (line 86) | TEST(MakeFromIEEEBitVector, NaNFloat64) {
function TEST (line 93) | TEST(MakeFromIEEEBitVector, onePointTwoFiveFloat32) {
function TEST (line 98) | TEST(MakeFromIEEEBitVector, onePointTwoFiveFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/MakeFromTriple.cpp
function testFloat32Bits (line 19) | void testFloat32Bits(jfs_nr_bitvector_ty sign, jfs_nr_bitvector_ty expon...
function testFloat64Bits (line 29) | void testFloat64Bits(jfs_nr_bitvector_ty sign, jfs_nr_bitvector_ty expon...
function TEST (line 40) | TEST(MakeFromTriple, PositiveZero) {
function TEST (line 45) | TEST(MakeFromTriple, NegativeZero) {
function TEST (line 50) | TEST(MakeFromTriple, PositiveInf) {
function TEST (line 56) | TEST(MakeFromTriple, NegativeInf) {
function TEST (line 62) | TEST(MakeFromTriple, PositiveOne) {
function TEST (line 67) | TEST(MakeFromTriple, NegativeOne) {
function TEST (line 72) | TEST(MakeFromTriple, NaN) {
function TEST (line 78) | TEST(MakeFromTriple, OnePointTwoFive) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Max.cpp
function TEST (line 14) | TEST(Max, Float32) {
function TEST (line 32) | TEST(Max, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Min.cpp
function TEST (line 14) | TEST(Min, Float32) {
function TEST (line 32) | TEST(Min, Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Mul.cpp
function TEST (line 14) | TEST(Mul, NaN) {
function TEST (line 19) | TEST(Mul, Simple) {
function TEST (line 24) | TEST(Mul, DiffResultRNE_RTP_Float32) {
function TEST (line 51) | TEST(Mul, DiffResultRNE_RTP_Float64) {
function TEST (line 75) | TEST(Mul, DiffResultRNE_RTN_Float32) {
function TEST (line 101) | TEST(Mul, DiffResultRNE_RTN_Float64) {
function TEST (line 125) | TEST(Mul, DiffResultRNE_RTZ_Float32) {
function TEST (line 151) | TEST(Mul, DiffResultRNE_RTZ_Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Neg.cpp
function TEST (line 15) | TEST(Neg, NaN) {
function TEST (line 28) | TEST(Neg, NegativeZero) {
function TEST (line 37) | TEST(Neg, PositiveZero) {
function TEST (line 46) | TEST(Neg, NegativeInfinity) {
function TEST (line 55) | TEST(Neg, PositiveInfinity) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Rem.cpp
function TEST (line 14) | TEST(Rem, NaN) {
function TEST (line 19) | TEST(Rem, Simple) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/RoundToIntegral.cpp
function TEST (line 14) | TEST(RoundToIntegral, NaN) {
function TEST (line 19) | TEST(RoundToIntegral, SimpleFloat32) {
function TEST (line 26) | TEST(RoundToIntegral, SimpleFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/SMTLIBEquals.cpp
function checkDisjointConstantsDisjoint (line 16) | void checkDisjointConstantsDisjoint() {
function TEST (line 37) | TEST(SMTLIBEquals, DisjointConstantsDisjointFloat32) {
function TEST (line 41) | TEST(SMTLIBEquals, DisjointConstantsDisjointFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/SpecialConstants.cpp
function TEST (line 15) | TEST(SpecialConstants, PositiveZeroFloat32) {
function TEST (line 21) | TEST(SpecialConstants, PositiveZeroFloat64) {
function TEST (line 27) | TEST(SpecialConstants, NegativeZeroFloat32) {
function TEST (line 33) | TEST(SpecialConstants, NegativeZeroFloat64) {
function TEST (line 39) | TEST(SpecialConstants, PositiveInfinityFloat32) {
function TEST (line 45) | TEST(SpecialConstants, PositiveInfinityFloat64) {
function TEST (line 51) | TEST(SpecialConstants, NegativeInfinityFloat32) {
function TEST (line 57) | TEST(SpecialConstants, NegativeInfinityFloat64) {
function TEST (line 63) | TEST(SpecialConstants, NaNFloat32) {
function TEST (line 68) | TEST(SpecialConstants, NaNFloat64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Sqrt.cpp
function TEST (line 14) | TEST(Sqrt, NaN) {
function TEST (line 19) | TEST(Sqrt, Simple) {
function TEST (line 24) | TEST(Sqrt, DiffResultRNE_RTP_Float32) {
function TEST (line 55) | TEST(Sqrt, DiffResultRNE_RTP_Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Float/Native/Sub.cpp
function TEST (line 14) | TEST(Sub, NaN) {
function TEST (line 19) | TEST(Sub, Simple) {
function TEST (line 24) | TEST(Sub, DiffResultRNE_RTP_Float32) {
function TEST (line 51) | TEST(Sub, DiffResultRNE_RTP_Float64) {
function TEST (line 75) | TEST(Sub, DiffResultRNE_RTN_Float32) {
function TEST (line 101) | TEST(Sub, DiffResultRNE_RTN_Float64) {
function TEST (line 125) | TEST(Sub, DiffResultRNE_RTZ_Float32) {
function TEST (line 151) | TEST(Sub, DiffResultRNE_RTZ_Float64) {
FILE: runtime/SMTLIB/SMTLIB/unittests/Logger/LoggerTests.cpp
function TEST (line 24) | TEST(Logger, createLog) {
FILE: runtime/SMTLIB/SMTLIB/unittests/SMTLIBRuntimeTestUtil.cpp
type jfs (line 14) | namespace jfs {
type smtlib_runtime_test_util (line 15) | namespace smtlib_runtime_test_util {
function to_signed_value (line 16) | int64_t to_signed_value(uint64_t bits, uint64_t N) {
function get_neg_bits (line 28) | uint64_t get_neg_bits(uint64_t v, uint64_t N) {
function to_expected_bits_from_signed_value (line 34) | uint64_t to_expected_bits_from_signed_value(int64_t bits, uint64_t N) {
FILE: runtime/SMTLIB/SMTLIB/unittests/SMTLIBRuntimeTestUtil.h
function namespace (line 14) | namespace jfs {
FILE: tests/system_tests/CXXFuzzingBackend/Fuzz/test_format.py
class JFSFuzzTestFormat (line 8) | class JFSFuzzTestFormat(lit.formats.ShTest):
method getTestsInDirectory (line 12) | def getTestsInDirectory(self, testSuite, path_in_suite, litConfig, loc...
class JFSFuzzTest (line 39) | class JFSFuzzTest(lit.Test.Test):
method __init__ (line 44) | def __init__(self, suite, path_in_suite, config, label = None):
method getFullName (line 48) | def getFullName(self):
method getExecPath (line 54) | def getExecPath(self):
FILE: tests/unit_tests/Core/FloatSpecialConstants.cpp
function mkContext (line 8) | std::unique_ptr<JFSContext> mkContext() {
function TEST (line 16) | TEST(Z3ASTNode, Float32AbsSmallestSubnormalPositive) {
function TEST (line 24) | TEST(Z3ASTNode, Float32AbsSmallestSubnormalNegative) {
function TEST (line 32) | TEST(Z3ASTNode, Float32AbsLargestSubnormalPositive) {
function TEST (line 39) | TEST(Z3ASTNode, Float32AbsLargestSubnormalNegative) {
function TEST (line 49) | TEST(Z3ASTNode, Float32AbsSmallestNormalPositive) {
function TEST (line 56) | TEST(Z3ASTNode, Float32AbsSmallestNormalNegative) {
function TEST (line 63) | TEST(Z3ASTNode, Float32AbsLargestNormalPositive) {
function TEST (line 70) | TEST(Z3ASTNode, Float32AbsLargestNormalNegative) {
function TEST (line 79) | TEST(Z3ASTNode, Float64AbsSmallestSubnormalPositive) {
function TEST (line 87) | TEST(Z3ASTNode, Float64AbsSmallestSubnormalNegative) {
function TEST (line 95) | TEST(Z3ASTNode, Float64AbsLargestSubnormalPositive) {
function TEST (line 102) | TEST(Z3ASTNode, Float64AbsLargestSubnormalNegative) {
function TEST (line 112) | TEST(Z3ASTNode, Float64AbsSmallestNormalPositive) {
function TEST (line 119) | TEST(Z3ASTNode, Float64AbsSmallestNormalNegative) {
function TEST (line 126) | TEST(Z3ASTNode, Float64AbsLargestNormalPositive) {
function TEST (line 133) | TEST(Z3ASTNode, Float64AbsLargestNormalNegative) {
FILE: tests/unit_tests/Dummy/Dummy.cpp
function TEST (line 3) | TEST(Dummy, DummyOne) {
FILE: tests/unit_tests/FuzzingCommon/EqualityExtractionPass.cpp
class ParserHelper (line 9) | class ParserHelper {
method ParserHelper (line 15) | ParserHelper() {
method JFSContext (line 20) | JFSContext &getContext() { return *ctx; }
method SMTLIB2Parser (line 21) | SMTLIB2Parser &getParser() { return *parser; }
function TEST (line 24) | TEST(EqualityExtractionPass, singleEquality) {
function TEST (line 57) | TEST(EqualityExtractionPass, ThreeEqualVars) {
function TEST (line 107) | TEST(EqualityExtractionPass, boolAssignmentTrue) {
function TEST (line 136) | TEST(EqualityExtractionPass, boolAssignmentFalse) {
function TEST (line 165) | TEST(EqualityExtractionPass, singleInconsistency) {
function TEST (line 207) | TEST(EqualityExtractionPass, mergeSets) {
FILE: tools/jfs-opt/main.cpp
type QueryPassTy (line 49) | enum QueryPassTy {
function AddPasses (line 77) | unsigned AddPasses(QueryPassManager &pm) {
function printVersion (line 115) | void printVersion(llvm::raw_ostream& os) {
function main (line 124) | int main(int argc, char **argv) {
FILE: tools/jfs-smt2cnf/main.cpp
function printVersion (line 42) | void printVersion(llvm::raw_ostream& os) {
function main (line 50) | int main(int argc, char** argv) {
FILE: tools/jfs-smt2cxx/main.cpp
function printVersion (line 46) | void printVersion(llvm::raw_ostream& os) {
function main (line 54) | int main(int argc, char** argv) {
FILE: tools/jfs/main.cpp
type RedirectOutputTy (line 89) | enum RedirectOutputTy {
type BackendTy (line 115) | enum BackendTy {
function shouldRequestModel (line 148) | bool shouldRequestModel() {
function printVersion (line 152) | void printVersion(llvm::raw_ostream& os) {
function makeWorkingDirectory (line 159) | std::unique_ptr<jfs::fuzzingCommon::WorkingDirectoryManager>
function shouldRedirectOutput (line 188) | bool shouldRedirectOutput(RedirectOutputTy rot, JFSContext& ctx) {
function makeSolver (line 205) | std::unique_ptr<Solver>
function handleInterrupt (line 264) | void handleInterrupt() {
function main (line 269) | int main(int argc, char** argv) {
FILE: tools/yaml-syntax-check/main.cpp
function main (line 26) | int main(int argc, char** argv) {
FILE: utils/FileCheck/FileCheck.cpp
type Check (line 82) | namespace Check {
type CheckType (line 83) | enum CheckType {
class Pattern (line 101) | class Pattern {
method Pattern (line 130) | explicit Pattern(Check::CheckType Ty) : CheckTy(Ty) {}
method SMLoc (line 133) | SMLoc getLoc() const { return PatternLoc; }
method hasVariable (line 142) | bool hasVariable() const {
method getCheckTy (line 146) | Check::CheckType getCheckTy() const { return CheckTy; }
type CheckString (line 609) | struct CheckString {
method CheckString (line 623) | CheckString(const Pattern &P, StringRef S, SMLoc L)
function StringRef (line 641) | static StringRef CanonicalizeFile(MemoryBuffer &MB,
function IsPartOfWord (line 670) | static bool IsPartOfWord(char c) {
function CheckTypeSize (line 675) | static size_t CheckTypeSize(Check::CheckType Ty) {
function FindCheckType (line 706) | static Check::CheckType FindCheckType(StringRef Buffer, StringRef Prefix) {
function SkipWord (line 742) | static size_t SkipWord(StringRef Str, size_t Loc) {
function StringRef (line 767) | static StringRef FindFirstMatchingPrefix(Regex &PrefixRE, StringRef &Buf...
function ReadCheckFile (line 817) | static bool ReadCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE,
function PrintCheckFailed (line 945) | static void PrintCheckFailed(const SourceMgr &SM, SMLoc Loc, const Patte...
function PrintCheckFailed (line 963) | static void PrintCheckFailed(const SourceMgr &SM, const CheckString &Che...
function CountNumNewlinesBetween (line 970) | static unsigned CountNumNewlinesBetween(StringRef Range,
function ValidateCheckPrefix (line 1211) | static bool ValidateCheckPrefix(StringRef CheckPrefix) {
function ValidateCheckPrefixes (line 1216) | static bool ValidateCheckPrefixes() {
function Regex (line 1239) | static Regex buildCheckPrefixRegex() {
function DumpCommandLine (line 1258) | static void DumpCommandLine(int argc, char **argv) {
function CheckInput (line 1269) | bool CheckInput(SourceMgr &SM, StringRef Buffer,
function main (line 1327) | int main(int argc, char **argv) {
FILE: utils/googletest/googletest/include/gtest/gtest-death-test.h
function namespace (line 43) | namespace testing {
FILE: utils/googletest/googletest/include/gtest/gtest-message.h
function namespace (line 57) | namespace testing {
function StreamHelper (line 206) | void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
function StreamHelper (line 214) | void StreamHelper(internal::false_type /*is_pointer*/,
function namespace (line 236) | namespace internal {
FILE: utils/googletest/googletest/include/gtest/gtest-param-test.h
function class (line 162) | class BaseTest : public ::testing::Test {
function namespace (line 197) | namespace testing {
function internal (line 1220) | inline internal::ParamGenerator<bool> Bool() {
FILE: utils/googletest/googletest/include/gtest/gtest-printers.h
function namespace (line 110) | namespace testing {
function namespace (line 217) | namespace testing_internal {
function namespace (line 254) | namespace testing {
function string (line 349) | string FormatForComparisonFailureMessage(
function ostream (line 454) | ostream* os) {
function PrintTo (line 487) | inline void PrintTo(char c, ::std::ostream* os) {
function PrintTo (line 495) | inline void PrintTo(bool x, ::std::ostream* os) {
function PrintTo (line 510) | inline void PrintTo(char* s, ::std::ostream* os) {
function PrintTo (line 516) | inline void PrintTo(const signed char* s, ::std::ostream* os) {
function PrintTo (line 519) | inline void PrintTo(signed char* s, ::std::ostream* os) {
function PrintTo (line 522) | inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
function PrintTo (line 525) | inline void PrintTo(unsigned char* s, ::std::ostream* os) {
function PrintTo (line 537) | inline void PrintTo(wchar_t* s, ::std::ostream* os) {
function PrintTo (line 559) | inline void PrintTo(const ::string& s, ::std::ostream* os) {
function PrintTo (line 565) | inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
function PrintTo (line 572) | inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
function PrintTo (line 579) | inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
function PrintTo (line 600) | inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
function Print (line 698) | static void Print(const T& value, ::std::ostream* os) {
function Print (line 764) | static void Print(const T& value, ::std::ostream* os) {
function Print (line 804) | static void Print(const char* str, ::std::ostream* os) {
FILE: utils/googletest/googletest/include/gtest/gtest-spi.h
function namespace (line 40) | namespace testing {
FILE: utils/googletest/googletest/include/gtest/gtest-test-part.h
function namespace (line 41) | namespace testing {
function class (line 126) | class GTEST_API_ TestPartResultArray {
function class (line 146) | class TestPartResultReporterInterface {
function namespace (line 153) | namespace internal {
FILE: utils/googletest/googletest/include/gtest/gtest-typed-test.h
type testing (line 57) | typedef testing::Types<char, int, unsigned int> MyTypes;
type testing (line 140) | typedef testing::Types<char, int, unsigned int> MyTypes;
FILE: utils/googletest/googletest/include/gtest/gtest.h
function namespace (line 83) | namespace testing {
function class (line 371) | class GTEST_API_ Test {
type internal (line 480) | typedef internal::TimeInMillis TimeInMillis;
function class (line 486) | class TestProperty {
function class (line 523) | class GTEST_API_ TestResult {
function class (line 644) | class GTEST_API_ TestInfo {
function class (line 778) | class GTEST_API_ TestCase {
function class (line 972) | class Environment {
function class (line 991) | class TestEventListener {
function class (line 1044) | class EmptyTestEventListener : public TestEventListener {
function class (line 1064) | class GTEST_API_ TestEventListeners {
function AssertionResult (line 1417) | AssertionResult Compare(const char* lhs_expression,
function AssertionResult (line 1430) | static AssertionResult Compare(const char* lhs_expression,
function AssertionResult (line 1448) | AssertionResult Compare(
function AssertionResult (line 1465) | AssertionResult Compare(
function namespace (line 1621) | namespace internal {
function class (line 1668) | class GTEST_API_ AssertHelper {
function virtual (line 1748) | virtual ~WithParamInterface() {}
FILE: utils/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
function namespace (line 44) | namespace testing {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-filepath.h
function namespace (line 45) | namespace testing {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-internal.h
function namespace (line 80) | namespace proto2 { class Message; }
function namespace (line 82) | namespace testing {
type IsContainer (line 930) | typedef int IsContainer;
type IsNotContainer (line 938) | typedef char IsNotContainer;
function IsContainerTest (line 940) | IsContainerTest(long /* dummy */) { return '\0'; }
type EnableIf (line 947) | struct EnableIf
type type (line 947) | typedef void type;
function ArrayEq (line 960) | bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
function ArrayEq (line 964) | bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
function CopyArray (line 1000) | void CopyArray(const T& from, U* to) { *to = from; }
function CopyArray (line 1004) | void CopyArray(const T(&from)[N], U(*to)[N]) {
type RelationToSourceReference (line 1022) | struct RelationToSourceReference {}
type RelationToSourceCopy (line 1023) | struct RelationToSourceCopy {}
type Element (line 1038) | typedef Element* iterator;
type Element (line 1039) | typedef const Element* const_iterator;
function InitCopy (line 1077) | void InitCopy(const Element* array, size_t a_size) {
function InitRef (line 1086) | void InitRef(const Element* array, size_t a_size) {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
function namespace (line 76) | namespace testing {
function T (line 182) | T* get() const { return value_; }
function depart (line 204) | void depart() {
function capture (line 208) | void capture(T* ptr) {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
function namespace (line 57) | namespace testing {
function virtual (line 3170) | virtual ~CartesianProductGenerator2() {}
function virtual (line 3172) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3175) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3192) | virtual ~Iterator() {}
function virtual (line 3194) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3199) | virtual void Advance() {
function virtual (line 3208) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3211) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3212) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3241) | void ComputeCurrentValue() {
function virtual (line 3285) | virtual ~CartesianProductGenerator3() {}
function virtual (line 3287) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3291) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3311) | virtual ~Iterator() {}
function virtual (line 3313) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3318) | virtual void Advance() {
function virtual (line 3331) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3334) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3335) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3368) | void ComputeCurrentValue() {
function virtual (line 3418) | virtual ~CartesianProductGenerator4() {}
function virtual (line 3420) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3424) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3448) | virtual ~Iterator() {}
function virtual (line 3450) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3455) | virtual void Advance() {
function virtual (line 3472) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3475) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3476) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3513) | void ComputeCurrentValue() {
function virtual (line 3569) | virtual ~CartesianProductGenerator5() {}
function virtual (line 3571) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3575) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3602) | virtual ~Iterator() {}
function virtual (line 3604) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3609) | virtual void Advance() {
function virtual (line 3630) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3633) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3634) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3675) | void ComputeCurrentValue() {
type testing (line 3732) | typedef ::testing::tuple<T1, T2, T3, T4, T5, T6> ParamType;
function virtual (line 3739) | virtual ~CartesianProductGenerator6() {}
function virtual (line 3741) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3745) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3775) | virtual ~Iterator() {}
function virtual (line 3777) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3782) | virtual void Advance() {
function virtual (line 3807) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3810) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3811) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3856) | void ComputeCurrentValue() {
type testing (line 3918) | typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
function virtual (line 3925) | virtual ~CartesianProductGenerator7() {}
function virtual (line 3927) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3932) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3965) | virtual ~Iterator() {}
function virtual (line 3967) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3972) | virtual void Advance() {
function virtual (line 4001) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4004) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4005) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4054) | void ComputeCurrentValue() {
type testing (line 4121) | typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
function virtual (line 4137) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 4174) | virtual ~Iterator() {}
function virtual (line 4176) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 4181) | virtual void Advance() {
function virtual (line 4214) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4217) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4218) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4271) | void ComputeCurrentValue() {
type testing (line 4343) | typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
function virtual (line 4359) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 4399) | virtual ~Iterator() {}
function virtual (line 4401) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 4406) | virtual void Advance() {
function virtual (line 4443) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4446) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4447) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4504) | void ComputeCurrentValue() {
type testing (line 4582) | typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamT...
function virtual (line 4599) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 4642) | virtual ~Iterator() {}
function virtual (line 4644) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 4649) | virtual void Advance() {
function virtual (line 4690) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4693) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4694) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4755) | void ComputeCurrentValue() {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-param-util.h
function namespace (line 54) | namespace testing {
function CalculateEndIndex (line 266) | static int CalculateEndIndex(const T& begin,
function virtual (line 297) | virtual ~ValuesInIteratorRangeGenerator() {}
function virtual (line 299) | virtual ParamIteratorInterface<T>* Begin() const {
function virtual (line 302) | virtual ParamIteratorInterface<T>* End() const {
function class (line 309) | class Iterator : public ParamIteratorInterface<T> {
type std (line 395) | typedef std::string Type(const TestParamInfo<ParamType>&);
function explicit (line 411) | explicit ParameterizedTestFactory(ParamType parameter) :
function virtual (line 413) | virtual Test* CreateTest() {
function virtual (line 452) | virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
function class (line 470) | class ParameterizedTestCaseInfoBase {
type ParamGenerator (line 506) | typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
type typename (line 507) | typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;
function explicit (line 509) | explicit ParameterizedTestCaseInfo(
function AddTestPattern (line 523) | void AddTestPattern(const char* test_case_name,
function AddTestCaseInstantiation (line 532) | int AddTestCaseInstantiation(const string& instantiation_name,
function virtual (line 546) | virtual void RegisterTests() {
type TestInfo (line 604) | struct TestInfo {
type std (line 616) | typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
type InstantiationInfo (line 620) | struct InstantiationInfo {
type std (line 638) | typedef ::std::vector<InstantiationInfo> InstantiationContainer;
function IsValidParamName (line 640) | static bool IsValidParamName(const std::string& name) {
function class (line 668) | class ParameterizedTestCaseRegistry {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-port.h
type _RTL_CRITICAL_SECTION (line 402) | struct _RTL_CRITICAL_SECTION
function namespace (line 696) | namespace std {
function namespace (line 988) | namespace testing {
function LogToStderr (line 1275) | inline void LogToStderr() {}
function FlushInfoLog (line 1276) | inline void FlushInfoLog() { fflush(NULL); }
function To (line 1343) | To ImplicitCast_(To x) { return x; }
function To (line 1367) | To DownCast_(From* f) { // so we only accept pointers
function SleepMilliseconds (line 1448) | inline void SleepMilliseconds(int n) {
function class (line 1468) | class Notification {
function class (line 1511) | class GTEST_API_ AutoHandle {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-string.h
function namespace (line 54) | namespace testing {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-tuple.h
function namespace (line 112) | namespace std {
function GTEST_1_TUPLE_ (line 213) | GTEST_1_TUPLE_(T) {
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 233) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 274) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 309) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 348) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 390) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 435) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 482) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 532) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 584) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 640) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function make_tuple (line 683) | GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
function make_tuple (line 688) | GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
function make_tuple (line 693) | GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 699) | GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 705) | GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 711) | GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 717) | GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 723) | GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 730) | GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
type typename (line 797) | typedef typename gtest_internal::TupleElement<
function namespace (line 805) | namespace gtest_internal {
function namespace (line 945) | namespace gtest_internal {
FILE: utils/googletest/googletest/include/gtest/internal/gtest-type-util.h
function namespace (line 57) | namespace testing {
type internal (line 754) | typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ...
type Types (line 761) | struct Types
type internal (line 790) | typedef internal::Types1<T1> type;
type internal (line 806) | typedef internal::Types2<T1, T2> type;
type internal (line 821) | typedef internal::Types3<T1, T2, T3> type;
type internal (line 836) | typedef internal::Types4<T1, T2, T3, T4> type;
type internal (line 851) | typedef internal::Types5<T1, T2, T3, T4, T5> type;
type internal (line 867) | typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
type internal (line 883) | typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
type internal (line 898) | typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
type internal (line 913) | typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
function namespace (line 1620) | namespace internal {
type Templates4 (line 1690) | typedef Templates4<T2, T3, T4, T5> Tail;
type Templates5 (line 1697) | typedef Templates5<T2, T3, T4, T5, T6> Tail;
type Templates6 (line 1705) | typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
type Templates7 (line 1713) | typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
type Templates8 (line 1721) | typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
type Templates9 (line 1730) | typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
type Templates10 (line 1739) | typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
type Templates11 (line 1748) | typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
type Templates12 (line 1758) | typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ...
type Templates13 (line 1768) | typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
type Templates14 (line 1779) | typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates15 (line 1791) | typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates16 (line 1803) | typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates17 (line 1815) | typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates18 (line 1828) | typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates19 (line 1841) | typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates20 (line 1854) | typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates21 (line 1868) | typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates22 (line 1882) | typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates23 (line 1896) | typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates24 (line 1911) | typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates25 (line 1926) | typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates26 (line 1941) | typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates27 (line 1957) | typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates28 (line 1974) | typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates29 (line 1991) | typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates30 (line 2009) | typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates31 (line 2027) | typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates32 (line 2045) | typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates33 (line 2064) | typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates34 (line 2083) | typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates35 (line 2102) | typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates36 (line 2122) | typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates37 (line 2142) | typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates38 (line 2162) | typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates39 (line 2183) | typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates40 (line 2204) | typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates41 (line 2225) | typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates42 (line 2248) | typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates43 (line 2271) | typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates44 (line 2294) | typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates45 (line 2318) | typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates46 (line 2342) | typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates47 (line 2366) | typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates48 (line 2391) | typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates49 (line 2416) | typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates (line 2469) | struct Templates
type Types1 (line 3303) | typedef Types1<T> type;
FILE: utils/googletest/googletest/samples/prime_tables.h
function class (line 43) | class PrimeTable {
function class (line 56) | class OnTheFlyPrimeTable : public PrimeTable {
function class (line 80) | class PreCalculatedPrimeTable : public PrimeTable {
function virtual (line 87) | virtual ~PreCalculatedPrimeTable() { delete[] is_prime_; }
function virtual (line 89) | virtual bool IsPrime(int n) const {
function virtual (line 93) | virtual int GetNextPrime(int p) const {
FILE: utils/googletest/googletest/samples/sample1.cc
function Factorial (line 37) | int Factorial(int n) {
function IsPrime (line 47) | bool IsPrime(int n) {
FILE: utils/googletest/googletest/samples/sample10_unittest.cc
class Water (line 51) | class Water {
method allocated (line 66) | static int allocated() { return allocated_; }
class LeakChecker (line 78) | class LeakChecker : public EmptyTestEventListener {
method OnTestStart (line 81) | virtual void OnTestStart(const TestInfo& /* test_info */) {
method OnTestEnd (line 86) | virtual void OnTestEnd(const TestInfo& /* test_info */) {
function TEST (line 98) | TEST(ListenersTest, DoesNotLeak) {
function TEST (line 105) | TEST(ListenersTest, LeaksWater) {
function main (line 112) | int main(int argc, char **argv) {
FILE: utils/googletest/googletest/samples/sample1_unittest.cc
function TEST (line 79) | TEST(FactorialTest, Negative) {
function TEST (line 103) | TEST(FactorialTest, Zero) {
function TEST (line 108) | TEST(FactorialTest, Positive) {
function TEST (line 119) | TEST(IsPrimeTest, Negative) {
function TEST (line 128) | TEST(IsPrimeTest, Trivial) {
function TEST (line 136) | TEST(IsPrimeTest, Positive) {
FILE: utils/googletest/googletest/samples/sample2.h
function class (line 41) | class MyString {
FILE: utils/googletest/googletest/samples/sample2_unittest.cc
function TEST (line 49) | TEST(MyString, DefaultConstructor) {
function TEST (line 80) | TEST(MyString, ConstructorFromCString) {
function TEST (line 88) | TEST(MyString, CopyConstructor) {
function TEST (line 95) | TEST(MyString, Set) {
FILE: utils/googletest/googletest/samples/sample3-inl.h
function QueueNode (line 57) | QueueNode* next() { return next_; }
function QueueNode (line 58) | const QueueNode* next() const { return next_; }
function Clear (line 83) | void Clear() {
function QueueNode (line 106) | const QueueNode<E>* Head() const { return head_; }
function QueueNode (line 110) | const QueueNode<E>* Last() const { return last_; }
function Enqueue (line 116) | void Enqueue(const E& element) {
function E (line 131) | E* Dequeue() {
FILE: utils/googletest/googletest/samples/sample3_unittest.cc
class QueueTest (line 70) | class QueueTest : public testing::Test {
method SetUp (line 77) | virtual void SetUp() {
method Double (line 91) | static int Double(int n) {
method MapTester (line 96) | void MapTester(const Queue<int> * q) {
function TEST_F (line 123) | TEST_F(QueueTest, DefaultConstructor) {
function TEST_F (line 129) | TEST_F(QueueTest, Dequeue) {
function TEST_F (line 147) | TEST_F(QueueTest, Map) {
FILE: utils/googletest/googletest/samples/sample4.h
function class (line 38) | class Counter {
FILE: utils/googletest/googletest/samples/sample4_unittest.cc
function TEST (line 36) | TEST(Counter, Increment) {
FILE: utils/googletest/googletest/samples/sample5_unittest.cc
class QuickTest (line 63) | class QuickTest : public testing::Test {
method SetUp (line 67) | virtual void SetUp() {
method TearDown (line 73) | virtual void TearDown() {
class IntegerFunctionTest (line 91) | class IntegerFunctionTest : public QuickTest {
function TEST_F (line 100) | TEST_F(IntegerFunctionTest, Factorial) {
function TEST_F (line 118) | TEST_F(IntegerFunctionTest, IsPrime) {
class QueueTest (line 144) | class QueueTest : public QuickTest {
method SetUp (line 146) | virtual void SetUp() {
function TEST_F (line 173) | TEST_F(QueueTest, DefaultConstructor) {
function TEST_F (line 178) | TEST_F(QueueTest, Dequeue) {
FILE: utils/googletest/googletest/samples/sample6_unittest.cc
function PrimeTable (line 48) | PrimeTable* CreatePrimeTable<OnTheFlyPrimeTable>() {
function PrimeTable (line 53) | PrimeTable* CreatePrimeTable<PreCalculatedPrimeTable>() {
class PrimeTableTest (line 59) | class PrimeTableTest : public testing::Test {
method PrimeTableTest (line 63) | PrimeTableTest() : table_(CreatePrimeTable<T>()) {}
function TYPED_TEST (line 100) | TYPED_TEST(PrimeTableTest, ReturnsFalseForNonPrimes) {
function TYPED_TEST (line 116) | TYPED_TEST(PrimeTableTest, ReturnsTrueForPrimes) {
function TYPED_TEST (line 125) | TYPED_TEST(PrimeTableTest, CanGetNextPrime) {
class PrimeTableTest2 (line 161) | class PrimeTableTest2 : public PrimeTableTest<T> {
function TYPED_TEST_P (line 171) | TYPED_TEST_P(PrimeTableTest2, ReturnsFalseForNonPrimes) {
function TYPED_TEST_P (line 180) | TYPED_TEST_P(PrimeTableTest2, ReturnsTrueForPrimes) {
function TYPED_TEST_P (line 189) | TYPED_TEST_P(PrimeTableTest2, CanGetNextPrime) {
FILE: utils/googletest/googletest/samples/sample7_unittest.cc
function PrimeTable (line 55) | PrimeTable* CreateOnTheFlyPrimeTable() {
function PrimeTable (line 60) | PrimeTable* CreatePreCalculatedPrimeTable() {
class PrimeTableTest (line 68) | class PrimeTableTest : public TestWithParam<CreatePrimeTableFunc*> {
method SetUp (line 71) | virtual void SetUp() { table_ = (*GetParam())(); }
method TearDown (line 72) | virtual void TearDown() {
function TEST_P (line 81) | TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
function TEST_P (line 90) | TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
function TEST_P (line 99) | TEST_P(PrimeTableTest, CanGetNextPrime) {
function TEST (line 128) | TEST(DummyTest, ValueParameterizedTestsAreNotSupportedOnThisPlatform) {}
FILE: utils/googletest/googletest/samples/sample8_unittest.cc
class HybridPrimeTable (line 50) | class HybridPrimeTable : public PrimeTable {
method HybridPrimeTable (line 52) | HybridPrimeTable(bool force_on_the_fly, int max_precalculated)
method IsPrime (line 62) | virtual bool IsPrime(int n) const {
method GetNextPrime (line 69) | virtual int GetNextPrime(int p) const {
class PrimeTableTest (line 93) | class PrimeTableTest : public TestWithParam< ::testing::tuple<bool, int>...
method SetUp (line 95) | virtual void SetUp() {
method TearDown (line 108) | virtual void TearDown() {
function TEST_P (line 115) | TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
function TEST_P (line 130) | TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
function TEST_P (line 139) | TEST_P(PrimeTableTest, CanGetNextPrime) {
function TEST (line 171) | TEST(DummyTest, CombineIsNotSupportedOnThisPlatform) {}
FILE: utils/googletest/googletest/samples/sample9_unittest.cc
class TersePrinter (line 52) | class TersePrinter : public EmptyTestEventListener {
method OnTestProgramStart (line 55) | virtual void OnTestProgramStart(const UnitTest& /* unit_test */) {}
method OnTestProgramEnd (line 58) | virtual void OnTestProgramEnd(const UnitTest& unit_test) {
method OnTestStart (line 64) | virtual void OnTestStart(const TestInfo& test_info) {
method OnTestPartResult (line 73) | virtual void OnTestPartResult(const TestPartResult& test_part_result) {
method OnTestEnd (line 84) | virtual void OnTestEnd(const TestInfo& test_info) {
function TEST (line 93) | TEST(CustomOutputTest, PrintsMessage) {
function TEST (line 97) | TEST(CustomOutputTest, Succeeds) {
function TEST (line 101) | TEST(CustomOutputTest, Fails) {
function main (line 108) | int main(int argc, char **argv) {
FILE: utils/googletest/googletest/scripts/common.py
function GetCommandOutput (line 46) | def GetCommandOutput(command):
function GetSvnInfo (line 55) | def GetSvnInfo():
function GetSvnTrunk (line 69) | def GetSvnTrunk():
function IsInGTestSvn (line 76) | def IsInGTestSvn():
function IsInGMockSvn (line 81) | def IsInGMockSvn():
FILE: utils/googletest/googletest/scripts/fuse_gtest_files.py
function VerifyFileExists (line 89) | def VerifyFileExists(directory, relative_path):
function ValidateGTestRootDir (line 103) | def ValidateGTestRootDir(gtest_root):
function VerifyOutputFile (line 113) | def VerifyOutputFile(output_dir, relative_path):
function ValidateOutputDir (line 139) | def ValidateOutputDir(output_dir):
function FuseGTestH (line 149) | def FuseGTestH(gtest_root, output_dir):
function FuseGTestAllCcToFile (line 178) | def FuseGTestAllCcToFile(gtest_root, output_file):
function FuseGTestAllCc (line 221) | def FuseGTestAllCc(gtest_root, output_dir):
function FuseGTest (line 229) | def FuseGTest(gtest_root, output_dir):
function main (line 239) | def main():
FILE: utils/googletest/googletest/scripts/gen_gtest_pred_impl.py
function HeaderPreamble (line 65) | def HeaderPreamble(n):
function Arity (line 164) | def Arity(n):
function Title (line 175) | def Title(word):
function OneTo (line 183) | def OneTo(n):
function Iter (line 189) | def Iter(n, format, sep=''):
function ImplementationForArity (line 205) | def ImplementationForArity(n):
function HeaderPostamble (line 293) | def HeaderPostamble():
function GenerateFile (line 302) | def GenerateFile(path, content):
function GenerateHeader (line 315) | def GenerateHeader(n):
function UnitTestPreamble (line 325) | def UnitTestPreamble():
function TestsForArity (line 411) | def TestsForArity(n):
function UnitTestPostamble (line 700) | def UnitTestPostamble():
function GenerateUnitTest (line 706) | def GenerateUnitTest(n):
function _Main (line 715) | def _Main():
FILE: utils/googletest/googletest/scripts/pump.py
class Cursor (line 87) | class Cursor:
method __init__ (line 90) | def __init__(self, line=-1, column=-1):
method __eq__ (line 94) | def __eq__(self, rhs):
method __ne__ (line 97) | def __ne__(self, rhs):
method __lt__ (line 100) | def __lt__(self, rhs):
method __le__ (line 104) | def __le__(self, rhs):
method __gt__ (line 107) | def __gt__(self, rhs):
method __ge__ (line 110) | def __ge__(self, rhs):
method __str__ (line 113) | def __str__(self):
method __add__ (line 119) | def __add__(self, offset):
method __sub__ (line 122) | def __sub__(self, offset):
method Clone (line 125) | def Clone(self):
function Eof (line 132) | def Eof():
class Token (line 137) | class Token:
method __init__ (line 140) | def __init__(self, start=None, end=None, value=None, token_type=None):
method __str__ (line 152) | def __str__(self):
method Clone (line 156) | def Clone(self):
function StartsWith (line 163) | def StartsWith(lines, pos, string):
function FindFirstInLine (line 169) | def FindFirstInLine(line, token_table):
function FindFirst (line 186) | def FindFirst(lines, token_table, cursor):
function SubString (line 208) | def SubString(lines, start, end):
function StripMetaComments (line 226) | def StripMetaComments(str):
function MakeToken (line 237) | def MakeToken(lines, start, end, token_type):
function ParseToken (line 243) | def ParseToken(lines, pos, regex, token_type):
function Skip (line 261) | def Skip(lines, pos, regex):
function SkipUntil (line 270) | def SkipUntil(lines, pos, regex, token_type):
function ParseExpTokenInParens (line 281) | def ParseExpTokenInParens(lines, pos):
function RStripNewLineFromToken (line 303) | def RStripNewLineFromToken(token):
function TokenizeLines (line 310) | def TokenizeLines(lines, pos):
function Tokenize (line 382) | def Tokenize(s):
class CodeNode (line 390) | class CodeNode:
method __init__ (line 391) | def __init__(self, atomic_code_list=None):
class VarNode (line 395) | class VarNode:
method __init__ (line 396) | def __init__(self, identifier=None, atomic_code=None):
class RangeNode (line 401) | class RangeNode:
method __init__ (line 402) | def __init__(self, identifier=None, exp1=None, exp2=None):
class ForNode (line 408) | class ForNode:
method __init__ (line 409) | def __init__(self, identifier=None, sep=None, code=None):
class ElseNode (line 415) | class ElseNode:
method __init__ (line 416) | def __init__(self, else_branch=None):
class IfNode (line 420) | class IfNode:
method __init__ (line 421) | def __init__(self, exp=None, then_branch=None, else_branch=None):
class RawCodeNode (line 427) | class RawCodeNode:
method __init__ (line 428) | def __init__(self, token=None):
class LiteralDollarNode (line 432) | class LiteralDollarNode:
method __init__ (line 433) | def __init__(self, token):
class ExpNode (line 437) | class ExpNode:
method __init__ (line 438) | def __init__(self, token, python_exp):
function PopFront (line 443) | def PopFront(a_list):
function PushFront (line 449) | def PushFront(a_list, elem):
function PopToken (line 453) | def PopToken(a_list, token_type=None):
function PeekToken (line 463) | def PeekToken(a_list):
function ParseExpNode (line 470) | def ParseExpNode(token):
function ParseElseNode (line 475) | def ParseElseNode(tokens):
function ParseAtomicCodeNode (line 503) | def ParseAtomicCodeNode(tokens):
function ParseCodeNode (line 564) | def ParseCodeNode(tokens):
function ParseToAST (line 577) | def ParseToAST(pump_src_text):
class Env (line 584) | class Env:
method __init__ (line 585) | def __init__(self):
method Clone (line 589) | def Clone(self):
method PushVariable (line 595) | def PushVariable(self, var, value):
method PopVariable (line 605) | def PopVariable(self):
method PushRange (line 608) | def PushRange(self, var, lower, upper):
method PopRange (line 611) | def PopRange(self):
method GetValue (line 614) | def GetValue(self, identifier):
method EvalExp (line 622) | def EvalExp(self, exp):
method GetRange (line 632) | def GetRange(self, identifier):
class Output (line 641) | class Output:
method __init__ (line 642) | def __init__(self):
method GetLastLine (line 645) | def GetLastLine(self):
method Append (line 652) | def Append(self, s):
function RunAtomicCode (line 656) | def RunAtomicCode(env, node, output):
function RunCode (line 702) | def RunCode(env, code_node, output):
function IsSingleLineComment (line 707) | def IsSingleLineComment(cur_line):
function IsInPreprocessorDirective (line 711) | def IsInPreprocessorDirective(prev_lines, cur_line):
function WrapComment (line 717) | def WrapComment(line, output):
function WrapCode (line 741) | def WrapCode(line, line_concat, output):
function WrapPreprocessorDirective (line 771) | def WrapPreprocessorDirective(line, output):
function WrapPlainCode (line 775) | def WrapPlainCode(line, output):
function IsMultiLineIWYUPragma (line 779) | def IsMultiLineIWYUPragma(line):
function IsHeaderGuardIncludeOrOneLineIWYUPragma (line 783) | def IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
function WrapLongLine (line 790) | def WrapLongLine(line, output):
function BeautifyCode (line 814) | def BeautifyCode(string):
function ConvertFromPumpSource (line 823) | def ConvertFromPumpSource(src_text):
function main (line 831) | def main(argv):
FILE: utils/googletest/googletest/scripts/release_docs.py
function DropWikiSuffix (line 82) | def DropWikiSuffix(wiki_filename):
class WikiBrancher (line 89) | class WikiBrancher(object):
method __init__ (line 92) | def __init__(self, dot_version):
method GetFilesToBranch (line 117) | def GetFilesToBranch(self):
method BranchFiles (line 127) | def BranchFiles(self):
method UpdateLinksInBranchedFiles (line 137) | def UpdateLinksInBranchedFiles(self):
function main (line 148) | def main():
FILE: utils/googletest/googletest/scripts/upload.py
function GetEmail (line 65) | def GetEmail(prompt):
function StatusUpdate (line 97) | def StatusUpdate(msg):
function ErrorExit (line 109) | def ErrorExit(msg):
class ClientLoginError (line 115) | class ClientLoginError(urllib2.HTTPError):
method __init__ (line 118) | def __init__(self, url, code, msg, headers, args):
class AbstractRpcServer (line 124) | class AbstractRpcServer(object):
method __init__ (line 127) | def __init__(self, host, auth_function, host_override=None, extra_head...
method _GetOpener (line 154) | def _GetOpener(self):
method _CreateRequest (line 162) | def _CreateRequest(self, url, data=None):
method _GetAuthToken (line 172) | def _GetAuthToken(self, email, password):
method _GetAuthCookie (line 215) | def _GetAuthCookie(self, auth_token):
method _Authenticate (line 239) | def _Authenticate(self):
method Send (line 291) | def Send(self, request_path, payload=None,
class HttpRpcServer (line 344) | class HttpRpcServer(AbstractRpcServer):
method _Authenticate (line 347) | def _Authenticate(self):
method _GetOpener (line 354) | def _GetOpener(self):
function GetRpcServer (line 458) | def GetRpcServer(options):
function EncodeMultipartFormData (line 498) | def EncodeMultipartFormData(fields, files):
function GetContentType (line 533) | def GetContentType(filename):
function RunShellWithReturnCode (line 541) | def RunShellWithReturnCode(command, print_output=False,
function RunShell (line 577) | def RunShell(command, silent_ok=False, universal_newlines=True,
class VersionControlSystem (line 588) | class VersionControlSystem(object):
method __init__ (line 591) | def __init__(self, options):
method GenerateDiff (line 599) | def GenerateDiff(self, args):
method GetUnknownFiles (line 608) | def GetUnknownFiles(self):
method CheckForUnknownFiles (line 613) | def CheckForUnknownFiles(self):
method GetBaseFile (line 625) | def GetBaseFile(self, filename):
method GetBaseFiles (line 642) | def GetBaseFiles(self, diff):
method UploadBaseFiles (line 661) | def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, opt...
method IsImage (line 713) | def IsImage(self, filename):
class SubversionVCS (line 721) | class SubversionVCS(VersionControlSystem):
method __init__ (line 724) | def __init__(self, options):
method GuessBase (line 742) | def GuessBase(self, required):
method _GuessBase (line 746) | def _GuessBase(self, required):
method GenerateDiff (line 790) | def GenerateDiff(self, args):
method _CollapseKeywords (line 805) | def _CollapseKeywords(self, content, keyword_str):
method GetUnknownFiles (line 836) | def GetUnknownFiles(self):
method ReadFile (line 844) | def ReadFile(self, filename):
method GetStatus (line 854) | def GetStatus(self, filename):
method GetBaseFile (line 898) | def GetBaseFile(self, filename):
class GitVCS (line 985) | class GitVCS(VersionControlSystem):
method __init__ (line 988) | def __init__(self, options):
method GenerateDiff (line 993) | def GenerateDiff(self, extra_args):
method GetUnknownFiles (line 1021) | def GetUnknownFiles(self):
method GetBaseFile (line 1026) | def GetBaseFile(self, filename):
class MercurialVCS (line 1042) | class MercurialVCS(VersionControlSystem):
method __init__ (line 1045) | def __init__(self, options, repo_dir):
method _GetRelPath (line 1058) | def _GetRelPath(self, filename):
method GenerateDiff (line 1064) | def GenerateDiff(self, extra_args):
method GetUnknownFiles (line 1090) | def GetUnknownFiles(self):
method GetBaseFile (line 1102) | def GetBaseFile(self, filename):
function SplitPatch (line 1141) | def SplitPatch(data):
function UploadSeparatePatches (line 1181) | def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
function GuessVCS (line 1209) | def GuessVCS(options):
function RealMain (line 1250) | def RealMain(argv, data=None):
function main (line 1377) | def main():
FILE: utils/googletest/googletest/scripts/upload_gtest.py
function main (line 49) | def main():
FILE: utils/googletest/googletest/src/gtest-death-test.cc
type testing (line 79) | namespace testing {
type internal (line 107) | namespace internal {
function InDeathTestChild (line 133) | bool InDeathTestChild() {
function ExitSummary (line 193) | static std::string ExitSummary(int exit_code) {
function ExitedUnsuccessfully (line 219) | bool ExitedUnsuccessfully(int exit_status) {
function DeathTestThreadWarning (line 228) | static std::string DeathTestThreadWarning(size_t thread_count) {
type DeathTestOutcome (line 255) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
function DeathTestAbort (line 262) | void DeathTestAbort(const std::string& message) {
function GetLastErrnoDescription (line 315) | std::string GetLastErrnoDescription() {
function FailFromInternalError (line 323) | static void FailFromInternalError(int fd) {
class DeathTestImpl (line 373) | class DeathTestImpl : public DeathTest {
method DeathTestImpl (line 375) | DeathTestImpl(const char* a_statement, const RE* a_regex)
method RE (line 391) | const RE* regex() const { return regex_; }
method spawned (line 392) | bool spawned() const { return spawned_; }
method set_spawned (line 393) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
method status (line 394) | int status() const { return status_; }
method set_status (line 395) | void set_status(int a_status) { status_ = a_status; }
method DeathTestOutcome (line 396) | DeathTestOutcome outcome() const { return outcome_; }
method set_outcome (line 397) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
method read_fd (line 398) | int read_fd() const { return read_fd_; }
method set_read_fd (line 399) | void set_read_fd(int fd) { read_fd_ = fd; }
method write_fd (line 400) | int write_fd() const { return write_fd_; }
method set_write_fd (line 401) | void set_write_fd(int fd) { write_fd_ = fd; }
function FormatDeathTestOutput (line 504) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
class WindowsDeathTest (line 619) | class WindowsDeathTest : public DeathTestImpl {
method WindowsDeathTest (line 621) | WindowsDeathTest(const char* a_statement,
class ForkingDeathTest (line 787) | class ForkingDeathTest : public DeathTestImpl {
method set_child_pid (line 795) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
class NoExecDeathTest (line 824) | class NoExecDeathTest : public ForkingDeathTest {
method NoExecDeathTest (line 826) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
class ExecDeathTest (line 879) | class ExecDeathTest : public ForkingDeathTest {
method ExecDeathTest (line 881) | ExecDeathTest(const char* a_statement, const RE* a_regex,
method GetArgvsForDeathTestChildProcess (line 886) | static ::std::vector<testing::internal::string>
class Arguments (line 903) | class Arguments {
method Arguments (line 905) | Arguments() {
method AddArgument (line 915) | void AddArgument(const char* argument) {
method AddArguments (line 920) | void AddArguments(const ::std::vector<Str>& arguments) {
type ExecDeathTestArgs (line 937) | struct ExecDeathTestArgs {
function ExecDeathTestChildMain (line 960) | static int ExecDeathTestChildMain(void* child_arg) {
function StackLowerThanAddress (line 999) | void StackLowerThanAddress(const void* ptr, bool* result) {
function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1005) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
function pid_t (line 1020) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
type internal (line 120) | namespace internal {
function InDeathTestChild (line 133) | bool InDeathTestChild() {
function ExitSummary (line 193) | static std::string ExitSummary(int exit_code) {
function ExitedUnsuccessfully (line 219) | bool ExitedUnsuccessfully(int exit_status) {
function DeathTestThreadWarning (line 228) | static std::string DeathTestThreadWarning(size_t thread_count) {
type DeathTestOutcome (line 255) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
function DeathTestAbort (line 262) | void DeathTestAbort(const std::string& message) {
function GetLastErrnoDescription (line 315) | std::string GetLastErrnoDescription() {
function FailFromInternalError (line 323) | static void FailFromInternalError(int fd) {
class DeathTestImpl (line 373) | class DeathTestImpl : public DeathTest {
method DeathTestImpl (line 375) | DeathTestImpl(const char* a_statement, const RE* a_regex)
method RE (line 391) | const RE* regex() const { return regex_; }
method spawned (line 392) | bool spawned() const { return spawned_; }
method set_spawned (line 393) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
method status (line 394) | int status() const { return status_; }
method set_status (line 395) | void set_status(int a_status) { status_ = a_status; }
method DeathTestOutcome (line 396) | DeathTestOutcome outcome() const { return outcome_; }
method set_outcome (line 397) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
method read_fd (line 398) | int read_fd() const { return read_fd_; }
method set_read_fd (line 399) | void set_read_fd(int fd) { read_fd_ = fd; }
method write_fd (line 400) | int write_fd() const { return write_fd_; }
method set_write_fd (line 401) | void set_write_fd(int fd) { write_fd_ = fd; }
function FormatDeathTestOutput (line 504) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
class WindowsDeathTest (line 619) | class WindowsDeathTest : public DeathTestImpl {
method WindowsDeathTest (line 621) | WindowsDeathTest(const char* a_statement,
class ForkingDeathTest (line 787) | class ForkingDeathTest : public DeathTestImpl {
method set_child_pid (line 795) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
class NoExecDeathTest (line 824) | class NoExecDeathTest : public ForkingDeathTest {
method NoExecDeathTest (line 826) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
class ExecDeathTest (line 879) | class ExecDeathTest : public ForkingDeathTest {
method ExecDeathTest (line 881) | ExecDeathTest(const char* a_statement, const RE* a_regex,
method GetArgvsForDeathTestChildProcess (line 886) | static ::std::vector<testing::internal::string>
class Arguments (line 903) | class Arguments {
method Arguments (line 905) | Arguments() {
method AddArgument (line 915) | void AddArgument(const char* argument) {
method AddArguments (line 920) | void AddArguments(const ::std::vector<Str>& arguments) {
type ExecDeathTestArgs (line 937) | struct ExecDeathTestArgs {
function ExecDeathTestChildMain (line 960) | static int ExecDeathTestChildMain(void* child_arg) {
function StackLowerThanAddress (line 999) | void StackLowerThanAddress(const void* ptr, bool* result) {
function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1005) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
function pid_t (line 1020) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
type internal (line 187) | namespace internal {
function InDeathTestChild (line 133) | bool InDeathTestChild() {
function ExitSummary (line 193) | static std::string ExitSummary(int exit_code) {
function ExitedUnsuccessfully (line 219) | bool ExitedUnsuccessfully(int exit_status) {
function DeathTestThreadWarning (line 228) | static std::string DeathTestThreadWarning(size_t thread_count) {
type DeathTestOutcome (line 255) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
function DeathTestAbort (line 262) | void DeathTestAbort(const std::string& message) {
function GetLastErrnoDescription (line 315) | std::string GetLastErrnoDescription() {
function FailFromInternalError (line 323) | static void FailFromInternalError(int fd) {
class DeathTestImpl (line 373) | class DeathTestImpl : public DeathTest {
method DeathTestImpl (line 375) | DeathTestImpl(const char* a_statement, const RE* a_regex)
method RE (line 391) | const RE* regex() const { return regex_; }
method spawned (line 392) | bool spawned() const { return spawned_; }
method set_spawned (line 393) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
method status (line 394) | int status() const { return status_; }
method set_status (line 395) | void set_status(int a_status) { status_ = a_status; }
method DeathTestOutcome (line 396) | DeathTestOutcome outcome() const { return outcome_; }
method set_outcome (line 397) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
method read_fd (line 398) | int read_fd() const { return read_fd_; }
method set_read_fd (line 399) | void set_read_fd(int fd) { read_fd_ = fd; }
method write_fd (line 400) | int write_fd() const { return write_fd_; }
method set_write_fd (line 401) | void set_write_fd(int fd) { write_fd_ = fd; }
function FormatDeathTestOutput (line 504) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
class WindowsDeathTest (line 619) | class WindowsDeathTest : public DeathTestImpl {
method WindowsDeathTest (line 621) | WindowsDeathTest(const char* a_statement,
class ForkingDeathTest (line 787) | class ForkingDeathTest : public DeathTestImpl {
method set_child_pid (line 795) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
class NoExecDeathTest (line 824) | class NoExecDeathTest : public ForkingDeathTest {
method NoExecDeathTest (line 826) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
class ExecDeathTest (line 879) | class ExecDeathTest : public ForkingDeathTest {
method ExecDeathTest (line 881) | ExecDeathTest(const char* a_statement, const RE* a_regex,
method GetArgvsForDeathTestChildProcess (line 886) | static ::std::vector<testing::internal::string>
class Arguments (line 903) | class Arguments {
method Arguments (line 905) | Arguments() {
method AddArgument (line 915) | void AddArgument(const char* argument) {
method AddArguments (line 920) | void AddArguments(const ::std::vector<Str>& arguments) {
type ExecDeathTestArgs (line 937) | struct ExecDeathTestArgs {
function ExecDeathTestChildMain (line 960) | static int ExecDeathTestChildMain(void* child_arg) {
function StackLowerThanAddress (line 999) | void StackLowerThanAddress(const void* ptr, bool* result) {
function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1005) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
function pid_t (line 1020) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
function GetStatusFileDescriptor (line 1227) | int GetStatusFileDescriptor(unsigned int parent_process_id,
function InternalRunDeathTestFlag (line 1294) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
FILE: utils/googletest/googletest/src/gtest-filepath.cc
type testing (line 63) | namespace testing {
type internal (line 64) | namespace internal {
function IsPathSeparator (line 90) | static bool IsPathSeparator(char c) {
function FilePath (line 99) | FilePath FilePath::GetCurrentDir() {
function FilePath (line 124) | FilePath FilePath::RemoveExtension(const char* extension) const {
function FilePath (line 155) | FilePath FilePath::RemoveDirectoryName() const {
function FilePath (line 166) | FilePath FilePath::RemoveFileName() const {
function FilePath (line 183) | FilePath FilePath::MakeFileName(const FilePath& directory,
function FilePath (line 199) | FilePath FilePath::ConcatPaths(const FilePath& directory,
function FilePath (line 286) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
function FilePath (line 346) | FilePath FilePath::RemoveTrailingPathSeparator() const {
FILE: utils/googletest/googletest/src/gtest-internal-inl.h
function namespace (line 73) | namespace testing {
FILE: utils/googletest/googletest/src/gtest-port.cc
type testing (line 80) | namespace testing {
type internal (line 81) | namespace internal {
function T (line 96) | T ReadProcFileField(const string& filename, int field) {
function GetThreadCount (line 109) | size_t GetThreadCount() {
function GetThreadCount (line 117) | size_t GetThreadCount() {
function GetThreadCount (line 138) | size_t GetThreadCount() {
function GetThreadCount (line 156) | size_t GetThreadCount() {
function GetThreadCount (line 169) | size_t GetThreadCount() {
function SleepMilliseconds (line 179) | void SleepMilliseconds(int n) {
class ThreadWithParamSupport (line 325) | class ThreadWithParamSupport : public ThreadWithParamBase {
method HANDLE (line 327) | static HANDLE CreateThread(Runnable* runnable,
type ThreadMainParam (line 348) | struct ThreadMainParam {
method ThreadMainParam (line 349) | ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
method DWORD (line 358) | static DWORD WINAPI ThreadMain(void* ptr) {
class ThreadLocalRegistryImpl (line 394) | class ThreadLocalRegistryImpl {
method ThreadLocalValueHolderBase (line 398) | static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
method OnThreadLocalDestroyed (line 426) | static void OnThreadLocalDestroyed(
method OnThreadExit (line 454) | static void OnThreadExit(DWORD thread_id) {
method StartWatcherThreadFor (line 492) | static void StartWatcherThreadFor(DWORD thread_id) {
method DWORD (line 520) | static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
method ThreadIdToThreadLocals (line 532) | static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
function ThreadLocalValueHolderBase (line 547) | ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentTh...
function IsInSet (line 627) | bool IsInSet(char ch, const char* str) {
function IsAsciiDigit (line 634) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
function IsAsciiPunct (line 635) | bool IsAsciiPunct(char ch) {
function IsRepeat (line 638) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
function IsAsciiWhiteSpace (line 639) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
function IsAsciiWordChar (line 640) | bool IsAsciiWordChar(char ch) {
function IsValidEscape (line 646) | bool IsValidEscape(char c) {
function AtomMatchesChar (line 652) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
function FormatRegexSyntaxError (line 674) | std::string FormatRegexSyntaxError(const char* regex, int index) {
function ValidateRegex (line 681) | bool ValidateRegex(const char* regex) {
function MatchRepetitionAndRegexAtHead (line 744) | bool MatchRepetitionAndRegexAtHead(
function MatchRegexAtHead (line 771) | bool MatchRegexAtHead(const char* regex, const char* str) {
function MatchRegexAnywhere (line 807) | bool MatchRegexAnywhere(const char* regex, const char* str) {
function FormatFileLocation (line 880) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
function FormatCompilerIndependentFileLocation (line 898) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
class CapturedStream (line 933) | class CapturedStream {
method CapturedStream (line 936) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
method GetCapturedString (line 988) | std::string GetCapturedString() {
function CaptureStream (line 1018) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
function GetCapturedStream (line 1027) | std::string GetCapturedStream(CapturedStream** captured_stream) {
function CaptureStdout (line 1037) | void CaptureStdout() {
function CaptureStderr (line 1042) | void CaptureStderr() {
function GetCapturedStdout (line 1047) | std::string GetCapturedStdout() {
function GetCapturedStderr (line 1052) | std::string GetCapturedStderr() {
function TempDir (line 1058) | std::string TempDir() {
function GetFileSize (line 1076) | size_t GetFileSize(FILE* file) {
function ReadEntireFile (line 1081) | std::string ReadEntireFile(FILE* file) {
function SetInjectableArgvs (line 1108) | void SetInjectableArgvs(const ::std::vector<testing::internal::strin...
type posix (line 1123) | namespace posix {
function Abort (line 1124) | void Abort() {
function FlagToEnvVar (line 1134) | static std::string FlagToEnvVar(const char* flag) {
function ParseInt32 (line 1149) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
function BoolFromGTestEnv (line 1191) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
function Int32 (line 1204) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
function StringFromGTestEnv (line 1229) | std::string StringFromGTestEnv(const char* flag, const char* default...
FILE: utils/googletest/googletest/src/gtest-printers.cc
type testing (line 53) | namespace testing {
function GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ (line 60) | GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
function PrintBytesInObjectToImpl (line 82) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
type internal2 (line 107) | namespace internal2 {
function PrintBytesInObjectTo (line 114) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
type internal (line 121) | namespace internal {
type CharFormat (line 128) | enum CharFormat {
function IsPrintableAscii (line 137) | inline bool IsPrintableAscii(wchar_t c) {
function CharFormat (line 146) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
function CharFormat (line 192) | static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
function CharFormat (line 207) | static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
function PrintCharAndCodeTo (line 217) | void PrintCharAndCodeTo(Char c, ostream* os) {
function PrintTo (line 241) | void PrintTo(unsigned char c, ::std::ostream* os) {
function PrintTo (line 244) | void PrintTo(signed char c, ::std::ostream* os) {
function PrintTo (line 250) | void PrintTo(wchar_t wc, ostream* os) {
function PrintCharsAsStringTo (line 262) | static void PrintCharsAsStringTo(
function UniversalPrintCharArray (line 286) | static void UniversalPrintCharArray(
function UniversalPrintArray (line 309) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
function UniversalPrintArray (line 315) | void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* ...
function PrintTo (line 320) | void PrintTo(const char* s, ostream* os) {
function PrintTo (line 337) | void PrintTo(const wchar_t* s, ostream* os) {
function PrintStringTo (line 349) | void PrintStringTo(const ::string& s, ostream* os) {
function PrintStringTo (line 354) | void PrintStringTo(const ::std::string& s, ostream* os) {
function PrintWideStringTo (line 360) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
function PrintWideStringTo (line 366) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
FILE: utils/googletest/googletest/src/gtest-test-part.cc
type testing (line 45) | namespace testing {
function TestPartResult (line 73) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
type internal (line 87) | namespace internal {
FILE: utils/googletest/googletest/src/gtest-typed-test.cc
type testing (line 35) | namespace testing {
type internal (line 36) | namespace internal {
function SplitIntoTestNames (line 48) | static std::vector<std::string> SplitIntoTestNames(const char* src) {
FILE: utils/googletest/googletest/src/gtest.cc
type testing (line 149) | namespace testing {
type internal (line 180) | namespace internal {
function UInt32 (line 311) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 330) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestCaseList (line 335) | static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
function TestCasePassed (line 345) | static bool TestCasePassed(const TestCase* test_case) {
function TestCaseFailed (line 350) | static bool TestCaseFailed(const TestCase* test_case) {
function ShouldRunTestCase (line 356) | static bool ShouldRunTestCase(const TestCase* test_case) {
function FilePath (line 399) | FilePath GetCurrentExecutableName() {
function TypeId (line 620) | TypeId GetTestTypeId() {
function AssertionResult (line 631) | AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 704) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 718) | TestPartResultReporterInterface*
function TimeInMillis (line 806) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 858) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 906) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 922) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 1027) | namespace edit_distance {
function CalculateOptimalEdits (line 1028) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 1088) | class InternalStrings {
method GetId (line 1090) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 1104) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 1126) | class Hunk {
method Hunk (line 1128) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 1135) | void PushLine(char edit, const char* line) {
method PrintTo (line 1153) | void PrintTo(std::ostream* os) {
method has_edits (line 1163) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 1166) | void FlushEdits() {
method PrintHeader (line 1175) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 1203) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 1272) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 1312) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 1346) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 1362) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 1384) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 1437) | AssertionResult CmpHelperEQ(const char* lhs_expression,
type internal (line 306) | namespace internal {
function UInt32 (line 311) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 330) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestCaseList (line 335) | static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
function TestCasePassed (line 345) | static bool TestCasePassed(const TestCase* test_case) {
function TestCaseFailed (line 350) | static bool TestCaseFailed(const TestCase* test_case) {
function ShouldRunTestCase (line 356) | static bool ShouldRunTestCase(const TestCase* test_case) {
function FilePath (line 399) | FilePath GetCurrentExecutableName() {
function TypeId (line 620) | TypeId GetTestTypeId() {
function AssertionResult (line 631) | AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 704) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 718) | TestPartResultReporterInterface*
function TimeInMillis (line 806) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 858) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 906) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 922) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 1027) | namespace edit_distance {
function CalculateOptimalEdits (line 1028) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 1088) | class InternalStrings {
method GetId (line 1090) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 1104) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 1126) | class Hunk {
method Hunk (line 1128) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 1135) | void PushLine(char edit, const char* line) {
method PrintTo (line 1153) | void PrintTo(std::ostream* os) {
method has_edits (line 1163) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 1166) | void FlushEdits() {
method PrintHeader (line 1175) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 1203) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 1272) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 1312) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 1346) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 1362) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 1384) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 1437) | AssertionResult CmpHelperEQ(const char* lhs_expression,
type internal (line 609) | namespace internal {
function UInt32 (line 311) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 330) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestCaseList (line 335) | static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
function TestCasePassed (line 345) | static bool TestCasePassed(const TestCase* test_case) {
function TestCaseFailed (line 350) | static bool TestCaseFailed(const TestCase* test_case) {
function ShouldRunTestCase (line 356) | static bool ShouldRunTestCase(const TestCase* test_case) {
function FilePath (line 399) | FilePath GetCurrentExecutableName() {
function TypeId (line 620) | TypeId GetTestTypeId() {
function AssertionResult (line 631) | AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 704) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 718) | TestPartResultReporterInterface*
function TimeInMillis (line 806) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 858) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 906) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 922) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 1027) | namespace edit_distance {
function CalculateOptimalEdits (line 1028) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 1088) | class InternalStrings {
method GetId (line 1090) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 1104) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 1126) | class Hunk {
method Hunk (line 1128) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 1135) | void PushLine(char edit, const char* line) {
method PrintTo (line 1153) | void PrintTo(std::ostream* os) {
method has_edits (line 1163) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 1166) | void FlushEdits() {
method PrintHeader (line 1175) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 1203) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 1272) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 1312) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 1346) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 1362) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 1384) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 1437) | AssertionResult CmpHelperEQ(const char* lhs_expression,
function Message (line 954) | Message& Message::operator <<(const wchar_t* wide_c_str) {
function Message (line 957) | Message& Message::operator <<(wchar_t* wide_c_str) {
function Message (line 964) | Message& Message::operator <<(const ::std::wstring& wstr) {
function Message (line 973) | Message& Message::operator <<(const ::wstring& wstr) {
function AssertionResult (line 1002) | AssertionResult AssertionResult::operator!() const {
function AssertionResult (line 1010) | AssertionResult AssertionSuccess() {
function AssertionResult (line 1015) | AssertionResult AssertionFailure() {
function AssertionResult (line 1021) | AssertionResult AssertionFailure(const Message& message) {
type internal (line 1025) | namespace internal {
function UInt32 (line 311) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 330) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestCaseList (line 335) | static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
function TestCasePassed (line 345) | static bool TestCasePassed(const TestCase* test_case) {
function TestCaseFailed (line 350) | static bool TestCaseFailed(const TestCase* test_case) {
function ShouldRunTestCase (line 356) | static bool ShouldRunTestCase(const TestCase* test_case) {
function FilePath (line 399) | FilePath GetCurrentExecutableName() {
function TypeId (line 620) | TypeId GetTestTypeId() {
function AssertionResult (line 631) | AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 704) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 718) | TestPartResultReporterInterface*
function TimeInMillis (line 806) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 858) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 906) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 922) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 1027) | namespace edit_distance {
function CalculateOptimalEdits (line 1028) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 1088) | class InternalStrings {
method GetId (line 1090) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 1104) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 1126) | class Hunk {
method Hunk (line 1128) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 1135) | void PushLine(char edit, const char* line) {
method PrintTo (line 1153) | void PrintTo(std::ostream* os) {
method has_edits (line 1163) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 1166) | void FlushEdits() {
method PrintHeader (line 1175) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 1203) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 1272) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 1312) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 1346) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 1362) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 1384) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 1437) | AssertionResult CmpHelperEQ(const char* lhs_expression,
function AssertionResult (line 1421) | AssertionResult FloatLE(const char* expr1, const char* expr2,
function AssertionResult (line 1428) | AssertionResult DoubleLE(const char* expr1, const char* expr2,
type internal (line 1433) | namespace internal {
function UInt32 (line 311) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 330) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestCaseList (line 335) | static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
function TestCasePassed (line 345) | static bool TestCasePassed(const TestCase* test_case) {
function TestCaseFailed (line 350) | static bool TestCaseFailed(const TestCase* test_case) {
function ShouldRunTestCase (line 356) | static bool ShouldRunTestCase(const TestCase* test_case) {
function FilePath (line 399) | FilePath GetCurrentExecutableName() {
function TypeId (line 620) | TypeId GetTestTypeId() {
function AssertionResult (line 631) | AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 704) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 718) | TestPartResultReporterInterface*
function TimeInMillis (line 806) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 858) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 906) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 922) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 1027) | namespace edit_distance {
function CalculateOptimalEdits (line 1028) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 1088) | class InternalStrings {
method GetId (line 1090) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 1104) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 1126) | class Hunk {
method Hunk (line 1128) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 1135) | void PushLine(char edit, const char* line) {
method PrintTo (line 1153) | void PrintTo(std::ostream* os) {
method has_edits (line 1163) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 1166) | void FlushEdits() {
method PrintHeader (line 1175) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 1203) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 1272) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 1312) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 1346) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 1362) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 1384) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 1437) | AssertionResult CmpHelperEQ(const char* lhs_expression,
function AssertionResult (line 1533) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
function IsSubstringPred (line 1557) | bool IsSubstringPred(const char* needle, const char* haystack) {
function IsSubstringPred (line 1564) | bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
function IsSubstringPred (line 1573) | bool IsSubstringPred(const StringType& needle,
function AssertionResult (line 1583) | AssertionResult IsSubstringImpl(
function AssertionResult (line 1606) | AssertionResult IsSubstring(
function AssertionResult (line 1612) | AssertionResult IsSubstring(
function AssertionResult (line 1618) | AssertionResult IsNotSubstring(
function AssertionResult (line 1624) | AssertionResult IsNotSubstring(
function AssertionResult (line 1630) | AssertionResult IsSubstring(
function AssertionResult (line 1636) | AssertionResult IsNotSubstring(
function AssertionResult (line 1643) | AssertionResult IsSubstring(
function AssertionResult (line 1649) | AssertionResult IsNotSubstring(
type internal (line 1656) | namespace internal {
function AssertionResult (line 1663) | AssertionResult HRESULTFailureHelper(const char* expr,
function AssertionResult (line 1704) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT
function AssertionResult (line 1711) | AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT
function UInt32 (line 1747) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
function CodePointToUtf8 (line 1759) | std::string CodePointToUtf8(UInt32 code_point) {
function IsUtf16SurrogatePair (line 1794) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
function UInt32 (line 1800) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
function WideStringToUtf8 (line 1823) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
function AssertionResult (line 1869) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
function AssertionResult (line 1885) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
function StringStreamToString (line 1982) | std::string StringStreamToString(::std::stringstream* ss) {
function AppendUserMessage (line 2001) | std::string AppendUserMessage(const std::string& gtest_msg,
function ReportFailureInUnknownLocation (line 2250) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
function FormatCxxExceptionMessage (line 2352) | static std::string FormatCxxExceptionMessage(const char* description,
function Result (line 2383) | Result HandleSehExceptionsInMethodIfSupported(
function Result (line 2410) | Result HandleExceptionsInMethodIfSupported(
function TestInfo (line 2543) | TestInfo* MakeAndRegisterTestInfo(
function ReportInvalidTestCaseType (line 2561) | void ReportInvalidTestCaseType(const char* test_case_name,
function PrintTestPartResultToString (line 2850) | static std::string PrintTestPartResultToString(
function PrintTestPartResult (line 2860) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
type GTestColor (line 2880) | enum GTestColor {
function WORD (line 2891) | WORD GetColorAttribute(GTestColor color) {
function ShouldUseColor (line 2916) | bool ShouldUseColor(bool stdout_is_tty) {
function ColoredPrintf (line 2956) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
function PrintFullTestCommentIfPresent (line 3009) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
class PrettyUnitTestResultPrinter (line 3029) | class PrettyUnitTestResultPrinter : public TestEventListener {
method PrettyUnitTestResultPrinter (line 3031) | PrettyUnitTestResultPrinter() {}
method PrintTestName (line 3032) | static void PrintTestName(const char * test_case, const char * test) {
method OnTestProgramStart (line 3037) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
method OnEnvironmentsSetUpEnd (line 3040) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
method OnEnvironmentsTearDownEnd (line 3047) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
method OnTestProgramEnd (line 3049) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
class TestEventRepeater (line 3236) | class TestEventRepeater : public TestEventListener {
method TestEventRepeater (line 3238) | TestEventRepeater() : forwarding_enabled_(true) {}
method forwarding_enabled (line 3245) | bool forwarding_enabled() const { return forwarding_enabled_; }
method set_forwarding_enabled (line 3246) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
function TestEventListener (line 3281) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
class XmlUnitTestResultPrinter (line 3349) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
method IsNormalizableWhitespace (line 3358) | static bool IsNormalizableWhitespace(char c) {
method IsValidXmlCharacter (line 3363) | static bool IsValidXmlCharacter(char c) {
method EscapeXmlAttribute (line 3377) | static std::string EscapeXmlAttribute(const std::string& str) {
method EscapeXmlText (line 3382) | static std::string EscapeXmlText(const char* str) {
function FormatTimeInMillisAsSeconds (line 3550) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
function PortableLocaltime (line 3556) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
function FormatEpochTimeInMillisAsIso8601 (line 3574) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
function string (line 3761) | string StreamingListener::UrlEncode(const char* str) {
function GTEST_LOCK_EXCLUDED
Condensed preview — 979 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,321K chars).
[
{
"path": ".clang-format",
"chars": 67,
"preview": "---\nBasedOnStyle: LLVM\nStandard: Cpp11\nPointerAlignment: Left\n...\n"
},
{
"path": ".dockerignore",
"chars": 186,
"preview": ".dockerignore\n# Pass `.git` directory so that\n# `jfs --version` gives git hash.\n#.git\n**/.*.swp\n**/*.Dockerfile\nscripts/"
},
{
"path": ".gitignore",
"chars": 65,
"preview": "# Vim swap files\n*.swp\n*.swo\nscripts/Dockerfiles/*.patched\n*.pyc\n"
},
{
"path": ".idea/codeStyleSettings.xml",
"chars": 2569,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project version=\"4\">\n <component name=\"ProjectCodeStyleSettingsManager\">\n <o"
},
{
"path": "CMakeLists.txt",
"chars": 17516,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "LICENSE.txt",
"chars": 1051,
"preview": "Copyright 2017 Daniel Liew\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis softwar"
},
{
"path": "README.md",
"chars": 8597,
"preview": "# JFS\n\nJFS (Just Fuzz it Solver) (originally JIT Fuzzing Solver) is an experimental\nconstraint solver designed to invest"
},
{
"path": "cmake/add_jfs_unit_test.cmake",
"chars": 1557,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/c_flags_override.cmake",
"chars": 1093,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/compiler_warnings.cmake",
"chars": 1176,
"preview": "set(GCC_AND_CLANG_WARNINGS\n \"-Wall\"\n)\nset(GCC_ONLY_WARNINGS \"\")\nset(CLANG_ONLY_WARNINGS \"\")\nset(MSVC_WARNINGS \"/W3\")\n"
},
{
"path": "cmake/cxx_flags_override.cmake",
"chars": 1110,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/git_utils.cmake",
"chars": 6341,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/jfs_add_component.cmake",
"chars": 1358,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/jfs_component_add_cxx_flag.cmake",
"chars": 1439,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/jfs_external_project_utils.cmake",
"chars": 1201,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "cmake/jfs_get_llvm_components.cmake",
"chars": 584,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "docs/tutorial/0-basics-example.smt2",
"chars": 391,
"preview": "(declare-fun a () (_ FloatingPoint 11 53))\n(declare-fun b () (_ FloatingPoint 11 53))\n(define-fun a_b_rne () (_ Floating"
},
{
"path": "docs/tutorial/0-basics.md",
"chars": 12407,
"preview": "# JFS basics\n\nThis tutorial will walk you through the basics of using JFS.\n\nJFS is designed to solve constraints in the "
},
{
"path": "docs/tutorial/1-setting-resource-limits.md",
"chars": 36,
"preview": "# Setting JFS resource limits\n\nTODO\n"
},
{
"path": "docs/tutorial/2-compilation-options-and-runtimes.md",
"chars": 41,
"preview": "# Compilation options and runtimes\n\nTODO\n"
},
{
"path": "docs/tutorial/3-resumming-fuzzing.md",
"chars": 26,
"preview": "# Resumming fuzzing\n\nTODO\n"
},
{
"path": "docs/tutorial/4-getting-models.md",
"chars": 33,
"preview": "# Getting a model from JFS\n\nTODO\n"
},
{
"path": "docs/tutorial/5-jfs-smt2cxx.md",
"chars": 31,
"preview": "# The `jfs-smt2cxx` tool\n\nTODO\n"
},
{
"path": "docs/tutorial/6-jfs-opt.md",
"chars": 27,
"preview": "# The `jfs-opt` tool\n\nTODO\n"
},
{
"path": "include/jfs/CXXFuzzingBackend/CXXFuzzingSolver.h",
"chars": 1265,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CXXFuzzingSolverOptions.h",
"chars": 2390,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CXXProgram.h",
"chars": 6070,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CXXProgramBuilderOptions.h",
"chars": 4285,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CXXProgramBuilderPass.h",
"chars": 1272,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/ClangInvocationManager.h",
"chars": 1388,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/ClangOptions.h",
"chars": 1791,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CmdLine/CXXProgramBuilderOptionsBuilder.h",
"chars": 829,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CmdLine/ClangOptionsBuilder.h",
"chars": 765,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/CmdLine/CommandLineCategory.h",
"chars": 618,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/CXXFuzzingBackend/JFSCXXProgramStat.h",
"chars": 1177,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Config/config.h.in",
"chars": 73,
"preview": "#ifndef JFS_CONFIG_CONFIG_H\n#define JFS_CONFIG_CONFIG_H\n\n// TODO\n\n#endif\n"
},
{
"path": "include/jfs/Config/depsVersion.h.in",
"chars": 591,
"preview": "#ifndef JFS_CONFIG_DEPS_VERSION_H\n#define JFS_CONFIG_DEPS_VERSION_H\n\n/* LLVM major version number */\n#define LLVM_VERSIO"
},
{
"path": "include/jfs/Config/version.h.in",
"chars": 521,
"preview": "#ifndef JFS_CONFIG_VERSION_H\n#define JFS_CONFIG_VERSION_H\n\n/* JFS major version number */\n#define JFS_VERSION_MAJOR @JFS"
},
{
"path": "include/jfs/Core/IfVerbose.h",
"chars": 880,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/JFSContext.h",
"chars": 2334,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/JFSTimerMacros.h",
"chars": 1774,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Model.h",
"chars": 1630,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/ModelValidator.h",
"chars": 2083,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Query.h",
"chars": 1464,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/RNG.h",
"chars": 736,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/SMTLIB2Parser.h",
"chars": 1269,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/ScopedJFSContextErrorHandler.h",
"chars": 852,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/SimpleModel.h",
"chars": 632,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Solver.h",
"chars": 1645,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/SolverOptions.h",
"chars": 1291,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/ToolErrorHandler.h",
"chars": 977,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Z3ASTCmp.h",
"chars": 1773,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Z3ASTVisitor.h",
"chars": 5500,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Z3Node.h",
"chars": 12511,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Z3NodeMap.h",
"chars": 826,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Z3NodeSet.h",
"chars": 919,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Core/Z3NodeUtil.h",
"chars": 1107,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/BufferAssignment.h",
"chars": 1685,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/BufferElement.h",
"chars": 1376,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/CmdLine/FreeVariableToBufferAssignmentPassOptionsBuilder.h",
"chars": 747,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/CmdLine/LibFuzzerOptionsBuilder.h",
"chars": 690,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/CmdLine/SeedManagerOptionsBuilder.h",
"chars": 739,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/CommandLineCategory.h",
"chars": 583,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/DummyFuzzingSolver.h",
"chars": 1132,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/EqualityExtractionPass.h",
"chars": 1591,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/FileSerializableModel.h",
"chars": 1164,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/FreeVariableToBufferAssignmentPass.h",
"chars": 2264,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.h",
"chars": 988,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/FuzzingAnalysisInfo.h",
"chars": 1134,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/FuzzingSolver.h",
"chars": 1373,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/FuzzingSolverOptions.h",
"chars": 1508,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/JFSRuntimeFuzzingStat.h",
"chars": 1416,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/LibFuzzerInvocationManager.h",
"chars": 1631,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/LibFuzzerOptions.h",
"chars": 1828,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SeedGenerator.h",
"chars": 1630,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SeedManager.h",
"chars": 2129,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SeedManagerOptions.h",
"chars": 786,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SeedManagerStat.h",
"chars": 991,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SortConformanceCheckPass.h",
"chars": 1113,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SpecialConstantSeedGenerator.h",
"chars": 1847,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/SpecialConstantSeedGeneratorStat.h",
"chars": 1266,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/FuzzingCommon/WorkingDirectoryManager.h",
"chars": 2099,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/CancellableProcess.h",
"chars": 1220,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/ErrorMessages.h",
"chars": 820,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/FileUtils.h",
"chars": 612,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/ICancellable.h",
"chars": 727,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/JFSStat.h",
"chars": 2004,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/ScopedJFSTimerStatAppender.h",
"chars": 1651,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/ScopedTimer.h",
"chars": 942,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/StatisticsManager.h",
"chars": 955,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/Timer.h",
"chars": 1914,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Support/version.h",
"chars": 477,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/AndHoistingPass.h",
"chars": 783,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/BitBlastPass.h",
"chars": 713,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/BvBoundPropagationPass.h",
"chars": 860,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/ConstantPropagationPass.h",
"chars": 768,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/DIMACSOutputPass.h",
"chars": 733,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/DuplicateConstraintEliminationPass.h",
"chars": 879,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/FpToBvPass.h",
"chars": 705,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/Passes.h",
"chars": 825,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/QueryPass.h",
"chars": 999,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/QueryPassManager.h",
"chars": 1475,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/SimpleContradictionsToFalsePass.h",
"chars": 857,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/SimplificationPass.h",
"chars": 741,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/StandardPasses.h",
"chars": 555,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/TrueConstraintEliminationPass.h",
"chars": 855,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Transform/Z3QueryPass.h",
"chars": 819,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "include/jfs/Z3Backend/Z3Solver.h",
"chars": 982,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CMakeLists.txt",
"chars": 501,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/CXXFuzzingBackend/CMakeLists.txt",
"chars": 818,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/CXXFuzzingBackend/CXXFuzzingSolver.cpp",
"chars": 15557,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CXXFuzzingSolverOptions.cpp",
"chars": 1592,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CXXProgram.cpp",
"chars": 5263,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CXXProgramBuilderOptions.cpp",
"chars": 526,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CXXProgramBuilderPass.cpp",
"chars": 1539,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CXXProgramBuilderPassImpl.cpp",
"chars": 65529,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CXXProgramBuilderPassImpl.h",
"chars": 10192,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/ClangInvocationManager.cpp",
"chars": 10275,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/ClangOptions.cpp",
"chars": 5598,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CmdLine/CMakeLists.txt",
"chars": 350,
"preview": "jfs_add_component(JFSCXXFuzzingBackendCmdLine\n ClangOptionsBuilder.cpp\n CommandLineCategory.cpp\n CXXProgramBuilderOpt"
},
{
"path": "lib/CXXFuzzingBackend/CmdLine/CXXProgramBuilderOptionsBuilder.cpp",
"chars": 3709,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CmdLine/ClangOptionsBuilder.cpp",
"chars": 4473,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/CmdLine/CommandLineCategory.cpp",
"chars": 596,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/CXXFuzzingBackend/JFSCXXProgramStat.cpp",
"chars": 1222,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/CMakeLists.txt",
"chars": 721,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/Core/JFSContext.cpp",
"chars": 7125,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/Model.cpp",
"chars": 3695,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/ModelValidator.cpp",
"chars": 4418,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/Query.cpp",
"chars": 3792,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/RNG.cpp",
"chars": 581,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/SMTLIB2Parser.cpp",
"chars": 3949,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/SimpleModel.cpp",
"chars": 583,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/Solver.cpp",
"chars": 1104,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/ToolErrorHandler.cpp",
"chars": 1343,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/Z3ASTVisitor.cpp",
"chars": 7114,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/Z3Node.cpp",
"chars": 21617,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Core/Z3NodeUtil.cpp",
"chars": 1439,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/BufferAssignment.cpp",
"chars": 1795,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/BufferElement.cpp",
"chars": 2392,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/CMakeLists.txt",
"chars": 3908,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/FuzzingCommon/CmdLine/CMakeLists.txt",
"chars": 688,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/FuzzingCommon/CmdLine/FreeVariableToBufferAssignmentPassOptionsBuilder.cpp",
"chars": 2686,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/CmdLine/LibFuzzerOptionsBuilder.cpp",
"chars": 2644,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/CmdLine/SeedManagerOptionsBuilder.cpp",
"chars": 2956,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/CommandLineCategory.cpp",
"chars": 576,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/DummyFuzzingSolver.cpp",
"chars": 1421,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/EqualityExtractionPass.cpp",
"chars": 9785,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/FileSerializableModel.cpp",
"chars": 14689,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/FreeVariableToBufferAssignmentPass.cpp",
"chars": 8938,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/FreeVariableToBufferAssignmentPassOptions.cpp",
"chars": 595,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/FuzzingAnalysisInfo.cpp",
"chars": 1397,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/FuzzingSolver.cpp",
"chars": 7830,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/FuzzingSolverOptions.cpp",
"chars": 1271,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/JFSRuntimeFuzzingStat.cpp",
"chars": 3626,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/LibFuzzerInvocationManager.cpp",
"chars": 10912,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/LibFuzzerOptions.cpp",
"chars": 841,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SMTLIBRuntimes.cpp.in",
"chars": 876,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SMTLIBRuntimes.h.in",
"chars": 766,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SeedGenerator.cpp",
"chars": 1729,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SeedManager.cpp",
"chars": 9562,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SeedManagerStat.cpp",
"chars": 874,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SortConformanceCheckPass.cpp",
"chars": 2114,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SpecialConstantSeedGenerator.cpp",
"chars": 13897,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/SpecialConstantSeedGeneratorStat.cpp",
"chars": 2061,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/FuzzingCommon/WorkingDirectoryManager.cpp",
"chars": 6175,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/CMakeLists.txt",
"chars": 666,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/Support/CancellableProcess.cpp",
"chars": 5912,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/ErrorMessages.cpp",
"chars": 1101,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/FileUtils.cpp",
"chars": 1968,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/ICancellable.cpp",
"chars": 487,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/JFSStat.cpp",
"chars": 2338,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/ScopedTimer.cpp",
"chars": 3217,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/StatisticsManager.cpp",
"chars": 1806,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/Timer.cpp",
"chars": 921,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Support/version.cpp",
"chars": 878,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/AndHoistingPass.cpp",
"chars": 2496,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/BitBlastPass.cpp",
"chars": 1877,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/BvBoundPropagationPass.cpp",
"chars": 2042,
"preview": "\n//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/CMakeLists.txt",
"chars": 754,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/Transform/ConstantPropagationPass.cpp",
"chars": 1898,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/DIMACSOutputPass.cpp",
"chars": 2561,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/DuplicateConstraintEliminationPass.cpp",
"chars": 1700,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/FpToBvPass.cpp",
"chars": 1866,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/QueryPassManager.cpp",
"chars": 5045,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/SimpleContradictionsToFalsePass.cpp",
"chars": 3339,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/SimplificationPass.cpp",
"chars": 2242,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/StandardPasses.cpp",
"chars": 3037,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/TrueConstraintEliminationPass.cpp",
"chars": 1440,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Transform/Z3QueryPass.cpp",
"chars": 1701,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "lib/Z3Backend/CMakeLists.txt",
"chars": 440,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "lib/Z3Backend/Z3Solver.cpp",
"chars": 2839,
"preview": "//===----------------------------------------------------------------------===//\n//\n// "
},
{
"path": "runtime/CMakeLists.txt",
"chars": 4522,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "runtime/LibFuzzer/CMakeLists.txt",
"chars": 2788,
"preview": "#===------------------------------------------------------------------------===#\n#\n# "
},
{
"path": "runtime/LibFuzzer/Fuzzer/CMakeLists.txt",
"chars": 900,
"preview": "add_library(LLVMFuzzer STATIC\n FuzzerClangCounters.cpp\n FuzzerCrossOver.cpp\n FuzzerDriver.cpp\n FuzzerExtFunctionsDls"
},
{
"path": "runtime/LibFuzzer/Fuzzer/FuzzerClangCounters.cpp",
"chars": 1957,
"preview": "//===- FuzzerExtraCounters.cpp - Extra coverage counters ------------------===//\n//\n// The LLVM Comp"
},
{
"path": "runtime/LibFuzzer/Fuzzer/FuzzerCommand.h",
"chars": 6116,
"preview": "//===- FuzzerCommand.h - Interface representing a process -------*- C++ -* ===//\n//\n// The LLVM Comp"
},
{
"path": "runtime/LibFuzzer/Fuzzer/FuzzerCorpus.h",
"chars": 9180,
"preview": "//===- FuzzerCorpus.h - Internal header for the Fuzzer ----------*- C++ -* ===//\n//\n// The LLVM Comp"
},
{
"path": "runtime/LibFuzzer/Fuzzer/FuzzerCrossOver.cpp",
"chars": 1920,
"preview": "//===- FuzzerCrossOver.cpp - Cross over two test inputs -------------------===//\n//\n// The LLVM Comp"
},
{
"path": "runtime/LibFuzzer/Fuzzer/FuzzerDefs.h",
"chars": 4525,
"preview": "//===- FuzzerDefs.h - Internal header for the Fuzzer ------------*- C++ -* ===//\n//\n// The LLVM Comp"
},
{
"path": "runtime/LibFuzzer/Fuzzer/FuzzerDictionary.h",
"chars": 3648,
"preview": "//===- FuzzerDictionary.h - Internal header for the Fuzzer ------*- C++ -* ===//\n//\n// The LLVM Comp"
}
]
// ... and 779 more files (download for full content)
About this extraction
This page contains the full source code of the delcypher/jfs GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 979 files (4.8 MB), approximately 1.3M tokens, and a symbol index with 4367 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.