Showing preview only (2,643K chars total). Download the full file or copy to clipboard to get everything.
Repository: mchalupa/dg
Branch: master
Commit: dc3615d03fed
Files: 506
Total size: 2.4 MB
Directory structure:
gitextract_sogryq7m/
├── .clang-format
├── .clang-tidy
├── .git-blame-ignore-revs
├── .github/
│ └── workflows/
│ ├── clang-format.yml
│ ├── docker.yml
│ ├── hash_map.yml
│ ├── linux.yml
│ ├── mac.yml
│ └── svf.yml
├── .gitignore
├── .travis.yml
├── CMakeLists.txt
├── Changelog
├── Dockerfile
├── LICENSE
├── README.md
├── dg.spec.rpkg
├── doc/
│ ├── CDA.md
│ ├── DDA.md
│ ├── PTA.md
│ ├── README.md
│ ├── SVF.md
│ ├── compiling.md
│ ├── compiling_ubuntu_trusty.md
│ ├── compiling_ubuntu_xenial.md
│ ├── downloading.md
│ ├── llvm-slicer.md
│ └── tools.md
├── include/
│ └── dg/
│ ├── ADT/
│ │ ├── Bits.h
│ │ ├── Bitvector.h
│ │ ├── DGContainer.h
│ │ ├── DisjunctiveIntervalMap.h
│ │ ├── HashMap.h
│ │ ├── HashMapImpl.h
│ │ ├── IntervalsList.h
│ │ ├── Map.h
│ │ ├── NumberSet.h
│ │ ├── Queue.h
│ │ ├── STLHashMap.h
│ │ ├── SetQueue.h
│ │ └── TslHopscotchHashMap.h
│ ├── AnalysisOptions.h
│ ├── BBlock.h
│ ├── BBlockBase.h
│ ├── BBlocksBuilder.h
│ ├── BFS.h
│ ├── CallGraph/
│ │ └── CallGraph.h
│ ├── ControlDependence/
│ │ └── ControlDependenceAnalysisOptions.h
│ ├── DFS.h
│ ├── DG2Dot.h
│ ├── DGParameters.h
│ ├── DataDependence/
│ │ ├── DataDependence.h
│ │ ├── DataDependenceAnalysisImpl.h
│ │ └── DataDependenceAnalysisOptions.h
│ ├── DependenceGraph.h
│ ├── Dominators/
│ │ ├── DominanceFrontiers.h
│ │ └── PostDominanceFrontiers.h
│ ├── MemorySSA/
│ │ ├── Definitions.h
│ │ ├── DefinitionsMap.h
│ │ ├── MemorySSA.h
│ │ └── ModRef.h
│ ├── MemoryState.h
│ ├── Node.h
│ ├── NodesWalk.h
│ ├── Offset.h
│ ├── PointerAnalysis/
│ │ ├── MemoryObject.h
│ │ ├── PSNode.h
│ │ ├── Pointer.h
│ │ ├── PointerAnalysis.h
│ │ ├── PointerAnalysisFI.h
│ │ ├── PointerAnalysisFS.h
│ │ ├── PointerAnalysisFSInv.h
│ │ ├── PointerAnalysisOptions.h
│ │ ├── PointerGraph.h
│ │ ├── PointerGraphOptimizations.h
│ │ ├── PointerGraphValidator.h
│ │ ├── PointsToMapping.h
│ │ ├── PointsToSet.h
│ │ └── PointsToSets/
│ │ ├── AlignedPointerIdPointsToSet.h
│ │ ├── AlignedSmallOffsetsPointsToSet.h
│ │ ├── LookupTable.h
│ │ ├── OffsetsSetPointsToSet.h
│ │ ├── PointerIdPointsToSet.h
│ │ ├── SeparateOffsetsPointsToSet.h
│ │ ├── SimplePointsToSet.h
│ │ └── SmallOffsetsPointsToSet.h
│ ├── ReadWriteGraph/
│ │ ├── DefSite.h
│ │ ├── RWBBlock.h
│ │ ├── RWNode.h
│ │ ├── RWSubgraph.h
│ │ └── ReadWriteGraph.h
│ ├── SCC.h
│ ├── Slicing.h
│ ├── SubgraphBase.h
│ ├── SubgraphNode.h
│ ├── SystemDependenceGraph/
│ │ ├── DGArgumentPair.h
│ │ ├── DGBBlock.h
│ │ ├── DGElement.h
│ │ ├── DGNode.h
│ │ ├── DGNodeCall.h
│ │ ├── DGParameters.h
│ │ ├── DepDGElement.h
│ │ ├── DependenceGraph.h
│ │ └── SystemDependenceGraph.h
│ ├── ValueRelations/
│ │ ├── Bucket.h
│ │ ├── Relations.h
│ │ └── RelationsGraph.h
│ ├── legacy/
│ │ ├── Analysis.h
│ │ ├── BFS.h
│ │ ├── DFS.h
│ │ ├── DataFlowAnalysis.h
│ │ └── NodesWalk.h
│ ├── llvm/
│ │ ├── CallGraph/
│ │ │ └── CallGraph.h
│ │ ├── ControlDependence/
│ │ │ ├── ControlDependence.h
│ │ │ ├── LLVMControlDependenceAnalysisImpl.h
│ │ │ └── LLVMControlDependenceAnalysisOptions.h
│ │ ├── DataDependence/
│ │ │ ├── DataDependence.h
│ │ │ └── LLVMDataDependenceAnalysisOptions.h
│ │ ├── Dominators/
│ │ │ └── Dominators.h
│ │ ├── LLVMAnalysisOptions.h
│ │ ├── LLVMDG2Dot.h
│ │ ├── LLVMDGAssemblyAnnotationWriter.h
│ │ ├── LLVMDependenceGraph.h
│ │ ├── LLVMDependenceGraphBuilder.h
│ │ ├── LLVMNode.h
│ │ ├── LLVMSlicer.h
│ │ ├── PointerAnalysis/
│ │ │ ├── DGPointerAnalysis.h
│ │ │ ├── LLVMPointerAnalysisOptions.h
│ │ │ ├── LLVMPointsToSet.h
│ │ │ ├── PointerAnalysis.h
│ │ │ ├── PointerGraph.h
│ │ │ └── SVFPointerAnalysis.h
│ │ ├── SystemDependenceGraph/
│ │ │ ├── SDG2Dot.h
│ │ │ ├── SystemDependenceGraph.h
│ │ │ └── SystemDependenceGraphBuilder.h
│ │ ├── ThreadRegions/
│ │ │ ├── ControlFlowGraph.h
│ │ │ ├── MayHappenInParallel.h
│ │ │ └── ThreadRegion.h
│ │ └── ValueRelations/
│ │ ├── GraphBuilder.h
│ │ ├── GraphElements.h
│ │ ├── RelationsAnalyzer.h
│ │ ├── StructureAnalyzer.h
│ │ ├── StructureElements.h
│ │ ├── UniquePtrVector.h
│ │ ├── ValueRelations.h
│ │ └── getValName.h
│ └── util/
│ ├── TimeMeasure.h
│ ├── cow_shared_ptr.h
│ ├── debug.h
│ └── iterators.h
├── lib/
│ ├── BBlockBase.cpp
│ ├── CMakeLists.txt
│ ├── ControlDependence/
│ │ ├── CDGraph.h
│ │ ├── ControlClosure.h
│ │ ├── DOD.h
│ │ ├── DODNTSCD.h
│ │ ├── NTSCD.cpp
│ │ └── NTSCD.h
│ ├── Debug.cpp
│ ├── MemorySSA/
│ │ ├── Definitions.cpp
│ │ ├── MemorySSA.cpp
│ │ └── ModRef.cpp
│ ├── Offset.cpp
│ ├── PointerAnalysis/
│ │ ├── Pointer.cpp
│ │ ├── PointerAnalysis.cpp
│ │ ├── PointerGraph.cpp
│ │ ├── PointerGraphOptimizations.cpp
│ │ ├── PointerGraphValidator.cpp
│ │ └── PointsToSet.cpp
│ ├── ReadWriteGraph/
│ │ └── ReadWriteGraph.cpp
│ ├── SystemDependenceGraph/
│ │ └── DependenceGraph.cpp
│ ├── ValueRelations/
│ │ └── Relations.cpp
│ └── llvm/
│ ├── ControlDependence/
│ │ ├── ControlClosure.h
│ │ ├── ControlDependence.cpp
│ │ ├── DOD.h
│ │ ├── GraphBuilder.h
│ │ ├── IGraphBuilder.h
│ │ ├── InterproceduralCD.cpp
│ │ ├── InterproceduralCD.h
│ │ ├── NTSCD.h
│ │ ├── SCD.cpp
│ │ ├── SCD.h
│ │ └── legacy/
│ │ ├── Block.cpp
│ │ ├── Block.h
│ │ ├── Function.cpp
│ │ ├── Function.h
│ │ ├── GraphBuilder.cpp
│ │ ├── GraphBuilder.h
│ │ ├── NTSCD.cpp
│ │ ├── NTSCD.h
│ │ └── TarjanAnalysis.h
│ ├── DataDependenceAnalysis/
│ │ └── LLVMDataDependenceAnalysis.cpp
│ ├── DefUse/
│ │ ├── DefUse.cpp
│ │ └── DefUse.h
│ ├── Dominators/
│ │ └── PostDominators.cpp
│ ├── ForkJoin/
│ │ ├── ForkJoin.cpp
│ │ └── ForkJoin.h
│ ├── GraphBuilder.h
│ ├── LLVMDGVerifier.cpp
│ ├── LLVMDGVerifier.h
│ ├── LLVMDependenceGraph.cpp
│ ├── LLVMNode.cpp
│ ├── PointerAnalysis/
│ │ ├── Block.cpp
│ │ ├── Calls.cpp
│ │ ├── Constants.cpp
│ │ ├── Globals.cpp
│ │ ├── Instructions.cpp
│ │ ├── Interprocedural.cpp
│ │ ├── PointerAnalysis.cpp
│ │ ├── PointerGraph.cpp
│ │ ├── PointerGraphValidator.cpp
│ │ ├── PointerGraphValidator.h
│ │ ├── Structure.cpp
│ │ └── Threads.cpp
│ ├── ReadWriteGraph/
│ │ ├── Calls.cpp
│ │ ├── Instructions.cpp
│ │ ├── LLVMReadWriteGraphBuilder.cpp
│ │ └── LLVMReadWriteGraphBuilder.h
│ ├── SummaryEdges.cpp
│ ├── SystemDependenceGraph/
│ │ ├── Dependencies.cpp
│ │ ├── SDG2Dot.cpp
│ │ └── SystemDependenceGraph.cpp
│ ├── ThreadRegions/
│ │ ├── Graphs/
│ │ │ ├── BlockGraph.cpp
│ │ │ ├── BlockGraph.h
│ │ │ ├── ControlFlowGraph.cpp
│ │ │ ├── CriticalSectionsBuilder.cpp
│ │ │ ├── CriticalSectionsBuilder.h
│ │ │ ├── FunctionGraph.cpp
│ │ │ ├── FunctionGraph.h
│ │ │ ├── GraphBuilder.cpp
│ │ │ ├── GraphBuilder.h
│ │ │ ├── ThreadRegionsBuilder.cpp
│ │ │ └── ThreadRegionsBuilder.h
│ │ ├── MayHappenInParallel.cpp
│ │ ├── Nodes/
│ │ │ ├── CallFuncPtrNode.cpp
│ │ │ ├── CallFuncPtrNode.h
│ │ │ ├── CallNode.cpp
│ │ │ ├── CallNode.h
│ │ │ ├── CallReturnNode.cpp
│ │ │ ├── CallReturnNode.h
│ │ │ ├── EntryNode.cpp
│ │ │ ├── EntryNode.h
│ │ │ ├── ExitNode.cpp
│ │ │ ├── ExitNode.h
│ │ │ ├── ForkNode.cpp
│ │ │ ├── ForkNode.h
│ │ │ ├── GeneralNode.cpp
│ │ │ ├── GeneralNode.h
│ │ │ ├── JoinNode.cpp
│ │ │ ├── JoinNode.h
│ │ │ ├── LockNode.cpp
│ │ │ ├── LockNode.h
│ │ │ ├── Node.cpp
│ │ │ ├── Node.h
│ │ │ ├── NodeIterator.cpp
│ │ │ ├── NodeIterator.h
│ │ │ ├── Nodes.h
│ │ │ ├── ReturnNode.cpp
│ │ │ ├── ReturnNode.h
│ │ │ ├── UnlockNode.cpp
│ │ │ └── UnlockNode.h
│ │ └── ThreadRegion.cpp
│ ├── ValueRelations/
│ │ ├── GraphBuilder.cpp
│ │ ├── GraphElements.cpp
│ │ ├── RelationsAnalyzer.cpp
│ │ ├── StructureAnalyzer.cpp
│ │ └── ValueRelations.cpp
│ └── llvm-utils.h
├── misc/
│ └── benchexec/
│ ├── README.md
│ ├── dgtool.py
│ ├── llvm-slicer-tests.xml
│ └── slicing-tests.set
├── tests/
│ ├── CMakeLists.txt
│ ├── adt-test.cpp
│ ├── bitvector-test.cpp
│ ├── catch-main.cpp
│ ├── catch2/
│ │ └── catch.hpp
│ ├── cmd-args.py
│ ├── disjunctive-intervals-map-test.cpp
│ ├── fuzzing/
│ │ ├── CMakeLists.txt
│ │ ├── bitvector1.cpp
│ │ ├── disjunctive-map1.cpp
│ │ └── numbers-set1.cpp
│ ├── llvm-dg-test.cpp
│ ├── nodes-walk-test.cpp
│ ├── numbers-set-test.cpp
│ ├── points-to-set-test.cpp
│ ├── points-to-test.cpp
│ ├── ptset-benchmark.cpp
│ ├── rdmap-test.cpp
│ ├── readwritegraph-test.cpp
│ ├── slicing/
│ │ ├── CMakeLists.txt
│ │ ├── sources/
│ │ │ ├── a_ptr.c
│ │ │ ├── alias_of_return.c
│ │ │ ├── atomic1.c
│ │ │ ├── atomic2.c
│ │ │ ├── atomic3.c
│ │ │ ├── bitcast1.c
│ │ │ ├── bitcast2.c
│ │ │ ├── bitcast3.c
│ │ │ ├── bitcast4.c
│ │ │ ├── bitcast5.c
│ │ │ ├── bitcast6.c
│ │ │ ├── control-regression1.c
│ │ │ ├── cyclic-realloc.c
│ │ │ ├── dynalloc1.c
│ │ │ ├── dynalloc2.c
│ │ │ ├── dynalloc3.c
│ │ │ ├── dynalloc4.c
│ │ │ ├── dynalloc5.c
│ │ │ ├── dynalloc6.c
│ │ │ ├── dynalloc7.c
│ │ │ ├── foo.c
│ │ │ ├── fptoui1.c
│ │ │ ├── funcarray1.c
│ │ │ ├── funcarray2.c
│ │ │ ├── funcarray3.c
│ │ │ ├── funcptr-regression1.c
│ │ │ ├── funcptr1.c
│ │ │ ├── funcptr10.c
│ │ │ ├── funcptr11.c
│ │ │ ├── funcptr12.c
│ │ │ ├── funcptr13.c
│ │ │ ├── funcptr14.c
│ │ │ ├── funcptr15.c
│ │ │ ├── funcptr16.c
│ │ │ ├── funcptr2.c
│ │ │ ├── funcptr3.c
│ │ │ ├── funcptr4.c
│ │ │ ├── funcptr5.c
│ │ │ ├── funcptr6.c
│ │ │ ├── funcptr7.c
│ │ │ ├── funcptr8.c
│ │ │ ├── funcptr9.c
│ │ │ ├── get_int.c
│ │ │ ├── get_output.c
│ │ │ ├── get_ptr.c
│ │ │ ├── glob_ptr-a.c
│ │ │ ├── glob_ptr.c
│ │ │ ├── global-init.c
│ │ │ ├── global1.c
│ │ │ ├── global10.c
│ │ │ ├── global2.c
│ │ │ ├── global3.c
│ │ │ ├── global4.c
│ │ │ ├── global5.c
│ │ │ ├── global6.c
│ │ │ ├── global7.c
│ │ │ ├── global8.c
│ │ │ ├── global9.c
│ │ │ ├── globalptr1.c
│ │ │ ├── globalptr2.c
│ │ │ ├── globalptr3.c
│ │ │ ├── globalptr4.c
│ │ │ ├── interprocedural1.c
│ │ │ ├── interprocedural2.c
│ │ │ ├── interprocedural3.c
│ │ │ ├── interprocedural4.c
│ │ │ ├── interprocedural5.c
│ │ │ ├── interprocedural6.c
│ │ │ ├── interprocedural7.c
│ │ │ ├── interprocedural8-a.c
│ │ │ ├── interprocedural8.c
│ │ │ ├── interprocedural8.output
│ │ │ ├── interprocedural9.c
│ │ │ ├── list1.c
│ │ │ ├── list2.c
│ │ │ ├── list3.c
│ │ │ ├── list4.c
│ │ │ ├── list5.c
│ │ │ ├── list6.c
│ │ │ ├── list7.c
│ │ │ ├── list8.c
│ │ │ ├── llvmmemcpy.c
│ │ │ ├── llvmmemcpy2.c
│ │ │ ├── loop1.c
│ │ │ ├── loop2.c
│ │ │ ├── loop3.c
│ │ │ ├── loop4.c
│ │ │ ├── loop5.c
│ │ │ ├── malloc-redef.c
│ │ │ ├── memcpy1.c
│ │ │ ├── memcpy2.c
│ │ │ ├── memcpy3.c
│ │ │ ├── memcpy4.c
│ │ │ ├── memcpy5.c
│ │ │ ├── memcpy6.c
│ │ │ ├── memset1.c
│ │ │ ├── negoffset1.c
│ │ │ ├── negoffset2.c
│ │ │ ├── negoffset3.c
│ │ │ ├── phi1.c
│ │ │ ├── phi2.c
│ │ │ ├── phi3.c
│ │ │ ├── phi4.c
│ │ │ ├── pointers1.c
│ │ │ ├── pointers2.c
│ │ │ ├── pointers3.c
│ │ │ ├── pointers4.c
│ │ │ ├── pointers5.c
│ │ │ ├── pointers6.c
│ │ │ ├── pointers7.c
│ │ │ ├── pta-inv-infinite-loop.c
│ │ │ ├── pta_fs_regression1.c
│ │ │ ├── pta_regression2.c
│ │ │ ├── ptr-9.c
│ │ │ ├── ptr.c
│ │ │ ├── ptrarray1.c
│ │ │ ├── ptrarray2.c
│ │ │ ├── ptrtoint1.c
│ │ │ ├── ptrtoint2.c
│ │ │ ├── ptrtoint3.c
│ │ │ ├── ptrtoint4.c
│ │ │ ├── ptrtoint5.c
│ │ │ ├── ptrtoint6.c
│ │ │ ├── ptrtoint7.c
│ │ │ ├── realloc1.c
│ │ │ ├── realloc2.c
│ │ │ ├── realloc3.c
│ │ │ ├── recursive1.c
│ │ │ ├── recursive2.c
│ │ │ ├── recursive3.c
│ │ │ ├── recursive4.c
│ │ │ ├── recursive5.c
│ │ │ ├── regression1.c
│ │ │ ├── sum1.c
│ │ │ ├── sum2.c
│ │ │ ├── sum3.c
│ │ │ ├── switch1.c
│ │ │ ├── switch2.c
│ │ │ ├── test1.c
│ │ │ ├── test2.c
│ │ │ ├── test22.c
│ │ │ ├── test222.c
│ │ │ ├── test3.c
│ │ │ ├── test4.c
│ │ │ ├── test5.c
│ │ │ ├── test6.c
│ │ │ ├── test7.c
│ │ │ ├── test8.c
│ │ │ ├── threads1.c
│ │ │ ├── undefcall1_true-unreach-call.c
│ │ │ ├── undefcall2_true-unreach-call.c
│ │ │ ├── unknown-interproc.c
│ │ │ ├── unknown-interproc2-a.c
│ │ │ ├── unknown-interproc2.c
│ │ │ ├── unknown-interproc3.c
│ │ │ ├── unknownptr1.c
│ │ │ ├── unknownptr10-a.c
│ │ │ ├── unknownptr10.c
│ │ │ ├── unknownptr11.c
│ │ │ ├── unknownptr2.c
│ │ │ ├── unknownptr3.c
│ │ │ ├── unknownptr4.c
│ │ │ ├── unknownptr5.c
│ │ │ ├── unknownptr6.c
│ │ │ ├── unknownptr7.c
│ │ │ ├── unknownptr8.c
│ │ │ ├── unknownptr9.c
│ │ │ ├── unknownptrfoo.c
│ │ │ ├── unknownptrfoo2.c
│ │ │ ├── vararg1.c
│ │ │ ├── vararg2.c
│ │ │ ├── vararg3.c
│ │ │ ├── vararg4.c
│ │ │ └── wl_list.c
│ │ ├── test-runner.py
│ │ ├── test_assert.c
│ │ ├── test_assert.h
│ │ └── tests.py
│ ├── slicing-stress.sh
│ ├── thread-regions-test-files/
│ │ ├── pthread_exit.c
│ │ └── simple.c
│ ├── thread-regions-test.cpp
│ └── value-relations-test.cpp
└── tools/
├── CMakeLists.txt
├── dgtool
├── git-version.h.in
├── include/
│ └── dg/
│ └── tools/
│ ├── llvm-slicer-opts.h
│ ├── llvm-slicer-preprocess.h
│ ├── llvm-slicer-utils.h
│ └── llvm-slicer.h
├── llvm-cda-bench.cpp
├── llvm-cda-dump.cpp
├── llvm-cda-stress.cpp
├── llvm-cg-dump.cpp
├── llvm-dda-dump.cpp
├── llvm-dg-dump.cpp
├── llvm-ntscd-dump.cpp
├── llvm-pta-ben.cpp
├── llvm-pta-compare.cpp
├── llvm-pta-dump.cpp
├── llvm-sdg-dump.cpp
├── llvm-slicer-crit.cpp
├── llvm-slicer-metadata.cpp
├── llvm-slicer-opts.cpp
├── llvm-slicer-preprocess.cpp
├── llvm-slicer-utils.cpp
├── llvm-slicer.cpp
├── llvm-thread-regions-dump.cpp
├── llvm-to-source.cpp
├── llvm-vr-dump.cpp
├── llvmdda-dump
├── llvmdg-show
├── pta-show
└── sliced-diff.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: false
AlignConsecutiveAssignments: false
AlignConsecutiveBitFields: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Empty
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 8
ContinuationIndentWidth: 8
Cpp11BracedListStyle: true
DeriveLineEnding: false
DerivePointerAlignment: false
DisableFormat: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IndentCaseLabels: false
IndentCaseBlocks: false
IndentGotoLabels: false
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentWidth: 4
IndentWrappedFunctionNames: false
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: Latest
TabWidth: 8
UseCRLF: false
UseTab: Never
...
================================================
FILE: .clang-tidy
================================================
---
# vim: syntax=yaml
# we might want to enable llvm-namespace-comment in the future
Checks: 'clang-diagnostic-*,clang-analyzer-*,modernize-*,-modernize-use-auto,-modernize-use-trailing-return-type,bugprone-*,llvm-*,-llvm-header-guard,-llvm-namespace-comment,misc-misplaced-const,misc-non-copyable-objects,misc-redundant-expression,misc-static-assert,misc-throw-by-value-catch-by-reference,misc-unconventional-assign-operator,misc-uniqueptr-reset-release,performace-*,readability-*,-readability-isolate-declaration,-readability-braces-around-statements,-readability-implicit-bool-conversion,-readability-static-accessed-through-instance,-readability-identifier-length'
WarningsAsErrors: ''
HeaderFilterRegex: 'include/|lib/|tools/'
AnalyzeTemporaryDtors: false
FormatStyle: file
CheckOptions:
- key: bugprone-argument-comment.CommentBoolLiterals
value: '0'
- key: bugprone-argument-comment.CommentCharacterLiterals
value: '0'
- key: bugprone-argument-comment.CommentFloatLiterals
value: '0'
- key: bugprone-argument-comment.CommentIntegerLiterals
value: '0'
- key: bugprone-argument-comment.CommentNullPtrs
value: '0'
- key: bugprone-argument-comment.CommentStringLiterals
value: '0'
- key: bugprone-argument-comment.CommentUserDefinedLiterals
value: '0'
- key: bugprone-argument-comment.IgnoreSingleArgument
value: '0'
- key: bugprone-argument-comment.StrictMode
value: '0'
- key: bugprone-assert-side-effect.AssertMacros
value: assert
- key: bugprone-assert-side-effect.CheckFunctionCalls
value: 'false'
- key: bugprone-dangling-handle.HandleClasses
value: 'std::basic_string_view;std::experimental::basic_string_view'
- key: bugprone-dynamic-static-initializers.HeaderFileExtensions
value: ';h;hh;hpp;hxx'
- key: bugprone-exception-escape.FunctionsThatShouldNotThrow
value: ''
- key: bugprone-exception-escape.IgnoredExceptions
value: ''
- key: bugprone-misplaced-widening-cast.CheckImplicitCasts
value: 'false'
- key: bugprone-narrowing-conversions.PedanticMode
value: 'false'
- key: bugprone-narrowing-conversions.WarnOnFloatingPointNarrowingConversion
value: 'true'
- key: bugprone-not-null-terminated-result.WantToUseSafeFunctions
value: 'true'
- key: bugprone-reserved-identifier.AggressiveDependentMemberLookup
value: 'false'
- key: bugprone-reserved-identifier.AllowedIdentifiers
value: ''
- key: bugprone-reserved-identifier.Invert
value: 'false'
- key: bugprone-signed-char-misuse.CharTypdefsToIgnore
value: ''
- key: bugprone-signed-char-misuse.DiagnoseSignedUnsignedCharComparisons
value: 'true'
- key: bugprone-sizeof-expression.WarnOnSizeOfCompareToConstant
value: 'true'
- key: bugprone-sizeof-expression.WarnOnSizeOfConstant
value: 'true'
- key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression
value: 'false'
- key: bugprone-sizeof-expression.WarnOnSizeOfThis
value: 'true'
- key: bugprone-string-constructor.LargeLengthThreshold
value: '8388608'
- key: bugprone-string-constructor.WarnOnLargeLength
value: 'true'
- key: bugprone-suspicious-enum-usage.StrictMode
value: 'false'
- key: bugprone-suspicious-include.HeaderFileExtensions
value: ';h;hh;hpp;hxx'
- key: bugprone-suspicious-include.ImplementationFileExtensions
value: 'c;cc;cpp;cxx'
- key: bugprone-suspicious-missing-comma.MaxConcatenatedTokens
value: '5'
- key: bugprone-suspicious-missing-comma.RatioThreshold
value: '0.200000'
- key: bugprone-suspicious-missing-comma.SizeThreshold
value: '5'
- key: bugprone-suspicious-string-compare.StringCompareLikeFunctions
value: ''
- key: bugprone-suspicious-string-compare.WarnOnImplicitComparison
value: 'true'
- key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison
value: 'false'
- key: bugprone-too-small-loop-variable.MagnitudeBitsUpperLimit
value: '16'
- key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField
value: 'true'
- key: bugprone-unused-return-value.CheckedFunctions
value: '::std::async;::std::launder;::std::remove;::std::remove_if;::std::unique;::std::unique_ptr::release;::std::basic_string::empty;::std::vector::empty;::std::back_inserter;::std::distance;::std::find;::std::find_if;::std::inserter;::std::lower_bound;::std::make_pair;::std::map::count;::std::map::find;::std::map::lower_bound;::std::multimap::equal_range;::std::multimap::upper_bound;::std::set::count;::std::set::find;::std::setfill;::std::setprecision;::std::setw;::std::upper_bound;::std::vector::at;::bsearch;::ferror;::feof;::isalnum;::isalpha;::isblank;::iscntrl;::isdigit;::isgraph;::islower;::isprint;::ispunct;::isspace;::isupper;::iswalnum;::iswprint;::iswspace;::isxdigit;::memchr;::memcmp;::strcmp;::strcoll;::strncmp;::strpbrk;::strrchr;::strspn;::strstr;::wcscmp;::access;::bind;::connect;::difftime;::dlsym;::fnmatch;::getaddrinfo;::getopt;::htonl;::htons;::iconv_open;::inet_addr;::isascii;::isatty;::mmap;::newlocale;::openat;::pathconf;::pthread_equal;::pthread_getspecific;::pthread_mutex_trylock;::readdir;::readlink;::recvmsg;::regexec;::scandir;::semget;::setjmp;::shm_open;::shmget;::sigismember;::strcasecmp;::strsignal;::ttyname'
- key: cert-dcl16-c.NewSuffixes
value: 'L;LL;LU;LLU'
- key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
value: '0'
- key: cert-str34-c.DiagnoseSignedUnsignedCharComparisons
value: '0'
- key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
value: '1'
- key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
value: '1'
- key: google-readability-braces-around-statements.ShortStatementLines
value: '1'
- key: google-readability-function-size.StatementThreshold
value: '800'
- key: google-readability-namespace-comments.ShortNamespaceLines
value: '10'
- key: google-readability-namespace-comments.SpacesBeforeComments
value: '2'
- key: llvm-else-after-return.WarnOnConditionVariables
value: 'false'
- key: llvm-else-after-return.WarnOnUnfixable
value: 'false'
- key: llvm-header-guard.HeaderFileExtensions
value: ';h;hh;hpp;hxx'
- key: llvm-namespace-comment.ShortNamespaceLines
value: '1'
- key: llvm-namespace-comment.SpacesBeforeComments
value: '1'
- key: llvm-qualified-auto.AddConstToQualified
value: 'false'
- key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
value: 'false'
- key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables
value: 'false'
- key: misc-throw-by-value-catch-by-reference.CheckThrowTemporaries
value: 'true'
- key: misc-throw-by-value-catch-by-reference.WarnOnLargeObjects
value: 'false'
- key: modernize-avoid-bind.PermissiveParameterList
value: 'false'
- key: modernize-loop-convert.MaxCopySize
value: '16'
- key: modernize-loop-convert.MinConfidence
value: reasonable
- key: modernize-loop-convert.NamingStyle
value: CamelCase
- key: modernize-make-shared.IgnoreMacros
value: 'true'
- key: modernize-make-shared.IncludeStyle
value: llvm
- key: modernize-make-shared.MakeSmartPtrFunction
value: 'std::make_shared'
- key: modernize-make-shared.MakeSmartPtrFunctionHeader
value: memory
- key: modernize-make-unique.IgnoreMacros
value: 'true'
- key: modernize-make-unique.IncludeStyle
value: llvm
- key: modernize-make-unique.MakeSmartPtrFunction
value: 'std::make_unique'
- key: modernize-make-unique.MakeSmartPtrFunctionHeader
value: memory
- key: modernize-pass-by-value.IncludeStyle
value: llvm
- key: modernize-pass-by-value.ValuesOnly
value: 'false'
- key: modernize-raw-string-literal.DelimiterStem
value: lit
- key: modernize-raw-string-literal.ReplaceShorterLiterals
value: 'false'
- key: modernize-replace-auto-ptr.IncludeStyle
value: llvm
- key: modernize-replace-disallow-copy-and-assign-macro.MacroName
value: DISALLOW_COPY_AND_ASSIGN
- key: modernize-replace-random-shuffle.IncludeStyle
value: llvm
- key: modernize-use-bool-literals.IgnoreMacros
value: 'true'
- key: modernize-use-default-member-init.IgnoreMacros
value: 'true'
- key: modernize-use-default-member-init.UseAssignment
value: 'false'
- key: modernize-use-emplace.ContainersWithPushBack
value: '::std::vector;::std::list;::std::deque'
- key: modernize-use-emplace.IgnoreImplicitConstructors
value: 'false'
- key: modernize-use-emplace.SmartPointers
value: '::std::shared_ptr;::std::unique_ptr;::std::auto_ptr;::std::weak_ptr'
- key: modernize-use-emplace.TupleMakeFunctions
value: '::std::make_pair;::std::make_tuple'
- key: modernize-use-emplace.TupleTypes
value: '::std::pair;::std::tuple'
- key: modernize-use-equals-default.IgnoreMacros
value: 'true'
- key: modernize-use-equals-delete.IgnoreMacros
value: 'true'
- key: modernize-use-nodiscard.ReplacementString
value: '[[nodiscard]]'
- key: modernize-use-noexcept.ReplacementString
value: ''
- key: modernize-use-noexcept.UseNoexceptFalse
value: 'true'
- key: modernize-use-nullptr.NullMacros
value: 'NULL'
- key: modernize-use-override.AllowOverrideAndFinal
value: 'false'
- key: modernize-use-override.FinalSpelling
value: final
- key: modernize-use-override.IgnoreDestructors
value: 'false'
- key: modernize-use-override.OverrideSpelling
value: override
- key: modernize-use-transparent-functors.SafeMode
value: 'false'
- key: modernize-use-using.IgnoreMacros
value: 'true'
- key: readability-braces-around-statements.ShortStatementLines
value: '0'
- key: readability-else-after-return.WarnOnConditionVariables
value: 'true'
- key: readability-else-after-return.WarnOnUnfixable
value: 'true'
- key: readability-function-size.BranchThreshold
value: '4294967295'
- key: readability-function-size.LineThreshold
value: '4294967295'
- key: readability-function-size.NestingThreshold
value: '4294967295'
- key: readability-function-size.ParameterThreshold
value: '4294967295'
- key: readability-function-size.StatementThreshold
value: '800'
- key: readability-function-size.VariableThreshold
value: '4294967295'
- key: readability-identifier-naming.AggressiveDependentMemberLookup
value: 'false'
- key: readability-identifier-naming.IgnoreFailedSplit
value: 'false'
- key: readability-identifier-naming.IgnoreMainLikeFunctions
value: 'false'
- key: readability-implicit-bool-conversion.AllowIntegerConditions
value: 'true'
- key: readability-implicit-bool-conversion.AllowPointerConditions
value: 'true'
- key: readability-inconsistent-declaration-parameter-name.IgnoreMacros
value: 'true'
- key: readability-inconsistent-declaration-parameter-name.Strict
value: 'false'
- key: readability-magic-numbers.IgnoreAllFloatingPointValues
value: 'false'
- key: readability-magic-numbers.IgnoreBitFieldsWidths
value: 'true'
- key: readability-magic-numbers.IgnorePowersOf2IntegerValues
value: 'false'
- key: readability-magic-numbers.IgnoredFloatingPointValues
value: '1.0;100.0;'
- key: readability-magic-numbers.IgnoredIntegerValues
value: '1;2;3;4;'
- key: readability-qualified-auto.AddConstToQualified
value: 'true'
- key: readability-redundant-declaration.IgnoreMacros
value: 'true'
- key: readability-redundant-member-init.IgnoreBaseInCopyConstructors
value: 'false'
- key: readability-redundant-smartptr-get.IgnoreMacros
value: 'true'
- key: readability-redundant-string-init.StringNames
value: '::std::basic_string'
- key: readability-simplify-boolean-expr.ChainedConditionalAssignment
value: 'false'
- key: readability-simplify-boolean-expr.ChainedConditionalReturn
value: 'false'
- key: readability-simplify-subscript-expr.Types
value: '::std::basic_string;::std::basic_string_view;::std::vector;::std::array'
- key: readability-static-accessed-through-instance.NameSpecifierNestingThreshold
value: '3'
- key: readability-uppercase-literal-suffix.IgnoreMacros
value: 'true'
- key: readability-uppercase-literal-suffix.NewSuffixes
value: ''
...
================================================
FILE: .git-blame-ignore-revs
================================================
# Reformat the whole project
2e60545c73a872b95d3c32a097e351ed9bfd8bf6
a69378f4f29a63d28cb79e0d6728d069353b19c8
================================================
FILE: .github/workflows/clang-format.yml
================================================
---
name: Find unformatted files
on: [push, pull_request]
jobs:
Format:
name: Find unformatted files
runs-on: ubuntu-22.04
steps:
- name: Checkout DG
uses: actions/checkout@v3
- name: Install clang-format 14
run: |
sudo apt install clang-format-14
- name: Find unformatted files
# Based on https://rigtorp.se/notes/clang-format/.
run: |
set -o pipefail
find . -regextype posix-extended \
-iregex '\./(include|lib|tests|tools)/.*\.(h|c|cpp|hpp)' \
-o -iregex '\./tests/catch2' -prune -type f | \
xargs clang-format-14 --style=file --dry-run -Werror --color=true
================================================
FILE: .github/workflows/docker.yml
================================================
---
name: Docker Image
on:
[push, pull_request]
jobs:
Docker:
runs-on: ubuntu-latest
steps:
- name: Checkout DG
uses: actions/checkout@v3
- name: Build the Docker image
run: |
docker build . --file Dockerfile \
--build-arg GIT_REF=$GITHUB_REF \
--build-arg GIT_REPO=$GITHUB_REPOSITORY \
--tag dg:$(date +%s)
================================================
FILE: .github/workflows/hash_map.yml
================================================
---
name: DG + External Hash Maps
on: [push, pull_request]
jobs:
Ubuntu:
strategy:
fail-fast: false
matrix:
os: [ubuntu-20.04]
compiler: [gcc, clang]
hashmap: [tsl-hopscotch]
runs-on: ${{matrix.os}}
env:
# for colours in ninja
CLICOLOR_FORCE: 1
steps:
- name: Checkout DG
uses: actions/checkout@v3
- name: Checkout TSL Hopscotch
uses: actions/checkout@v3
with:
repository: Tessil/hopscotch-map
path: tsl-hopscotch
- name: Install dependencies
run: |
sudo apt update
sudo apt install ccache cmake ninja-build clang-10 llvm-10-dev
- name: Set environment
id: env
run: |
# set expected name of selected hashmap
case "${{matrix.hashmap}}" in
"tsl-hopscotch") echo "HASHMAP=TSL_HOPSCOTCH_DIR" >> $GITHUB_ENV;;
*) echo "Unknown hashmap selected." && exit 1;;
esac
if [[ "${{matrix.compiler}}" = "clang" ]]; then
echo "CC=clang-10" >> $GITHUB_ENV
echo "CXX=clang++-10" >> $GITHUB_ENV
# force coloured output
echo "CFLAGS=$CFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
echo "CXXFLAGS=$CXXFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
else
echo "CC=gcc" >> $GITHUB_ENV
echo "CXX=g++" >> $GITHUB_ENV
# force coloured output
echo "CFLAGS=$CFLAGS -fdiagnostics-color=always" >> $GITHUB_ENV
echo "CXXFLAGS=$CXXFLAGS -fdiagnostics-color=always" >> $GITHUB_ENV
fi
# set up ccache
sudo /usr/sbin/update-ccache-symlinks
echo "/usr/lib/ccache" >> $GITHUB_PATH
echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> $GITHUB_ENV
echo "CCACHE_COMPRESS=true" >> $GITHUB_ENV
echo "CCACHE_COMPRESSLEVEL=6" >> $GITHUB_ENV
echo "CCACHE_MAXSIZE=400M" >> $GITHUB_ENV
echo "::set-output name=timestamp::$(date -u -Iseconds)"
- name: Set up ccache
uses: actions/cache@v3
with:
path: .ccache
key: ${{matrix.os}}-${{matrix.hashmap}}-${{matrix.compiler}}-${{steps.env.outputs.timestamp}}
restore-keys: ${{matrix.os}}-${{matrix.hashmap}}-${{matrix.compiler}}
- name: Configure CMake project
run: |
cmake -S. \
-B_build \
-GNinja \
-DUSE_SANITIZERS:BOOL=ON \
-DLLVM_DIR:PATH="$(llvm-config-10 --cmakedir)" \
-D${HASHMAP}:PATH="$GITHUB_WORKSPACE/${{matrix.hashmap}}"
- name: Build
run: cmake --build _build
- name: Run tests
# TODO: turn off the detection of leaks, we're working on it
run: ASAN_OPTIONS=detect_leaks=0 cmake --build _build --target check
- name: ccache statistics
run: ccache -s
================================================
FILE: .github/workflows/linux.yml
================================================
---
name: Linux CI
on: [push, pull_request]
jobs:
build64:
name: Ubuntu 64-bit
strategy:
fail-fast: false
matrix:
include:
# Linux with GCC
- {os: ubuntu-18.04, llvm: '3.9', compiler: gcc}
- {os: ubuntu-18.04, llvm: '4.0', compiler: gcc}
- {os: ubuntu-18.04, llvm: '5.0', compiler: gcc}
- {os: ubuntu-18.04, llvm: '6.0', compiler: gcc}
- {os: ubuntu-18.04, llvm: 7, compiler: gcc}
- {os: ubuntu-18.04, llvm: 8, compiler: gcc}
- {os: ubuntu-18.04, llvm: 9, compiler: gcc}
- {os: ubuntu-20.04, llvm: 10, compiler: gcc}
- {os: ubuntu-20.04, llvm: 11, compiler: gcc}
- {os: ubuntu-20.04, llvm: 12, compiler: gcc}
- {os: ubuntu-22.04, llvm: 13, compiler: gcc}
- {os: ubuntu-22.04, llvm: 14, compiler: gcc}
- {os: ubuntu-22.04, llvm: 14, compiler: gcc, type: Debug}
# Linux with Clang
- {os: ubuntu-18.04, llvm: '3.9', compiler: clang}
- {os: ubuntu-18.04, llvm: '4.0', compiler: clang}
- {os: ubuntu-18.04, llvm: '5.0', compiler: clang}
- {os: ubuntu-18.04, llvm: '6.0', compiler: clang}
- {os: ubuntu-18.04, llvm: 7, compiler: clang}
- {os: ubuntu-18.04, llvm: 8, compiler: clang}
- {os: ubuntu-18.04, llvm: 9, compiler: clang}
- {os: ubuntu-20.04, llvm: 10, compiler: clang}
- {os: ubuntu-20.04, llvm: 11, compiler: clang}
- {os: ubuntu-20.04, llvm: 12, compiler: clang}
- {os: ubuntu-22.04, llvm: 13, compiler: clang}
- {os: ubuntu-22.04, llvm: 14, compiler: clang}
- {os: ubuntu-22.04, llvm: 14, compiler: clang, type: Debug}
runs-on: ${{matrix.os}}
env:
# for colours in ninja
CLICOLOR_FORCE: 1
steps:
- name: Checkout DG
uses: actions/checkout@v3
- name: '[LLVM ${{matrix.llvm}}] Add repositories'
if: matrix.llvm >= 15
run: |
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
sudo apt-add-repository "deb https://apt.llvm.org/jammy/ llvm-toolchain-jammy-${{matrix.llvm}} main"
- name: Install dependencies
run: |
sudo apt update
sudo apt install ccache cmake ninja-build clang-${{matrix.llvm}} \
llvm-${{matrix.llvm}}-dev
- name: Set environment
id: env
run: |
if [[ "${{matrix.compiler}}" = "clang" ]]; then
echo "CC=clang-${{matrix.llvm}}" >> $GITHUB_ENV
echo "CXX=clang++-${{matrix.llvm}}" >> $GITHUB_ENV
# force coloured output
echo "CFLAGS=$CFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
echo "CXXFLAGS=$CXXFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
else
echo "CC=gcc" >> $GITHUB_ENV
echo "CXX=g++" >> $GITHUB_ENV
# force coloured output
echo "CFLAGS=$CFLAGS -fdiagnostics-color=always" >> $GITHUB_ENV
echo "CXXFLAGS=$CXXFLAGS -fdiagnostics-color=always" >> $GITHUB_ENV
fi
# set up ccache
sudo /usr/sbin/update-ccache-symlinks
echo "/usr/lib/ccache" >> $GITHUB_PATH
# Bionic does not create symlinks to versioned clang
sudo ln -sfr /usr/bin/ccache /usr/lib/ccache/clang-${{matrix.llvm}}
sudo ln -sfr /usr/bin/ccache /usr/lib/ccache/clang++-${{matrix.llvm}}
echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> $GITHUB_ENV
echo "CCACHE_COMPRESS=true" >> $GITHUB_ENV
echo "CCACHE_COMPRESSLEVEL=6" >> $GITHUB_ENV
echo "CCACHE_MAXSIZE=400M" >> $GITHUB_ENV
echo "::set-output name=timestamp::$(date -u -Iseconds)"
- name: Set up ccache
uses: actions/cache@v3
with:
path: .ccache
key: ${{matrix.os}}-${{matrix.llvm}}-${{matrix.compiler}}-${{matrix.type}}-${{steps.env.outputs.timestamp}}
restore-keys: ${{matrix.os}}-${{matrix.llvm}}-${{matrix.compiler}}-${{matrix.type}}
- name: '[Dynamic LLVM] Configure CMake project'
run: |
cmake -S. \
-B_build \
-GNinja \
-DCMAKE_BUILD_TYPE:STRING="${{matrix.type}}" \
-DUSE_SANITIZERS:BOOL=ON \
-DLLVM_DIR:PATH="/usr/lib/llvm-${{matrix.llvm}}/lib/cmake/llvm"
# llvm-config-3.9 does not take --cmakedir yet!
- name: '[Dynamic LLVM] Build'
run: cmake --build _build
- name: '[Dynamic LLVM] Run tests'
# TODO: turn off the detection of leaks, we're working on it
run: ASAN_OPTIONS=detect_leaks=0 cmake --build _build --target check
- name: '[Static LLVM] Re-configure CMake project'
run: |
cmake -S. \
-B_build \
-DLLVM_LINK_DYLIB:BOOL=OFF
cmake --build _build --target clean
- name: '[Static LLVM] Build'
run: cmake --build _build
- name: '[Static LLVM] Run tests'
# TODO: turn off the detection of leaks, we're working on it
run: ASAN_OPTIONS=detect_leaks=0 cmake --build _build --target check
- name: ccache statistics
run: ccache -s
# Warning: untested and incomplete
#
# build32:
# name: Ubuntu 32-bit
# runs-on: ubuntu-20.04
# container: ubuntu:latest
#
# strategy:
# fail-fast: false
# matrix:
# compiler: [gcc, clang]
# build_type: [Debug, Release]
#
# steps:
# - uses: actions/checkout@v2
# - name: Install dependencies
# run: |
# dpkg --add-architecture i386
# apt update
# apt install -y cmake ninja-build clang:i386 llvm-dev:i386 libc-dev:i386
#
# - name: Set environment
# run: |
# CFLAGS="$CFLAGS -m32"
# CXXFLAGS="$CXXFLAGS -m32"
#
# if [[ "${{matrix.compiler}}" = "clang" ]]; then
# echo "CC=clang" >> $GITHUB_ENV
# echo "CXX=clang++" >> $GITHUB_ENV
#
# # force coloured output
# echo "CFLAGS=$CFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
# echo "CXXFLAGS=$CXXFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
# else
# echo "CC=gcc" >> $GITHUB_ENV
# echo "CXX=g++" >> $GITHUB_ENV
#
# # force coloured output
# echo "CFLAGS=$CFLAGS -fdiagnostics-color" >> $GITHUB_ENV
# echo "CXXFLAGS=$CXXFLAGS -fdiagnostics-color" >> $GITHUB_ENV
# fi
#
# - name: Configure CMake project
# run: |
# cmake -Bbuild -S. \
# -GNinja \
# -DUSE_SANITIZERS=ON \
# -DCMAKE_BUILD_TYPE='${{matrix.build_type}}'
#
# - name: Build
# run: ninja -C build
#
# - name: Run tests
# # TODO: turn off the detection of leaks, we're working on it
# run: ASAN_OPTIONS=detect_leaks=0 ninja check -C build
================================================
FILE: .github/workflows/mac.yml
================================================
---
name: macOS CI
on: [push, pull_request]
jobs:
build:
name: macOS
strategy:
fail-fast: false
matrix:
os: [macos-12]
build: [Debug, RelWithDebInfo]
runs-on: ${{matrix.os}}
env:
# for colours in ninja
CLICOLOR_FORCE: 1
steps:
- name: Checkout DG
uses: actions/checkout@v3
- name: Install dependencies
run: brew install ninja ccache llvm@14
- name: Set environment
id: env
run: |
echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> $GITHUB_ENV
echo "CCACHE_COMPRESS=true" >> $GITHUB_ENV
echo "CCACHE_COMPRESSLEVEL=6" >> $GITHUB_ENV
echo "CCACHE_MAXSIZE=400M" >> $GITHUB_ENV
echo "/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
echo "::set-output name=timestamp::$(date -u +%Y-%m-%dT%H:%M:%S%z)"
- name: Set-up ccache
uses: actions/cache@v3
with:
path: .ccache
key: ${{matrix.os}}-${{matrix.build}}-${{steps.env.outputs.timestamp}}
restore-keys: ${{matrix.os}}-${{matrix.build}}
- name: Configure CMake project
run: |
cmake -S. \
-B_build \
-GNinja \
-DCMAKE_BUILD_TYPE:STRING=${{matrix.build}} \
-DUSE_SANITIZERS:BOOL=ON \
-DLLVM_DIR:PATH="$($(brew --prefix llvm@14)/bin/llvm-config --cmakedir)"
env:
# for coloured output
CFLAGS: -fcolor-diagnostics
CXXFLAGS: -fcolor-diagnostics
- name: Build
run: cmake --build _build
- name: Run tests
# TODO: turn off the detection of leaks, we're working on it
run: ASAN_OPTIONS=detect_leaks=0 cmake --build _build --target check
- name: ccache statistics
run: ccache -s
================================================
FILE: .github/workflows/svf.yml
================================================
---
name: DG + SVF
on: [push, pull_request]
jobs:
Ubuntu:
strategy:
fail-fast: false
matrix:
os: [ubuntu-22.04]
compiler: [gcc, clang]
runs-on: ${{matrix.os}}
env:
# for colours in ninja
CLICOLOR_FORCE: 1
steps:
- name: Checkout DG
uses: actions/checkout@v3
- name: Checkout SVF
uses: actions/checkout@v3
with:
ref: SVF-2.4
repository: SVF-tools/SVF
path: svf
- name: Checkout SVF test-suite
uses: actions/checkout@v3
with:
# ref corresponding to the SVF ref above
ref: 2338ede904c1f46293b64ccf32feb09b3904401f
repository: SVF-tools/Test-Suite
path: svf/Test-Suite
- name: Install dependencies
run: |
sudo apt update
sudo apt install ccache cmake ninja-build clang-13 llvm-13-dev \
libz3-dev
- name: Set environment
id: env
run: |
if [[ "${{matrix.compiler}}" = "clang" ]]; then
echo "CC=clang-13" >> $GITHUB_ENV
echo "CXX=clang++-13" >> $GITHUB_ENV
# force coloured output
echo "CFLAGS=$CFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
echo "CXXFLAGS=$CXXFLAGS -fcolor-diagnostics" >> $GITHUB_ENV
else
echo "CC=gcc" >> $GITHUB_ENV
echo "CXX=g++" >> $GITHUB_ENV
# force coloured output
echo "CFLAGS=$CFLAGS -fdiagnostics-color=always" >> $GITHUB_ENV
echo "CXXFLAGS=$CXXFLAGS -fdiagnostics-color=always" >> $GITHUB_ENV
fi
# set up ccache
sudo /usr/sbin/update-ccache-symlinks
echo "/usr/lib/ccache" >> $GITHUB_PATH
echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> $GITHUB_ENV
echo "CCACHE_COMPRESS=true" >> $GITHUB_ENV
echo "CCACHE_COMPRESSLEVEL=6" >> $GITHUB_ENV
echo "CCACHE_MAXSIZE=400M" >> $GITHUB_ENV
echo "::set-output name=timestamp::$(date -u -Iseconds)"
- name: Set up ccache
uses: actions/cache@v3
with:
path: .ccache
key: ${{matrix.os}}-svf-${{matrix.compiler}}-${{steps.env.outputs.timestamp}}
restore-keys: ${{matrix.os}}-svf-${{matrix.compiler}}
- name: Build SVF
run: |
# Build directory name format is hard-coded in SVF tests...
# do not build with -Werror (needed for GCC 11.2.0)
sed -i 's/-Werror//' svf/CMakeLists.txt
# WARNING: DO NOT SET CMAKE_BUILD_TYPE! (except Debug)
# SVF expects that NDEBUG will never be defined!
cmake -Ssvf \
-Bsvf/Release-build \
-GNinja \
-DLLVM_DIR:PATH="$(llvm-config-13 --cmakedir)"
cmake --build svf/Release-build
(cd svf/Release-build && \
PATH="$(llvm-config-13 --bindir):$PATH" \
ctest --progress --output-on-failure)
- name: '[Dynamic LLVM] Configure CMake project'
run: |
cmake -S. \
-B_build \
-GNinja \
-DUSE_SANITIZERS:BOOL=ON \
-DLLVM_DIR:PATH="$(llvm-config-13 --cmakedir)" \
-DSVF_DIR:PATH="$GITHUB_WORKSPACE/svf/Release-build"
- name: '[Dynamic LLVM] Build'
run: cmake --build _build
- name: '[Dynamic LLVM] Run tests'
# TODO: turn off the detection of leaks, we're working on it
run: ASAN_OPTIONS=detect_leaks=0 cmake --build _build --target check
- name: '[Static LLVM] Re-configure CMake project'
run: |
cmake -S. \
-B_build \
-DLLVM_LINK_DYLIB:BOOL=OFF
cmake --build _build --target clean
- name: '[Static LLVM] Build'
run: cmake --build _build
- name: '[Static LLVM] Run tests'
# TODO: turn off the detection of leaks, we're working on it
run: ASAN_OPTIONS=detect_leaks=0 cmake --build _build --target check
- name: ccache statistics
run: ccache -s
================================================
FILE: .gitignore
================================================
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
# cmake
*.cmake
*Makefile*
# swp files
*.swp
*.swo
*.swm
# vim config files
*.vimrc
tags
*/tags
*/cscope.out
*.swn
*.dot
*.ps
# LLVM files
*.bc
*.sliced
*.linked
*.opt
*.ll
*.i
tests/*-test
tests/fuzzing/regressions/
# clangd
.cache
.clangd
# pycache
__pycache__
# C files in tools are test codes
tools/*.c
tools/*.bc
tools/llvm-dg-dump
tools/llvm-to-source
tools/llvm-slicer
git-version.h
# build directory
build
# sourcetrail files
dg.srctrl*
compile_commands.json
CMakeLists.txt.user*
================================================
FILE: .travis.yml
================================================
language: cpp
sudo: true
dist: trusty
git:
depth: 1
addons:
apt:
sources:
# newer gcc and clang
- ubuntu-toolchain-r-test
- sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-4.0 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main'
packages:
- libz-dev
env:
- LLVM=3.8 BUILD_TYPE=Release
- LLVM=3.8 BUILD_TYPE=Debug
- LLVM=4.0 BUILD_TYPE=Release
- LLVM=4.0 BUILD_TYPE=Debug
- LLVM=5.0 BUILD_TYPE=Release
- LLVM=5.0 BUILD_TYPE=Debug
compiler:
- 'clang++'
- 'g++'
- 'g++-5'
install:
- git clone --depth 1 https://github.com/tomsik68/travis-llvm.git
- cd travis-llvm
- chmod +x travis-llvm.sh
- ./travis-llvm.sh ${LLVM}
- cd ..
script:
- cmake -DCMAKE_BUILD_TYPE="$BUILD_TYPE" -DUSE_SANITIZERS=ON .
- make -j2
# for now turn off the detection of leaks, we're working on it
- ASAN_OPTIONS=detect_leaks=0 make check -j2
notifications:
email: false
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.1)
# FIXME: Unfortunately, C is (at least temporarily) required due to a bug
# in LLVM 14. See https://github.com/llvm/llvm-project/issues/53950.
project(dg LANGUAGES C CXX)
include(CTest)
# we need at least C++11 standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
OPTION(LLVM_DG "Support for LLVM Dependency graph" ON)
OPTION(ENABLE_CFG "Add support for CFG edges to the graph" ON)
OPTION(NO_EXCEPTIONS "Compile with -fno-exceptions (ON by default)" ON)
if(NOT CMAKE_BUILD_TYPE)
message(STATUS "Build type not set. Setting default.")
set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "" FORCE)
endif()
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "RelWithDebInfo"
"MinSizeRel" "Release")
if (LLVM_DG)
# for llvm dg we need cfg and postdom edges
if (NOT ENABLE_CFG)
message(STATUS "Enabling CFG edges due to llvm dg")
endif()
set(ENABLE_CFG ON)
find_package(LLVM REQUIRED CONFIG)
message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
message(STATUS "LLVM binaries: ${LLVM_TOOLS_BINARY_DIR}")
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${LLVM_DIR}")
include(LLVMConfig)
include(AddLLVM)
message(STATUS "LLVM include dir: ${LLVM_INCLUDE_DIRS}")
message(STATUS "LLVM libraries dir: ${LLVM_LIBRARY_DIRS}")
message(STATUS "LLVM definitions: ${LLVM_DEFINITIONS}")
# if we were provided a path to custom sources
# use that path
if (LLVM_SRC_PATH)
include_directories(SYSTEM ${LLVM_SRC_PATH}/include)
message(STATUS "Looking for headers in given: ${LLVM_SRC_PATH}/include")
else()
include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
message(STATUS "Looking for headers in: ${LLVM_INCLUDE_DIRS}")
endif()
# if we were provided a path to custom build directory
# use that
if (LLVM_BUILD_PATH)
link_directories(${LLVM_BUILD_PATH}/lib)
# llvm-config.h
include_directories(SYSTEM "${LLVM_BUILD_PATH}/include")
message(STATUS "Looking for libraries in given: ${LLVM_BUILD_PATH}/lib")
else()
link_directories(${LLVM_LIBRARY_DIRS})
message(STATUS "Looking for libraries in: ${LLVM_LIBRARY_DIRS}")
endif(LLVM_BUILD_PATH)
add_definitions(${LLVM_DEFINITIONS})
option(LLVM_LINK_DYLIB "Link with LLVM dynamically" ON)
if (LLVM_LINK_DYLIB)
message(STATUS "LLVM linking: dynamic")
if (${LLVM_PACKAGE_VERSION} VERSION_LESS "3.8")
set(llvm LLVM-${LLVM_PACKAGE_VERSION})
else()
# only LLVM 3.8+ provide unversioned library
set(llvm LLVM)
endif()
else()
message(STATUS "LLVM linking: static")
if (${LLVM_PACKAGE_VERSION} VERSION_GREATER "3.4")
llvm_map_components_to_libnames(llvm_analysis analysis)
llvm_map_components_to_libnames(llvm_irreader irreader)
llvm_map_components_to_libnames(llvm_bitwriter bitwriter)
else()
llvm_map_components_to_libraries(llvm_irreader irreader)
llvm_map_components_to_libraries(llvm_bitwriter bitwriter)
llvm_map_components_to_libraries(llvm_analysis analysis)
endif()
endif()
# LLVM 10 and newer require at least c++14 standard
if (${LLVM_PACKAGE_VERSION} VERSION_GREATER "9.0")
set(CMAKE_CXX_STANDARD 14)
option(USE_CXX14 "Use C++14 standard" ON)
endif()
endif(LLVM_DG)
if (SVF_DIR)
set(HAVE_SVF ON)
add_definitions(-DHAVE_SVF)
set(SVF_LIBDIR ${SVF_DIR}/lib)
if (NOT SVF_INCLUDE)
if (EXISTS "${SVF_DIR}/include/WPA/Andersen.h")
set(SVF_INCLUDE ${SVF_DIR}/include)
elseif (EXISTS "${SVF_DIR}/../include/WPA/Andersen.h")
set(SVF_INCLUDE ${SVF_DIR}/../include)
else()
message(FATAL_ERROR "Did not find the directory with SVF headers")
endif()
endif()
set(SVF_LIBS Svf Cudd)
include_directories(SYSTEM ${SVF_INCLUDE})
link_directories(${SVF_LIBDIR} ${SVF_LIBDIR}/CUDD)
if (NOT LLVM_LINK_DYLIB)
if (${LLVM_PACKAGE_VERSION} VERSION_GREATER "3.4")
llvm_map_components_to_libnames(llvm_transformutils transformutils)
else()
llvm_map_components_to_libraries(llvm_transformutils transformutils)
endif()
endif()
message(STATUS "SVF dir: ${SVF_DIR}")
message(STATUS "SVF libraries dir: ${SVF_LIBDIR}")
message(STATUS "SVF include dir: ${SVF_INCLUDE}")
message(STATUS "SVF libs: ${SVF_LIBS}")
endif(SVF_DIR)
if (TSL_HOPSCOTCH_DIR)
set(HOPSCOTCH_DIR ${TSL_HOPSCOTCH_DIR}/include/)
if (NOT EXISTS "${HOPSCOTCH_DIR}/tsl/hopscotch_map.h")
message(FATAL_ERROR "Tessil hopscotch map NOT FOUND in ${TSL_HOPSCOTCH_DIR}" )
endif()
include_directories(SYSTEM ${HOPSCOTCH_DIR})
message(STATUS "Found Tessil Hopscotch map in ${HOPSCOTCH_DIR}" )
message(STATUS "Adding include dir ${HOPSCOTCH_DIR}")
add_definitions(-DHAVE_TSL_HOPSCOTCH)
endif()
if (ENABLE_CFG)
add_definitions(-DENABLE_CFG)
endif()
message(STATUS "Using compiler: ${CMAKE_CXX_COMPILER}")
# --------------------------------------------------
# Fuzzing
# --------------------------------------------------
include(CheckCXXCompilerFlag)
set(CMAKE_REQUIRED_FLAGS "-fsanitize=fuzzer")
check_cxx_source_compiles(
"#include <cstddef>
extern \"C\" int LLVMFuzzerTestOneInput(const void *, size_t) { return 0; }"
HAS_FUZZER)
set(CMAKE_REQUIRED_FLAGS "")
option(ENABLE_FUZZING "Enable fuzzing tests" ${HAS_FUZZER})
if(NOT ENABLE_FUZZING)
message(STATUS "Will NOT build fuzzing tests (requires Clang 6 or newer)")
endif()
# --------------------------------------------------
# clang-tidy
# --------------------------------------------------
option(USE_CLANG_TIDY "Enable clang-tidy checks" OFF)
if(USE_CLANG_TIDY)
message(STATUS "Clang-tidy build enabled")
# read config from .clang-tidy
set(CMAKE_CXX_CLANG_TIDY "clang-tidy;--config=")
endif()
# --------------------------------------------------
# Compiler flags
# --------------------------------------------------
# explicitly add -std=c++11 (-std=c++14) and -fno-rtti
# we have CMAKE_CXX_STANDARD, but for some reason it does not
# put the -std=c++11 (-std=c++14) or -std=gnu++11 (-std=gnu++14)
# to the flags on some systems.
# For the -fno-rtti: LLVM still got problems with turning RTTI off...
if (USE_CXX14)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -Wall -Wextra")
if (NO_EXCEPTIONS)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
endif()
if (USE_SANITIZERS)
set(CMAKE_REQUIRED_FLAGS "-fsanitize=undefined,address") # for linker
check_cxx_compiler_flag("-fsanitize=undefined,address" sanitizers_work)
set(CMAKE_REQUIRED_FLAGS "")
if (sanitizers_work)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined,address")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fno-omit-frame-pointer")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-sanitize-recover=all")
add_definitions(-DUSING_SANITIZERS)
else()
message(WARNING "Used compiler does not support sanitizers or its support is incomplete.")
endif()
endif()
# Debug Release RelWithDebInfo MinSizeRel.
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
add_definitions(-DDEBUG_ENABLED)
message(STATUS "Using compilation flags: ${CMAKE_CXX_FLAGS_DEBUG}")
elseif (CMAKE_BUILD_TYPE STREQUAL "Release")
message(STATUS "Using compilation flags: ${CMAKE_CXX_FLAGS_RELEASE}")
elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
message(STATUS
"Using compilation flags: ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
elseif (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
message(STATUS "Using compilation flags: ${CMAKE_CXX_FLAGS_MINSIZEREL}")
endif ()
message(STATUS "Additional compilation flags: ${CMAKE_CXX_FLAGS}")
include(GNUInstallDirs)
message(STATUS "CMAKE_INSTALL_LIBDIR: \"${CMAKE_INSTALL_LIBDIR}\"")
message(STATUS "CMAKE_INSTALL_INCLUDEDIR: \"${CMAKE_INSTALL_INCLUDEDIR}\"")
include_directories(include)
include_directories(lib)
add_subdirectory(lib)
add_subdirectory(tools)
add_subdirectory(tests EXCLUDE_FROM_ALL)
if(NOT LLVM_DG)
set(INSTALL_EXCLUDE_PATTERNS PATTERN "llvm" EXCLUDE)
endif()
install(DIRECTORY include/
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
${INSTALL_EXCLUDE_PATTERNS})
================================================
FILE: Changelog
================================================
-- 3. 10. 2018
* The project was re-structured from src/ structure to lib/ and include/
structure. As a consequence, all public headers were moved to dg/
subdirectory, e.g. "llvm/LLVMDependenceGraph.h" is now
"dg/llvm/LLVMDependenceGraph.h"
* Renamed files:
- llvm/Slicer.h -> dg/llvm/LLVMSlicer.h
- llvm/analysis/PointsTo/PointsTo.h -> dg/llvm/analysis/PointsTo/PointerAnalysis.h
- analysis/PointsTo/PointsToFlowSensitive.h -> dg/analysis/PointsTo/PointerAnalysisFS.h
- analysis/PointsTo/PointsToFlowInsensitive.h -> dg/analysis/PointsTo/PointerAnalysisFI.h
- analysis/PointsTo/PointsToWithInvalidate.h -> dg/analysis/PointsTo/PointerAnalysisFSInv.h
* A new library libDGAnalysis.so was added. You must link to this library
when linking with any dg library.
================================================
FILE: Dockerfile
================================================
# --------------------------------------------------
# Base container
# --------------------------------------------------
FROM docker.io/ubuntu:jammy AS base
RUN set -e
# Install packages
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update
RUN apt-get install -yq --no-install-recommends clang llvm
# --------------------------------------------------
# Build container
# --------------------------------------------------
FROM base as build
# Can be used to specify which git ref to checkout
ARG GIT_REF=master
ARG GIT_REPO=mchalupa/dg
# Install build dependencies
RUN apt-get install -yq --no-install-recommends ca-certificates cmake git \
ninja-build llvm-dev python3
# Clone
RUN git clone https://github.com/$GIT_REPO
WORKDIR /dg
RUN git fetch origin $GIT_REF:build
RUN git checkout build
# libfuzzer does not like the container environment
RUN cmake -S. -GNinja -Bbuild -DCMAKE_INSTALL_PREFIX=/opt/dg \
-DCMAKE_CXX_COMPILER=clang++ -DENABLE_FUZZING=OFF
RUN cmake --build build
RUN cmake --build build --target check
# Install
RUN cmake --build build --target install/strip
# -------------------------------------------------
# Release container
# -------------------------------------------------
FROM base AS release
COPY --from=build /opt/dg /opt/dg
ENV PATH="/opt/dg/bin:$PATH"
ENV LD_LIBRARY_PATH="/opt/dg/lib"
# Verify it works
RUN llvm-slicer --version
================================================
FILE: LICENSE
================================================
Copyright (c) 2015-2020 Marek Chalupa
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 (including the
next paragraph) 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
================================================
# DG
[](https://github.com/mchalupa/dg/actions/workflows/linux.yml)
[](https://github.com/mchalupa/dg/actions/workflows/mac.yml)
DG is a library containing various bits for program analysis. However, the main motivation of this library is program slicing. The library contains implementation of a pointer analysis, data dependence analysis, control dependence analysis, and an analysis of relations between values in LLVM bitcode. All of the analyses target LLVM bitcode, but most of them are written in a generic way, so they are not dependent on LLVM in particular.
Further, DG contains an implementation of dependence graphs and a [static program slicer](doc/llvm-slicer.md) for LLVM bitcode. Some documentation can be found in the [doc/](doc/) directory.
* [Downloading DG](doc/downloading.md)
* [Compiling DG](doc/compiling.md)
* [Using llvm-slicer](doc/llvm-slicer.md)
* [Other tools](doc/tools.md)
------------------------------------------------
You can find a high-level description of DG in [DG: a program analysis library](https://doi.org/10.1016/j.simpa.2020.100038) or [DG: Analysis and slicing of LLVM bitcode](https://www.fi.muni.cz/~xchalup4/dg_atva20_preprint.pdf) papers. More detailed information about dg is in the doc/ folder or in my [master thesis](http://is.muni.cz/th/396236/fi_m/thesis.pdf).
You can write e-mails with issues to <mchqwerty@gmail.com> (or file issue in github).
================================================
FILE: dg.spec.rpkg
================================================
# vim: syntax=spec
# Do out-of-source build by default on Fedora
%undefine __cmake_in_source_build
Name: {{{ git_dir_name }}}
Version: {{{ git_dir_version }}}
Release: 1%{?dist}
Summary: Analyses, construction of dependence graphs and slicing of LLVM bitcode
License: MIT
URL: https://github.com/mchalupa/dg
VCS: {{{ git_dir_vcs }}}
Source: {{{ git_dir_archive }}}
BuildRequires: clang
BuildRequires: cmake
BuildRequires: gcc
BuildRequires: gcc-c++
BuildRequires: llvm-devel
BuildRequires: make
BuildRequires: ncurses-devel
BuildRequires: python3
BuildRequires: zlib-devel
Requires: clang
Requires: llvm
%description
DG is a library containing various bits for program analysis. However, the
main motivation of this library is program slicing. The library contains
implementation of a pointer analysis, data dependence analysis, control
dependence analysis, and an analysis of relations between values in LLVM
bitcode. All of the analyses target LLVM bitcode, but most of them are written
in a generic way, so they are not dependent on LLVM in particular.
%prep
{{{ git_dir_setup_macro }}}
%build
GIT_VERSION={{{ git rev-parse --short --sq HEAD }}}
%cmake -DGIT_VERSION="$GIT_VERSION"
%cmake_build
%install
%cmake_install
%check
%if 0%{?suse_version}
%cmake_build -C %{__builddir} check
%else
%if 0%{?epel}
%cmake_build check
%else
%cmake_build --target check
%endif
%endif
%files
%license LICENSE
%doc doc/*
%{_bindir}/*
%{_includedir}/%{name}
%{_libdir}/*
================================================
FILE: doc/CDA.md
================================================
# Control Dependence Analysis
In DG, we implemented several algorithms for the computation of different control dependencies.
These control dependencies are:
- Standard (SCD) control dependence (Ferrante et al. [1])
- Non-termination sensitive control dependence (NTSCD) (Ranangath et al.[2])
- Decisive order dependence (DOD) (Ranangath et al.[2])
- [experimental/WIP] Strong control closures (Strong CC) (Danicic et al.[3])
## Public API
The class through which you can run and access the results of control dependence analysis
is called `LLVMControlDependenceAnalysis` and is defined in
[dg/llvm/ControlDependence/ControlDependence.h](../include/dg/llvm/ControlDependence/ControlDependence.h)
The class takes an instance of `LLVMControlDependenceAnalysisOptions` in constructor. This object
describes which analysis to run and whether to compute also interprocedural dependencies (see below).
The public API of `LLVMControlDependenceAnalysis` contains several methods:
* `run()` to run the analysis
* `getDependencies()` to get dependencies of an instruction or a basic block (there are two polymorphic methods).
As we compute intraprocedural dependencies on basic block level, these two method return different things.
`getDependencies` for a basic block returns a set of values on which depend all the instructions in the basic
block. `getDependencies` for instruction then returns additional dependencies, e.g., interprocedural.
Therefore, if you want _all_ dependencies for an instruction, you should always query both, `getDependencies`
for the instruction and also `getDependencies` for the basic block of the instruction.
Note that the return value may be either an instruction or a basic block.
If a basic block is returned as a dependence, it means that the queried value depends on the terminator
instruction of the returned basic block.
* `getDependent()` methods return values (instructions and blocks) that depend on the given instruction (block).
They work similarly as `getDependencies` methods, just return dependent values instead of dependencies.
If a block is returned, then all instructions of the block depend on the given value.
* `getNoReturns()` return possibly no-returning points of the given function (those are usually calls to functions
that may not return). If interprocedural analysis is disabled, returns always an empty vector.
Then there are methods for closure-based algorithms, but these are mostly unimplemented (in fact, the Strong CC algorithm
works, just these getter methods are not implemented yet).
## Interprocedural dependencies
DG supports the computation of control dependencies that arise due to e.g., calling `abort()` from inside of a procedure.
Consider this example:
```C
void foo(int x) { if (x < 0) abort(); }
int main() {
int a = input();
foo();
assert(a > 0);
}
```
In the example above, the assertion cannot be violated, because for values of `a` that would violate the
assert the program is killed by the call to `abort`. That is, the assertion in fact depends on the if statement
in the `foo` function. Such control dependencies between procedures are omitted by the classical algorithms.
In DG, compute these dependencies by a standalone analysis that runs after computing intraprocedural control dependencies.
Results of the interprocedural analysis are returned by `getDependencies` and `getDependent` along with
results of the intraprocedural analysis (of course, only if interprocedural analysis is enabled by the options
object).
Also, NTSCD and DOD algorithms can be executed on interprocedural (inlined) CFG (ICFG).
That is, a one big CFG that contains nodes for all basic blocks/instructions of the
program and there are regular intraprocedural edges and also interprocedural
edges going between calls and entry blocks/instructions and from returns to return-sites.
For this functionality, use -cda-icfg.
## Tools
There is the `llvm-cda-dump` tool that dumps the results of control dependence analysis.
By default, it shows the results directly on LLVM bitcode. You can you the `-ir`switch to see the internal
representation from the analyses. To select the analysis to run, use the `-cda` switch with one of these options:
|opt | description |
|----------------|---------------------------------------|
|`scd` | standard CD (the default) |
|`standard` | an alias for stanard |
|`classic` | an alias for standard |
|`ntscd` | non-termination sensitive CD |
|`ntscd2` | NTSCD (a different implementation) |
|`ntscd-ranganath` | Ranganath et al's algorithm for NTSCD (warning: it is incorrect) |
|`dod` | Standalone DOD computation |
|`dod-ranganath` | Ranganath et al's algorithm (the original algorithm was incorrect, this is a fixed version) |
|`dod+ntscd` | NTSCD + DOD |
|`scc` | Strong control closures |
Note that `llvm-slicer` takes the very same options.
There are also tools `llvm-ntscd-dump` specialized for showing internals and results of the NTSCD analysis,
`llvm-cda-bench` that benchmarks a given list of analyses (the list is given without the `-cda` switch,
e.g., `-ntscd -ntscd2 -dod`, see the help message) on a given program, and `llvm-cda-stress`
that works like `llvm-cda-bench` with the difference that it generates and uses a random control flow graph
and it works with only a subset of analyses (all except SCD).
## Other notes
The algorithm for computing standard control dependencies does not have a generic implementation in DG
as we heavily rely on LLVM in computation of post dominators.
[1] Jeanne Ferrante, Karl J. Ottenstein, Joe D. Warren: The Program Dependence Graph and Its Use in Optimization.
ACM Trans. Program. Lang. Syst. 9(3): 319-349 (1987)
[2] Venkatesh Prasad Ranganath, Torben Amtoft, Anindya Banerjee, Matthew B. Dwyer, John Hatcliff:
A New Foundation for Control-Dependence and Slicing for Modern Program Structures. ESOP 2005: 77-93
[3] Sebastian Danicic, Richard W.Barraclough, Mark Harman, John D.Howroyd, Ákos Kiss, Michael R.Laurence: A unifying theory of control dependence and its application to arbitrary program structures. Theoretical Computer Science, Volume 412, Issue 49, 2011, Pages 6809-6842
================================================
FILE: doc/DDA.md
================================================
# Data Dependence Analysis
DG contains the analysis of data dependencies (also called value-flow)
based on constructing memory SSA form of the program.
## Public API
The data dependence analysis class for LLVM is `LLVMDataDependenceAnalysis`.
Its constructor takes the LLVM module, results of pointer analysis and optionally an instance of
`LLVMDataDependenceAnalysisOptions`.
Relevant methods from the public API are two polymorphic methods `getLLVMDefinitions`.
One takes LLVM value which is required to read memory (can be checked by `isUse` method)
and returns a vector of LLVM values that may have possibly written the values read
by the given value.
The other takes parameters `where`, `mem`, `off`, and `len` and returns all LLVM values that
may write to the memory allocated by instruction or global variable `mem` at bytes from `off`
to `off + len - 1` and the written value may be read at `where` (i.e., it has not been surely
overwritten at `where` yet).
## Modeling external (undefined) functions
The class `LLVMDataDependenceAnalysisOptions` has the possibility of registering
models for functions. If the analysis then hits a call of the given function,
it uses this model instead of calling the function (if the function is defined
in the module) or instead of assuming that the function may do anything.
The methods that take care of registering models of functions are
`functionModelAddDef` and `functionModelAddUse`.
These methods take the name of the modelled function and a tripple `(argidx, offset, len)`
which means that the function defines/uses the memory pointed by the `argidx`-th argument
(beginning at 0) and define `len` bytes from the memory beginning at `argidx + offset`.
If `len` (`offset`, resp.) are of type `Offset`, these are interpreted as constant numbers.
However, if those are of type `unsigned`, those are interpreted as indexes of arguments
(the same as `argidx`) meaning that the real number of bytes and offset is given
by the argument of the called function. If the argument is not a constant,
it is taken as UNKNOWN. For example,
```C
functionModelAddUse("memset", {0, Offset(0), 2})`
```
tell the analysis that `memset` function defines the memory pointed by the first argument
(with index 0) and this memory is defined from the byte where the first argument points.
Also, only the number of bytes specified by the third argument (with index 2) are used.
For the code
```C
int array[10];
memset(array + 2, 0, 20);
```
The analysis will create a model that tells that this call to `memset` defines bytes 8 - 27 of `array`
(given that the size of int is 4 bytes).Another examples of using these functions can be found in
[LLVMDataDependenceAnalysisOptions.h](../include/dg/llvm/DataDependence/LLVMDataDependenceAnalysisOptions.h).
## Tools
There is `llvm-dda-dump` that dumps the results of data dependence analysis. If dumped to .dot file
(`-dot` option) the computed memory SSA along with def-use chains is shown.
================================================
FILE: doc/PTA.md
================================================
# Pointer Analysis in DG
Pointer analysis (PTA) implementation in DG consists of a general part and LLVM
part. The general part include a program representation (graph) and the
pointer analysis algorithm that runs on the graph. The LLVM part takes care of
building the pointer graph from the LLVM module and translating results from
the analysis to consumers of LLVM bitcode (i.e., if we ask for points-to set of
a LLVM value, we get a set of LLVM values and not the analysi's internal
nodes).
The program representation (`PointerGraph`) is a graph whose nodes (`PSNode`)
contain information about pointer handlings, e.g., casts, storing and loading
to/from memory, shifting, etc. Further, the graph is subdivided into subgraphs
(`PointerSubgraph`) that correspond to procedures.
Once we build the pointer graph, we can run an analysis on it. In DG, the
pointer analysis class has virtual `getMemoryObjects` method whose definition
changes the behavior of the analysis (along with auxiliary `processefore` and
`processAfter`). Once the `run` method of pointer analysis is invoked, the
analysis computes points-to sets of nodes (that correspond to top-level values
in LLVM) until fixpoint is reached.
We have implemented flow-sensitive (data-flow) and flow-insensitive
(Andersen's-like) pointer analysis (this one is used by default).
## LLVM pointer analysis
Files from [dg/llvm/PointerAnalysis/](../include/dg/llvm/PointerAnalysis/)
The pointer analysis for LLVM is provided by the `LLVMPointerAnalysis` class.
This class can have different implementations, all of them complying with a
basic public API:
##### `hasPointsTo`
returns true if
1) PTA has any points-to set for the given value
2) the points-to set is non-empty```
##### `getLLVMPointsTo`
returns points-to set (object of the class `LLVMPointsToSet`, see below) for the given value.
If `hasPointsTo` would be false for the given value, points-to set containging the only
element `unknown` is returned.
##### `getLLVMPointsToChecked`
returns points-to set (object of the class `LLVMPointsToSet`) for the given value
and a bool which corresponds with the result of `hasPointsTo`.
The boolean returned is good for checking whether the `unknown` pointer in the points-to set
(if any) is a result of the analysis (e.g., a pointer returned from an undefined function) or
is there because the analysis has no information about the queried value.
##### `getAccessedMemory`
is a wrapper around getLLVMPointsTo that returns `LLVMMemoryRegionSet`.
This object represents a set of tripples (memory, offset, length) describing the regions
of memory accessed by the given instruction (e.g., store or load).
`LLVMPointsToSet` is an object that yields `LLVMPointer` objects upon
iteration. Each `LLVMPointer` object is a pair of LLVM `Value` and `Offset`
containing the allocation that allocated the pointed memory and the offset into
the memory. `LLVMPointsToSet` has also methods `hasUnknown`, `hasNull`, and
`hasInvalidated` that return true if the points-to set contains `unknown`,
`null`, or `invalidated` (i.e., pointing to freed or destroyed memory) element.
Note that these elements are not physically present in the points-to set as
there are no LLVM Values that would represent them (and thus could be returned
in LLVMPointer).
## Tools
Results of pointer analysis can be dumped by the `llvm-pta-dump` tool which can be found in `tools/` directory.
Possible options are:
Option | Values | Description
----------------------|-------------|-------------
`-pta` | fi, fs, inv, svf | Type of analysis - flow-insensitive, flow-sensitive, flow-sensitive with tracking invalidated memory, and SVF (if available)
`-pta-field-sensitive` | BYTES | Set field sensitivity: how many bytes to track on each object
`-callgraph` | | Dump also call graph
`-callgraph-only` | | Dump only call graph
`-iteration` | NUM | How many iterations to perform (for debugging)
`-graph-only` | | Do not run PTA, just build and dump the pointer graph
`-stats` | | Dump statistics
`-entry` | FUN | Set entry function to FUN
`-dbg` | | Show debugging messages
`-ir` | | Dump internal representation of the analysis
`-c-lines` | | Dump output on the level of C lines (needs debug info)
`-dot` | | Dump IR and results of the analysis to .dot file
`-v` `-vv` | | Verbose output
Further, there is the tool `llvm-pta-ben` for evaulation of files annotated according to the [PTABen](https://github.com/SVF-tools/PTABen) project, and `llvm-pta-compare` that compares results different pointer analyses.
================================================
FILE: doc/README.md
================================================
# DG library
DG is a C++ library containing bits for building various static program
analyses. The main part of the library aims at building dependence graph and
program slicing. In particular, DG contains an implementation of static program
slicer for LLVM bitcode.
#### Supported operating systems
We develop and target DG on GNU/Linux. The project should be compilable on OSX,
though there were some issues in the past (issue [#230](https://github.com/mchalupa/dg/issues/230)).
There were also some unresolved attempts to compile DG on Windows.
Although the code does not use any compiler-specific
or non-portable features, so it should be compilable on Windows,
the compilation was failing due to problems with linking to LLVM libraries
(issues [#196](https://github.com/mchalupa/dg/issues/196) and
[#315](https://github.com/mchalupa/dg/issues/315)).
## Analyses
- [Pointer analysis](PTA.md)
- [Data dependence analysis](DDA.md)
- [Control dependence analysis](CDA.md)
- [Value-relations analysis](VRA.md)
## Tools
- [llvm-slicer](llvm-slicer.md)
- [Other tools](tools.md)
## External Libraries
- [SVF](SVF.md)
================================================
FILE: doc/SVF.md
================================================
# Integration of SVF into DG
DG can use pointer anlysis from the SVF project. This analysis should scale
much more better than ours, however, our analysis can be more precise in some
cases.
## Building DG with SVF
To use SVF with DG, you first needs a build of
[SVF](https://github.com/SVF-tools/SVF). Build the project according its
instructions. To configure DG with SVF, setup `SVF_DIR` variable to point
to the build of SVF:
```
cmake . -DSVF_DIR=/path/to/svf/build
```
During configuration, cmake should inform you about the found SVF build:
```cmake
-- SVF dir: /home/user/SVF/Debug-build
-- SVF libraries dir: /home/user/SVF/Debug-build/lib
-- SVF include dir: /home/user/SVF/Debug-build/../include
-- SVF libs: LLVMSvf;LLVMCudd
```
In cases of out-of-source build of SVF you may want to manually specify
the varable for include directory:
```
cmake . -DSVF_DIR=/path/to/svf/build -DSVF_INCLUDE=/path/to/svf/include
```
`SVF_DIR` must point to a directory that contains the `lib` subdirectory with
libraries. `SVF_INCLUDE` must point to directly to a directory that contains
the header files.
## Using DG with SVF
DG now integrates only pointer analysis from SVF. To use SVF from C++ API,
just specify in the `LLVMPointerAnalysisOptions` object
that the analysis is of type `LLVMPointerAnalysisOptions::AnalysisType::svf`.
For tools, the switch that turns on SVF pointer analysis is `-pta svf`,
for example:
```
tools/llvm-slicer -c foo -pta svf test.ll
```
================================================
FILE: doc/compiling.md
================================================
# Compiling DG from sources
## Requirements
DG needs LLVM 3.4 or higher. Further requirements are `cmake`, `make`, `g++` or `clang++`
in a version that supports at least C++11 standard.
And, of course, `git` for downloading the project. On some systems,
also `zlib` is required. For compilation of files into LLVM, we need also `clang`
compiler. To run slicing tests and some of the tools, you need also an installation
of `python`.
On Ubuntu, you install the dependencies with:
```
apt install git cmake make llvm zlib1g-dev clang g++ python3
```
On ArchLinux, the command for installing the dependencies is the following:
```
pacman -S git cmake make llvm clang gcc python
```
On CentOS/RHEL/Fedora, the command for installing the dependencies is the following:
```
dnf install git cmake make zlib-devel llvm-devel gcc-c++ ncurses-devel
```
You can use also LLVM compiled from sources (see below).
## Building docker image
The DG repository contains a prepared Dockerfile that
builds DG under Ubuntu 20.04. To build the docker image,
go into the top-level project's directory (the one containing
Dockerfile) and run:
```
docker build . --tag dg:latest
docker run -ti dg:latest
```
The Dockerfile installs only the prerequisities for dg.
If you need anything else to try out dg (e.g., vim or emacs), you must install
it manually inside the image.
## Compiling DG
The first step is to clone the repository to your machine:
```
git clone https://github.com/mchalupa/dg
cd dg
```
Once you have the project cloned, you need to configure it.
When LLVM is installed on your system in standard paths,
the configuration should be as easy as calling `cmake`:
```
cmake .
```
or
```
mkdir build
cd build
cmake ..
```
However, if you have LLVM installed in non-standard paths, or you have several
versions of LLVM and want to use a particular one, you must manually specify
path to the installation:
```
cmake -DLLVM_SRC_PATH=/path/to/src -DLLVM_BUILD_PATH=/path/to/build -DLLVM_DIR=path/to/llvm/share/llvm/cmake .
```
LLVM\_DIR is an environment variable used by LLVM to find cmake config files
(it points to the build or install directory), LLVM\_SRC\_DIR is a variable
that tells cmake where to look for llvm's sources and it is used to override
include paths. The same holds for LLVM\_BUILD\_PATH that is used to override
library paths. Usually, you don't need to specify all these variables:
LLVM\_DIR variable is useful if there is any collision (i.e. there are more
versions of LLVM installed) and you want to use a particular build of LLVM. In
that case, define the LLVM\_DIR variable to point to the directory where are
the config files of the desired version (`$PREFIX/share/llvm/cmake` or
`$PREFIX/lib/cmake/llvm/` for newer versions of LLVM -- for system
installations, `PREFIX` is usually set to `/usr`). If you have LLVM compiled
from sources but not installed anywhere, you may need to use LLVM\_SRC\_PATH
and LLVM\_BUILD\_PATH variables to specify the directory with sources and
build. As an example, suppose you have LLVM built in /home/user/llvm-build
from sources in /home/user/llvm-src. Then the following configuration should
work:
```
cmake -DLLVM_SRC_PATH=/home/user/llvm-src -DLLVM_BUILD_PATH=/home/user/llvm-build -DLLVM_DIR=/home/user/llvm-build/share/llvm/cmake .
```
The LLVM is linked dynamically by default. This behaviour can be toggled by
turning the `LLVM_LINK_DYLIB` option `OFF`. Note that some additional packages
might be required than those listed above when linking statically.
If you want to build the project with debugging information and assertions, you
may specify the build type by adding `-DCMAKE_BUILD_TYPE=Debug` during
configuration. Also, you may enable building with sanitizers by adding
`-DUSE_SANITIZERS=ON`.
After configuring the project, usual `make` takes place:
```
make -j4
```
In this documentation, you can find also some reports of how we compiled DG on
different Linux systems with the system LLVM packages. These documents describe
just the one-time experience and are not maintained. Therefore,
the reports may be out-of-date:
- [Compiling on Ubuntu Trusty](compiling_ubuntu_trusty.md)
- [Compiling on Ubuntu Xenial](compiling_ubuntu_xenial.md)
## Building with SVF support
If you want to build DG with the support of the
[SVF](https://github.com/SVF-tools/SVF) library, you must specify `SVF_DIR`
variable to point to the build of SVF. For more information, see [documentation
for SVF](SVF.md).
## Testing
You can run tests with `make check`. The command runs unit tests and also tests
of slicing LLVM bitcode in several different configurations, so it may take a
while. If your compiler supports `libFuzzer`, fuzzing tests are compiled and
run as well.
================================================
FILE: doc/compiling_ubuntu_trusty.md
================================================
# The experience with compiling DG on Ubuntu Trusty
This is my experience with compiling DG on (a clean installation of) Ubuntu Trusty for different versions of LLVM.
To summarize, compiling DG with a custom build of LLVM goes fine on Ubuntu Trusty.
Using system LLVM packages does not work at all. The only way how to compile DG without compiling also LLVM
is to use our packages that we use in CI.
If LLVM is compiled from sources, it should be enough to set `LLVM_DIR` (and possibly
`LLVM_SRC_DIR` and `LLVM_BUILD_DIR` to the right directories.
The LLVM 3.4-3.8 packages from the system repositories unfortunately contain broken cmake files.
Not only the config file is named `LLVM-Config.cmake` instead of `LLVMConfig.cmake`
for some LLVM version,but there is also broken the mapping to LLVM libraries.
The configuration with system LLVM 3.9 goes smoothly, but the compilation fails with this error:
```
/usr/lib/llvm-3.9/lib/libLLVMCore.a(AsmWriter.cpp.o): unrecognized relocation (0x2a) in section `.text._ZN4llvm24AssemblyAnnotationWriterD2Ev'
```
Greater versions of LLVM are not available from the repositories.
## Building with LLVM package from our CI
If you do not want to compile LLVM from sources,
for LLVM 3.8, 4, and 5 you can use the packages that we use in our CI:
```
git clone --depth 1 https://github.com/tomsik68/travis-llvm.git
cd travis-llvm
chmod +x travis-llvm.sh
./travis-llvm.sh 3.8 # change 3.8 to 4 or 5 if wanted
```
Now we can proceed normally with configuration and compilation:
```
cd dg
cmake . -DLLVM_DIR=/usr/share/llvm-3.8/cmake
make -j4
```
================================================
FILE: doc/compiling_ubuntu_xenial.md
================================================
# The experience with compiling DG on Ubuntu Trusty
This is my experience with compiling DG on (a clean installation of) Ubuntu Xenial for different versions of LLVM.
Compiling DG with LLVM built from sources should work fine, so here I focus only on the compilation
with LLVM from the repositories packages.
First of all, install the dependencies.
```
apt update
apt install git cmake make zlib1g-dev clang g++ python3
```
## LLVM 3.8
The default LLVM is 3.8 which you can install with:
```
apt install llvm
```
Unfortunately, it still suffers from the broken cmake files as in Ubuntu Trusty
(the files are in `/usr/share/llvm-3.8/cmake/`, but cmake is instructed to look
for the configuration files in `/usr/share/llvm/cmake/`. So for LLVm 3.8, the
only option is to build LLVM from sources or use our CI package
(see [Compiling on Ubuntu Trusty](compiling_ubuntu_trusty.md) page).
## LLVM >= 3.9
Compiling DG with system LLVM 3.9 and higher (Xenial has packages
for LLVM 3.9, 4.0, 5.0, 6.0, and 8.0) should work out of the box.
After the installation of prerequisities, just install LLVM, configure DG
and compile (replace `-3.9` with the desired version of LLVM):
```
apt install llvm-3.9
cmake . # you may need to use -DLLVM_DIR=/usr/lib/llvm-3.9/cmake
make -j2
```
Don't forget to compile source code to LLVM with the right version of clang:
```
apt install clang-3.9
```
The binaries `clang`, `llvm-link`, `opt`, and `lli` (for running slicing tests) may have the suffix `-3.9`,
so you may need to create symbolic links with names without the suffix to successfully run tests.
================================================
FILE: doc/downloading.md
================================================
# Getting pre-compiled DG
You can obtain pre-compiled DG project in several forms.
## Docker image
You can download the image from [Docker Hub](https://hub.docker.com/r/mchalupa/dg). The image
contains, apart from DG, also vim and emacs editors and clang, so that you can try dg out.
(Note that this image is not being updated regularly).
Alternatively, the root folder of dg contains a Dockerfile which allows you to build
a docker image with dg installed. Just run these commands from the dg's root directory:
```
docker build . --tag dg:latest
docker run -ti dg:latest
```
Note that the locally built image does not contain either vim or emacs, so you must
install one of them if you need.
## Binary Packages
We have packed DG for several systems. The packages contain only the library and `llvm-slicer`. Other tools are not included.
### Ubuntu package
A binary package for Ubuntu 18.04 can be found in [Releases](https://github.com/mchalupa/dg/releases/tag/v0.9-pre).
### Archlinux AUR package
There is also the [dg-git](https://aur.archlinux.org/packages/dg-git/) AUR package for Archlinux users.
================================================
FILE: doc/llvm-slicer.md
================================================
# llvm-slicer
DG project contains a static slicer for LLVM bitcode. The slicer supports backward and forward (experimental) slicing.
It is designed and tested on slicing code generated from sequential C programs. However, there is an experimental
support for parallel programs and it should handle bitcode generated from other languages in many cases.
There is a section on using the slicer with bitcode generated from C++ at the end of this file.
### Using the llvm-slicer
The compiled `llvm-slicer` can be found in the `tools/` subdirectory. First, you need to compile your
program into LLVM IR (make sure you are using the correct version of LLVM binaries if you have more than one):
```
clang -c -emit-llvm source.c -o bitcode.bc
```
If the program is split into more source files (exactly one of them must contain main),
you must compile each of them separately (as above) and then link the bitcodes together using `llvm-link`:
```
llvm-link bitcode1.bc bitcode2.bc ... -o bitcode.bc
```
Now, you're ready to slice the program:
```
./llvm-slicer -c slicing_criterion bitcode.bc
```
The `slicing_criterion` is either a call-site of a function or `ret` to slice
with respect to the return value of the main function. Alternatively, if the program was compiled with the `-g` option,
you can also use `line:variable` as slicing criterion. Slicer will then try to find a use of the variable
on the provided line and mark this use, if found, as a slicing criterion.
If no line is provided (e.g. `:x`), then the variable is considered to be global variable.
You can provide a comma-separated list of slicing criterions, e.g.: `-c crit1,crit2,crit3`.
More about specifying slicing criteria can be found [later](#slicing-criteria) in this document.
You can view the dependence graph that was used to slice the bitcode by exporting it into .dot file.
To achieve this, use `-dump-dg` switch with `llvm-slicer` or a stand-alone tool like
`llvm-dg-dump` (this one is deprecated, but should still work):
```
./llvm-dg-dump bitcode.bc > file.dot
```
You can highlight nodes from the dependence graph that will be in the slice using the `-mark` switch:
```
./llvm-dg-dump -mark slicing_criterion bitcode.bc > file.dot
```
When using `-dump-dg` with `llvm-slicer`, the nodes should be already highlighted.
Also a .dot file with the sliced dependence graph is generated (similar behaviour
can be achieved with `llvm-dg-dump` using the `-slice` switch).
If the dependence graph is too big to be displayed using .dot files, you can debug/see the slice right from
the LLVM language. Just pass `-annotate` option to the `llvm-slicer` and it will store readable annotated LLVM in `file-debug.ll`
(where `file.bc` is the name of file being sliced). There are more options (try `llvm-slicer -help` for show all of them),
but the most interesting is probably the `-annotate slice`:
```
./llvm-slicer -c crit -annotate slice code.bc
```
The content of `code-debug.ll` will look like this:
```LLVM
; <label>:25 ; preds = %20
; x call void @llvm.dbg.value(metadata !{i32* %i}, i64 0, metadata !151), !dbg !164
%26 = load i32* %i, align 4, !dbg !164
%27 = add nsw i32 %26, 1, !dbg !164
; x call void @llvm.dbg.value(metadata !{i32 %27}, i64 0, metadata !151), !dbg !164
store i32 %27, i32* %i, align 4, !dbg !164
; x call void @llvm.dbg.value(metadata !{i32* %j}, i64 0, metadata !153), !dbg !161
; x %28 = load i32* %j, align 4, !dbg !161
; x %29 = add nsw i32 %28, 1, !dbg !161
; x call void @llvm.dbg.value(metadata !{i32 %29}, i64 0, metadata !153), !dbg !161
; x br label %20, !dbg !165
.critedge: ; preds = %20
; x call void @llvm.dbg.value(metadata !{i32* %j}, i64 0, metadata !153), !dbg !166
; x %30 = load i32* %j, align 4, !dbg !166
; x %31 = icmp sgt i32 %30, 99, !dbg !166
; x br i1 %31, label %19, label %32, !dbg !166
```
Other options for `-annotate` are `pta`, `dd`, `cd`, `memacc` to annotate points-to information,
data dependencies, control dependencies or memory accessed by instructions.
You can provide comma-separated list of multiple options (`-annotate cd,slice,dd`)
### Example
We can try slicing, for example, this program (with respect to the assertion):
```C
#include <assert.h>
#include <stdio.h>
long int fact(int x)
{
long int r = x;
while (--x >=2)
r *= x;
return r;
}
int main(void)
{
int a, b, c = 7;
while (scanf("%d", &a) > 0) {
assert(a > 0);
printf("fact: %lu\n", fact(a));
}
return 0;
}
```
Let's say the program is stored in a file `fact.c`. We translate it into LLVM bitcode and then slice it:
```
$ cd tools
$ clang -c -emit-llvm fact.c -o fact.bc
$ ./llvm-slicer -c __assert_fail fact.bc
```
The output is in `fact.sliced`, we can look at the result using `llvm-dis` or `sliced-diff.sh` script:
```LLVM
; Function Attrs: nounwind uwtable
define i32 @main() #0 {
%a = alloca i32, align 4
br label %1
; <label>:1 ; preds = %4, %0
%2 = call i32 (i8*, ...) @__isoc99_scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i32* %a)
%3 = icmp sgt i32 %2, 0
br i1 %3, label %4, label %safe_return
; <label>:4 ; preds = %1
%5 = load i32, i32* %a, align 4
%6 = icmp sgt i32 %5, 0
br i1 %6, label %1, label %7
; <label>:7 ; preds = %4
call void @__assert_fail(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), ... [truncated])
unreachable
safe_return: ; preds = %1
ret i32 0
}
```
### Slicing criteria (the -c and -2c options)
The `slicing_criterion` is either a call-site of a function or `ret` to slice
with respect to the return value of the main function. Alternatively, if the program was compiled with the `-g` option,
you can also use `line:variable` as slicing criterion. Slicer will then try to find a use of the variable
on the provided line and mark this use, if found, as a slicing criterion. `llvm-slicer` should then inform you
that it matched a slicing criterion with a given instruction.
If no line is provided (e.g. `:x`), then the variable is considered to be a global variable.
You can provide a comma-separated list of slicing criteria, e.g.: `-c crit1,crit2,crit3`.
For example, consider this program:
```C
1. int main() {
2. int a = 8, b = input();
3. while (a > b) {
4. ++b;
5. }
6. check(a == b);
7. check2();
8. print(a)
}
```
Assuming that the slicing criteria are calls to function `check` (`-c check`),
therefore the slicer will detect the calls to `check` and slice the code w.r.t. these calls
(including their arguments, as the arguments are used by the calls).
Therefore, the slice w.r.t. `-c check` would correspond to (if mapped back to C):
```C
1. int main() {
2. int a = 8, b = input();
3. while (a > b) {
4. ++b;
5. }
6. check(a == b);
}
```
The same way you can specify the slicing criteria are calls to `check2`, in which case the slice would be just:
```C
7. check2();
```
as `check2` does not use any variables and therefore has no dependencies
(well, this is not true with non-termination sensitive control dependence).
Alternatively, if you compile the program to LLVM with debugging information (`-g` option),
you can specify a line and variable that should be used as slicing criterion. In our example, if you use `-c 8:a`,
then the program is sliced w.r.t accesses to variable `a` on line 8, so the slice would be:
```C
1. int main() {
2. int a = 8;
8. // read of a will stay in LLVM here
}
```
Here is a restriction that the specified variable must be used at the given line.
Just to fill in the details, a slicing criterion is always a node of a dependence graph.
If you dump the dependence graph of the program (`-dump-dg`), then you can see what nodes are there and therefore
what can be a slicing criterion. Alternatively, nodes in dep. graph correspond to instructions,
so a slicing criterion is always an instruction in LLVM (check `-annotate slice` option,
which generates `-debug.ll` file with information about sliced instructions; slicing criteria are marked in the file too).
### Secondary slicing criteria
`llvm-slicer` supports also something that we call a _secondary_ slicing critera. A secondary slicing criterion
is a node (instruction) that is taken as slicing criterion only if it is on a path into a regular slicing criterion.
Take, for example this small program:
```C
int x = nondet();
assume(x > 0);
check(x > 0);
```
In the example above, if we just set `check` to be the slicing criterion (`-c check`), the `assume` gets sliced away
because it does not modify `x`. Therefore, we can say that calls to `assume` are secondary slicing criteria
(`-2c assume`) and therefore any `assume` that appears on a path into `check` is set as a slicing criterion too
and is preserved.
Secondary slicing criteria does not bring any additional power to slicing. Indeed, we can either say the slicer that
`assume` modifies `x`, or add control dependence from `assume` to nodes reachable from the call (as `assume` may in fact
terminate the execution). However, with secondary slicing criteria, we save edges.
Further, we can specify that a secondary slicing criterion is a _data_ secondary slicing criterion, which means
that it is considered as a slicing criterion only if it is on a path into a regular slicing criterion and
at the same time it uses the same memory as the regular slicing criterion. In `llvm-slicer`, we do that by adding
`()` after the secondary slicing criterion, e.g., `-2c assume()`.
### Slicing criteria (the -sc option)
`llvm-slicer` supports specifying slicing criteria also with `-sc` option, which is designed for further extensions
for C++ and allows to bind a secondary slicing criterion to every primary slicing criterion.
`-sc` takes a list of semi-colon-separated slicing criteria pairs, i.e.,
`-sc 'S;S;S;...'` where `S` describes a primary-secondary slicing criteria pair. A pair is divided by `|`, i.e.
the pair is in the form: `X|Y`. Either the primary or the secondary criterion can be empty (not both, though).
If the primary criterion is empty, the secondary slicing criterion is attached to all primary slicing criteria.
Finally, `X` and `Y` are in the form `file#function#line#obj`.
The fields `file`, `function`, `line`, and `obj` can be empty and the prefix of `###..` can be left out.
The `obj` field matches either a call of a function or a use of a variable (given that the program is
compiled with debugging information) and can be further specified to be a (global) variable or a function call:
`[&][@]obj[()]`. For example, `&x` means variable `x`, `fun()` means call of `fun` and `@g` (or `&@g`) means
global variable `g`.
Examples:
```
'fun()|&x' -- matches calls of fun() as primary SC and instructions using variable x as secondary SC
'x|f' -- matches calls of function x or uses of variable x as primary SC and the same with f as secondary SC
'file.c###fun()|&x' -- matches calls of fun() in file file.c as primary SC and instructions using variable x as secondary SC
'#8#|main#7#' -- matches all instruction on line 8 (in any file) as primary SC and instructions in (any)
function main on line 7 as secondary SC
'foo();boo();|fun()' -- matches calls of functions foo and boo as primary SC and calls of fun as secondary SC for both foo and boo
'foo();boo()|fun()' -- matches calls of functions foo as primary SC and boo as primary SC with calls of fun as secondary SC
```
Note that the matching is performed in approximation manner, i.e., if the slicer lacks information about an instruction,
it assume it matches the slicing criterion.
### Options
A set of useful options is:
Option | Arguments | Description
-------------------|------------------|--------------------------------------------
`-c` | crit1,crit2,... | A comma-separated list of slicing criteria
`-2c` | crit1,crit2,... | A comma-separated list of secondary slicing criteria
`-annotate` | val1,val2,... | Generate annotated bitcode. The argument is a comma-separated list of `slice`,`pta`,`dd`,`cd`,`memacc`
`-allocation-funs` | func:type,... | Treat the given functions as allocations. `type` is one of `malloc`, `calloc`, `realloc`
`-pta` | fi, fs, svf | Set PTA type to flow-insensitive, flow-sensitive, or SVF (if supported)
`-cda` | standard, ntscd | Set the type of used control dependencies (termination insensitive or sensitive)
`-interproc-cd` | | Take into account also not returning from function calls (on by default)
`-dump-dg` | | Dump dependence graph to .dot file
`-entry` | FUN | Set entry function to FUN
`-forward` | | Perform forward slicing
`-statistics` | | Dump statistics about bitcode before and after slicing
`-undefined-funs` | {read,write}-{args,any}, pure | Set how to handle calls to undefined functions
`-o` | FILE | Output the sliced bitcode into FILE
`-help` | | Show all possible options
## Using slicer on C++ bitcode
DG is not made for analysing C++ bitcode. At least not yet. However, in many cases it should be able to sucessfully analyze and slice
such a bitcode. Unsupported are instructions like `invoke` and `landingpad` that are used in code that uses exceptions.
In some cases, you can use `-lowerinvoke` pass to get rid of these.
Another issue is names mangling. C++ compilers mangle the names, so for example it changes the name of function `f` with the type `void (*)(int *, int)`
to `_Z1fPii`. This can be confusing when specifying slicing criteria. Instead of `-sc 'f##x'` to slice w.r.t uses of `x` in function `f` one must use
`-sc '_Z1fPii##x'`.
================================================
FILE: doc/tools.md
================================================
## Tools
In the `tools/` directory, there are a few scripts for convenient manipulation
with sliced bitcode. First is a `sliced-diff.sh`. This script takes file and shows
differences after slicing. It uses `meld` or `kompare` or just `diff` program
to display the results (the first that is available on the system, in this order)
```
./llvm-slicer -c crit code.bc
./slicer-diff.sh code.bc
```
If the program was compiled with `-g`, you can use `llvm-to-source sliced-bitcode.bc source.c` to see the original lines of the source that stayed in the sliced program. Note that this program just dumps the lines of the original code that are present in the sliced bitcode, it does not produce a syntactically valid C program.
Another script is a wrapper around the `llvm-dg-dump`. It uses `xdot` or `evince` or `okular` (or `xdg-open`).
It takes exactly the same arguments as the `llvm-dg-dump`:
```
./llvmdg-show -mark crit code.bc
```
### All tools
The tools subdirectory contains a set of useful programs for debugging
and playing with the llvm bitcode. Except for the `llvm-slicer` you can find there:
* `llvm-dg-dump` - Dump the dependence graph for given program to graphviz format (to stdout)
* `llvm-pta-dump` - dump pointer subgraph and results of the points-to analysis to stdout
* `llvm-dda-dump` - display data dependencies between instructions in a llvm bitcode
* `llvm-cda-dump` - display control dependencies between instructions in a llvm bitcode
* `llvm-cg-dump` - dump call graph of the given LLVM bitcode (based on pointer analysis)
* `llvmdg-show` - wrapper for llvm-dg-dump that displays the dependence graph in dot
* `llvmdda-dump` - wrapper for llvm-dda-dump that displays data dependencies in dot
* `pta-show` - wrapper for llvm-pta-dump that prints the PS in grapviz to pdf
* `llvm-to-source` - find lines from the source code that are in given file
* `dgtool` - a wrapper around clang that compiles code and passes it to a specified tool
All these programs take as an input llvm bitcode, for example:
```
./pta-show code.bc
```
will show the pointer state subgraph for code.bc and the results of points-to analysis.
Some useful switches for all programs are `-pta fs` and `-pta fi` that switch between flow-sensitive
and flow-insensitive points-to analysis within all these programs that use points-to analysis.
Some of these tools support the `-c-lines` switch that dumps the output on the level of
C file (where an instruction is represented as the line:column pair). For this switch to work,
the program must be compiled with debugging information (`-g`).
### dgtool
`dgtool` is a wrapper around clang that compiles given files (C or LLVM bitcode or a mix),
links them together and then calls the program given as an argument on the bitcode.
For example,
```
dgtool llvm-slicer -c __assert_fail -cda ntscd main.c foo.c
```
You can pass arguments to clang if you preceed them with `-Xclang`, the same way, you can pass arguments to
`dgtool` itself when using `-Xdg`, for example:
```
dgtool -Xclang -O3 -Xclang -fno-discard-value-names -Xdg dbg llvm-dda-dump test.c
```
================================================
FILE: include/dg/ADT/Bits.h
================================================
#ifndef _DG_SPARSE_BITS_H_
#define _DG_SPARSE_BITS_H_
#include <cassert>
#include <cstddef> // size_t
#include <cstdint>
namespace dg {
namespace ADT {
// an element that holds a sequence of bits (up to 64 bits usually)
// along with offset. So this class can represent a sequence
// of [S, S(+sizeof(InnerT)*8)] bits. (E.g. 100th, 101th, ..., 163th bit)
template <typename InnerT = uint64_t, typename ShiftT = uint64_t>
class ShiftedBits {
InnerT _bits{0};
ShiftT _shift;
public:
ShiftedBits(ShiftT shift) : _shift(shift) {}
static size_t bitsNum() { return sizeof(InnerT) * 8; }
bool operator==(const ShiftedBits &rhs) const {
return _bits == rhs._bits && _shift == rhs._shift;
}
bool operator!=(const ShiftedBits &rhs) const { return !operator==(rhs); }
bool mayContain(size_t i) const {
return i >= _shift && i - _shift < bitsNum();
}
size_t size() const {
size_t num = 0;
for (size_t i = 0; i < bitsNum(); ++i)
if (_bits & (static_cast<InnerT>(1) << i))
++num;
return num;
}
bool empty() const { return _bits == 0; }
bool get(size_t i) const {
if (!mayContain(i))
return false;
assert(i - _shift < bitsNum());
return _bits & (static_cast<InnerT>(1) << (i - _shift));
}
// return the previous value
bool set(size_t i) {
assert(mayContain(i));
bool ret = get(i);
_bits |= (static_cast<InnerT>(1) << (i - _shift));
return ret;
}
class const_iterator {
const ShiftedBits *bits{nullptr};
size_t pos{0};
bool isEnd() const { return pos == ShiftedBits::bitsNum(); }
void _findNext() {
assert(pos < ShiftedBits::bitsNum());
while (!(bits->_bits & (static_cast<InnerT>(1) << pos))) {
++pos;
if (isEnd())
return;
}
}
const_iterator(const ShiftedBits *bits, size_t pos = 0)
: bits(bits), pos(pos) {
assert(bits && "No bits given");
// start at the first element
if (!isEnd() && !(bits->_bits & 1))
operator++();
}
public:
const_iterator() = default;
const_iterator(const const_iterator &) = default;
const_iterator &operator=(const const_iterator &) = default;
const_iterator &operator++() {
++pos;
if (!isEnd())
_findNext();
return *this;
}
const_iterator operator++(int) {
auto tmp = *this;
operator++();
return tmp;
}
size_t operator*() const {
assert(pos < ShiftedBits::bitsNum());
assert(bits->mayContain(bits->_shift + pos));
return bits->_shift + pos;
}
bool operator==(const const_iterator &rhs) const {
return pos == rhs.pos && bits == rhs.bits;
}
bool operator!=(const const_iterator &rhs) const {
return !operator==(rhs);
}
friend class ShiftedBits;
};
const_iterator begin() const { return const_iterator(this); }
const_iterator end() const { return const_iterator(this, bitsNum()); }
friend class const_iterator;
};
// a set of bits with 0 offset. This is a special case
// of ShiftedBits with _shift = 0
template <typename InnerT = uint64_t>
class Bits {
InnerT _bits{0};
public:
static size_t bitsNum() { return sizeof(InnerT) * 8; }
bool operator==(const Bits &rhs) const { return _bits == rhs._bits; }
bool operator!=(const Bits &rhs) const { return !operator==(rhs); }
bool empty() const { return _bits == 0; }
bool mayContain(size_t i) const { return i < bitsNum(); }
size_t size() const {
size_t num = 0;
for (size_t i = 0; i < bitsNum(); ++i)
if (_bits & (static_cast<InnerT>(1) << i))
++num;
return num;
}
bool get(size_t i) const {
if (!mayContain(i))
return false;
assert(i < bitsNum());
return _bits & (static_cast<InnerT>(1) << i);
}
// return the previous value
bool set(size_t i) {
assert(mayContain(i));
bool ret = get(i);
_bits |= (static_cast<InnerT>(1) << i);
return ret;
}
class const_iterator {
const Bits *bits{nullptr};
size_t pos{0};
bool isEnd() const { return pos == Bits::bitsNum(); }
void _findNext() {
assert(pos < Bits::bitsNum());
while (!(bits->_bits & (static_cast<InnerT>(1) << pos))) {
++pos;
if (isEnd())
return;
}
}
const_iterator(const Bits *bits, size_t pos = 0)
: bits(bits), pos(pos) {
assert(bits && "No bits given");
// start at the first element
if (!isEnd() && !(bits->_bits & 1))
operator++();
}
public:
const_iterator() = default;
const_iterator(const const_iterator &) = default;
const_iterator &operator=(const const_iterator &) = default;
const_iterator &operator++() {
++pos;
if (!isEnd())
_findNext();
return *this;
}
const_iterator operator++(int) {
auto tmp = *this;
operator++();
return tmp;
}
size_t operator*() const {
assert(pos < Bits::bitsNum());
assert(bits->mayContain(pos));
return pos;
}
bool operator==(const const_iterator &rhs) const {
return pos == rhs.pos && bits == rhs.bits;
}
bool operator!=(const const_iterator &rhs) const {
return !operator==(rhs);
}
friend class Bits;
};
const_iterator begin() const { return const_iterator(this); }
const_iterator end() const { return const_iterator(this, bitsNum()); }
friend class const_iterator;
};
} // namespace ADT
} // namespace dg
#endif // _DG_SPARSE_BITS_H_
================================================
FILE: include/dg/ADT/Bitvector.h
================================================
#ifndef DG_SPARSE_BITVECTOR_H_
#define DG_SPARSE_BITVECTOR_H_
#include <cassert>
#include <cstdint>
#include "HashMap.h"
#include "Map.h"
namespace dg {
namespace ADT {
using std::size_t;
template <typename BitsT = uint64_t, typename ShiftT = uint64_t,
typename IndexT = uint64_t, size_t SCALE = 1,
typename BitsContainerT = dg::Map<ShiftT, BitsT>>
class SparseBitvectorImpl {
// mapping from shift to bits
BitsContainerT _bits{};
static const size_t BITS_IN_BYTE = 8;
static const size_t BITS_IN_BUCKET = sizeof(BitsT) * BITS_IN_BYTE;
static ShiftT _shift(IndexT i) { return i - (i % BITS_IN_BUCKET); }
static size_t _countBits(BitsT bits) {
size_t num = 0;
while (bits) {
if (bits & 0x1)
++num;
bits = bits >> 1;
}
return num;
}
void _addBit(IndexT i) {
// for now we just push it back,
// but we would rather do it somehow
// more smartly (probably not using the vector)
auto sft = _shift(i);
_bits.emplace(sft, BitsT{1} << (i - sft));
}
public:
SparseBitvectorImpl() = default;
SparseBitvectorImpl(IndexT i) { _addBit(i); } // singleton ctor
SparseBitvectorImpl(const SparseBitvectorImpl &) = default;
SparseBitvectorImpl(SparseBitvectorImpl &&) = default;
void reset() { _bits.clear(); }
bool empty() const { return _bits.empty(); }
void swap(SparseBitvectorImpl &oth) { _bits.swap(oth._bits); }
// TODO: use SFINAE to define empty body if a class without
// reserve() is used...
void reserve(size_t n) { _bits.reserve(n); }
bool get(IndexT i) const {
auto sft = _shift(i);
assert(sft % BITS_IN_BUCKET == 0);
auto it = _bits.find(sft);
if (it == _bits.end()) {
return false;
}
return (it->second & (BitsT{1} << (i - sft)));
}
// returns the previous value of the i-th bit
bool set(IndexT i) {
auto sft = _shift(i);
auto &B = _bits[sft];
bool prev = B & (BitsT{1} << (i - sft));
B |= BitsT{1} << (i - sft);
return prev;
}
// union operation
bool set(const SparseBitvectorImpl &rhs) {
bool changed = false;
for (auto &pair : rhs._bits) {
auto &B = _bits[pair.first];
auto old = B;
B |= pair.second;
changed |= old != B;
}
return changed;
}
// returns the previous value of the i-th bit
bool unset(IndexT i) {
auto sft = _shift(i);
auto it = _bits.find(sft);
if (it == _bits.end()) {
assert(get(i) == 0);
return false;
}
// FIXME: use this implementation only for hash map
// which returns read-only object and
// modify directly it->second in other cases (for std::map)
auto res = it->second & ~(BitsT{1} << (i - sft));
if (res == 0) {
_bits.erase(it);
// tests that size() = 0 <=> empty()
assert(((size() != 0) ^ empty()) && "Inconsistence");
} else {
_bits[sft] = res;
}
assert(get(i) == 0 && "Failed removing");
return true;
}
// FIXME: track the number of elements
// in a variable, to avoid this search...
size_t size() const {
size_t num = 0;
for (auto &it : _bits)
num += _countBits(it.second);
return num;
}
class const_iterator {
typename BitsContainerT::const_iterator container_it;
typename BitsContainerT::const_iterator container_end;
size_t pos{0};
const_iterator(const BitsContainerT &cont, bool end = false)
: container_it(end ? cont.end() : cont.begin()),
container_end(cont.end()) {
// set-up the initial position
if (!end && !cont.empty())
_findClosestBit();
}
void _findClosestBit() {
assert(pos < BITS_IN_BUCKET);
while (!(container_it->second & (BitsT{1} << pos))) {
if (++pos == BITS_IN_BUCKET)
return;
}
}
public:
const_iterator() = default;
const_iterator &operator++() {
// shift to the next bit in the current bits
assert(pos < BITS_IN_BUCKET);
assert(container_it != container_end && "operator++ called on end");
if (++pos != BITS_IN_BUCKET)
_findClosestBit();
if (pos == BITS_IN_BUCKET) {
++container_it;
pos = 0;
if (container_it != container_end) {
assert(container_it->second != 0 &&
"Empty bucket in a bitvector");
_findClosestBit();
}
}
return *this;
}
const_iterator operator++(int) {
auto tmp = *this;
operator++();
return tmp;
}
IndexT operator*() const { return container_it->first + pos; }
bool operator==(const const_iterator &rhs) const {
return pos == rhs.pos && container_it == rhs.container_it;
}
bool operator!=(const const_iterator &rhs) const {
return !operator==(rhs);
}
friend class SparseBitvectorImpl;
};
const_iterator begin() const { return const_iterator(_bits); }
const_iterator end() const { return const_iterator(_bits, true /* end */); }
friend class const_iterator;
};
using SparseBitvectorMapImpl =
SparseBitvectorImpl<uint64_t, uint64_t, uint64_t, 1,
dg::Map<uint64_t, uint64_t>>;
using SparseBitvectorHashImpl =
SparseBitvectorImpl<uint64_t, uint64_t, uint64_t, 1,
dg::HashMap<uint64_t, uint64_t>>;
using SparseBitvector = SparseBitvectorMapImpl;
} // namespace ADT
} // namespace dg
#endif // DG_SPARSE_BITVECTOR_H_
================================================
FILE: include/dg/ADT/DGContainer.h
================================================
#ifndef DG_CONTAINER_H_
#define DG_CONTAINER_H_
#include <algorithm>
#include <cassert>
#include <set>
namespace dg {
/// ------------------------------------------------------------------
// - DGContainer
//
// This is basically just a wrapper for real container, so that
// we have the container defined on one place for all edges.
// It may have more implementations depending on available features
/// ------------------------------------------------------------------
template <typename ValueT, unsigned int EXPECTED_ELEMENTS_NUM = 8>
class DGContainer {
public:
// XXX use llvm ADTs when available, or BDDs?
using ContainerT = typename std::set<ValueT>;
using iterator = typename ContainerT::iterator;
using const_iterator = typename ContainerT::const_iterator;
using size_type = typename ContainerT::size_type;
iterator begin() { return container.begin(); }
const_iterator begin() const { return container.begin(); }
iterator end() { return container.end(); }
const_iterator end() const { return container.end(); }
size_type size() const { return container.size(); }
bool insert(ValueT n) { return container.insert(n).second; }
bool contains(ValueT n) const { return container.count(n) != 0; }
size_t erase(ValueT n) { return container.erase(n); }
void clear() { container.clear(); }
bool empty() { return container.empty(); }
void swap(DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> &oth) {
container.swap(oth.container);
}
void intersect(const DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> &oth) {
DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> tmp;
std::set_intersection(
container.begin(), container.end(), oth.container.begin(),
oth.container.end(),
std::inserter(tmp.container, tmp.container.begin()));
// swap containers
container.swap(tmp.container);
}
bool
operator==(const DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> &oth) const {
if (container.size() != oth.size())
return false;
// the sets are ordered, so this will work
iterator snd = oth.container.begin();
for (iterator fst = container.begin(), efst = container.end();
fst != efst; ++fst, ++snd)
if (*fst != *snd)
return false;
return true;
}
bool
operator!=(const DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> &oth) const {
return !operator==(oth);
}
private:
ContainerT container;
};
// Edges are pointers to other nodes
template <typename NodeT, unsigned int EXPECTED_EDGES_NUM = 4>
class EdgesContainer : public DGContainer<NodeT *, EXPECTED_EDGES_NUM> {};
} // namespace dg
#endif // DG_CONTAINER_H_
================================================
FILE: include/dg/ADT/DisjunctiveIntervalMap.h
================================================
#ifndef DG_DISJUNCTIVE_INTERVAL_MAP_H_
#define DG_DISJUNCTIVE_INTERVAL_MAP_H_
#include <algorithm>
#include <cassert>
#include <map>
#include <set>
#include <vector>
#ifndef NDEBUG
#include <iostream>
#endif
#include "dg/Offset.h"
namespace dg {
namespace ADT {
template <typename T = int64_t>
struct DiscreteInterval {
using ValueT = T;
T start;
T end;
DiscreteInterval(T s, T e) : start(s), end(e) {
assert(s <= e && "Invalid interval");
}
T length() const {
// +1 as the intervals are discrete
// (interval |0|1|2|3| has length 4)
return end - start + 1;
}
// total order on intervals so that we can insert them
// to std containers. We want to compare them only
// according to the start value.
bool operator<(const DiscreteInterval &I) const { return start < I.start; }
bool operator==(const DiscreteInterval &I) const {
return start == I.start && end == I.end;
}
bool operator!=(const DiscreteInterval &I) const { return !operator==(I); }
bool overlaps(const DiscreteInterval &I) const {
return (start <= I.start && end >= I.start) || I.end >= start;
}
bool covers(const DiscreteInterval &I) const {
return (start <= I.start && end >= I.end);
}
bool overlaps(T rhs_start, T rhs_end) const {
return overlaps(DiscreteInterval(rhs_start, rhs_end));
}
bool covers(T rhs_start, T rhs_end) const {
return covers(DiscreteInterval(rhs_start, rhs_end));
}
#ifndef NDEBUG
void dump() const;
#endif
};
///
// Mapping of disjunctive discrete intervals of values
// to sets of ValueT.
template <typename ValueT, typename IntervalValueT = Offset>
class DisjunctiveIntervalMap {
public:
using IntervalT = DiscreteInterval<IntervalValueT>;
using ValuesT = std::set<ValueT>;
using MappingT = std::map<IntervalT, ValuesT>;
using iterator = typename MappingT::iterator;
using const_iterator = typename MappingT::const_iterator;
///
// Return true if the mapping is updated anyhow
// (intervals split, value added).
bool add(const IntervalValueT start, const IntervalValueT end,
const ValueT &val) {
return add(IntervalT(start, end), val);
}
bool add(const IntervalT &I, const ValueT &val) {
return _add(I, val, false);
}
template <typename ContT>
bool add(const IntervalT &I, const ContT &vals) {
bool changed = false;
for (const ValueT &val : vals) {
changed |= _add(I, val, false);
}
return changed;
}
bool update(const IntervalValueT start, const IntervalValueT end,
const ValueT &val) {
return update(IntervalT(start, end), val);
}
bool update(const IntervalT &I, const ValueT &val) {
return _add(I, val, true);
}
template <typename ContT>
bool update(const IntervalT &I, const ContT &vals) {
bool changed = false;
for (const ValueT &val : vals) {
changed |= _add(I, val, true);
}
return changed;
}
// add the value 'val' to all intervals
bool addAll(const ValueT &val) {
bool changed = false;
for (auto &it : _mapping) {
changed |= it.second.insert(val).second;
}
return changed;
}
// return true if some intervals from the map
// has a overlap with I
bool overlaps(const IntervalT &I) const {
if (_mapping.empty())
return false;
auto ge = _find_ge(I);
if (ge == _mapping.end()) {
auto last = _get_last();
return last->first.end >= I.start;
}
return ge->first.start <= I.end;
}
bool overlaps(IntervalValueT start, IntervalValueT end) const {
return overlaps(IntervalT(start, end));
}
// return true if the map has an entry for
// each single byte from the interval I
bool overlapsFull(const IntervalT &I) const {
if (_mapping.empty()) {
return false;
}
auto ge = _find_ge(I);
if (ge == _mapping.end()) {
auto last = _get_last();
return last->first.end >= I.end;
}
if (ge->first.start > I.start) {
if (ge == _mapping.begin())
return false;
auto prev = ge;
--prev;
if (prev->first.end != ge->first.start - 1)
return false;
}
IntervalValueT last_end = ge->first.end;
while (ge->first.end < I.end) {
++ge;
if (ge == _mapping.end())
return false;
if (ge->first.start != last_end + 1)
return false;
last_end = ge->first.end;
}
// full overlap means that there are not uncovered bytes
assert(uncovered(I).empty());
return true;
}
bool overlapsFull(IntervalValueT start, IntervalValueT end) const {
return overlapsFull(IntervalT(start, end));
}
DisjunctiveIntervalMap
intersection(const DisjunctiveIntervalMap &rhs) const {
DisjunctiveIntervalMap tmp;
// FIXME: this could be done more efficiently
auto it = _mapping.begin();
for (auto &rhsit : rhs._mapping) {
while (it->first.end < rhsit.first.start) {
if (it == _mapping.end()) {
return tmp;
}
}
if (it->first.overlaps(rhsit.first)) {
decltype(rhsit.second) vals;
std::set_intersection(it->second.begin(), it->second.end(),
rhsit.second.begin(), rhsit.second.end(),
std::inserter(vals, vals.begin()));
tmp.add(IntervalT{std::max(it->first.start, rhsit.first.start),
std::min(it->first.end, rhsit.first.end)},
vals);
}
}
return tmp;
}
///
// Gather all values that are covered by the interval I
std::set<ValueT> gather(IntervalValueT start, IntervalValueT end) const {
return gather(IntervalT(start, end));
}
std::set<ValueT> gather(const IntervalT &I) const {
std::set<ValueT> ret;
auto it = le(I);
if (it == end())
return ret;
assert(it->first.overlaps(I) && "The found interval should overlap");
while (it != end() && it->first.overlaps(I)) {
ret.insert(it->second.begin(), it->second.end());
++it;
}
return ret;
}
std::vector<IntervalT> uncovered(IntervalValueT start,
IntervalValueT end) const {
return uncovered(IntervalT(start, end));
}
std::vector<IntervalT> uncovered(const IntervalT &I) const {
if (_mapping.empty())
return {I};
auto it = le(I);
if (it == end())
return {I};
std::vector<IntervalT> ret;
IntervalT cur = I;
if (cur.start > it->first.start) {
// the first interval covers the whole I?
if (it->first.end >= I.end) {
return {};
}
assert(cur == I);
cur.start = it->first.end + 1;
assert(cur.end == I.end);
assert(I.end > it->first.end);
// we handled this interval, move further
++it;
// nothing else to handle...
if (it == _mapping.end()) {
if (cur.start <= cur.end)
return {cur};
}
}
while (true) {
assert(cur.start <= it->first.start);
if (cur.start != it->first.start && cur.start < it->first.start) {
assert(it->first.start != 0 && "Underflow");
ret.push_back(IntervalT{cur.start, it->first.start - 1});
}
// does the rest of the interval covers all?
if (it->first.end >= I.end)
break;
assert(it->first.end != (~static_cast<IntervalValueT>(0)) &&
"Overflow");
cur.start = it->first.end + 1;
assert(cur.end == I.end);
++it;
if (it == end()) {
if (cur.start <= cur.end)
ret.push_back(cur);
// we're done here
break;
}
}
return ret;
}
bool empty() const { return _mapping.empty(); }
size_t size() const { return _mapping.size(); }
iterator begin() { return _mapping.begin(); }
const_iterator begin() const { return _mapping.begin(); }
iterator end() { return _mapping.end(); }
const_iterator end() const { return _mapping.end(); }
bool operator==(
const DisjunctiveIntervalMap<ValueT, IntervalValueT> &rhs) const {
return _mapping == rhs._mapping;
}
// return the iterator to an element that is the first
// that overlaps the interval I or end() if there is
// no such interval
iterator le(const IntervalT &I) { return _shift_le(_find_ge(I), I); }
const_iterator le(const IntervalT &I) const {
return _shift_le(_find_ge(I), I);
}
iterator le(const IntervalValueT start, const IntervalValueT end) {
return le(IntervalT(start, end));
}
const_iterator le(const IntervalValueT start,
const IntervalValueT end) const {
return le(IntervalT(start, end));
}
#ifndef NDEBUG
friend std::ostream &
operator<<(std::ostream &os,
const DisjunctiveIntervalMap<ValueT, IntervalValueT> &map) {
os << "{";
for (const auto &pair : map) {
if (pair.second.empty())
continue;
os << "{ ";
os << pair.first.start << "-" << pair.first.end;
os << ": " << *pair.second.begin();
os << " }, ";
}
os << "}";
return os;
}
void dump() const { std::cout << *this << "\n"; }
#endif
#if 0
friend llvm::raw_ostream& operator<<(llvm::raw_ostream& os, const DisjunctiveIntervalMap<ValueT, IntervalValueT>& map) {
os << "{";
for (const auto& pair : map) {
if (pair.second.empty())
continue;
os << "{ ";
os << *pair.first.start << "-" << *pair.first.end;
os << ": " << *pair.second.begin();
os << " }, ";
}
os << "}";
return os;
}
#endif
private:
// shift the iterator such that it will point to the
// first element that overlaps with I, or to end
// if there is no such interval
template <typename IteratorT>
IteratorT _shift_le(const IteratorT &startge, const IntervalT &I) const {
// find the element that starts at the same value
// as I or later (i.e. I.start >= it.start)
if (startge == end()) {
auto last = _get_last();
if (last->first.end >= I.start) {
assert(last->first.overlaps(I));
return last;
}
return end();
}
assert(startge->first.start >= I.start);
// check whether there's
// an previous interval with an overlap
if (startge != begin()) {
auto tmp = startge;
--tmp;
if (tmp->first.end >= I.start) {
assert(tmp->first.overlaps(I));
return tmp;
}
// fall-through
}
// starge is the first interval or the
// previous interval does not overlap.
// Just check whether this interval overlaps
if (startge->first.start > I.end)
return end();
assert(startge->first.overlaps(I));
return startge;
}
// Split interval [a,b] to two intervals [a, where] and [where + 1, b].
// Each of the new intervals has a copy of the original set associated
// to the original interval.
// Returns the new lower interval
// XXX: could we pass just references to the iterator?
template <typename IteratorT, typename HintIteratorT>
IteratorT splitIntervalHint(IteratorT I, IntervalValueT where,
HintIteratorT hint) {
auto interval = I->first;
auto values = std::move(I->second);
assert(interval.start != interval.end && "Cannot split such interval");
assert(interval.start <= where && where <= interval.end &&
"Value 'where' must lie inside the interval");
assert(where < interval.end && "The second interval would be empty");
// remove the original interval and replace it with
// two splitted intervals
_mapping.erase(I);
auto ret = _mapping.emplace_hint(hint, IntervalT(interval.start, where),
values);
_mapping.emplace_hint(hint, IntervalT(where + 1, interval.end),
std::move(values));
return ret;
}
bool splitExtBorders(const IntervalT &I) {
assert(!_mapping.empty());
bool changed = false;
auto ge = _mapping.lower_bound(I);
if (ge == _mapping.end()) {
// the last interval must start somewhere to the
// left from our new interval
auto last = _get_last();
assert(last->first.start < I.start);
if (last->first.end > I.end) {
last = splitIntervalHint(last, I.end, ge);
changed |= true;
}
if (last->first.end >= I.start) {
splitIntervalHint(last, I.start - 1, ge);
changed |= true;
}
return changed;
}
// we found an interval starting at I.start
// or later
assert(ge->first.start >= I.start);
// FIXME: optimize this...
// add _find_le to find the "closest" interval from the right
// (maybe iterating like this is faster, though)
auto it = ge;
while (it->first.start <= I.end) {
if (it->first.end > I.end) {
it = splitIntervalHint(it, I.end, _mapping.end());
changed = true;
break;
}
++it;
if (it == _mapping.end())
break;
}
// we may have also overlap from the previous interval
if (changed)
ge = _mapping.lower_bound(I);
if (ge != _mapping.begin()) {
auto prev = ge;
--prev;
auto prev_end = prev->first.end;
if (prev_end >= I.start) {
ge = splitIntervalHint(prev, I.start - 1, ge);
changed = true;
}
// is the new interval entirely covered by the previous?
if (prev_end > I.end) {
// get the higher of the new intervals
++ge;
assert(ge != _mapping.end());
assert(ge->first.end == prev_end);
#ifndef NDEBUG
auto check =
#endif
splitIntervalHint(ge, I.end, _mapping.end());
assert(check->first == I);
changed = true;
}
}
return changed;
}
template <typename IteratorT>
bool _addValue(IteratorT I, ValueT val, bool update) {
if (update) {
if (I->second.size() == 1 && I->second.count(val) > 0)
return false;
I->second.clear();
I->second.insert(val);
return true;
}
return I->second.insert(val).second;
}
// If the boolean 'update' is set to true, the value
// is not added, but rewritten
bool _add(const IntervalT &I, const ValueT &val, bool update = false) {
if (_mapping.empty()) {
_mapping.emplace(I, ValuesT{val});
return true;
}
// fast path
// auto fastit = _mapping.lower_bound(I);
// if (fastit != _mapping.end() &&
// fastit->first == I) {
// return _addValue(fastit, val, update);
//}
// XXX: pass the lower_bound iterator from the fast path
// so that we do not search the mapping again
bool changed = splitExtBorders(I);
_check();
// splitExtBorders() arranged the intervals such
// that some interval starts with ours
// and some interval ends with ours.
// Now we just create new intervals in the gaps
// and add values to the intervals that we have
// FIXME: splitExtBorders() can return the iterator,
// so that we do not need to search the map again.
auto it = _find_ge(I);
assert(!changed || it != _mapping.end());
// we do not have any overlapping interval
if (it == _mapping.end() || I.end < it->first.start) {
assert(!overlaps(I) && "Bug in add() or in overlaps()");
_mapping.emplace(I, ValuesT{val});
return true;
}
auto rest = I;
assert(rest.end >= it->first.start); // we must have some overlap here
while (it != _mapping.end()) {
if (rest.start < it->first.start) {
// add the gap interval
_mapping.emplace_hint(
it, IntervalT(rest.start, it->first.start - 1),
ValuesT{val});
rest.start = it->first.start;
changed = true;
} else {
// update the existing interval and shift
// to the next interval
assert(rest.start == it->first.start);
changed |= _addValue(it, val, update);
if (it->first.end == rest.end)
break;
rest.start = it->first.end + 1;
++it;
// our interval spans to the right
// after the last covered interval
if (it == _mapping.end() || it->first.start > rest.end) {
_mapping.emplace_hint(it, rest, ValuesT{val});
changed = true;
break;
}
}
}
_check();
return changed;
}
// find the elements starting at
// or right to the interval
typename MappingT::iterator _find_ge(const IntervalT &I) {
// lower_bound = lower upper bound
return _mapping.lower_bound(I);
}
typename MappingT::const_iterator _find_ge(const IntervalT &I) const {
return _mapping.lower_bound(I);
}
typename MappingT::iterator _get_last() {
assert(!_mapping.empty());
return (--_mapping.end());
}
typename MappingT::const_iterator _get_last() const {
assert(!_mapping.empty());
return (--_mapping.end());
}
void _check() const {
#ifndef NDEBUG
// check that the keys are disjunctive
auto it = _mapping.begin();
auto last = it->first;
++it;
while (it != _mapping.end()) {
assert(last.start <= last.end);
// this one is nontrivial (the other assertions
// should be implied by the Interval and std::map propertis)
assert(last.end < it->first.start);
assert(it->first.start <= it->first.end);
last = it->first;
++it;
}
#endif // NDEBUG
}
MappingT _mapping;
};
} // namespace ADT
} // namespace dg
#endif // _DG_DISJUNCTIVE_INTERVAL_MAP_H_
================================================
FILE: include/dg/ADT/HashMap.h
================================================
#ifndef DG_HASH_MAP_H_
#define DG_HASH_MAP_H_
#ifdef HAVE_TSL_HOPSCOTCH
#include "TslHopscotchHashMap.h"
namespace dg {
template <typename Key, typename Val>
using HashMap = HopscotchHashMap<Key, Val>;
}
#else
#include "STLHashMap.h"
namespace dg {
template <typename Key, typename Val>
using HashMap = STLHashMap<Key, Val>;
}
#endif
#endif
================================================
FILE: include/dg/ADT/HashMapImpl.h
================================================
#ifndef DG_HASH_MAP_IMPL_H_
#define DG_HASH_MAP_IMPL_H_
namespace dg {
template <typename Key, typename Val, typename Impl>
class HashMapImpl : public Impl {
public:
using iterator = typename Impl::iterator;
using const_iterator = typename Impl::const_iterator;
bool put(const Key &k, Val v) {
auto it = this->insert(std::make_pair(k, v));
return it.second;
}
const Val *get(const Key &k) const {
auto it = this->find(k);
if (it != this->end())
return &it->second;
return nullptr;
}
Val *get(Key &k) {
auto it = this->find(k);
if (it != this->end())
return &it->second;
return nullptr;
}
};
} // namespace dg
#endif
================================================
FILE: include/dg/ADT/IntervalsList.h
================================================
#ifndef DG_INTERVALS_LIST_H_
#define DG_INTERVALS_LIST_H_
#include "dg/Offset.h"
#include <cassert>
#include <list>
namespace dg {
namespace dda {
class IntervalsList {
struct Interval {
Offset start;
Offset end;
Interval(Offset s, Offset e) : start(s), end(e) {
assert(start <= end);
}
Interval(const std::pair<Offset, Offset> &I)
: Interval(I.first, I.second) {}
bool overlaps(const Interval &I) const {
return start <= I.end && end >= I.start;
}
Offset length() const { return end - start + 1; }
};
std::list<Interval> intervals;
template <typename Iterator>
void _replace_overlapping(const Interval &I, Iterator it, Iterator to) {
assert(it->overlaps(I) && to->overlaps(I));
assert(it != intervals.end());
assert(to != intervals.end());
it->start = std::min(it->start, I.start);
it->end = std::max(to->end, I.end);
++it;
++to;
if (it != intervals.end()) {
intervals.erase(it, to);
} else {
assert(to == intervals.end());
}
}
#ifndef NDEBUG
bool _check() {
auto it = intervals.begin();
if (it != intervals.end()) {
assert(it->start < it->end);
auto last = it++;
while (it != intervals.end()) {
assert(last->start < last->end);
assert(last->end < it->start);
assert(it->start < it->end);
}
}
return true;
}
#endif // NDEBUG
public:
void add(Offset start, Offset end) { add({start, end}); }
void add(const Interval &I) {
if (intervals.empty())
intervals.push_back(I);
auto it = intervals.begin();
auto end = intervals.end();
while (it != end) {
if (I.overlaps(*it)) {
auto to = ++it;
while (to != end && I.overlaps(*to)) {
++to;
}
if (to == end) {
--to;
}
_replace_overlapping(I, it, to);
break;
}
if (it->start > I.end) {
intervals.insert(it, I);
break;
}
++it;
}
if (it == end) {
intervals.push_back(I);
}
assert(_check());
}
IntervalsList &intersectWith(const IntervalsList &rhs) {
if (intervals.empty())
return *this;
auto it = intervals.begin();
for (const auto &RI : rhs.intervals) {
while (it->end < RI.start) {
auto tmp = it++;
intervals.erase(tmp);
if (it == intervals.end()) {
return *this;
}
}
if (it->overlaps(RI)) {
it->start = std::max(it->start, RI.start);
it->end = std::min(it->end, RI.end);
}
}
return *this;
}
auto begin() -> decltype(intervals.begin()) { return intervals.begin(); }
auto begin() const -> decltype(intervals.begin()) {
return intervals.begin();
}
auto end() -> decltype(intervals.end()) { return intervals.end(); }
auto end() const -> decltype(intervals.end()) { return intervals.end(); }
};
} // namespace dda
} // namespace dg
#endif
================================================
FILE: include/dg/ADT/Map.h
================================================
#ifndef DG_MAP_IMPL_H_
#define DG_MAP_IMPL_H_
#include <cstddef>
#include <map>
namespace dg {
// an ordered map with a unified API
template <typename Key, typename Val, typename Impl>
class MapImpl : public Impl {
public:
using iterator = typename Impl::iterator;
using const_iterator = typename Impl::const_iterator;
bool put(const Key &k, Val v) {
auto it = this->insert(std::make_pair(k, v));
return it.second;
}
const Val *get(const Key &k) const {
auto it = this->find(k);
if (it != this->end())
return &it->second;
return nullptr;
}
Val *get(Key &k) {
auto it = this->find(k);
if (it != this->end())
return &it->second;
return nullptr;
}
void reserve(size_t /*unused*/) {
// so that we can exchangabily use with HashMap
}
};
template <typename Key, typename Val>
using Map = MapImpl<Key, Val, std::map<Key, Val>>;
} // namespace dg
#endif
================================================
FILE: include/dg/ADT/NumberSet.h
================================================
#ifndef _DG_NUMBER_SET_H_
#define _DG_NUMBER_SET_H_
#include "Bits.h"
#include "Bitvector.h"
namespace dg {
namespace ADT {
// this is just a wrapper around sparse bitvector
// that translates the bitvector methods to a new methods.
// There is no possibility to remove elements from the set.
class BitvectorNumberSet {
using NumT = uint64_t;
using ContainerT = SparseBitvectorImpl<uint64_t, NumT>;
ContainerT _bitvector;
public:
using const_iterator = typename ContainerT::const_iterator;
BitvectorNumberSet() = default;
BitvectorNumberSet(size_t n) : _bitvector(n){};
BitvectorNumberSet(BitvectorNumberSet &&) = default;
bool add(NumT n) { return !_bitvector.set(n); }
bool has(NumT n) const { return _bitvector.get(n); }
bool empty() const { return _bitvector.empty(); }
size_t size() const { return _bitvector.size(); }
void swap(BitvectorNumberSet &oth) { oth._bitvector.swap(_bitvector); }
const_iterator begin() const { return _bitvector.begin(); }
const_iterator end() const { return _bitvector.end(); }
};
// This class is a container for a set of numbers
// that is optimized for holding small values
// (values less than sizeof(NumT)*8*SmallElemNum)).
// If a greater value is inserted, the whole container
// is lifted to a normal set.
// There is no possibility to remove elements from the set.
class SmallNumberSet {
using NumT = uint64_t;
// NOTE: if we change this to something that
// has non-trivial ctors/dtors, we must reflect it in the code!
using SmallSetT = Bits<NumT>;
using BigSetT = BitvectorNumberSet;
bool is_small{true};
union SetT {
SmallSetT small;
BigSetT big;
SetT() : small() {}
~SetT() {}
} _set;
void _lift(NumT n) {
assert(is_small);
auto S = BigSetT(n);
for (auto x : _set.small)
S.add(x);
// initialize the big-set
new (&_set.big) BigSetT();
S.swap(_set.big);
is_small = false;
}
public:
~SmallNumberSet() {
// if we used the big set, call its destructor
// (for smalls set there's nothing to do)
if (!is_small)
_set.big.~BigSetT();
}
bool add(NumT n) {
if (is_small) {
if (_set.small.mayContain(n))
return !_set.small.set(n);
_lift(n);
return true;
} else
return _set.big.add(n);
}
bool has(NumT n) const {
return is_small ? _set.small.get(n) : _set.big.has(n);
}
bool empty() const {
return is_small ? _set.small.empty() : _set.big.empty();
}
size_t size() const {
return is_small ? _set.small.size() : _set.big.size();
}
class const_iterator {
const bool is_small;
union ItT {
SmallSetT::const_iterator small_it;
BigSetT::const_iterator big_it;
ItT() {}
~ItT() {}
} _it;
public:
const_iterator(const SmallNumberSet &S, bool end = false)
: is_small(S.is_small) {
if (is_small) {
if (end)
_it.small_it = S._set.small.end();
else
_it.small_it = S._set.small.begin();
} else {
if (end)
_it.big_it = S._set.big.end();
else
_it.big_it = S._set.big.begin();
}
}
const_iterator(const const_iterator &) = default;
const_iterator &operator++() {
if (is_small)
++_it.small_it;
else
++_it.big_it;
return *this;
}
const_iterator operator++(int) {
auto tmp = *this;
operator++();
return tmp;
}
size_t operator*() const {
if (is_small)
return *_it.small_it;
return *_it.big_it;
}
bool operator==(const const_iterator &rhs) const {
if (is_small != rhs.is_small)
return false;
if (is_small)
return _it.small_it == rhs._it.small_it;
return _it.big_it == rhs._it.big_it;
}
bool operator!=(const const_iterator &rhs) const {
return !operator==(rhs);
}
};
const_iterator begin() const { return const_iterator(*this); }
const_iterator end() const { return const_iterator(*this, true /* end */); }
friend class const_iterator;
};
#if 0
// This class is a container for a set of numbers
// that is optimized for holding small values
// (values less than sizeof(NumT)*8*SmallElemNum)).
// If a greater value is inserted, the whole container
// is lifted to a normal set.
// There is no possibility to remove elements from the set.
template <typename NumT = uint64_t,
typename BigSetT = BitvectorNumberSet,
size_t SmallElemNum = 1>
class SmallNumberSet {
NumT[SmallElemNum] _smallNums{};
std::unique_ptr<BigSetT> _bigSet;
static size_t smallSetElemSize() { return sizeof(NumT)*8; }
static size_t smallSetSize() { return smallSetElemSize*SmallElemNum; }
static bool isInSmallSet(NumT n) { return n < smallSetSize(); }
// split a number from small set to offset to _smallNums
// and a bit of the element
std::pair<size_t, NumT> _split(NumT n) {
assert(!_bigSet);
size_t pos = 0;
while (n >= smallSetElemSize()) {
n =>> smallSetElemSize() - 1;
++pos;
}
assert(pos < SmallElemNum);
return {pos, n};
}
// add a number
bool _add(NumT n) {
if (isInSmallSet(n)) {
size_t pos;
std::tie(pos, n) = _getSmallPos(n);
if (_smallNums[pos] & (1UL << num)) {
return false;
} else {
_smallNums[pos] |= (1UL << num);
return true;
}
} else {
assert(!_bigSet);
auto S = std::unique_ptr<BigSetT>(new BigSetT(n));
// copy the elements from small set to the big set
for (auto x : *this)
S.add(x);
// set the big set
_bigSet = std::move(S);
return true;
}
};
size_t _sizeSmall() const {
assert(!_bigSet);
size_t n;
for (auto x : _smallNums) {
while(x) {
if (x & 0x1)
++n;
x >>= 1;
}
}
return n;
}
bool _emptySmall() const { return _sizeSmall() == 0; }
bool _hasSmall(NumT n) const {
std::tie(pos, n) = _getSmallPos(n);
assert(pos < smallSetSize());
assert(n < smallSetElemSize());
auto pos = _getSmallPos(n);
return _smallNums[pos] & (1UL << num);
}
public:
bool add(NumT n) { return _bigSet ? _bigSet->add(n) : _add(n); }
bool has(NumT n) const { return _bigSet ? _bigSet.has(n) : _hasSmall(n); }
bool empty() const { return _bigSet ? _bigSet.empty() : _emptySmall(); }
size_t size() const { return _bigSet ? _bigSet.size() : _sizeSmall(); }
/*
const_iterator begin() const { return _bitvector.begin(); }
const_iterator end() const { return _bitvector.end(); }
*/
}
#endif
/*
// this is just a wrapper around std::set
template <typename NumT = uint64_t>
class SimpleNumberSet {
using ContainerT = std::set<NumT>;
}
*/
} // namespace ADT
} // namespace dg
#endif // _DG_NUMBER_SET_H_
================================================
FILE: include/dg/ADT/Queue.h
================================================
#ifndef DG_ADT_QUEUE_H_
#define DG_ADT_QUEUE_H_
#include <queue>
#include <set>
#include <stack>
namespace dg {
namespace ADT {
template <typename ValueT>
class QueueLIFO {
using ContainerT = std::stack<ValueT>;
public:
using ValueType = ValueT;
ValueT pop() {
ValueT ret = Container.top();
Container.pop();
return ret;
}
ValueT &top() { return Container.top(); }
void push(const ValueT &what) { Container.push(what); }
bool empty() const { return Container.empty(); }
typename ContainerT::size_type size() const { return Container.size(); }
void swap(QueueLIFO<ValueT> &oth) { Container.swap(oth.Container); }
private:
ContainerT Container;
};
template <typename ValueT>
class QueueFIFO {
using ContainerT = std::queue<ValueT>;
public:
using ValueType = ValueT;
ValueT pop() {
ValueT ret = Container.front();
Container.pop();
return ret;
}
ValueT &top() { return Container.top(); }
void push(const ValueT &what) { Container.push(what); }
bool empty() const { return Container.empty(); }
typename ContainerT::size_type size() const { return Container.size(); }
void swap(QueueFIFO<ValueT> &oth) { Container.swap(oth.Container); }
private:
ContainerT Container;
};
template <typename ValueT, typename Comp>
class PrioritySet {
using ContainerT = std::set<ValueT, Comp>;
public:
using ValueType = ValueT;
ValueT pop() {
ValueT ret = *(Container.begin());
Container.erase(Container.begin());
return ret;
}
void push(const ValueT &what) { Container.insert(what); }
bool empty() const { return Container.empty(); }
typename ContainerT::size_type size() const { return Container.size(); }
private:
ContainerT Container;
};
} // namespace ADT
} // namespace dg
#endif // DG_ADT_QUEUE_H_
================================================
FILE: include/dg/ADT/STLHashMap.h
================================================
#ifndef DG_STL_HASH_MAP_H_
#define DG_STL_HASH_MAP_H_
#include <unordered_map>
#include "HashMapImpl.h"
namespace dg {
template <typename Key, typename Val>
class STLHashMap : public HashMapImpl<Key, Val, std::unordered_map<Key, Val>> {
};
// unordered_map that caches last several accesses
// XXX: use a different implementation than std::unordered_map
template <typename Key, typename T, unsigned CACHE_SIZE = 4U>
class CachingHashMap : public std::unordered_map<Key, T> {
std::pair<Key, T *> _cache[CACHE_SIZE];
unsigned _insert_pos{0};
unsigned _last{0};
T *_get_from_cache(const Key &key) {
if (_last > 0) {
for (unsigned i = 0; i < _last; ++i) {
if (_cache[i].first == key)
return _cache[i].second;
}
}
return nullptr;
}
void _insert_to_cache(const Key &key, T *v) {
_last = std::min(_last + 1, CACHE_SIZE);
_cache[_insert_pos] = {key, v};
_insert_pos = (_insert_pos + 1) % CACHE_SIZE;
assert(_insert_pos < CACHE_SIZE);
assert(_last <= CACHE_SIZE);
}
void _invalidate_cache() {
_last = 0;
_insert_pos = 0;
}
public:
using iterator = typename std::unordered_map<Key, T>::iterator;
using const_iterator = typename std::unordered_map<Key, T>::const_iterator;
T &operator[](const Key &key) {
if (auto *v = _get_from_cache(key)) {
return *v;
}
auto &ret = std::unordered_map<Key, T>::operator[](key);
_insert_to_cache(key, &ret);
return ret;
}
iterator erase(const_iterator pos) {
_invalidate_cache();
return std::unordered_map<Key, T>::erase(pos);
}
iterator erase(const_iterator first, const_iterator last) {
_invalidate_cache();
return std::unordered_map<Key, T>::erase(first, last);
}
};
} // namespace dg
#endif
================================================
FILE: include/dg/ADT/SetQueue.h
================================================
#ifndef DG_ADT_SET_QUEUE_H_
#define DG_ADT_SET_QUEUE_H_
#include "Queue.h"
#include <set>
namespace dg {
namespace ADT {
// A queue where each element can be queued only once
template <typename QueueT>
class SetQueue {
std::set<typename QueueT::ValueType> _queued;
QueueT _queue;
public:
using ValueType = typename QueueT::ValueType;
ValueType pop() { return _queue.pop(); }
ValueType &top() { return _queue.top(); }
bool empty() const { return _queue.empty(); }
size_t size() const { return _queue.size(); }
void push(const ValueType &what) {
if (_queued.insert(what).second)
_queue.push(what);
}
void swap(SetQueue<QueueT> &oth) {
_queue.swap(oth._queue);
_queued.swap(oth._queued);
}
};
} // namespace ADT
} // namespace dg
#endif // DG_ADT_QUEUE_H_
================================================
FILE: include/dg/ADT/TslHopscotchHashMap.h
================================================
#ifndef DG_TSL_HOPSCOTCH_MAP_H_
#define DG_TSL_HOPSCOTCH_MAP_H_
#include <tsl/hopscotch_map.h>
#include "HashMapImpl.h"
namespace dg {
template <typename Key, typename Val>
class HopscotchHashMap
: public HashMapImpl<Key, Val, tsl::hopscotch_map<Key, Val>> {};
} // namespace dg
#endif
================================================
FILE: include/dg/AnalysisOptions.h
================================================
#ifndef DG_ANALYSIS_OPTIONS_H_
#define DG_ANALYSIS_OPTIONS_H_
#include <cassert>
#include <map>
#include <string>
#include "Offset.h"
namespace dg {
///
// Enumeration for functions that are known to
// return freshly allocated memory.
enum class AllocationFunction {
NONE, // not an allocation function
MALLOC, // function behaves like malloc
CALLOC, // function behaves like calloc
ALLOCA, // function behaves like alloca
REALLOC, // function behaves like realloc
MALLOC0, // function behaves like malloc,
// but cannot return NULL
CALLOC0, // function behaves like calloc,
// but cannot return NULL
};
struct AnalysisOptions {
// Number of bytes in objects to track precisely
Offset fieldSensitivity{Offset::UNKNOWN};
AnalysisOptions &setFieldSensitivity(Offset o) {
fieldSensitivity = o;
return *this;
}
std::map<const std::string, AllocationFunction> allocationFunctions = {
{"malloc", AllocationFunction::MALLOC},
{"calloc", AllocationFunction::CALLOC},
{"alloca", AllocationFunction::ALLOCA},
{"realloc", AllocationFunction::REALLOC},
};
void addAllocationFunction(const std::string &name, AllocationFunction F) {
#ifndef NDEBUG
auto ret =
#endif
allocationFunctions.emplace(name, F);
assert(ret.second && "Already have this allocation function");
}
AllocationFunction getAllocationFunction(const std::string &name) const {
auto it = allocationFunctions.find(name);
if (it == allocationFunctions.end())
return AllocationFunction::NONE;
return it->second;
}
bool isAllocationFunction(const std::string &name) const {
return getAllocationFunction(name) != AllocationFunction::NONE;
}
};
} // namespace dg
#endif
================================================
FILE: include/dg/BBlock.h
================================================
#ifndef BBLOCK_H_
#define BBLOCK_H_
#include <cassert>
#include <list>
#include "ADT/DGContainer.h"
#include "dg/util/iterators.h"
#include "legacy/Analysis.h"
namespace dg {
/// ------------------------------------------------------------------
// - BBlock
// Basic block structure for dependence graph
/// ------------------------------------------------------------------
template <typename NodeT>
class BBlock {
public:
using BBlockLabelTy = uint8_t;
static const BBlockLabelTy ARTIFICIAL_BBLOCK_LABEL = 255;
static const BBlockLabelTy MAX_BBLOCK_LABEL = ARTIFICIAL_BBLOCK_LABEL;
using KeyT = typename NodeT::KeyType;
using DependenceGraphT = typename NodeT::DependenceGraphType;
struct BBlockEdge {
BBlockEdge(BBlock<NodeT> *t, uint8_t label = 0)
: target(t), label(label) {}
BBlock<NodeT> *target;
// we'll have just numbers as labels now.
// We can change it if there's a need
BBlockLabelTy label;
bool operator==(const BBlockEdge &oth) const {
return target == oth.target && label == oth.label;
}
bool operator!=(const BBlockEdge &oth) const { return operator==(oth); }
bool operator<(const BBlockEdge &oth) const {
return target == oth.target ? label < oth.label
: target < oth.target;
}
};
BBlock<NodeT>(NodeT *head = nullptr, DependenceGraphT *dg = nullptr)
: key(KeyT()), dg(dg), ipostdom(nullptr) {
if (head) {
append(head);
assert(!dg || head->getDG() == nullptr || dg == head->getDG());
}
}
~BBlock<NodeT>() {
if (delete_nodes_on_destr) {
for (NodeT *nd : nodes)
delete nd;
}
}
using BBlockContainerT = EdgesContainer<BBlock<NodeT>>;
// we don't need labels with predecessors
using PredContainerT = EdgesContainer<BBlock<NodeT>>;
using SuccContainerT = DGContainer<BBlockEdge>;
SuccContainerT &successors() { return nextBBs; }
const SuccContainerT &successors() const { return nextBBs; }
PredContainerT &predecessors() { return prevBBs; }
const PredContainerT &predecessors() const { return prevBBs; }
const BBlockContainerT &controlDependence() const { return controlDeps; }
const BBlockContainerT &revControlDependence() const {
return revControlDeps;
}
// similary to nodes, basic blocks can have keys
// they are not stored anywhere, it is more due to debugging
void setKey(const KeyT &k) { key = k; }
const KeyT &getKey() const { return key; }
// XXX we should do it a common base with node
// to not duplicate this - something like
// GraphElement that would contain these attributes
void setDG(DependenceGraphT *d) { dg = d; }
DependenceGraphT *getDG() const { return dg; }
const std::list<NodeT *> &getNodes() const { return nodes; }
std::list<NodeT *> &getNodes() { return nodes; }
bool empty() const { return nodes.empty(); }
size_t size() const { return nodes.size(); }
void append(NodeT *n) {
assert(n && "Cannot add null node to BBlock");
n->setBasicBlock(this);
nodes.push_back(n);
}
void prepend(NodeT *n) {
assert(n && "Cannot add null node to BBlock");
n->setBasicBlock(this);
nodes.push_front(n);
}
bool hasControlDependence() const { return !controlDeps.empty(); }
// return true if all successors point
// to the same basic block (not considering labels,
// just the targets)
bool successorsAreSame() const {
if (nextBBs.size() < 2)
return true;
typename SuccContainerT::const_iterator start, iter, end;
iter = nextBBs.begin();
end = nextBBs.end();
BBlock<NodeT> *block = iter->target;
// iterate over all successor and
// check if they are all the same
for (++iter; iter != end; ++iter)
if (iter->target != block)
return false;
return true;
}
// return true if all successors point
// to the same basic block (not considering labels,
// just the targets)
bool hasSuccessor(BBlock<NodeT> *B) const {
return dg::any_of(successors(), [B](const BBlockEdge &succB) {
return succB.target == B;
});
}
// remove all edges from/to this BB and reconnect them to
// other nodes
void isolate() {
// take every predecessor and reconnect edges from it
// to successors
for (BBlock<NodeT> *pred : prevBBs) {
// find the edge that is going to this node
// and create new edges to all successors. The new edges
// will have the same label as the found one
DGContainer<BBlockEdge> new_edges;
for (auto I = pred->nextBBs.begin(), E = pred->nextBBs.end();
I != E;) {
auto cur = I++;
if (cur->target == this) {
// create edges that will go from the predecessor
// to every successor of this node
for (const BBlockEdge &succ : nextBBs) {
// we cannot create an edge to this bblock (we're
// isolating _this_ bblock), that would be incorrect. It
// can occur when we're isolatin a bblock with self-loop
if (succ.target != this)
new_edges.insert(
BBlockEdge(succ.target, cur->label));
}
// remove the edge from predecessor
pred->nextBBs.erase(*cur);
}
}
// add newly created edges to predecessor
for (const BBlockEdge &edge : new_edges) {
assert(edge.target != this &&
"Adding an edge to a block that is being isolated");
pred->addSuccessor(edge);
}
}
removeSuccessors();
// NOTE: nextBBs were cleared in removeSuccessors()
prevBBs.clear();
// remove reverse edges to this BB
for (BBlock<NodeT> *B : controlDeps) {
// we don't want to corrupt the iterator
// if this block is control dependent on itself.
// We're gonna clear it anyway
if (B == this)
continue;
B->revControlDeps.erase(this);
}
// clear also cd edges that blocks have
// to this block
for (BBlock<NodeT> *B : revControlDeps) {
if (B == this)
continue;
B->controlDeps.erase(this);
}
revControlDeps.clear();
controlDeps.clear();
}
void remove(bool with_nodes = true) {
// do not leave any dangling reference
isolate();
if (dg) {
#ifndef NDEBUG
bool ret =
#endif
dg->removeBlock(key);
assert(ret && "BUG: block was not in DG");
if (dg->getEntryBB() == this)
dg->setEntryBB(nullptr);
}
if (with_nodes) {
for (NodeT *n : nodes) {
// we must set basic block to nullptr
// otherwise the node will try to remove the
// basic block again if it is of size 1
n->setBasicBlock(nullptr);
// remove dependency edges, let be CFG edges
// as we'll destroy all the nodes
n->removeCDs();
n->removeDDs();
// remove the node from dg
assert(n->getDG());
n->getDG()->removeNode(n);
delete n;
}
}
delete this;
}
void removeNode(NodeT *n) { nodes.remove(n); }
size_t successorsNum() const { return nextBBs.size(); }
size_t predecessorsNum() const { return prevBBs.size(); }
bool addSuccessor(const BBlockEdge &edge) {
bool ret = nextBBs.insert(edge);
edge.target->prevBBs.insert(this);
return ret;
}
bool addSuccessor(BBlock<NodeT> *b, uint8_t label = 0) {
return addSuccessor(BBlockEdge(b, label));
}
void removeSuccessors() {
// remove references to this node from successors
for (const BBlockEdge &succ : nextBBs) {
// This assertion does not hold anymore, since if we have
// two edges with different labels to the same successor,
// and we remove the successor, then we remove 'this'
// from prevBBs twice. If we'll add labels even to predecessors,
// this assertion must hold again
// bool ret = succ.target->prevBBs.erase(this);
// assert(ret && "Did not have this BB in successor's pred");
succ.target->prevBBs.erase(this);
}
nextBBs.clear();
}
bool hasSelfLoop() { return nextBBs.contains(this); }
void removeSuccessor(const BBlockEdge &succ) {
succ.target->prevBBs.erase(this);
nextBBs.erase(succ);
}
unsigned removeSuccessorsTarget(BBlock<NodeT> *target) {
unsigned removed = 0;
SuccContainerT tmp;
// approx
for (auto &edge : nextBBs) {
if (edge.target != target)
tmp.insert(edge);
else
++removed;
}
nextBBs.swap(tmp);
return removed;
}
void removePredecessors() {
for (BBlock<NodeT> *BB : prevBBs)
BB->nextBBs.erase(this);
prevBBs.clear();
}
bool addControlDependence(BBlock<NodeT> *b) {
bool ret;
#ifndef NDEBUG
bool ret2;
#endif
ret = controlDeps.insert(b);
#ifndef NDEBUG
ret2 =
#endif
b->revControlDeps.insert(this);
// we either have both edges or none
assert(ret == ret2);
return ret;
}
// get first node from bblock
// or nullptr if the block is empty
NodeT *getFirstNode() const {
if (nodes.empty())
return nullptr;
return nodes.front();
}
// get last node from block
// or nullptr if the block is empty
NodeT *getLastNode() const {
if (nodes.empty())
return nullptr;
return nodes.back();
}
// XXX: do this optional?
BBlockContainerT &getPostDomFrontiers() { return postDomFrontiers; }
const BBlockContainerT &getPostDomFrontiers() const {
return postDomFrontiers;
}
bool addPostDomFrontier(BBlock<NodeT> *BB) {
return postDomFrontiers.insert(BB);
}
bool addDomFrontier(BBlock<NodeT> *DF) { return domFrontiers.insert(DF); }
BBlockContainerT &getDomFrontiers() { return domFrontiers; }
const BBlockContainerT &getDomFrontiers() const { return domFrontiers; }
void setIPostDom(BBlock<NodeT> *BB) {
assert(!ipostdom && "Already has the immedate post-dominator");
ipostdom = BB;
BB->postDominators.insert(this);
}
BBlock<NodeT> *getIPostDom() { return ipostdom; }
const BBlock<NodeT> *getIPostDom() const { return ipostdom; }
BBlockContainerT &getPostDominators() { return postDominators; }
const BBlockContainerT &getPostDominators() const { return postDominators; }
void setIDom(BBlock<NodeT> *BB) {
assert(!idom && "Already has immediate dominator");
idom = BB;
BB->addDominator(this);
}
void addDominator(BBlock<NodeT> *BB) {
assert(BB && "need dominator bblock");
dominators.insert(BB);
}
BBlock<NodeT> *getIDom() { return idom; }
const BBlock<NodeT> *getIDom() const { return idom; }
BBlockContainerT &getDominators() { return dominators; }
const BBlockContainerT &getDominators() const { return dominators; }
unsigned int getDFSOrder() const { return analysisAuxData.dfsorder; }
// in order to fasten up interprocedural analyses,
// we register all the call sites in the BBlock
unsigned int getCallSitesNum() const { return callSites.size(); }
const std::set<NodeT *> &getCallSites() { return callSites; }
bool addCallsite(NodeT *n) {
assert(n->getBBlock() == this &&
"Cannot add callsite from different BB");
return callSites.insert(n).second;
}
bool removeCallSite(NodeT *n) {
assert(n->getBBlock() == this && "Removing callsite from different BB");
return callSites.erase(n) != 0;
}
void setSlice(uint64_t sid) { slice_id = sid; }
uint64_t getSlice() const { return slice_id; }
void deleteNodesOnDestruction(bool v = true) { delete_nodes_on_destr = v; }
private:
// optional key
KeyT key;
// reference to dg if needed
DependenceGraphT *dg;
// nodes contained in this bblock
std::list<NodeT *> nodes;
SuccContainerT nextBBs;
PredContainerT prevBBs;
// when we have basic blocks, we do not need
// to keep control dependencies in nodes, because
// all nodes in block has the same control dependence
BBlockContainerT controlDeps;
BBlockContainerT revControlDeps;
// post-dominator frontiers
BBlockContainerT postDomFrontiers;
BBlock<NodeT> *ipostdom;
// the post-dominator tree edges
// (reverse to immediate post-dominator)
BBlockContainerT postDominators;
// parent of @this in dominator tree
BBlock<NodeT> *idom = nullptr;
// BB.dominators = all children in dominator tree
BBlockContainerT dominators;
// dominance frontiers
BBlockContainerT domFrontiers;
// is this block in some slice?
uint64_t slice_id{0};
// delete nodes on destruction of the block
bool delete_nodes_on_destr = false;
// auxiliary data for analyses
std::set<NodeT *> callSites;
// auxiliary data for different analyses
legacy::AnalysesAuxiliaryData analysisAuxData;
friend class legacy::BBlockAnalysis<NodeT>;
};
} // namespace dg
#endif // _BBLOCK_H_
================================================
FILE: include/dg/BBlockBase.h
================================================
#ifndef DG_BBLOCK_BASE_H_
#define DG_BBLOCK_BASE_H_
#include <list>
#include <vector>
namespace dg {
class ElemId {
static unsigned idcnt;
unsigned id;
public:
ElemId() : id(++idcnt) {}
unsigned getID() const { return id; }
};
template <typename ElemT>
class ElemWithEdges {
using EdgesT = std::vector<ElemT *>;
protected:
EdgesT _successors;
EdgesT _predecessors;
public:
auto succ_begin() -> decltype(_successors.begin()) {
return _successors.begin();
}
auto succ_end() -> decltype(_successors.begin()) {
return _successors.end();
}
auto pred_begin() -> decltype(_predecessors.begin()) {
return _predecessors.begin();
}
auto pred_end() -> decltype(_predecessors.begin()) {
return _predecessors.end();
}
auto succ_begin() const -> decltype(_successors.begin()) {
return _successors.begin();
}
auto succ_end() const -> decltype(_successors.begin()) {
return _successors.end();
}
auto pred_begin() const -> decltype(_predecessors.begin()) {
return _predecessors.begin();
}
auto pred_end() const -> decltype(_predecessors.begin()) {
return _predecessors.end();
}
const EdgesT &successors() const { return _successors; }
const EdgesT &predecessors() const { return _predecessors; }
bool hasSuccessors() const { return !_successors.empty(); }
bool hasPredecessors() const { return !_predecessors.empty(); }
void addSuccessor(ElemT *s) {
for (auto *succ : _successors) {
if (succ == s)
return;
}
_successors.push_back(s);
for (auto *pred : s->_predecessors) {
if (pred == this)
return;
}
s->_predecessors.push_back(static_cast<ElemT *>(this));
}
ElemT *getSinglePredecessor() {
return _predecessors.size() == 1 ? _predecessors.back() : nullptr;
}
ElemT *getSingleSuccessor() {
return _successors.size() == 1 ? _successors.back() : nullptr;
}
};
template <typename ElemT>
class CFGElement : public ElemId, public ElemWithEdges<ElemT> {};
template <typename ElemT, typename NodeT>
class BBlockBase : public CFGElement<ElemT> {
using NodesT = std::list<NodeT *>;
NodesT _nodes;
public:
void append(NodeT *n) {
_nodes.push_back(n);
n->setBBlock(static_cast<ElemT *>(this));
}
void prepend(NodeT *n) {
_nodes.push_front(n);
n->setBBlock(static_cast<ElemT *>(this));
}
void insertBefore(NodeT *n, NodeT *before) {
assert(!_nodes.empty());
auto it = _nodes.begin();
while (it != _nodes.end()) {
if (*it == before)
break;
++it;
}
assert(it != _nodes.end() && "Did not find 'before' node");
_nodes.insert(it, n);
n->setBBlock(static_cast<ElemT *>(this));
}
// FIXME: rename to nodes()
const NodesT &getNodes() const { return _nodes; }
NodesT &getNodes() { return _nodes; }
// FIXME: rename to first/front(), last/back()
NodeT *getFirst() { return _nodes.empty() ? nullptr : _nodes.front(); }
NodeT *getLast() { return _nodes.empty() ? nullptr : _nodes.back(); }
const NodeT *getFirst() const {
return _nodes.empty() ? nullptr : _nodes.front();
}
const NodeT *getLast() const {
return _nodes.empty() ? nullptr : _nodes.back();
}
bool empty() const { return _nodes.empty(); }
auto size() const -> decltype(_nodes.size()) { return _nodes.size(); }
};
} // namespace dg
#endif
================================================
FILE: include/dg/BBlocksBuilder.h
================================================
#ifndef DG_BBLOCKS_BUILDER_H_
#define DG_BBLOCKS_BUILDER_H_
#include <cassert>
#include <memory>
#include "dg/ADT/Queue.h"
namespace dg {
///
// Generate basic blocks from nodes with successors.
template <typename BBlockT>
class BBlocksBuilder {
using NodeT = typename BBlockT::NodeT;
std::vector<std::unique_ptr<BBlockT>> _blocks;
// FIXME: use bitvector?
std::set<unsigned> _processed;
ADT::QueueFIFO<NodeT *> _queue;
bool enqueue(NodeT *n) {
// the id 0 is reserved for invalid nodes
assert(n->getID() != 0 && "Queued invalid node");
if (!static_cast<bool>(_processed.insert(n->getID()).second))
return false; // we already queued this node
_queue.push(n);
assert(enqueue(n) == false);
return true;
}
void setNewBlock(NodeT *cur) {
auto *blk = new BBlockT();
_blocks.emplace_back(blk);
blk->append(cur);
cur->setBBlock(blk);
}
void addToBlock(NodeT *cur, BBlockT *blk) {
cur->setBBlock(blk);
blk->append(cur);
}
void setBlock(NodeT *cur) {
if (cur->predecessorsNum() == 0 // root node
|| cur->predecessorsNum() > 1) { // join
setNewBlock(cur);
return;
}
assert(cur->predecessorsNum() == 1);
// if we are the entry node after branching,
// we create a new block
if (cur->getSinglePredecessor()->successorsNum() > 1) {
setNewBlock(cur);
return;
}
// We are inside a block, set the block from
// the predecessor
assert(cur->getSinglePredecessor()->getBBlock());
addToBlock(cur, cur->getSinglePredecessor()->getBBlock());
}
public:
void buildBlocks(NodeT *root) {
enqueue(root);
while (!_queue.empty()) {
NodeT *cur = _queue.pop();
assert(cur->getBBlock() == nullptr);
setBlock(cur);
// queue successors for processing
for (NodeT *succ : cur->successors()) {
enqueue(succ);
}
}
}
std::vector<std::unique_ptr<BBlockT>> &getBlocks() { return _blocks; }
std::vector<std::unique_ptr<BBlockT>> &&buildAndGetBlocks(NodeT *root) {
buildBlocks(root);
return std::move(_blocks);
}
};
} // namespace dg
#endif
================================================
FILE: include/dg/BFS.h
================================================
#ifndef DG_BFS_H_
#define DG_BFS_H_
#include "dg/ADT/Queue.h"
#include "dg/NodesWalk.h"
using dg::ADT::QueueFIFO;
namespace dg {
template <typename Node, typename VisitTracker = SetVisitTracker<Node>,
typename EdgeChooser = SuccessorsEdgeChooser<Node>>
struct BFS
: public NodesWalk<Node, QueueFIFO<Node *>, VisitTracker, EdgeChooser> {
BFS() = default;
BFS(EdgeChooser chooser)
: NodesWalk<Node, QueueFIFO<Node *>, VisitTracker, EdgeChooser>(
std::move(chooser)) {}
BFS(VisitTracker tracker)
: NodesWalk<Node, QueueFIFO<Node *>, VisitTracker, EdgeChooser>(
std::move(tracker)) {}
BFS(VisitTracker tracker, EdgeChooser chooser)
: NodesWalk<Node, QueueFIFO<Node *>, VisitTracker, EdgeChooser>(
std::move(tracker), std::move(chooser)) {}
};
} // namespace dg
#endif
================================================
FILE: include/dg/CallGraph/CallGraph.h
================================================
#ifndef DG_GENERIC_CALLGRAPH_H_
#define DG_GENERIC_CALLGRAPH_H_
#include <map>
#include <vector>
#include "dg/util/iterators.h"
namespace dg {
template <typename ValueT>
class GenericCallGraph {
public:
class FuncNode {
unsigned _id;
unsigned _scc_id{0};
std::vector<FuncNode *> _calls;
std::vector<FuncNode *> _callers;
template <typename Cont>
bool _contains(const FuncNode *x, const Cont &C) const {
return dg::any_of(C, [x](FuncNode *s) { return s == x; });
}
public:
const ValueT value;
FuncNode(unsigned id, const ValueT &nd) : _id(id), value(nd){};
FuncNode(FuncNode &&) = default;
bool calls(const FuncNode *x) const { return _contains(x, _calls); }
bool isCalledBy(FuncNode *x) const { return _contains(x, _callers); }
unsigned getID() const { return _id; }
unsigned getSCCId() const { return _scc_id; }
void setSCCId(unsigned id) { _scc_id = id; }
bool addCall(FuncNode *x) {
if (calls(x))
return false;
_calls.push_back(x);
if (!x->isCalledBy(this))
x->_callers.push_back(this);
return true;
}
const std::vector<FuncNode *> &getCalls() const { return _calls; }
// alias for getCalls()
const std::vector<FuncNode *> &successors() const { return getCalls(); }
const std::vector<FuncNode *> &getCallers() const { return _callers; }
const ValueT &getValue() const { return value; };
};
private:
unsigned last_id{0};
FuncNode *getOrCreate(const ValueT &v) {
auto it = _mapping.find(v);
if (it == _mapping.end()) {
auto newIt = _mapping.emplace(v, FuncNode(++last_id, v));
return &newIt.first->second;
}
return &it->second;
}
std::map<const ValueT, FuncNode> _mapping;
public:
// just create a node for the value
// (e.g., the entry node)
FuncNode *createNode(const ValueT &a) { return getOrCreate(a); }
// a calls b
bool addCall(const ValueT &a, const ValueT &b) {
auto A = getOrCreate(a);
auto B = getOrCreate(b);
return A->addCall(B);
}
const FuncNode *get(const ValueT &v) const {
auto it = _mapping.find(v);
if (it == _mapping.end()) {
return nullptr;
}
return &it->second;
}
FuncNode *get(const ValueT &v) {
auto it = _mapping.find(v);
if (it == _mapping.end()) {
return nullptr;
}
return &it->second;
}
bool empty() const { return _mapping.empty(); }
auto begin() -> decltype(_mapping.begin()) { return _mapping.begin(); }
auto end() -> decltype(_mapping.end()) { return _mapping.end(); }
auto begin() const -> decltype(_mapping.begin()) {
return _mapping.begin();
}
auto end() const -> decltype(_mapping.end()) { return _mapping.end(); }
};
} // namespace dg
#endif
================================================
FILE: include/dg/ControlDependence/ControlDependenceAnalysisOptions.h
================================================
#ifndef DG_CDA_OPTIONS_H_
#define DG_CDA_OPTIONS_H_
#include "dg/AnalysisOptions.h"
namespace dg {
struct ControlDependenceAnalysisOptions : AnalysisOptions {
// FIXME: add options class for CD
enum class CDAlgorithm {
STANDARD,
NTSCD_LEGACY,
NTSCD2,
NTSCD_RANGANATH, // fixed version of Ranganath's alg.
NTSCD_RANGANATH_ORIG, // original (wrong) version of Ranaganath's alg.
NTSCD,
DOD_RANGANATH,
DOD,
DODNTSCD, // DOD + NTSCD
STRONG_CC
} algorithm;
// take into account interprocedural control dependencies
// (raising e.g., from calls to exit() which terminates the program)
bool interprocedural{true};
bool standardCD() const { return algorithm == CDAlgorithm::STANDARD; }
bool ntscdCD() const { return algorithm == CDAlgorithm::NTSCD; }
bool ntscd2CD() const { return algorithm == CDAlgorithm::NTSCD2; }
bool ntscdRanganathCD() const {
return algorithm == CDAlgorithm::NTSCD_RANGANATH;
}
bool ntscdRanganathOrigCD() const {
return algorithm == CDAlgorithm::NTSCD_RANGANATH_ORIG;
}
bool ntscdLegacyCD() const {
return algorithm == CDAlgorithm::NTSCD_LEGACY;
}
bool dodRanganathCD() const {
return algorithm == CDAlgorithm::DOD_RANGANATH;
}
bool dodCD() const { return algorithm == CDAlgorithm::DOD; }
bool dodntscdCD() const { return algorithm == CDAlgorithm::DODNTSCD; }
bool strongCC() const { return algorithm == CDAlgorithm::STRONG_CC; }
bool interproceduralCD() const { return interprocedural; }
///
// Return true if the computed control dependencies
// contain NTSCD dependencies
bool isNonterminationSensitive() const {
// DOD is for infinite loops, but it is not what we
// want when asking for non-termination sensitive...
return !standardCD() && !dodCD() && !dodRanganathCD();
}
};
} // namespace dg
#endif
================================================
FILE: include/dg/DFS.h
================================================
#ifndef DG_DFS_H_
#define DG_DFS_H_
#include "dg/ADT/Queue.h"
#include "dg/NodesWalk.h"
using dg::ADT::QueueLIFO;
namespace dg {
template <typename Node, typename VisitTracker = SetVisitTracker<Node>,
typename EdgeChooser = SuccessorsEdgeChooser<Node>>
struct DFS
: public NodesWalk<Node, QueueLIFO<Node *>, VisitTracker, EdgeChooser> {
DFS() = default;
DFS(EdgeChooser chooser)
: NodesWalk<Node, QueueLIFO<Node *>, VisitTracker, EdgeChooser>(
std::move(chooser)) {}
DFS(VisitTracker tracker)
: NodesWalk<Node, QueueLIFO<Node *>, VisitTracker, EdgeChooser>(
std::move(tracker)) {}
DFS(VisitTracker tracker, EdgeChooser chooser)
: NodesWalk<Node, QueueLIFO<Node *>, VisitTracker, EdgeChooser>(
std::move(tracker), std::move(chooser)) {}
};
} // namespace dg
#endif
================================================
FILE: include/dg/DG2Dot.h
================================================
#ifndef DG_2_DOT_H_
#define DG_2_DOT_H_
#include <fstream>
#include <iostream>
#include <set>
#include "dg/DFS.h"
#include "dg/DependenceGraph.h"
namespace dg {
namespace debug {
enum dg2dot_options {
PRINT_NONE = 0, // print no edges
PRINT_CFG = 1 << 0,
PRINT_REV_CFG = 1 << 1,
PRINT_DD = 1 << 2,
PRINT_REV_DD = 1 << 3,
PRINT_USE = 1 << 4,
PRINT_USER = 1 << 5,
PRINT_CD = 1 << 6,
PRINT_REV_CD = 1 << 7,
PRINT_ID = 1 << 8,
PRINT_REV_ID = 1 << 9,
PRINT_CALL = 1 << 10,
PRINT_POSTDOM = 1 << 11,
PRINT_ALL = 0xfff
};
struct Indent {
int ind;
Indent(int ind = 1) : ind(ind) {}
friend std::ostream &operator<<(std::ostream &os, const Indent &ind);
};
std::ostream &operator<<(std::ostream &os, const Indent &ind) {
for (int i = 0; i < ind.ind; ++i)
os << "\t";
return os;
}
template <typename NodeT>
class DG2Dot {
std::set<const typename DependenceGraph<NodeT>::ContainerType *>
dumpedGlobals;
// slicing criteria
std::set<NodeT *> criteria;
public:
using KeyT = typename NodeT::KeyType;
DG2Dot<NodeT>(DependenceGraph<NodeT> *dg,
uint32_t opts = PRINT_CFG | PRINT_DD | PRINT_CD | PRINT_USE,
const char *file = nullptr)
: options(opts), dg(dg), file(file) {
// if a graph has no global nodes, this will forbid trying to print them
dumpedGlobals.insert(nullptr);
reopen(file);
}
void setSlicingCriteria(const std::set<NodeT *> &crit) { criteria = crit; }
bool open(const char *new_file) {
if (out.is_open()) {
std::cerr << "File already opened (" << file << ")" << std::endl;
return false;
}
reopen(new_file);
}
virtual std::ostream &printKey(std::ostream &os, KeyT key) {
os << key;
return os;
}
// \return - error state: true if there's an error, false otherwise
virtual bool checkNode(std::ostream &os, NodeT *node) {
bool err = false;
if (!node->getBBlock()) {
err = true;
os << "\\nERR: no BB";
}
return err;
}
bool ensureFile(const char *fl) {
if (fl)
reopen(fl);
if (!out.is_open()) {
std::cerr << "File '" << file << "' not opened" << std::endl;
return false;
}
return true;
}
virtual bool dump(const char *new_file = nullptr,
const char *only_functions = nullptr) {
(void) only_functions;
if (!ensureFile(new_file))
return false;
start();
#ifdef ENABLE_CFG
dumpBBs(dg);
#endif
// even when we have printed nodes while
// going through BBs, print nodes again,
// so that we'll see if there are any nodes
// that are not in BBs
dump_nodes();
dump_edges();
// print subgraphs once we printed all the nodes
if (!subgraphs.empty())
out << "\n\t/* ----------- SUBGRAPHS ---------- */\n\n";
for (auto sub : subgraphs) {
dump_subgraph(sub);
}
end();
out.close();
return true;
}
/* if user want's manual printing, he/she can */
void start() {
out << "digraph \"DependenceGraph\" {\n";
out << "\tcompound=true label=\"Graph " << dg << " has " << dg->size()
<< " nodes\\n\n"
<< "\tdd edges color: " << dd_color << "\n"
<< "\tuse edges color: " << use_color << ", dashed\n"
<< "\tcd edges color: " << cd_color << "\n"
<< "\tcfg edges color: " << cfg_color << "\"\n\n";
}
void end() { out << "}\n"; }
void dumpSubgraphStart(DependenceGraph<NodeT> *sub,
const char *name = nullptr) {
out << "\t/* subgraph " << sub << " nodes */\n";
out << "\tsubgraph cluster_" << sub << " {\n";
out << "\t\tstyle=\"filled, rounded\" fillcolor=gray95\n";
out << "\t\tlabel=\"Subgraph ";
if (name)
out << name << " ";
out << "[" << sub << "]"
<< "\\nhas " << sub->size() << " nodes\n";
uint64_t slice_id = sub->getSlice();
if (slice_id != 0)
out << "\\nslice: " << slice_id;
out << "\"\n";
// dump BBs of the formal parameters
dump_parameters(sub, 2);
}
void dumpSubgraphEnd(DependenceGraph<NodeT> *sub, bool with_nodes = true) {
if (with_nodes) {
// dump all nodes, to get it without BBlocks
// (we may not have BBlocks or we just don't want
// to print them
for (auto &I : *sub) {
dump_node(I.second, 2);
dump_node_edges(I.second, 2);
}
if (dumpedGlobals.insert(sub->getGlobalNodes().get()).second) {
for (auto &I : *sub->getGlobalNodes()) {
dump_node(I.second, 2, "GLOB");
dump_node_edges(I.second, 2);
}
}
}
out << "\t}\n";
}
void dumpSubgraph(DependenceGraph<NodeT> *sub) {
dumpSubgraphStart(sub);
dumpSubgraphEnd(sub);
}
void dumpBBlock(BBlock<NodeT> *BB, int ind = 2) { dumpBB(BB, ind); }
void dumpBBlockEdges(BBlock<NodeT> *BB, int ind = 1) {
dumpBBedges(BB, ind);
}
private:
// what all to print?
uint32_t options;
void reopen(const char *new_file) {
if (!new_file)
new_file = "/dev/stdout";
if (out.is_open())
out.close();
out.open(new_file);
file = new_file;
}
void dumpBB(const BBlock<NodeT> *BB, int indent) {
Indent Ind(indent);
out << Ind << "/* Basic Block ";
printKey(out, BB->getKey());
out << " [" << BB << "] */\n";
out << Ind << "subgraph cluster_bb_" << BB << " {\n";
out << Ind << "\tstyle=filled fillcolor=white\n";
out << Ind << "\tlabel=\"";
printKey(out, BB->getKey());
out << " [" << BB << "]";
unsigned int dfsorder = BB->getDFSOrder();
if (dfsorder != 0)
out << Ind << "\\ndfs order: " << dfsorder;
uint64_t slice_id = BB->getSlice();
if (slice_id != 0)
out << "\\nslice: " << slice_id;
out << "\"\n";
for (NodeT *n : BB->getNodes()) {
// print nodes in BB, edges will be printed later
out << Ind << "\tNODE" << n << " [shape=rect label=\""
<< n->getKey() << "\"]\n";
}
out << Ind << "} /* cluster_bb_" << BB << " */\n\n";
}
void dumpBBedges(BBlock<NodeT> *BB, int indent) {
Indent Ind(indent);
if (options & PRINT_CFG) {
for (auto S : BB->successors()) {
NodeT *lastNode = BB->getLastNode();
NodeT *firstNode = S.target->getFirstNode();
out << Ind << "NODE" << lastNode << " -> "
<< "NODE" << firstNode << " [penwidth=2 label=\""
<< static_cast<int>(S.label) << "\""
<< " ltail=cluster_bb_" << BB << " lhead=cluster_bb_"
<< S.target << " color=\"" << cfg_color << "\""
<< "]\n";
}
}
if (options & PRINT_REV_CFG) {
for (auto S : BB->predecessors()) {
NodeT *lastNode = S->getLastNode();
NodeT *firstNode = BB->getFirstNode();
out << Ind << "NODE" << firstNode << " -> "
<< "NODE" << lastNode << " [penwidth=2 color=\""
<< cfg_color << "\" dashed"
<< " ltail=cluster_bb_" << BB << " lhead=cluster_bb_" << S
<< " constraint=false]\n";
}
}
if (options & PRINT_CD) {
for (auto S : BB->controlDependence()) {
NodeT *lastNode = BB->getLastNode();
NodeT *firstNode = S->getFirstNode();
out << Ind << "NODE" << lastNode << " -> "
<< "NODE" << firstNode << " [penwidth=2 color=blue"
<< " ltail=cluster_bb_" << BB << " lhead=cluster_bb_" << S
<< "]\n";
}
for (BBlock<NodeT> *S : BB->getPostDomFrontiers()) {
NodeT *start = BB->getFirstNode();
NodeT *end = S->getLastNode();
out << Ind << "/* post-dominance frontiers */\n"
<< "NODE" << start << " -> "
<< "NODE" << end << " [penwidth=3 color=green"
<< " ltail=cluster_bb_" << BB << " lhead=cluster_bb_" << S
<< " constraint=false]\n";
}
}
if (options & PRINT_POSTDOM) {
BBlock<NodeT> *ipd = BB->getIPostDom();
if (ipd) {
NodeT *firstNode = BB->getFirstNode();
NodeT *lastNode = ipd->getLastNode();
out << Ind << "NODE" << lastNode << " -> "
<< "NODE" << firstNode << " [penwidth=3 color=purple"
<< " ltail=cluster_bb_" << BB << " lhead=cluster_bb_"
<< ipd << " constraint=false]\n";
}
}
}
void dump_parameters(NodeT *node, int ind) {
DGParameters<NodeT> *params = node->getParameters();
if (params) {
dump_parameters(params, ind, false);
}
}
void dump_parameters(DependenceGraph<NodeT> *g, int ind) {
DGParameters<NodeT> *params = g->getParameters();
if (params) {
dump_parameters(params, ind, true);
}
}
void dump_parameters(DGParameters<NodeT> *params, int ind, bool formal) {
Indent Ind(ind);
// FIXME
// out << Ind << "/* Input parameters */\n";
// dumpBB(params->getBBIn(), data);
// out << Ind << "/* Output parameters */\n";
// dumpBB(params->getBBOut(), data);
// dump all the nodes again to get the names
for (auto it : *params) {
auto &p = it.second;
if (p.in) {
dump_node(p.in, ind, formal ? "[f] IN ARG" : "IN ARG");
dump_node_edges(p.in, ind);
} else
out << "NO IN ARG";
if (p.out) {
dump_node(p.out, ind, formal ? "[f] OUT ARG" : "OUT ARG");
dump_node_edges(p.out, ind);
} else
out << "NO OUT ARG";
}
for (auto I = params->global_begin(), E = params->global_end(); I != E;
++I) {
auto &p = I->second;
if (p.in) {
dump_node(p.in, ind, formal ? "[f] GLOB IN" : "GLOB IN");
dump_node_edges(p.in, ind);
} else
out << "NO GLOB IN ARG";
if (p.out) {
dump_node(p.out, ind, formal ? "[f] GLOB OUT" : "GLOB OUT");
dump_node_edges(p.out, ind);
} else
out << "NO GLOB OUT ARG";
}
auto p = params->getVarArg();
if (p) {
if (p->in) {
dump_node(p->in, ind, "[va] IN ARG");
dump_node_edges(p->in, ind);
} else
out << "NO IN va ARG";
if (p->out) {
dump_node(p->out, ind, "[va] OUT ARG");
dump_node_edges(p->out, ind);
} else
out << "NO OUT ARG";
}
if (auto *noret = params->getNoReturn()) {
dump_node(noret, ind, "[noret]");
dump_node_edges(noret, ind);
}
}
void dump_subgraph(DependenceGraph<NodeT> *sub) {
dumpSubgraphStart(sub);
#ifdef ENABLE_CFG
// dump BBs in the subgraph
dumpBBs(sub, 2);
#endif
// dump all nodes again, if there is any that is
// not in any BB
for (auto &I : *sub)
dump_node(I.second, 2);
// dump edges between nodes
for (auto &I : *sub)
dump_node_edges(I.second, 2);
dumpSubgraphEnd(sub);
}
void dumpBBs(DependenceGraph<NodeT> *graph, int ind = 1) {
for (auto it : graph->getBlocks())
dumpBB(it.second, ind);
// print CFG edges between BBs
if (options & (PRINT_CFG | PRINT_REV_CFG)) {
out << Indent(ind) << "/* CFG edges */\n";
for (auto it : graph->getBlocks())
dumpBBedges(it.second, ind);
}
}
void dump_node(NodeT *node, int ind = 1, const char *prefix = nullptr) {
bool err = false;
unsigned int dfsorder = node->getDFSOrder();
unsigned int bfsorder = node->getDFSOrder();
uint32_t slice_id = node->getSlice();
Indent Ind(ind);
out << Ind << "NODE" << node << " [label=\"";
if (prefix)
out << prefix << " ";
printKey(out, node->getKey());
if (node->hasSubgraphs())
out << "\\nsubgraphs: " << node->subgraphsNum();
if (dfsorder != 0)
out << "\\ndfs order: " << dfsorder;
if (bfsorder != 0)
out << "\\nbfs order: " << bfsorder;
if (slice_id != 0)
out << "\\nslice: " << slice_id;
// check if the node is OK, and if not
// highlight it
err = checkNode(out, node);
// end of label
out << "\" ";
if (err) {
out << "style=filled fillcolor=red";
} else if (criteria.count(node) > 0) {
out << "style=filled fillcolor=orange";
} else if (slice_id != 0)
out << "style=filled fillcolor=greenyellow";
else
out << "style=filled fillcolor=white";
out << "]\n";
dump_parameters(node, ind);
if (node->hasSubgraphs() && (options & PRINT_CALL)) {
// add call-site to callee edges
for (auto subgraph : node->getSubgraphs()) {
out << Ind << "NODE" << node << " -> NODE"
<< subgraph->getEntry() << " [label=\"call\""
<< " lhead=cluster_" << subgraph
<< " penwidth=3 style=dashed]\n";
}
}
}
void dump_nodes() {
out << "\t/* nodes */\n";
for (auto &I : *dg) {
auto *node = I.second;
dump_node(node);
for (auto subgraph : node->getSubgraphs()) {
subgraphs.insert(subgraph);
}
}
if (dumpedGlobals.insert(dg->getGlobalNodes().get()).second)
for (auto &I : *dg->getGlobalNodes())
dump_node(I.second, 1, "GL");
}
void dump_edges() {
for (auto &I : *dg) {
dump_node_edges(I.second);
}
if (dumpedGlobals.insert(dg->getGlobalNodes().get()).second)
for (auto &I : *dg->getGlobalNodes())
dump_node_edges(I.second);
}
void dump_node_edges(NodeT *n, int ind = 1) {
Indent Ind(ind);
out << Ind << "/* -- node " << n->getKey() << "\n"
<< Ind << " * ------------------------------------------- */\n";
if (options & PRINT_DD) {
out << Ind << "/* DD edges */\n";
for (auto II = n->data_begin(), EE = n->data_end(); II != EE; ++II)
out << Ind << "NODE" << n << " -> NODE" << *II << " [color=\""
<< dd_color << "\" rank=max]\n";
}
if (options & PRINT_REV_DD) {
out << Ind << "/* reverse DD edges */\n";
for (auto II = n->rev_data_begin(), EE = n->rev_data_end();
II != EE; ++II)
out << Ind << "NODE" << n << " -> NODE" << *II << " [color=\""
<< dd_color << "\" st
gitextract_sogryq7m/
├── .clang-format
├── .clang-tidy
├── .git-blame-ignore-revs
├── .github/
│ └── workflows/
│ ├── clang-format.yml
│ ├── docker.yml
│ ├── hash_map.yml
│ ├── linux.yml
│ ├── mac.yml
│ └── svf.yml
├── .gitignore
├── .travis.yml
├── CMakeLists.txt
├── Changelog
├── Dockerfile
├── LICENSE
├── README.md
├── dg.spec.rpkg
├── doc/
│ ├── CDA.md
│ ├── DDA.md
│ ├── PTA.md
│ ├── README.md
│ ├── SVF.md
│ ├── compiling.md
│ ├── compiling_ubuntu_trusty.md
│ ├── compiling_ubuntu_xenial.md
│ ├── downloading.md
│ ├── llvm-slicer.md
│ └── tools.md
├── include/
│ └── dg/
│ ├── ADT/
│ │ ├── Bits.h
│ │ ├── Bitvector.h
│ │ ├── DGContainer.h
│ │ ├── DisjunctiveIntervalMap.h
│ │ ├── HashMap.h
│ │ ├── HashMapImpl.h
│ │ ├── IntervalsList.h
│ │ ├── Map.h
│ │ ├── NumberSet.h
│ │ ├── Queue.h
│ │ ├── STLHashMap.h
│ │ ├── SetQueue.h
│ │ └── TslHopscotchHashMap.h
│ ├── AnalysisOptions.h
│ ├── BBlock.h
│ ├── BBlockBase.h
│ ├── BBlocksBuilder.h
│ ├── BFS.h
│ ├── CallGraph/
│ │ └── CallGraph.h
│ ├── ControlDependence/
│ │ └── ControlDependenceAnalysisOptions.h
│ ├── DFS.h
│ ├── DG2Dot.h
│ ├── DGParameters.h
│ ├── DataDependence/
│ │ ├── DataDependence.h
│ │ ├── DataDependenceAnalysisImpl.h
│ │ └── DataDependenceAnalysisOptions.h
│ ├── DependenceGraph.h
│ ├── Dominators/
│ │ ├── DominanceFrontiers.h
│ │ └── PostDominanceFrontiers.h
│ ├── MemorySSA/
│ │ ├── Definitions.h
│ │ ├── DefinitionsMap.h
│ │ ├── MemorySSA.h
│ │ └── ModRef.h
│ ├── MemoryState.h
│ ├── Node.h
│ ├── NodesWalk.h
│ ├── Offset.h
│ ├── PointerAnalysis/
│ │ ├── MemoryObject.h
│ │ ├── PSNode.h
│ │ ├── Pointer.h
│ │ ├── PointerAnalysis.h
│ │ ├── PointerAnalysisFI.h
│ │ ├── PointerAnalysisFS.h
│ │ ├── PointerAnalysisFSInv.h
│ │ ├── PointerAnalysisOptions.h
│ │ ├── PointerGraph.h
│ │ ├── PointerGraphOptimizations.h
│ │ ├── PointerGraphValidator.h
│ │ ├── PointsToMapping.h
│ │ ├── PointsToSet.h
│ │ └── PointsToSets/
│ │ ├── AlignedPointerIdPointsToSet.h
│ │ ├── AlignedSmallOffsetsPointsToSet.h
│ │ ├── LookupTable.h
│ │ ├── OffsetsSetPointsToSet.h
│ │ ├── PointerIdPointsToSet.h
│ │ ├── SeparateOffsetsPointsToSet.h
│ │ ├── SimplePointsToSet.h
│ │ └── SmallOffsetsPointsToSet.h
│ ├── ReadWriteGraph/
│ │ ├── DefSite.h
│ │ ├── RWBBlock.h
│ │ ├── RWNode.h
│ │ ├── RWSubgraph.h
│ │ └── ReadWriteGraph.h
│ ├── SCC.h
│ ├── Slicing.h
│ ├── SubgraphBase.h
│ ├── SubgraphNode.h
│ ├── SystemDependenceGraph/
│ │ ├── DGArgumentPair.h
│ │ ├── DGBBlock.h
│ │ ├── DGElement.h
│ │ ├── DGNode.h
│ │ ├── DGNodeCall.h
│ │ ├── DGParameters.h
│ │ ├── DepDGElement.h
│ │ ├── DependenceGraph.h
│ │ └── SystemDependenceGraph.h
│ ├── ValueRelations/
│ │ ├── Bucket.h
│ │ ├── Relations.h
│ │ └── RelationsGraph.h
│ ├── legacy/
│ │ ├── Analysis.h
│ │ ├── BFS.h
│ │ ├── DFS.h
│ │ ├── DataFlowAnalysis.h
│ │ └── NodesWalk.h
│ ├── llvm/
│ │ ├── CallGraph/
│ │ │ └── CallGraph.h
│ │ ├── ControlDependence/
│ │ │ ├── ControlDependence.h
│ │ │ ├── LLVMControlDependenceAnalysisImpl.h
│ │ │ └── LLVMControlDependenceAnalysisOptions.h
│ │ ├── DataDependence/
│ │ │ ├── DataDependence.h
│ │ │ └── LLVMDataDependenceAnalysisOptions.h
│ │ ├── Dominators/
│ │ │ └── Dominators.h
│ │ ├── LLVMAnalysisOptions.h
│ │ ├── LLVMDG2Dot.h
│ │ ├── LLVMDGAssemblyAnnotationWriter.h
│ │ ├── LLVMDependenceGraph.h
│ │ ├── LLVMDependenceGraphBuilder.h
│ │ ├── LLVMNode.h
│ │ ├── LLVMSlicer.h
│ │ ├── PointerAnalysis/
│ │ │ ├── DGPointerAnalysis.h
│ │ │ ├── LLVMPointerAnalysisOptions.h
│ │ │ ├── LLVMPointsToSet.h
│ │ │ ├── PointerAnalysis.h
│ │ │ ├── PointerGraph.h
│ │ │ └── SVFPointerAnalysis.h
│ │ ├── SystemDependenceGraph/
│ │ │ ├── SDG2Dot.h
│ │ │ ├── SystemDependenceGraph.h
│ │ │ └── SystemDependenceGraphBuilder.h
│ │ ├── ThreadRegions/
│ │ │ ├── ControlFlowGraph.h
│ │ │ ├── MayHappenInParallel.h
│ │ │ └── ThreadRegion.h
│ │ └── ValueRelations/
│ │ ├── GraphBuilder.h
│ │ ├── GraphElements.h
│ │ ├── RelationsAnalyzer.h
│ │ ├── StructureAnalyzer.h
│ │ ├── StructureElements.h
│ │ ├── UniquePtrVector.h
│ │ ├── ValueRelations.h
│ │ └── getValName.h
│ └── util/
│ ├── TimeMeasure.h
│ ├── cow_shared_ptr.h
│ ├── debug.h
│ └── iterators.h
├── lib/
│ ├── BBlockBase.cpp
│ ├── CMakeLists.txt
│ ├── ControlDependence/
│ │ ├── CDGraph.h
│ │ ├── ControlClosure.h
│ │ ├── DOD.h
│ │ ├── DODNTSCD.h
│ │ ├── NTSCD.cpp
│ │ └── NTSCD.h
│ ├── Debug.cpp
│ ├── MemorySSA/
│ │ ├── Definitions.cpp
│ │ ├── MemorySSA.cpp
│ │ └── ModRef.cpp
│ ├── Offset.cpp
│ ├── PointerAnalysis/
│ │ ├── Pointer.cpp
│ │ ├── PointerAnalysis.cpp
│ │ ├── PointerGraph.cpp
│ │ ├── PointerGraphOptimizations.cpp
│ │ ├── PointerGraphValidator.cpp
│ │ └── PointsToSet.cpp
│ ├── ReadWriteGraph/
│ │ └── ReadWriteGraph.cpp
│ ├── SystemDependenceGraph/
│ │ └── DependenceGraph.cpp
│ ├── ValueRelations/
│ │ └── Relations.cpp
│ └── llvm/
│ ├── ControlDependence/
│ │ ├── ControlClosure.h
│ │ ├── ControlDependence.cpp
│ │ ├── DOD.h
│ │ ├── GraphBuilder.h
│ │ ├── IGraphBuilder.h
│ │ ├── InterproceduralCD.cpp
│ │ ├── InterproceduralCD.h
│ │ ├── NTSCD.h
│ │ ├── SCD.cpp
│ │ ├── SCD.h
│ │ └── legacy/
│ │ ├── Block.cpp
│ │ ├── Block.h
│ │ ├── Function.cpp
│ │ ├── Function.h
│ │ ├── GraphBuilder.cpp
│ │ ├── GraphBuilder.h
│ │ ├── NTSCD.cpp
│ │ ├── NTSCD.h
│ │ └── TarjanAnalysis.h
│ ├── DataDependenceAnalysis/
│ │ └── LLVMDataDependenceAnalysis.cpp
│ ├── DefUse/
│ │ ├── DefUse.cpp
│ │ └── DefUse.h
│ ├── Dominators/
│ │ └── PostDominators.cpp
│ ├── ForkJoin/
│ │ ├── ForkJoin.cpp
│ │ └── ForkJoin.h
│ ├── GraphBuilder.h
│ ├── LLVMDGVerifier.cpp
│ ├── LLVMDGVerifier.h
│ ├── LLVMDependenceGraph.cpp
│ ├── LLVMNode.cpp
│ ├── PointerAnalysis/
│ │ ├── Block.cpp
│ │ ├── Calls.cpp
│ │ ├── Constants.cpp
│ │ ├── Globals.cpp
│ │ ├── Instructions.cpp
│ │ ├── Interprocedural.cpp
│ │ ├── PointerAnalysis.cpp
│ │ ├── PointerGraph.cpp
│ │ ├── PointerGraphValidator.cpp
│ │ ├── PointerGraphValidator.h
│ │ ├── Structure.cpp
│ │ └── Threads.cpp
│ ├── ReadWriteGraph/
│ │ ├── Calls.cpp
│ │ ├── Instructions.cpp
│ │ ├── LLVMReadWriteGraphBuilder.cpp
│ │ └── LLVMReadWriteGraphBuilder.h
│ ├── SummaryEdges.cpp
│ ├── SystemDependenceGraph/
│ │ ├── Dependencies.cpp
│ │ ├── SDG2Dot.cpp
│ │ └── SystemDependenceGraph.cpp
│ ├── ThreadRegions/
│ │ ├── Graphs/
│ │ │ ├── BlockGraph.cpp
│ │ │ ├── BlockGraph.h
│ │ │ ├── ControlFlowGraph.cpp
│ │ │ ├── CriticalSectionsBuilder.cpp
│ │ │ ├── CriticalSectionsBuilder.h
│ │ │ ├── FunctionGraph.cpp
│ │ │ ├── FunctionGraph.h
│ │ │ ├── GraphBuilder.cpp
│ │ │ ├── GraphBuilder.h
│ │ │ ├── ThreadRegionsBuilder.cpp
│ │ │ └── ThreadRegionsBuilder.h
│ │ ├── MayHappenInParallel.cpp
│ │ ├── Nodes/
│ │ │ ├── CallFuncPtrNode.cpp
│ │ │ ├── CallFuncPtrNode.h
│ │ │ ├── CallNode.cpp
│ │ │ ├── CallNode.h
│ │ │ ├── CallReturnNode.cpp
│ │ │ ├── CallReturnNode.h
│ │ │ ├── EntryNode.cpp
│ │ │ ├── EntryNode.h
│ │ │ ├── ExitNode.cpp
│ │ │ ├── ExitNode.h
│ │ │ ├── ForkNode.cpp
│ │ │ ├── ForkNode.h
│ │ │ ├── GeneralNode.cpp
│ │ │ ├── GeneralNode.h
│ │ │ ├── JoinNode.cpp
│ │ │ ├── JoinNode.h
│ │ │ ├── LockNode.cpp
│ │ │ ├── LockNode.h
│ │ │ ├── Node.cpp
│ │ │ ├── Node.h
│ │ │ ├── NodeIterator.cpp
│ │ │ ├── NodeIterator.h
│ │ │ ├── Nodes.h
│ │ │ ├── ReturnNode.cpp
│ │ │ ├── ReturnNode.h
│ │ │ ├── UnlockNode.cpp
│ │ │ └── UnlockNode.h
│ │ └── ThreadRegion.cpp
│ ├── ValueRelations/
│ │ ├── GraphBuilder.cpp
│ │ ├── GraphElements.cpp
│ │ ├── RelationsAnalyzer.cpp
│ │ ├── StructureAnalyzer.cpp
│ │ └── ValueRelations.cpp
│ └── llvm-utils.h
├── misc/
│ └── benchexec/
│ ├── README.md
│ ├── dgtool.py
│ ├── llvm-slicer-tests.xml
│ └── slicing-tests.set
├── tests/
│ ├── CMakeLists.txt
│ ├── adt-test.cpp
│ ├── bitvector-test.cpp
│ ├── catch-main.cpp
│ ├── catch2/
│ │ └── catch.hpp
│ ├── cmd-args.py
│ ├── disjunctive-intervals-map-test.cpp
│ ├── fuzzing/
│ │ ├── CMakeLists.txt
│ │ ├── bitvector1.cpp
│ │ ├── disjunctive-map1.cpp
│ │ └── numbers-set1.cpp
│ ├── llvm-dg-test.cpp
│ ├── nodes-walk-test.cpp
│ ├── numbers-set-test.cpp
│ ├── points-to-set-test.cpp
│ ├── points-to-test.cpp
│ ├── ptset-benchmark.cpp
│ ├── rdmap-test.cpp
│ ├── readwritegraph-test.cpp
│ ├── slicing/
│ │ ├── CMakeLists.txt
│ │ ├── sources/
│ │ │ ├── a_ptr.c
│ │ │ ├── alias_of_return.c
│ │ │ ├── atomic1.c
│ │ │ ├── atomic2.c
│ │ │ ├── atomic3.c
│ │ │ ├── bitcast1.c
│ │ │ ├── bitcast2.c
│ │ │ ├── bitcast3.c
│ │ │ ├── bitcast4.c
│ │ │ ├── bitcast5.c
│ │ │ ├── bitcast6.c
│ │ │ ├── control-regression1.c
│ │ │ ├── cyclic-realloc.c
│ │ │ ├── dynalloc1.c
│ │ │ ├── dynalloc2.c
│ │ │ ├── dynalloc3.c
│ │ │ ├── dynalloc4.c
│ │ │ ├── dynalloc5.c
│ │ │ ├── dynalloc6.c
│ │ │ ├── dynalloc7.c
│ │ │ ├── foo.c
│ │ │ ├── fptoui1.c
│ │ │ ├── funcarray1.c
│ │ │ ├── funcarray2.c
│ │ │ ├── funcarray3.c
│ │ │ ├── funcptr-regression1.c
│ │ │ ├── funcptr1.c
│ │ │ ├── funcptr10.c
│ │ │ ├── funcptr11.c
│ │ │ ├── funcptr12.c
│ │ │ ├── funcptr13.c
│ │ │ ├── funcptr14.c
│ │ │ ├── funcptr15.c
│ │ │ ├── funcptr16.c
│ │ │ ├── funcptr2.c
│ │ │ ├── funcptr3.c
│ │ │ ├── funcptr4.c
│ │ │ ├── funcptr5.c
│ │ │ ├── funcptr6.c
│ │ │ ├── funcptr7.c
│ │ │ ├── funcptr8.c
│ │ │ ├── funcptr9.c
│ │ │ ├── get_int.c
│ │ │ ├── get_output.c
│ │ │ ├── get_ptr.c
│ │ │ ├── glob_ptr-a.c
│ │ │ ├── glob_ptr.c
│ │ │ ├── global-init.c
│ │ │ ├── global1.c
│ │ │ ├── global10.c
│ │ │ ├── global2.c
│ │ │ ├── global3.c
│ │ │ ├── global4.c
│ │ │ ├── global5.c
│ │ │ ├── global6.c
│ │ │ ├── global7.c
│ │ │ ├── global8.c
│ │ │ ├── global9.c
│ │ │ ├── globalptr1.c
│ │ │ ├── globalptr2.c
│ │ │ ├── globalptr3.c
│ │ │ ├── globalptr4.c
│ │ │ ├── interprocedural1.c
│ │ │ ├── interprocedural2.c
│ │ │ ├── interprocedural3.c
│ │ │ ├── interprocedural4.c
│ │ │ ├── interprocedural5.c
│ │ │ ├── interprocedural6.c
│ │ │ ├── interprocedural7.c
│ │ │ ├── interprocedural8-a.c
│ │ │ ├── interprocedural8.c
│ │ │ ├── interprocedural8.output
│ │ │ ├── interprocedural9.c
│ │ │ ├── list1.c
│ │ │ ├── list2.c
│ │ │ ├── list3.c
│ │ │ ├── list4.c
│ │ │ ├── list5.c
│ │ │ ├── list6.c
│ │ │ ├── list7.c
│ │ │ ├── list8.c
│ │ │ ├── llvmmemcpy.c
│ │ │ ├── llvmmemcpy2.c
│ │ │ ├── loop1.c
│ │ │ ├── loop2.c
│ │ │ ├── loop3.c
│ │ │ ├── loop4.c
│ │ │ ├── loop5.c
│ │ │ ├── malloc-redef.c
│ │ │ ├── memcpy1.c
│ │ │ ├── memcpy2.c
│ │ │ ├── memcpy3.c
│ │ │ ├── memcpy4.c
│ │ │ ├── memcpy5.c
│ │ │ ├── memcpy6.c
│ │ │ ├── memset1.c
│ │ │ ├── negoffset1.c
│ │ │ ├── negoffset2.c
│ │ │ ├── negoffset3.c
│ │ │ ├── phi1.c
│ │ │ ├── phi2.c
│ │ │ ├── phi3.c
│ │ │ ├── phi4.c
│ │ │ ├── pointers1.c
│ │ │ ├── pointers2.c
│ │ │ ├── pointers3.c
│ │ │ ├── pointers4.c
│ │ │ ├── pointers5.c
│ │ │ ├── pointers6.c
│ │ │ ├── pointers7.c
│ │ │ ├── pta-inv-infinite-loop.c
│ │ │ ├── pta_fs_regression1.c
│ │ │ ├── pta_regression2.c
│ │ │ ├── ptr-9.c
│ │ │ ├── ptr.c
│ │ │ ├── ptrarray1.c
│ │ │ ├── ptrarray2.c
│ │ │ ├── ptrtoint1.c
│ │ │ ├── ptrtoint2.c
│ │ │ ├── ptrtoint3.c
│ │ │ ├── ptrtoint4.c
│ │ │ ├── ptrtoint5.c
│ │ │ ├── ptrtoint6.c
│ │ │ ├── ptrtoint7.c
│ │ │ ├── realloc1.c
│ │ │ ├── realloc2.c
│ │ │ ├── realloc3.c
│ │ │ ├── recursive1.c
│ │ │ ├── recursive2.c
│ │ │ ├── recursive3.c
│ │ │ ├── recursive4.c
│ │ │ ├── recursive5.c
│ │ │ ├── regression1.c
│ │ │ ├── sum1.c
│ │ │ ├── sum2.c
│ │ │ ├── sum3.c
│ │ │ ├── switch1.c
│ │ │ ├── switch2.c
│ │ │ ├── test1.c
│ │ │ ├── test2.c
│ │ │ ├── test22.c
│ │ │ ├── test222.c
│ │ │ ├── test3.c
│ │ │ ├── test4.c
│ │ │ ├── test5.c
│ │ │ ├── test6.c
│ │ │ ├── test7.c
│ │ │ ├── test8.c
│ │ │ ├── threads1.c
│ │ │ ├── undefcall1_true-unreach-call.c
│ │ │ ├── undefcall2_true-unreach-call.c
│ │ │ ├── unknown-interproc.c
│ │ │ ├── unknown-interproc2-a.c
│ │ │ ├── unknown-interproc2.c
│ │ │ ├── unknown-interproc3.c
│ │ │ ├── unknownptr1.c
│ │ │ ├── unknownptr10-a.c
│ │ │ ├── unknownptr10.c
│ │ │ ├── unknownptr11.c
│ │ │ ├── unknownptr2.c
│ │ │ ├── unknownptr3.c
│ │ │ ├── unknownptr4.c
│ │ │ ├── unknownptr5.c
│ │ │ ├── unknownptr6.c
│ │ │ ├── unknownptr7.c
│ │ │ ├── unknownptr8.c
│ │ │ ├── unknownptr9.c
│ │ │ ├── unknownptrfoo.c
│ │ │ ├── unknownptrfoo2.c
│ │ │ ├── vararg1.c
│ │ │ ├── vararg2.c
│ │ │ ├── vararg3.c
│ │ │ ├── vararg4.c
│ │ │ └── wl_list.c
│ │ ├── test-runner.py
│ │ ├── test_assert.c
│ │ ├── test_assert.h
│ │ └── tests.py
│ ├── slicing-stress.sh
│ ├── thread-regions-test-files/
│ │ ├── pthread_exit.c
│ │ └── simple.c
│ ├── thread-regions-test.cpp
│ └── value-relations-test.cpp
└── tools/
├── CMakeLists.txt
├── dgtool
├── git-version.h.in
├── include/
│ └── dg/
│ └── tools/
│ ├── llvm-slicer-opts.h
│ ├── llvm-slicer-preprocess.h
│ ├── llvm-slicer-utils.h
│ └── llvm-slicer.h
├── llvm-cda-bench.cpp
├── llvm-cda-dump.cpp
├── llvm-cda-stress.cpp
├── llvm-cg-dump.cpp
├── llvm-dda-dump.cpp
├── llvm-dg-dump.cpp
├── llvm-ntscd-dump.cpp
├── llvm-pta-ben.cpp
├── llvm-pta-compare.cpp
├── llvm-pta-dump.cpp
├── llvm-sdg-dump.cpp
├── llvm-slicer-crit.cpp
├── llvm-slicer-metadata.cpp
├── llvm-slicer-opts.cpp
├── llvm-slicer-preprocess.cpp
├── llvm-slicer-utils.cpp
├── llvm-slicer.cpp
├── llvm-thread-regions-dump.cpp
├── llvm-to-source.cpp
├── llvm-vr-dump.cpp
├── llvmdda-dump
├── llvmdg-show
├── pta-show
└── sliced-diff.sh
Copy disabled (too large)
Download .txt
Showing preview only (376,881K chars total). Download the full file to get everything.
SYMBOL INDEX (3012 symbols across 429 files)
FILE: include/dg/ADT/Bits.h
function namespace (line 8) | namespace dg {
FILE: include/dg/ADT/Bitvector.h
function BitsContainerT (line 20) | BitsContainerT _bits{}
function ShiftT (line 24) | static ShiftT _shift(IndexT i) { return i - (i % BITS_IN_BUCKET); }
function _countBits (line 26) | static size_t _countBits(BitsT bits) {
function _addBit (line 38) | void _addBit(IndexT i) {
function reset (line 53) | void reset() { _bits.clear(); }
function swap (line 55) | void swap(SparseBitvectorImpl &oth) { _bits.swap(oth._bits); }
function reserve (line 59) | void reserve(size_t n) { _bits.reserve(n); }
function set (line 85) | bool set(const SparseBitvectorImpl &rhs) {
FILE: include/dg/ADT/DGContainer.h
function namespace (line 8) | namespace dg {
function iterator (line 28) | iterator end() { return container.end(); }
function insert (line 33) | bool insert(ValueT n) { return container.insert(n).second; }
function contains (line 35) | bool contains(ValueT n) const { return container.count(n) != 0; }
function erase (line 37) | size_t erase(ValueT n) { return container.erase(n); }
function clear (line 39) | void clear() { container.clear(); }
function empty (line 41) | bool empty() { return container.empty(); }
function swap (line 43) | void swap(DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> &oth) {
function intersect (line 47) | void intersect(const DGContainer<ValueT, EXPECTED_ELEMENTS_NUM> &oth) {
FILE: include/dg/ADT/DisjunctiveIntervalMap.h
function namespace (line 16) | namespace dg {
function add (line 83) | bool add(const IntervalValueT start, const IntervalValueT end,
function add (line 88) | bool add(const IntervalT &I, const ValueT &val) {
function update (line 101) | bool update(const IntervalValueT start, const IntervalValueT end,
function update (line 106) | bool update(const IntervalT &I, const ValueT &val) {
function addAll (line 120) | bool addAll(const ValueT &val) {
function splitExtBorders (line 435) | bool splitExtBorders(const IntervalT &I) {
function typename (line 594) | typename MappingT::iterator _find_ge(const IntervalT &I) {
function typename (line 599) | typename MappingT::const_iterator _find_ge(const IntervalT &I) const {
function typename (line 603) | typename MappingT::iterator _get_last() {
function _check (line 613) | void _check() const {
FILE: include/dg/ADT/HashMap.h
function namespace (line 6) | namespace dg {
function namespace (line 12) | namespace dg {
FILE: include/dg/ADT/HashMapImpl.h
function namespace (line 4) | namespace dg {
FILE: include/dg/ADT/IntervalsList.h
function namespace (line 8) | namespace dg {
function end (line 123) | auto begin() const -> decltype(intervals.begin()) {
FILE: include/dg/ADT/Map.h
function namespace (line 7) | namespace dg {
FILE: include/dg/ADT/NumberSet.h
function namespace (line 7) | namespace dg {
FILE: include/dg/ADT/Queue.h
function namespace (line 8) | namespace dg {
FILE: include/dg/ADT/STLHashMap.h
function namespace (line 8) | namespace dg {
FILE: include/dg/ADT/SetQueue.h
function namespace (line 7) | namespace dg {
FILE: include/dg/ADT/TslHopscotchHashMap.h
function namespace (line 8) | namespace dg {
FILE: include/dg/AnalysisOptions.h
type class (line 15) | enum class
type AnalysisOptions (line 27) | struct AnalysisOptions {
function addAllocationFunction (line 43) | void addAllocationFunction(const std::string &name, AllocationFunction F) {
function AllocationFunction (line 51) | AllocationFunction getAllocationFunction(const std::string &name) const {
function isAllocationFunction (line 58) | bool isAllocationFunction(const std::string &name) const {
FILE: include/dg/BBlock.h
function namespace (line 11) | namespace dg {
function setKey (line 80) | void setKey(const KeyT &k) { key = k; }
function setDG (line 86) | void setDG(DependenceGraphT *d) { dg = d; }
function DependenceGraphT (line 87) | DependenceGraphT *getDG() const { return dg; }
function append (line 94) | void append(NodeT *n) {
function prepend (line 101) | void prepend(NodeT *n) {
function hasSuccessor (line 134) | bool hasSuccessor(BBlock<NodeT> *B) const {
function removeNode (line 243) | void removeNode(NodeT *n) { nodes.remove(n); }
function addSuccessor (line 248) | bool addSuccessor(const BBlockEdge &edge) {
function removeSuccessors (line 259) | void removeSuccessors() {
function hasSelfLoop (line 275) | bool hasSelfLoop() { return nextBBs.contains(this); }
function removeSuccessor (line 277) | void removeSuccessor(const BBlockEdge &succ) {
function removeSuccessorsTarget (line 282) | unsigned removeSuccessorsTarget(BBlock<NodeT> *target) {
function slice_id (line 445) | uint64_t slice_id{0}
FILE: include/dg/BBlockBase.h
function namespace (line 7) | namespace dg {
function pred_end (line 33) | auto pred_begin() -> decltype(_predecessors.begin()) {
function pred_begin (line 42) | auto succ_end() const -> decltype(_successors.begin()) {
function addSuccessor (line 58) | void addSuccessor(ElemT *s) {
FILE: include/dg/BBlocksBuilder.h
function namespace (line 9) | namespace dg {
FILE: include/dg/BFS.h
function namespace (line 9) | namespace dg {
FILE: include/dg/CallGraph/CallGraph.h
function namespace (line 9) | namespace dg {
function begin (line 100) | auto end() -> decltype(_mapping.end()) { return _mapping.end(); }
FILE: include/dg/ControlDependence/ControlDependenceAnalysisOptions.h
type ControlDependenceAnalysisOptions (line 8) | struct ControlDependenceAnalysisOptions
function CDAlgorithm (line 10) | enum class CDAlgorithm {
FILE: include/dg/DFS.h
function namespace (line 9) | namespace dg {
FILE: include/dg/DG2Dot.h
type dg2dot_options (line 14) | enum dg2dot_options {
type Indent (line 31) | struct Indent {
function setSlicingCriteria (line 63) | void setSlicingCriteria(const std::set<NodeT *> &crit) { criteria = crit; }
function open (line 65) | bool open(const char *new_file) {
function virtual (line 73) | virtual std::ostream &printKey(std::ostream &os, KeyT key) {
function virtual (line 79) | virtual bool checkNode(std::ostream &os, NodeT *node) {
function ensureFile (line 90) | bool ensureFile(const char *fl) {
function dump_parameters (line 325) | void dump_parameters(DependenceGraph<NodeT> *g, int ind) {
FILE: include/dg/DGParameters.h
function namespace (line 10) | namespace dg {
FILE: include/dg/DataDependence/DataDependence.h
function namespace (line 15) | namespace dg {
FILE: include/dg/DataDependence/DataDependenceAnalysisImpl.h
function namespace (line 13) | namespace dg {
FILE: include/dg/DataDependence/DataDependenceAnalysisOptions.h
function namespace (line 11) | namespace dg {
type Operand (line 51) | struct Operand {
function addDef (line 62) | void addDef(unsigned operand, OperandValue from, OperandValue to) {
function addUse (line 66) | void addUse(unsigned operand, OperandValue from, OperandValue to) {
function addDef (line 70) | void addDef(const Operand &op) { _defines.emplace(op.operand, op); }
function addUse (line 71) | void addUse(const Operand &op) { _uses.emplace(op.operand, op); }
function Operand (line 73) | const Operand *defines(unsigned operand) const {
function Operand (line 78) | const Operand *uses(unsigned operand) const {
function handles (line 83) | bool handles(unsigned i) const { return defines(i) || uses(i); }
function namespace (line 90) | namespace dda {
type DataDependenceAnalysisOptions (line 100) | struct DataDependenceAnalysisOptions
type class (line 102) | enum class
function fieldInsensitive (line 110) | bool fieldInsensitive{false};
FILE: include/dg/DependenceGraph.h
function class (line 17) | class DependenceGraphBase {
function NodeT (line 208) | NodeT *getNode(KeyT k) { return _getNode(k); }
function NodeT (line 209) | const NodeT *getNode(const KeyT k) const { return _getNode(k); }
function NodeT (line 224) | NodeT *getGlobalNode(KeyT k) { return _getGlobalNode(k); }
function NodeT (line 225) | const NodeT *getGlobalNode(const KeyT k) const { return _getGlobalNode(k...
function NodeT (line 230) | NodeT *setEntry(NodeT *n) {
function NodeT (line 237) | NodeT *setExit(NodeT *n) {
function NodeT (line 244) | NodeT *getEntry() const { return entryNode; }
function NodeT (line 245) | NodeT *getExit() const { return exitNode; }
function setGlobalNodes (line 247) | void setGlobalNodes(const std::shared_ptr<ContainerType> &ngn) {
function allocateGlobalNodes (line 252) | void allocateGlobalNodes() {
function ContainerType (line 258) | ContainerType *getNodes() { return &nodes; }
function ContainerType (line 260) | const ContainerType *getNodes() const { return &nodes; }
function addNode (line 274) | bool addNode(KeyT k, NodeT *n) {
function addNode (line 287) | bool addNode(NodeT *n) {
function addGlobalNode (line 293) | bool addGlobalNode(KeyT k, NodeT *n) {
function addGlobalNode (line 298) | bool addGlobalNode(NodeT *n) { return addGlobalNode(n->getKey(), n); }
function NodeT (line 300) | NodeT *removeNode(KeyT k) { return _removeNode(k, &nodes); }
function NodeT (line 302) | NodeT *removeNode(NodeT *n) { return removeNode(n->getKey()); }
function NodeT (line 306) | NodeT *removeGlobalNode(KeyT k) {
function NodeT (line 313) | NodeT *removeGlobalNode(NodeT *n) { return removeGlobalNode(n->getKey()); }
function deleteNode (line 322) | bool deleteNode(NodeT *n) { return deleteNode(n->getKey()); }
function deleteNode (line 324) | bool deleteNode(KeyT k) {
function deleteNode (line 331) | bool deleteNode(iterator &it) {
function deleteGlobalNode (line 338) | bool deleteGlobalNode(KeyT k) {
function deleteGlobalNode (line 345) | bool deleteGlobalNode(NodeT *n) { return deleteGlobalNode(n->getKey()); }
function deleteGlobalNode (line 347) | bool deleteGlobalNode(iterator &it) {
function addCaller (line 356) | bool addCaller(NodeT *sg) { return callers.insert(sg); }
function addBlock (line 363) | bool addBlock(KeyT key, BBlock<NodeT> *B) {
function removeBlock (line 367) | bool removeBlock(KeyT key) { return _blocks.erase(key) == 1; }
function setPostDominatorTreeRoot (line 370) | void setPostDominatorTreeRoot(BBlock<NodeT> *r) {
function NodeT (line 403) | NodeT *_removeNode(KeyT k, ContainerType *cont) {
FILE: include/dg/Dominators/DominanceFrontiers.h
function namespace (line 9) | namespace dg {
FILE: include/dg/Dominators/PostDominanceFrontiers.h
function namespace (line 9) | namespace dg {
FILE: include/dg/MemorySSA/Definitions.h
function namespace (line 11) | namespace dg {
FILE: include/dg/MemorySSA/DefinitionsMap.h
function namespace (line 15) | namespace dg {
FILE: include/dg/MemorySSA/MemorySSA.h
function namespace (line 23) | namespace dg {
FILE: include/dg/MemorySSA/ModRef.h
function namespace (line 9) | namespace dg {
FILE: include/dg/MemoryState.h
function Object (line 15) | const Object *get(Key k) const {
function Object (line 22) | Object *getWritable(Key k) { return _memory[k].getWritable(); }
function put (line 24) | void put(Key k, Object *o) { _memory[k].reset(o); }
function copyMissing (line 28) | bool copyMissing(const MemoryState &rhs) {
FILE: include/dg/Node.h
function key (line 44) | Node(const KeyT &k) : key(k) {}
function DependenceGraphT (line 46) | DependenceGraphT *setDG(DependenceGraphT *dg) {
function DependenceGraphT (line 53) | DependenceGraphT *getDG() const { return dg; }
function addControlDependence (line 57) | bool addControlDependence(NodeT *n) {
function addDataDependence (line 64) | bool addDataDependence(NodeT *n) {
function addUseDependence (line 70) | bool addUseDependence(NodeT *n) {
function addInterferenceDependence (line 75) | bool addInterferenceDependence(NodeT *n) {
function removeControlDependence (line 82) | bool removeControlDependence(NodeT *n) {
function removeDataDependence (line 88) | bool removeDataDependence(NodeT *n) {
function removeUseDependence (line 93) | bool removeUseDependence(NodeT *n) {
function removeInterferenceDependence (line 98) | bool removeInterferenceDependence(NodeT *n) {
function removeOutcomingCDs (line 105) | void removeOutcomingCDs() {
function removeIncomingCDs (line 110) | void removeIncomingCDs() {
function removeCDs (line 119) | void removeCDs() {
function removeOutcomingDDs (line 124) | void removeOutcomingDDs() {
function removeIncomingDDs (line 129) | void removeIncomingDDs() {
function removeDDs (line 139) | void removeDDs() {
function removeOutcomingUses (line 144) | void removeOutcomingUses() {
function removeIncomingUses (line 149) | void removeIncomingUses() {
function removeUses (line 159) | void removeUses() {
function isolate (line 165) | void isolate() {
function control_iterator (line 199) | control_iterator control_begin() { return controlDepEdges.begin(); }
function control_iterator (line 203) | control_iterator control_end() { return controlDepEdges.end(); }
function control_iterator (line 207) | control_iterator rev_control_begin() { return revControlDepEdges.begin(); }
function control_iterator (line 211) | control_iterator rev_control_end() { return revControlDepEdges.end(); }
function interference_iterator (line 220) | interference_iterator interference_begin() {
function interference_iterator (line 226) | interference_iterator interference_end() {
function interference_iterator (line 234) | interference_iterator rev_interference_begin() {
function interference_iterator (line 240) | interference_iterator rev_interference_end() {
function data_iterator (line 254) | data_iterator data_begin() { return dataDepEdges.begin(); }
function data_iterator (line 256) | data_iterator data_end() { return dataDepEdges.end(); }
function data_iterator (line 260) | data_iterator rev_data_begin() { return revDataDepEdges.begin(); }
function data_iterator (line 264) | data_iterator rev_data_end() { return revDataDepEdges.end(); }
function use_iterator (line 269) | use_iterator use_begin() { return useEdges.begin(); }
function use_iterator (line 271) | use_iterator use_end() { return useEdges.end(); }
function use_iterator (line 275) | use_iterator user_begin() { return userEdges.begin(); }
function use_iterator (line 277) | use_iterator user_end() { return userEdges.end(); }
function BBlock (line 291) | const BBlock<NodeT> *getBBlock() const { return basicBlock; }
function addSubgraph (line 303) | bool addSubgraph(DependenceGraphT *sub) {
function setSlice (line 336) | uint32_t setSlice(uint32_t sid) {
function slice_id (line 398) | uint32_t slice_id{0};
FILE: include/dg/NodesWalk.h
function namespace (line 7) | namespace dg {
function range (line 44) | range operator()(Node *n) const { return range(n); }
function namespace (line 47) | namespace sfinae {
function EdgeChooser (line 68) | EdgeChooser _chooser{}
function VisitTracker (line 69) | VisitTracker _visits{}
function Queue (line 70) | Queue _queue{}
function _enqueue (line 72) | void _enqueue(Node *n) {
function _visits (line 119) | _chooser(std::move(chooser)), _visits(std::move(tracker)) {}
FILE: include/dg/Offset.h
function namespace (line 10) | namespace dg {
FILE: include/dg/PointerAnalysis/MemoryObject.h
function namespace (line 17) | namespace pta {
function addPointsTo (line 54) | bool addPointsTo(const Offset &off, const Pointer &ptr) {
function addPointsTo (line 61) | bool addPointsTo(const Offset &off, const PointsToSetT &pointers) {
function addPointsTo (line 67) | bool addPointsTo(const Offset &off,
FILE: include/dg/PointerAnalysis/PSNode.h
function namespace (line 19) | namespace pta {
function PSNode (line 253) | PSNode *stripCasts() {
function dumpv (line 267) | void dumpv() const override {
function class (line 312) | class PSNodeAlloc : public PSNode {
function PSNodeAlloc (line 332) | static PSNodeAlloc *cast(PSNode *n) { return _cast<PSNodeAlloc>(n); }
function setZeroInitialized (line 334) | void setZeroInitialized() { zeroInitialized = true; }
function setIsHeap (line 337) | void setIsHeap() { is_heap = true; }
function setIsGlobal (line 340) | void setIsGlobal() { is_global = true; }
function setIsTemporary (line 343) | void setIsTemporary() { is_temporary = true; }
function class (line 348) | class PSNodeTemporaryAlloc : public PSNodeAlloc {
function class (line 363) | class PSNodeConstant : public PSNode {
function PSNodeConstant (line 372) | static PSNodeConstant *get(PSNode *n) {
function PSNodeConstant (line 377) | static PSNodeConstant *cast(PSNode *n) { return _cast<PSNodeConstant>(n); }
function PSNode (line 381) | PSNode *getTarget() { return getOperand(0); }
function PSNode (line 382) | const PSNode *getTarget() const { return getOperand(0); }
function class (line 385) | class PSNodeMemcpy : public PSNode {
function PSNodeMemcpy (line 397) | static PSNodeMemcpy *cast(PSNode *n) { return _cast<PSNodeMemcpy>(n); }
function PSNode (line 399) | PSNode *getSource() const { return getOperand(0); }
function PSNode (line 400) | PSNode *getDestination() const { return getOperand(1); }
function class (line 404) | class PSNodeGep : public PSNode {
function PSNodeGep (line 416) | static PSNodeGep *cast(PSNode *n) { return _cast<PSNodeGep>(n); }
function PSNode (line 418) | PSNode *getSource() const { return getOperand(0); }
function setOffset (line 420) | void setOffset(uint64_t o) { offset = o; }
function PSNodeEntry (line 432) | static PSNodeEntry *get(PSNode *n) {
function PSNodeEntry (line 436) | static PSNodeEntry *cast(PSNode *n) { return _cast<PSNodeEntry>(n); }
function setFunctionName (line 438) | void setFunctionName(const std::string &name) { functionName = name; }
function addCaller (line 443) | bool addCaller(PSNode *n) {
function PSNodeCall (line 473) | static PSNodeCall *cast(PSNode *n) { return _cast<PSNodeCall>(n); }
function setCallReturn (line 475) | void setCallReturn(PSNode *callRet) { callReturn = callRet; }
function PSNode (line 476) | PSNode *getCallReturn() { return callReturn; }
function PSNode (line 477) | const PSNode *getCallReturn() const { return callReturn; }
function addCallee (line 481) | bool addCallee(PointerSubgraph *ps) {
function setCallInst (line 638) | void setCallInst(PSNode *callInst) { callInstruction = callInst; }
function PSNode (line 640) | PSNode *callInst() const { return callInstruction; }
function class (line 645) | class PSNodeJoin : public PSNode {
function ALLOC (line 685) | struct GetNodeType<PSNodeType::ALLOC> {
function CONSTANT (line 690) | struct GetNodeType<PSNodeType::CONSTANT> {
function GEP (line 695) | struct GetNodeType<PSNodeType::GEP> {
function MEMCPY (line 700) | struct GetNodeType<PSNodeType::MEMCPY> {
function ENTRY (line 705) | struct GetNodeType<PSNodeType::ENTRY> {
function FORK (line 717) | struct GetNodeType<PSNodeType::FORK> {
function JOIN (line 722) | struct GetNodeType<PSNodeType::JOIN> {
function RETURN (line 727) | struct GetNodeType<PSNodeType::RETURN> {
function CALL_RETURN (line 732) | struct GetNodeType<PSNodeType::CALL_RETURN> {
FILE: include/dg/PointerAnalysis/Pointer.h
function namespace (line 8) | namespace dg {
function namespace (line 57) | namespace std {
FILE: include/dg/PointerAnalysis/PointerAnalysis.h
function namespace (line 15) | namespace pta {
FILE: include/dg/PointerAnalysis/PointerAnalysisFI.h
function namespace (line 10) | namespace dg {
function preprocess (line 46) | void preprocess() override {
function getMemoryObjects (line 51) | void getMemoryObjects(PSNode *where, const Pointer &pointer,
FILE: include/dg/PointerAnalysis/PointerAnalysisFS.h
function namespace (line 10) | namespace dg {
FILE: include/dg/PointerAnalysis/PointerAnalysisFSInv.h
function namespace (line 8) | namespace pta {
function isLocal (line 104) | static bool isLocal(PSNodeAlloc *alloc, PSNode *where) {
function handleInvalidateLocals (line 149) | static bool handleInvalidateLocals(PSNode *node) {
FILE: include/dg/PointerAnalysis/PointerAnalysisOptions.h
type PointerAnalysisOptions (line 8) | struct PointerAnalysisOptions
function preprocessGeps (line 13) | bool preprocessGeps{true};
FILE: include/dg/PointerAnalysis/PointerGraph.h
function namespace (line 19) | namespace dg {
FILE: include/dg/PointerAnalysis/PointerGraphOptimizations.h
function namespace (line 6) | namespace dg {
FILE: include/dg/PointerAnalysis/PointerGraphValidator.h
function namespace (line 7) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToMapping.h
function namespace (line 7) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToSet.h
function namespace (line 12) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToSets/AlignedPointerIdPointsToSet.h
function namespace (line 13) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToSets/AlignedSmallOffsetsPointsToSet.h
function namespace (line 12) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToSets/LookupTable.h
function class (line 18) | class PointerIDLookupTable {
FILE: include/dg/PointerAnalysis/PointsToSets/OffsetsSetPointsToSet.h
function namespace (line 10) | namespace dg {
function swap (line 164) | void swap(OffsetsSetPointsToSet &rhs) { pointers.swap(rhs.pointers); }
function class (line 166) | class const_iterator {
FILE: include/dg/PointerAnalysis/PointsToSets/PointerIdPointsToSet.h
function getPointerID (line 28) | static size_t getPointerID(const Pointer &ptr) {
function Pointer (line 32) | static const Pointer &getPointer(size_t id) { return lookupTable.get(id); }
function addWithUnknownOffset (line 34) | bool addWithUnknownOffset(PSNode *node) {
function explicit (line 45) | explicit PointerIdPointsToSet(const std::initializer_list<Pointer> &elem...
function add (line 49) | bool add(PSNode *target, Offset off) { return add(Pointer(target, off)); }
function add (line 51) | bool add(const Pointer &ptr) {
FILE: include/dg/PointerAnalysis/PointsToSets/SeparateOffsetsPointsToSet.h
function namespace (line 11) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToSets/SimplePointsToSet.h
function namespace (line 11) | namespace dg {
FILE: include/dg/PointerAnalysis/PointsToSets/SmallOffsetsPointsToSet.h
function namespace (line 13) | namespace dg {
FILE: include/dg/ReadWriteGraph/DefSite.h
function intervalsDisjunctive (line 24) | inline bool intervalsDisjunctive(uint64_t a, uint64_t a_len, uint64_t b,
function intervalsOverlap (line 53) | inline bool intervalsOverlap(uint64_t a1, uint64_t a2, uint64_t b1,
function class (line 112) | class DefSiteSet : public std::set<DefSite> {
FILE: include/dg/ReadWriteGraph/RWBBlock.h
function namespace (line 10) | namespace dda {
FILE: include/dg/ReadWriteGraph/RWNode.h
function namespace (line 14) | namespace dda {
function RWNode (line 301) | RWNode *calledValue{nullptr};
function class (line 315) | class RWNodeCall : public RWNode {
FILE: include/dg/ReadWriteGraph/RWSubgraph.h
function namespace (line 10) | namespace dg {
FILE: include/dg/ReadWriteGraph/ReadWriteGraph.h
function namespace (line 14) | namespace dg {
FILE: include/dg/SCC.h
function namespace (line 10) | namespace dg {
FILE: include/dg/Slicing.h
function mark (line 43) | void mark(const std::set<NodeT *> &start, uint32_t slice_id) {
function mark (line 48) | void mark(NodeT *start, uint32_t slice_id) {
function std (line 55) | const std::set<BBlock<NodeT> *> &getMarkedBlocks() { return markedBlocks; }
type WalkData (line 61) | struct WalkData {
type SlicerStatistics (line 129) | struct SlicerStatistics {
function nodesRemoved (line 136) | uint64_t nodesRemoved{0}
function blocksRemoved (line 138) | uint32_t blocksRemoved{0};
function slice_id (line 144) | uint32_t slice_id{0}
function sliceNodes (line 149) | void sliceNodes(DependenceGraph<NodeT> *dg, uint32_t slice_id) {
function virtual (line 252) | virtual bool removeNode(NodeT * /*unused*/) { return true; }
type RemoveBlockData (line 257) | struct RemoveBlockData {
function getBlocksToRemove (line 262) | static void getBlocksToRemove(BBlock<NodeT> *BB, RemoveBlockData &data) {
FILE: include/dg/SubgraphBase.h
function namespace (line 4) | namespace dg {
FILE: include/dg/SubgraphNode.h
function namespace (line 20) | namespace pta {
function namespace (line 23) | namespace dda {
function scc_id (line 51) | unsigned int scc_id{0}
function size (line 63) | size_t size{0}
function setSize (line 77) | void setSize(size_t s) { size = s; }
function setSCCId (line 79) | void setSCCId(unsigned id) { scc_id = id; }
function T (line 88) | T *getData() const {
function T (line 105) | T *getUserData() const {
function NodeT (line 116) | NodeT *getOperand(size_t idx) const {
function setOperand (line 122) | void setOperand(size_t idx, NodeT *nd) {
function removeAllOperands (line 130) | void removeAllOperands() {
function hasOperand (line 158) | bool hasOperand(NodeT *n) const {
function addSuccessor (line 162) | void addSuccessor(NodeT *succ) {
function replaceSingleSuccessor (line 175) | void replaceSingleSuccessor(NodeT *succ) {
function removeSingleSuccessor (line 181) | void removeSingleSuccessor() {
function NodeT (line 193) | NodeT *getSingleSuccessor() const {
function NodeT (line 200) | NodeT *getSingleSuccessorOrNull() const {
function NodeT (line 208) | NodeT *getSinglePredecessor() const {
function NodeT (line 215) | NodeT *getSinglePredecessorOrNull() const {
function insertAfter (line 224) | void insertAfter(NodeT *n) {
function insertBefore (line 246) | void insertBefore(NodeT *n) {
function insertSequenceBefore (line 267) | void insertSequenceBefore(std::pair<NodeT *, NodeT *> &seq) {
FILE: include/dg/SystemDependenceGraph/DGArgumentPair.h
function namespace (line 7) | namespace dg {
FILE: include/dg/SystemDependenceGraph/DGBBlock.h
function namespace (line 10) | namespace dg {
FILE: include/dg/SystemDependenceGraph/DGElement.h
function namespace (line 11) | namespace dg {
FILE: include/dg/SystemDependenceGraph/DGNode.h
function namespace (line 9) | namespace dg {
function class (line 132) | class DGNodeArtificial : public DGNode {
FILE: include/dg/SystemDependenceGraph/DGNodeCall.h
function namespace (line 9) | namespace dg {
FILE: include/dg/SystemDependenceGraph/DGParameters.h
function DGNodeArtificial (line 21) | DGNodeArtificial *_noreturn{nullptr};
FILE: include/dg/SystemDependenceGraph/DepDGElement.h
function namespace (line 7) | namespace dg {
FILE: include/dg/SystemDependenceGraph/DependenceGraph.h
function namespace (line 13) | namespace dg {
FILE: include/dg/SystemDependenceGraph/SystemDependenceGraph.h
function namespace (line 14) | namespace sdg {
FILE: include/dg/ValueRelations/Bucket.h
function namespace (line 17) | namespace dg {
function clear (line 78) | void clear() { vec.clear(); }
function iterator (line 82) | iterator begin() { return vec.begin(); }
function iterator (line 83) | iterator end() { return vec.end(); }
function iterator (line 87) | iterator rbegin() { return vec.rbegin(); }
function iterator (line 88) | iterator rend() { return vec.rend(); }
type Bucket (line 98) | struct Bucket {
function class (line 147) | class DirectRelIterator {
function nextViableEdge (line 177) | bool nextViableEdge() {
function id (line 239) | Bucket(size_t i) : id(i) { relatedBuckets[Relations::EQ].emplace(*this); }
function merge (line 241) | void merge(const Bucket &other) {
function disconnect (line 254) | void disconnect() {
function unset (line 297) | bool unset(Relations::Type rel) {
function setVisited (line 438) | void setVisited(Visited &v) { visited = v; }
function iterator (line 452) | iterator begin(iterator::Visited &visited, const Relations &relations,
function iterator (line 458) | iterator begin(iterator::Visited &visited) const {
function iterator (line 462) | static iterator end(iterator::Visited &visited) {
FILE: include/dg/ValueRelations/Relations.h
function namespace (line 11) | namespace dg {
FILE: include/dg/ValueRelations/RelationsGraph.h
function namespace (line 19) | namespace vr {
function skipSuccessors (line 129) | void skipSuccessors() {
FILE: include/dg/legacy/Analysis.h
function namespace (line 4) | namespace dg {
function namespace (line 51) | namespace dg {
FILE: include/dg/legacy/BFS.h
function namespace (line 7) | namespace dg {
FILE: include/dg/legacy/DFS.h
function namespace (line 7) | namespace dg {
function convertBBFlags (line 96) | static uint32_t inline convertBBFlags(uint32_t flags) {
FILE: include/dg/legacy/DataFlowAnalysis.h
function namespace (line 11) | namespace legacy {
FILE: include/dg/legacy/NodesWalk.h
function namespace (line 8) | namespace legacy {
function enqueue (line 140) | void enqueue(NodeT *n) {
FILE: include/dg/llvm/CallGraph/CallGraph.h
function namespace (line 18) | namespace dg {
function FuncVec (line 332) | FuncVec _getAddressTakenFuns(const llvm::CallInst *C) {
FILE: include/dg/llvm/ControlDependence/ControlDependence.h
function namespace (line 13) | namespace dg {
function ValVec (line 92) | ValVec getDependencies(const llvm::Instruction *v) {
function ValVec (line 95) | ValVec getDependent(const llvm::Instruction *v) { return _getDependent(v...
function ValVec (line 97) | ValVec getDependencies(const llvm::BasicBlock *b) {
function ValVec (line 100) | ValVec getDependent(const llvm::BasicBlock *b) { return _getDependent(b); }
function ValVec (line 102) | ValVec getNoReturns(const llvm::Function *F) {
function ValVec (line 110) | ValVec getClosure(const llvm::Function *F,
FILE: include/dg/llvm/ControlDependence/LLVMControlDependenceAnalysisImpl.h
function namespace (line 9) | namespace llvm {
function namespace (line 15) | namespace dg {
FILE: include/dg/llvm/ControlDependence/LLVMControlDependenceAnalysisOptions.h
function namespace (line 7) | namespace dg {
FILE: include/dg/llvm/DataDependence/DataDependence.h
function namespace (line 18) | namespace dg {
FILE: include/dg/llvm/DataDependence/LLVMDataDependenceAnalysisOptions.h
function namespace (line 7) | namespace dg {
FILE: include/dg/llvm/LLVMAnalysisOptions.h
function namespace (line 7) | namespace dg {
FILE: include/dg/llvm/LLVMDG2Dot.h
function namespace (line 21) | namespace debug {
FILE: include/dg/llvm/LLVMDGAssemblyAnnotationWriter.h
function namespace (line 18) | namespace dg {
function emitNodeAnnotations (line 136) | void emitNodeAnnotations(LLVMNode *node, llvm::formatted_raw_ostream &os) {
function emitModuleComment (line 259) | void emitModuleComment(std::string &&comment) {
function emitFunctionAnnot (line 263) | void emitFunctionAnnot(const llvm::Function * /*unused*/,
FILE: include/dg/llvm/LLVMDependenceGraph.h
function namespace (line 11) | namespace llvm {
function namespace (line 31) | namespace dda {
function LLVMNode (line 71) | LLVMNode *getNoReturn() {
function gatherCallsites (line 87) | void gatherCallsites(const char *name, std::set<LLVMNode *> *callSites) {
function addCallNode (line 106) | bool addCallNode(LLVMNode *c) { return callNodes.insert(c).second; }
function verify (line 122) | bool verify() const;
function LLVMPointerAnalysis (line 137) | LLVMPointerAnalysis *getPTA() const { return PTA; }
function LLVMDataDependenceAnalysis (line 138) | LLVMDataDependenceAnalysis *getDDA() const { return DDA; }
function LLVMPointerAnalysis (line 197) | LLVMPointerAnalysis *PTA{nullptr};
FILE: include/dg/llvm/LLVMDependenceGraphBuilder.h
function namespace (line 28) | namespace llvm {
type LLVMDependenceGraphOptions (line 36) | struct LLVMDependenceGraphOptions {
function LLVMDataDependenceAnalysisOptions (line 38) | LLVMDataDependenceAnalysisOptions DDAOptions{}
function LLVMControlDependenceAnalysisOptions (line 39) | LLVMControlDependenceAnalysisOptions CDAOptions{}
function preserveDbg (line 43) | bool preserveDbg{true};
FILE: include/dg/llvm/LLVMNode.h
function namespace (line 13) | namespace dg {
function LLVMDGParameters (line 47) | LLVMDGParameters *getOrCreateParameters() {
FILE: include/dg/llvm/LLVMSlicer.h
function namespace (line 22) | namespace dg {
function sliceGraph (line 419) | void sliceGraph(LLVMDependenceGraph *graph, uint32_t slice_id) {
function dontTouch (line 469) | bool dontTouch(const llvm::StringRef &r) {
function reconnectBBlock (line 477) | static void reconnectBBlock(LLVMBBlock *BB, llvm::BasicBlock *llvmBB) {
FILE: include/dg/llvm/PointerAnalysis/DGPointerAnalysis.h
function namespace (line 21) | namespace dg {
FILE: include/dg/llvm/PointerAnalysis/LLVMPointerAnalysisOptions.h
type LLVMPointerAnalysisOptions (line 9) | struct LLVMPointerAnalysisOptions
function AnalysisType (line 11) | enum class AnalysisType { fi, fs, inv, svf }
function threads (line 13) | bool threads{false};
FILE: include/dg/llvm/PointerAnalysis/LLVMPointsToSet.h
function namespace (line 11) | namespace dg {
type LLVMMemoryRegion (line 44) | struct LLVMMemoryRegion {
function coveredBy (line 86) | bool coveredBy(const OffsetPair &rhs) const {
function coveredBy (line 90) | bool coveredBy(const Offset o, const Offset l) const {
function extends (line 98) | bool extends(const OffsetPair &rhs) const {
function extends (line 102) | bool extends(const Offset o, const Offset l) const {
function std (line 130) | const std::vector<OffsetPair> *_get(llvm::Value *v) const {
function class (line 255) | class LLVMPointsToSetImpl {
FILE: include/dg/llvm/PointerAnalysis/PointerAnalysis.h
function namespace (line 23) | namespace dg {
function functionPointerCall (line 97) | bool functionPointerCall(PSNode *callsite, PSNode *called) override {
function handleFork (line 143) | bool handleFork(PSNode *forkNode, PSNode *called) override {
function handleJoin (line 170) | bool handleJoin(PSNode *joinNode) override {
function class (line 175) | class DGLLVMPointerAnalysis : public LLVMPointerAnalysis {
function PointsToSetT (line 190) | static const PointsToSetT &getUnknownPTSet() {
function PSNode (line 213) | PSNode *getPointsToNode(const llvm::Value *val) const {
function pta (line 218) | const pta::PointerAnalysis *getPTA() const { return PTA.get(); }
function hasPointsTo (line 222) | bool hasPointsTo(const llvm::Value *val) override {
function LLVMPointsToSet (line 236) | LLVMPointsToSet getLLVMPointsTo(const llvm::Value *val) override {
function std (line 270) | const std::vector<std::unique_ptr<PSNode>> &getNodes() {
function PointerGraph (line 278) | PointerGraph *getPS() { return PS; }
function PointerGraph (line 279) | const PointerGraph *getPS() const { return PS; }
function LLVMPointerGraphBuilder (line 281) | LLVMPointerGraphBuilder *getBuilder() { return _builder.get(); }
function LLVMPointerGraphBuilder (line 282) | const LLVMPointerGraphBuilder *getBuilder() const { return _builder.get(...
function buildSubgraph (line 284) | void buildSubgraph() {
function initialize (line 306) | void initialize() {
function run (line 328) | bool run() override {
function std (line 337) | inline std::vector<const llvm::Function *>
FILE: include/dg/llvm/PointerAnalysis/PointerGraph.h
function namespace (line 19) | namespace dg {
function isRelevantIntrinsic (line 432) | inline bool isRelevantIntrinsic(const llvm::Function *func,
function isInvalid (line 451) | inline bool isInvalid(const llvm::Value *val, bool invalidate_nodes) {
FILE: include/dg/llvm/PointerAnalysis/SVFPointerAnalysis.h
function class (line 30) | class SvfLLVMPointsToSet : public LLVMPointsToSetImplTemplate<const Poin...
function llvm (line 92) | const llvm::Module *_module{nullptr};
FILE: include/dg/llvm/SystemDependenceGraph/SDG2Dot.h
function namespace (line 20) | namespace dg {
function dumpParamEdges (line 147) | void dumpParamEdges(std::ostream &out, sdg::DGParameters ¶ms) const {
FILE: include/dg/llvm/SystemDependenceGraph/SystemDependenceGraph.h
function namespace (line 13) | namespace llvm {
function namespace (line 18) | namespace dg {
FILE: include/dg/llvm/SystemDependenceGraph/SystemDependenceGraphBuilder.h
function namespace (line 24) | namespace llvm {
function namespace (line 29) | namespace dg {
FILE: include/dg/llvm/ThreadRegions/ControlFlowGraph.h
function namespace (line 9) | namespace dg {
function namespace (line 13) | namespace llvm {
function class (line 22) | class ControlFlowGraph {
FILE: include/dg/llvm/ThreadRegions/MayHappenInParallel.h
function class (line 8) | class MayHappenInParallel {
FILE: include/dg/llvm/ThreadRegions/ThreadRegion.h
function namespace (line 10) | namespace llvm {
function class (line 14) | class ThreadRegion {
FILE: include/dg/llvm/ValueRelations/GraphBuilder.h
function namespace (line 8) | namespace dg {
FILE: include/dg/llvm/ValueRelations/GraphElements.h
function namespace (line 18) | namespace vr {
function class (line 183) | class VRCodeGraph {
FILE: include/dg/llvm/ValueRelations/RelationsAnalyzer.h
function class (line 24) | class RelationsAnalyzer {
FILE: include/dg/llvm/ValueRelations/StructureAnalyzer.h
function namespace (line 16) | namespace dg {
FILE: include/dg/llvm/ValueRelations/StructureElements.h
function namespace (line 9) | namespace vr {
type CallRelation (line 46) | struct CallRelation {
type BorderValue (line 62) | struct BorderValue {
FILE: include/dg/llvm/ValueRelations/UniquePtrVector.h
function namespace (line 7) | namespace dg {
function reference (line 72) | reference at(size_type pos) const { return *_v.at(pos); }
function reference (line 73) | reference operator[](size_type pos) const { return *_v[pos]; }
function clear (line 81) | void clear() { _v.clear(); }
function iterator (line 96) | iterator erase(iterator pos) { return iterator(_v.erase(pos.it)); }
function iterator (line 98) | iterator erase(iterator b, iterator e) {
function swap (line 102) | void swap(UniquePtrVector &other) {
FILE: include/dg/llvm/ValueRelations/ValueRelations.h
function namespace (line 16) | namespace dg {
function reference (line 176) | reference operator*() { return current; }
function pointer (line 177) | pointer operator->() { return ¤t; }
function class (line 180) | class PlainValueIterator {
function pointer (line 235) | pointer operator->() const { return &(*valueIt); }
function updateChanged (line 246) | void updateChanged(bool ch) { changed |= ch; }
function I (line 259) | I *getInstance(V v) const {
function I (line 267) | I *getInstance(Handle h) const {
function unsetAllLoads (line 321) | void unsetAllLoads() { unset(Relations::PT); }
function plain_iterator (line 416) | plain_iterator begin() const;
function RelationsMap (line 431) | RelationsMap getAllRelated(const X &val) const {
function RelationsMap (line 435) | RelationsMap getRelated(const X &val,
function Handle (line 475) | Handle newBorderBucket(size_t id) {
function unsetChanged (line 499) | bool unsetChanged() {
FILE: include/dg/llvm/ValueRelations/getValName.h
function namespace (line 10) | namespace dg {
FILE: include/dg/util/TimeMeasure.h
function namespace (line 8) | namespace debug {
FILE: include/dg/util/cow_shared_ptr.h
function owner (line 12) | bool owner{true};
FILE: include/dg/util/debug.h
function namespace (line 10) | namespace dg {
function dbg_enable (line 53) | inline void dbg_enable() { _setDebugLvl(1); }
function dbg_is_enabled (line 55) | inline bool dbg_is_enabled() { return _getDebugLvl() > 0; }
FILE: include/dg/util/iterators.h
function namespace (line 6) | namespace dg {
FILE: lib/BBlockBase.cpp
type dg (line 3) | namespace dg {
FILE: lib/ControlDependence/CDGraph.h
function namespace (line 12) | namespace dg {
FILE: lib/ControlDependence/ControlClosure.h
function namespace (line 12) | namespace dg {
FILE: lib/ControlDependence/DOD.h
function namespace (line 15) | namespace dg {
FILE: lib/ControlDependence/NTSCD.h
function namespace (line 13) | namespace dg {
FILE: lib/Debug.cpp
type dg (line 2) | namespace dg {
type debug (line 3) | namespace debug {
FILE: lib/MemorySSA/Definitions.cpp
type dg (line 9) | namespace dg {
type dda (line 10) | namespace dda {
FILE: lib/MemorySSA/MemorySSA.cpp
type dg (line 10) | namespace dg {
type dda (line 11) | namespace dda {
function RWNode (line 94) | RWNode *MemorySSATransformation::createPhi(const DefSite &ds, RWNode...
function RWNode (line 106) | RWNode *MemorySSATransformation::createPhi(Definitions &D, const Def...
function RWNode (line 131) | RWNode *MemorySSATransformation::createAndPlacePhi(RWBBlock *block,
function canBeInput (line 140) | static inline bool canBeInput(const RWNode *node, RWSubgraph *subg) {
function Definitions (line 414) | Definitions &MemorySSATransformation::getBBlockDefinitions(RWBBlock *b,
function Definitions (line 459) | Definitions MemorySSATransformation::findDefinitionsInBlock(RWNode *to,
function Definitions (line 475) | Definitions
function joinDefinitions (line 496) | static void joinDefinitions(DefinitionsMap<RWNode> &from,
function joinDefinitions (line 522) | static void joinDefinitions(Definitions &from, Definitions &to,
function Definitions (line 606) | Definitions MemorySSATransformation::collectAllDefinitions(RWNode *f...
function RWNode (line 763) | RWNode *MemorySSATransformation::insertUse(RWNode *where, RWNode *mem,
function recGatherNonPhisDefs (line 776) | static void recGatherNonPhisDefs(RWNode *phi,
function gatherNonPhisDefs (line 801) | std::vector<RWNode *> gatherNonPhisDefs(ReadWriteGraph *graph,
FILE: lib/MemorySSA/ModRef.cpp
type dg (line 4) | namespace dg {
type dda (line 5) | namespace dda {
function canBeOutput (line 7) | static inline bool canBeOutput(const RWNode *node, RWSubgraph *subg) {
function modRefAdd (line 14) | static void modRefAdd(MR &modref, const C &c, RWNode *node, RWSubgra...
FILE: lib/Offset.cpp
type dg (line 3) | namespace dg {
FILE: lib/PointerAnalysis/Pointer.cpp
type dg (line 7) | namespace dg {
type pta (line 8) | namespace pta {
FILE: lib/PointerAnalysis/PointerAnalysis.cpp
type dg (line 7) | namespace dg {
type pta (line 8) | namespace pta {
function canBeDereferenced (line 12) | static inline bool canBeDereferenced(const Pointer &ptr) {
function funHasAddressTaken (line 23) | static bool funHasAddressTaken(PSNode *node) {
function Pointer (line 175) | static Pointer unwrapConstants(const Pointer &ptr) {
function setToEmpty (line 479) | static void setToEmpty(std::vector<PSNode *> &nodes) {
FILE: lib/PointerAnalysis/PointerGraph.cpp
type dg (line 8) | namespace dg {
type pta (line 9) | namespace pta {
FILE: lib/PointerAnalysis/PointerGraphOptimizations.cpp
type dg (line 4) | namespace dg {
type pta (line 5) | namespace pta {
function isStoreOfUnknown (line 7) | static inline bool isStoreOfUnknown(PSNode *S, PSNode *to) {
function usersImplyUnknown (line 12) | static inline bool usersImplyUnknown(PSNode *alloc) {
function removeNode (line 28) | void removeNode(PointerGraph *G, PSNode *nd) {
function allOperandsAreSame (line 87) | static inline bool allOperandsAreSame(PSNode *nd) {
FILE: lib/PointerAnalysis/PointerGraphValidator.cpp
type dg (line 7) | namespace dg {
type pta (line 8) | namespace pta {
function dumpNode (line 10) | static void dumpNode(const PSNode *nd, std::string &errors) {
function hasDuplicateOperand (line 66) | static bool hasDuplicateOperand(const PSNode *nd) {
function hasNonpointerOperand (line 76) | static bool hasNonpointerOperand(const PSNode *nd) {
function isInPredecessors (line 182) | static inline bool isInPredecessors(const PSNode *nd, const PSNode *...
function canBeOutsideGraph (line 187) | static inline bool canBeOutsideGraph(const PSNode *nd) {
function reachableNodes (line 197) | std::set<const PSNode *> reachableNodes(const PSNode *nd) {
FILE: lib/PointerAnalysis/PointsToSet.cpp
type dg (line 10) | namespace dg {
type pta (line 11) | namespace pta {
FILE: lib/ReadWriteGraph/ReadWriteGraph.cpp
type dg (line 7) | namespace dg {
type dda (line 8) | namespace dda {
function RWBBlock (line 100) | static RWBBlock *
FILE: lib/SystemDependenceGraph/DependenceGraph.cpp
type dg (line 9) | namespace dg {
type sdg (line 10) | namespace sdg {
function DGNodeArtificial (line 23) | DGNodeArtificial &DGFormalParameters::createVarArg() {
function DGNode (line 29) | DGNode &DGParameters::createNoReturn() {
function DGNode (line 35) | DGNode &DGParameters::createReturn() {
FILE: lib/ValueRelations/Relations.cpp
type dg (line 7) | namespace dg {
type vr (line 8) | namespace vr {
function Relations (line 74) | Relations Relations::conflicting(Relations::Type type) {
function Relations (line 113) | Relations &Relations::addImplied() {
function Relations (line 127) | Relations &Relations::invert() {
function Relations (line 139) | Relations Relations::getAugmented(Relations rels) {
function Relations (line 173) | Relations compose(const Relations <, const Relations &rt) {
FILE: lib/llvm/ControlDependence/ControlClosure.h
function namespace (line 15) | namespace llvm {
function namespace (line 19) | namespace dg {
FILE: lib/llvm/ControlDependence/ControlDependence.cpp
type dg (line 9) | namespace dg {
FILE: lib/llvm/ControlDependence/DOD.h
function namespace (line 17) | namespace llvm {
function namespace (line 21) | namespace dg {
function ICDGraphBuilder (line 215) | ICDGraphBuilder igraphBuilder{}
function CDResultT (line 220) | CDResultT controlDependence{}
function CDResultT (line 222) | CDResultT revControlDependence{}
FILE: lib/llvm/ControlDependence/GraphBuilder.h
type BBlock (line 27) | struct BBlock {
FILE: lib/llvm/ControlDependence/IGraphBuilder.h
function namespace (line 16) | namespace dg {
FILE: lib/llvm/ControlDependence/InterproceduralCD.cpp
type dg (line 13) | namespace dg {
type llvmdg (line 14) | namespace llvmdg {
function hasNoSuccessors (line 28) | static inline bool hasNoSuccessors(const llvm::BasicBlock *bb) {
type BlkInfo (line 97) | struct BlkInfo {
FILE: lib/llvm/ControlDependence/InterproceduralCD.h
function namespace (line 12) | namespace llvm {
type FuncInfo (line 28) | struct FuncInfo {
function FuncInfo (line 43) | FuncInfo *getFuncInfo(const llvm::Function *F) {
function FuncInfo (line 48) | const FuncInfo *getFuncInfo(const llvm::Function *F) const {
function hasFuncInfo (line 53) | bool hasFuncInfo(const llvm::Function *fun) const {
FILE: lib/llvm/ControlDependence/NTSCD.h
function namespace (line 16) | namespace llvm {
function namespace (line 20) | namespace dg {
function ICDGraphBuilder (line 217) | ICDGraphBuilder igraphBuilder{}
function CDResultT (line 222) | CDResultT controlDependence{}
function CDResultT (line 224) | CDResultT revControlDependence{}
FILE: lib/llvm/ControlDependence/SCD.cpp
type dg (line 13) | namespace dg {
type llvmdg (line 14) | namespace llvmdg {
class PostDominanceFrontiers (line 16) | class PostDominanceFrontiers {
method DomSetType (line 36) | DomSetType &calculate(const llvm::PostDominatorTree &DT,
FILE: lib/llvm/ControlDependence/SCD.h
function namespace (line 13) | namespace llvm {
function namespace (line 17) | namespace dg {
FILE: lib/llvm/ControlDependence/legacy/Block.cpp
type dg (line 10) | namespace dg {
type llvmdg (line 11) | namespace llvmdg {
type legacy (line 12) | namespace legacy {
FILE: lib/llvm/ControlDependence/legacy/Block.h
function namespace (line 9) | namespace llvm {
function namespace (line 15) | namespace dg {
FILE: lib/llvm/ControlDependence/legacy/Function.cpp
type dg (line 7) | namespace dg {
type llvmdg (line 8) | namespace llvmdg {
type legacy (line 9) | namespace legacy {
function Block (line 21) | Block *Function::entry() const { return firstBlock; }
function Block (line 23) | Block *Function::exit() const { return lastBlock; }
FILE: lib/llvm/ControlDependence/legacy/Function.h
function namespace (line 7) | namespace dg {
FILE: lib/llvm/ControlDependence/legacy/GraphBuilder.cpp
type dg (line 17) | namespace dg {
type llvmdg (line 18) | namespace llvmdg {
type legacy (line 19) | namespace legacy {
function isExit (line 32) | bool isExit(const TarjanAnalysis<Block>::StronglyConnectedComponen...
function Function (line 41) | Function *GraphBuilder::buildFunction(const llvm::Function *llvmFu...
function Function (line 132) | Function *GraphBuilder::findFunction(const llvm::Function *llvmFun...
function Function (line 143) | Function *
function predecessorsNumber (line 251) | int predecessorsNumber(const llvm::BasicBlock *basicBlock) {
function successorsNumber (line 256) | int successorsNumber(const llvm::BasicBlock *basicBlock) {
function isReachable (line 261) | bool isReachable(const llvm::BasicBlock *basicBlock) {
FILE: lib/llvm/ControlDependence/legacy/GraphBuilder.h
function namespace (line 9) | namespace llvm {
function namespace (line 17) | namespace dg {
FILE: lib/llvm/ControlDependence/legacy/NTSCD.cpp
type llvm (line 5) | namespace llvm {
class Function (line 6) | class Function
type dg (line 19) | namespace dg {
type llvmdg (line 20) | namespace llvmdg {
type legacy (line 21) | namespace legacy {
FILE: lib/llvm/ControlDependence/legacy/NTSCD.h
function namespace (line 16) | namespace llvm {
function class (line 27) | class NTSCD : public LLVMControlDependenceAnalysisImpl {
function ValVec (line 49) | ValVec getDependencies(const llvm::Instruction * /*unused*/) override {
function ValVec (line 52) | ValVec getDependent(const llvm::Instruction * /*unused*/) override {
FILE: lib/llvm/ControlDependence/legacy/TarjanAnalysis.h
function namespace (line 13) | namespace llvmdg {
FILE: lib/llvm/DataDependenceAnalysis/LLVMDataDependenceAnalysis.cpp
type dg (line 6) | namespace dg {
type dda (line 7) | namespace dda {
function LLVMReadWriteGraphBuilder (line 11) | LLVMReadWriteGraphBuilder *LLVMDataDependenceAnalysis::createBuilder...
function DataDependenceAnalysis (line 16) | DataDependenceAnalysis *LLVMDataDependenceAnalysis::createDDA() {
function RWNode (line 24) | RWNode *LLVMDataDependenceAnalysis::getNode(const llvm::Value *val) {
function RWNode (line 28) | const RWNode *
FILE: lib/llvm/DefUse/DefUse.cpp
type dg (line 30) | namespace dg {
function handleOperands (line 33) | static void handleOperands(const Instruction *Inst, LLVMNode *node) {
FILE: lib/llvm/DefUse/DefUse.h
function namespace (line 15) | namespace llvm {
function namespace (line 20) | namespace dg {
FILE: lib/llvm/Dominators/PostDominators.cpp
type dg (line 10) | namespace dg {
FILE: lib/llvm/ForkJoin/ForkJoin.cpp
type dg (line 5) | namespace dg {
FILE: lib/llvm/ForkJoin/ForkJoin.h
function class (line 11) | class ForkJoinAnalysis {
FILE: lib/llvm/GraphBuilder.h
function namespace (line 12) | namespace dg {
type SubgraphInfo (line 45) | struct SubgraphInfo {
function subgraph (line 52) | subgraph(s) {}
function buildCFG (line 72) | void buildCFG(SubgraphInfo &subginfo) {
FILE: lib/llvm/LLVMDGVerifier.cpp
type dg (line 12) | namespace dg {
FILE: lib/llvm/LLVMDGVerifier.h
function namespace (line 6) | namespace llvm {
function namespace (line 11) | namespace dg {
FILE: lib/llvm/LLVMDependenceGraph.cpp
type dg (line 42) | namespace dg {
function addGlobals (line 100) | static void addGlobals(llvm::Module *m, LLVMDependenceGraph *dg) {
function LLVMNode (line 118) | LLVMNode *LLVMDependenceGraph::findNode(llvm::Value *value) const {
function LLVMDependenceGraph (line 151) | LLVMDependenceGraph *LLVMDependenceGraph::buildSubgraph(LLVMNode *node) {
function addSubgraphGlobParams (line 195) | static bool addSubgraphGlobParams(LLVMDependenceGraph *parentdg,
function LLVMDependenceGraph (line 232) | LLVMDependenceGraph *
function is_func_defined (line 298) | static bool is_func_defined(const llvm::Function *func) {
function LLVMNode (line 302) | LLVMNode *LLVMDependenceGraph::getOrCreateNoReturn() {
function LLVMNode (line 317) | LLVMNode *LLVMDependenceGraph::getOrCreateNoReturn(LLVMNode *call) {
function LLVMDGParameters (line 332) | LLVMDGParameters *LLVMDependenceGraph::getOrCreateParameters() {
function isMemAllocationFunc (line 379) | static bool isMemAllocationFunc(const llvm::Function *func) {
function LLVMBBlock (line 497) | LLVMBBlock *LLVMDependenceGraph::build(llvm::BasicBlock &llvmBB) {
function LLVMBBlock (line 575) | static LLVMBBlock *createSingleExitBB(LLVMDependenceGraph *graph) {
function addControlDepsToPHI (line 589) | static void addControlDepsToPHI(LLVMDependenceGraph *graph, LLVMNode *...
function addControlDepsToPHIs (line 608) | static void addControlDepsToPHIs(LLVMDependenceGraph *graph) {
function array_match (line 770) | static bool array_match(llvm::StringRef name, const char *names[]) {
function array_match (line 781) | static bool array_match(llvm::StringRef name,
function match_callsite_name (line 791) | static bool match_callsite_name(LLVMNode *callNode, const char *names[...
function match_callsite_name (line 828) | static bool match_callsite_name(LLVMNode *callNode,
function LLVMNode (line 1281) | LLVMNode *findInstruction(llvm::Instruction *instruction,
FILE: lib/llvm/LLVMNode.cpp
type dg (line 14) | namespace dg {
function addGlobalsParams (line 16) | static void addGlobalsParams(LLVMDGParameters *params, LLVMNode *callN...
function addDynMemoryParams (line 48) | static void addDynMemoryParams(LLVMDGParameters *params, LLVMNode *cal...
function addOperandsParams (line 84) | static void addOperandsParams(LLVMDGParameters *params,
FILE: lib/llvm/PointerAnalysis/Block.cpp
type dg (line 15) | namespace dg {
type pta (line 16) | namespace pta {
FILE: lib/llvm/PointerAnalysis/Calls.cpp
type dg (line 4) | namespace dg {
type pta (line 5) | namespace pta {
function PSNode (line 95) | PSNode *LLVMPointerGraphBuilder::createUnknownCall() {
function PSNode (line 109) | PSNode *
function PSNode (line 205) | PSNode *
function PSNode (line 263) | PSNode *LLVMPointerGraphBuilder::createFree(const llvm::Instruction ...
function PSNode (line 270) | PSNode *LLVMPointerGraphBuilder::createDynamicAlloc(const llvm::Call...
FILE: lib/llvm/PointerAnalysis/Constants.cpp
type dg (line 4) | namespace dg {
type pta (line 5) | namespace pta {
function Pointer (line 7) | Pointer
function Pointer (line 20) | Pointer
function Pointer (line 38) | Pointer
function Pointer (line 77) | Pointer LLVMPointerGraphBuilder::handleConstantArithmetic(
function Pointer (line 105) | Pointer
function Pointer (line 127) | Pointer
function Pointer (line 156) | Pointer
FILE: lib/llvm/PointerAnalysis/Globals.cpp
type dg (line 24) | namespace dg {
type pta (line 25) | namespace pta {
function getAllocatedSize (line 77) | static uint64_t getAllocatedSize(const llvm::GlobalVariable *GV,
FILE: lib/llvm/PointerAnalysis/Instructions.cpp
type dg (line 4) | namespace dg {
type pta (line 5) | namespace pta {
function PSNode (line 45) | PSNode *
function Offset (line 115) | Offset accumulateEVOffsets(const llvm::ExtractValueInst *EV,
FILE: lib/llvm/PointerAnalysis/Interprocedural.cpp
type dg (line 17) | namespace dg {
type pta (line 18) | namespace pta {
FILE: lib/llvm/PointerAnalysis/PointerAnalysis.cpp
type dg (line 6) | namespace dg {
FILE: lib/llvm/PointerAnalysis/PointerGraph.cpp
type dg (line 33) | namespace dg {
type pta (line 34) | namespace pta {
function PSNode (line 36) | PSNode *LLVMPointerGraphBuilder::getConstant(const llvm::Value *val) {
function PSNode (line 58) | PSNode *LLVMPointerGraphBuilder::tryGetOperand(const llvm::Value *va...
function PSNode (line 93) | PSNode *LLVMPointerGraphBuilder::getOperand(const llvm::Value *val) {
function PointerSubgraph (line 105) | PointerSubgraph &
function PointerSubgraph (line 230) | PointerSubgraph &
function PointerSubgraph (line 249) | PointerSubgraph *LLVMPointerGraphBuilder::getSubgraph(const llvm::Fu...
function isRelevantCall (line 271) | static bool isRelevantCall(const llvm::Instruction *Inst, bool inval...
function getBasicBlocksInDominatorOrder (line 487) | std::vector<const llvm::BasicBlock *>
function PointerSubgraph (line 542) | PointerSubgraph &
function PointerGraph (line 627) | PointerGraph *LLVMPointerGraphBuilder::buildLLVMPointerGraph() {
FILE: lib/llvm/PointerAnalysis/PointerGraphValidator.cpp
type dg (line 6) | namespace dg {
type pta (line 7) | namespace pta {
FILE: lib/llvm/PointerAnalysis/PointerGraphValidator.h
function namespace (line 7) | namespace dg {
FILE: lib/llvm/PointerAnalysis/Structure.cpp
type dg (line 25) | namespace dg {
type pta (line 26) | namespace pta {
function PSNode (line 106) | PSNode *LLVMPointerGraphBuilder::connectArguments(const llvm::Functi...
FILE: lib/llvm/PointerAnalysis/Threads.cpp
type dg (line 33) | namespace dg {
type pta (line 34) | namespace pta {
function PSNodeJoin (line 50) | PSNodeJoin *
function PSNodeFork (line 129) | PSNodeFork *LLVMPointerGraphBuilder::createForkNode(const llvm::Call...
function PSNodeJoin (line 150) | PSNodeJoin *LLVMPointerGraphBuilder::createJoinNode(const llvm::Call...
FILE: lib/llvm/ReadWriteGraph/Calls.cpp
type dg (line 19) | namespace dg {
type dda (line 20) | namespace dda {
function reportIncompatibleCalls (line 22) | static void reportIncompatibleCalls(
function RWNode (line 85) | RWNode *
function RWNode (line 175) | RWNode *
function getFromTo (line 259) | std::pair<Offset, Offset> getFromTo(const llvm::CallInst *CInst, T w...
function RWNode (line 272) | RWNode *LLVMReadWriteGraphBuilder::funcFromModel(const FunctionModel...
function RWNode (line 324) | RWNode *LLVMReadWriteGraphBuilder::createCallToUndefinedFunction(
function RWNode (line 352) | RWNode *LLVMReadWriteGraphBuilder::createPthreadCreateCalls(
function RWNode (line 373) | RWNode *
function RWNode (line 383) | RWNode *
FILE: lib/llvm/ReadWriteGraph/Instructions.cpp
type dg (line 20) | namespace dg {
type dda (line 21) | namespace dda {
function RWNode (line 36) | RWNode *LLVMReadWriteGraphBuilder::createAlloc(const llvm::Instructi...
function RWNode (line 79) | RWNode *LLVMReadWriteGraphBuilder::createDynAlloc(const llvm::Instru...
function RWNode (line 117) | RWNode *
function RWNode (line 198) | RWNode *
function RWNode (line 203) | RWNode *LLVMReadWriteGraphBuilder::createStore(const llvm::Instructi...
function RWNode (line 232) | RWNode *LLVMReadWriteGraphBuilder::createLoad(const llvm::Instructio...
function RWNode (line 248) | RWNode *
function isRelevantCall (line 318) | static bool isRelevantCall(const llvm::Instruction *Inst, OptsT &opt...
FILE: lib/llvm/ReadWriteGraph/LLVMReadWriteGraphBuilder.cpp
type dg (line 30) | namespace dg {
type dda (line 31) | namespace dda {
function RWNode (line 126) | RWNode *LLVMReadWriteGraphBuilder::getOperand(const llvm::Value *val) {
FILE: lib/llvm/ReadWriteGraph/LLVMReadWriteGraphBuilder.h
function namespace (line 24) | namespace dg {
FILE: lib/llvm/SummaryEdges.cpp
type dg (line 11) | namespace dg {
class SummaryEdgesComputation (line 18) | class SummaryEdgesComputation {
method propagate (line 30) | void propagate(const Edge &e) {
method propagate (line 36) | void propagate(NodeT *n1, NodeT *n2) { propagate({n1, n2}); }
method initialize (line 38) | void initialize() {
method isActualOut (line 70) | bool isActualOut(NodeT *n) const { return actualOutVertices.count(n)...
method isFormalIn (line 71) | bool isFormalIn(NodeT *n) const { return formalInVertices.count(n) >...
method handleActualOut (line 73) | void handleActualOut(const Edge &e) {
method handleGenericEdge (line 86) | void handleGenericEdge(const Edge &e) {
method handleFormalIn (line 102) | void handleFormalIn(const Edge &e) {
method computeSummaryEdges (line 137) | void computeSummaryEdges() {
FILE: lib/llvm/SystemDependenceGraph/Dependencies.cpp
type dg (line 6) | namespace dg {
type llvmdg (line 7) | namespace llvmdg {
type SDGDependenciesBuilder (line 11) | struct SDGDependenciesBuilder {
method SDGDependenciesBuilder (line 16) | SDGDependenciesBuilder(llvmdg::SystemDependenceGraph &g,
method addUseDependencies (line 21) | void addUseDependencies(sdg::DGElement *nd, llvm::Instruction &I) {
method addControlDep (line 61) | void addControlDep(sdg::DepDGElement *elem, const llvm::Value *on) {
method addControlDependencies (line 91) | void addControlDependencies(sdg::DepDGElement *elem, llvm::Instruc...
method addControlDependencies (line 98) | void addControlDependencies(sdg::DGBBlock *block, llvm::BasicBlock...
method addDataDependencies (line 105) | void addDataDependencies(sdg::DGElement *nd, llvm::Instruction &I) {
method addInterprocDataDependencies (line 109) | void addInterprocDataDependencies(sdg::DGElement *nd,
method processInstr (line 136) | void processInstr(llvm::Instruction &I) {
method processDG (line 152) | void processDG(llvm::Function &F) {
method processFuns (line 186) | void processFuns() {
FILE: lib/llvm/SystemDependenceGraph/SystemDependenceGraph.cpp
type dg (line 6) | namespace dg {
type llvmdg (line 7) | namespace llvmdg {
type SDGBuilder (line 9) | struct SDGBuilder {
method SDGBuilder (line 13) | SDGBuilder(SystemDependenceGraph *llvmsdg, llvm::Module *m)
method buildBBlock (line 61) | void buildBBlock(sdg::DependenceGraph &dg, llvm::BasicBlock &B) {
method buildFormalParameters (line 88) | void buildFormalParameters(sdg::DependenceGraph &dg, llvm::Functio...
method buildDG (line 103) | void buildDG(sdg::DependenceGraph &dg, llvm::Function &F) {
method buildGlobals (line 115) | void buildGlobals(sdg::DependenceGraph &entry) {
method buildFuns (line 128) | void buildFuns() {
FILE: lib/llvm/ThreadRegions/Graphs/BlockGraph.cpp
function Node (line 9) | Node *BlockGraph::firstNode() const { return firstNode_; }
function Node (line 11) | Node *BlockGraph::lastNode() const { return lastNode_; }
FILE: lib/llvm/ThreadRegions/Graphs/BlockGraph.h
function namespace (line 8) | namespace llvm {
function class (line 14) | class BlockGraph {
FILE: lib/llvm/ThreadRegions/Graphs/CriticalSectionsBuilder.h
function namespace (line 14) | namespace llvm {
function class (line 19) | class CriticalSection {
function class (line 36) | class CriticalSectionsBuilder {
FILE: lib/llvm/ThreadRegions/Graphs/FunctionGraph.cpp
function EntryNode (line 8) | EntryNode *FunctionGraph::entryNode() const { return entryNode_; }
function ExitNode (line 10) | ExitNode *FunctionGraph::exitNode() const { return exitNode_; }
FILE: lib/llvm/ThreadRegions/Graphs/FunctionGraph.h
function namespace (line 4) | namespace llvm {
function class (line 11) | class FunctionGraph {
FILE: lib/llvm/ThreadRegions/Graphs/GraphBuilder.cpp
function ForkNode (line 42) | ForkNode *GraphBuilder::addNode(ForkNode *node) {
function JoinNode (line 59) | JoinNode *GraphBuilder::addNode(JoinNode *node) {
function LockNode (line 76) | LockNode *GraphBuilder::addNode(LockNode *node) {
function UnlockNode (line 93) | UnlockNode *GraphBuilder::addNode(UnlockNode *node) {
function Node (line 216) | Node *GraphBuilder::findInstruction(const llvm::Instruction *instruction) {
function BlockGraph (line 224) | BlockGraph *GraphBuilder::findBlock(const llvm::BasicBlock *basicBlock) {
function FunctionGraph (line 235) | FunctionGraph *GraphBuilder::findFunction(const llvm::Function *function) {
function predecessorsNumber (line 576) | int predecessorsNumber(const BasicBlock *basicBlock) {
function successorsNumber (line 581) | int successorsNumber(const BasicBlock *basicBlock) {
function isReachable (line 586) | bool isReachable(const BasicBlock *basicBlock) {
FILE: lib/llvm/ThreadRegions/Graphs/GraphBuilder.h
function namespace (line 10) | namespace dg {
function namespace (line 19) | namespace llvm {
function class (line 34) | class GraphBuilder {
FILE: lib/llvm/ThreadRegions/Graphs/ThreadRegionsBuilder.cpp
function ThreadRegion (line 71) | ThreadRegion *ThreadRegionsBuilder::region(Node *node) const {
function ThreadRegion (line 123) | ThreadRegion *ThreadRegionsBuilder::regionOfVisitedNode(Node *node) const {
function ThreadRegion (line 131) | ThreadRegion *ThreadRegionsBuilder::regionOfExaminedNode(Node *node) con...
FILE: lib/llvm/ThreadRegions/Graphs/ThreadRegionsBuilder.h
function class (line 14) | class ThreadRegionsBuilder {
FILE: lib/llvm/ThreadRegions/Nodes/CallFuncPtrNode.h
function class (line 6) | class CallFuncPtrNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/CallNode.h
function class (line 6) | class CallNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/CallReturnNode.h
function class (line 6) | class CallReturnNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/EntryNode.h
function class (line 10) | class EntryNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/ExitNode.h
function class (line 10) | class ExitNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/ForkNode.h
function class (line 9) | class ForkNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/GeneralNode.h
function class (line 6) | class GeneralNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/JoinNode.h
function class (line 11) | class JoinNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/LockNode.h
function class (line 8) | class LockNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/Node.cpp
function NodeIterator (line 19) | NodeIterator Node::begin() const { return NodeIterator(this, true); }
function NodeIterator (line 21) | NodeIterator Node::end() const { return NodeIterator(this, false); }
function NodeType (line 25) | NodeType Node::getType() const { return nodeType_; }
function string (line 27) | string Node::dotName() const { return "NODE" + to_string(id_); }
function Instruction (line 71) | const Instruction *Node::llvmInstruction() const { return llvmInstructio...
function CallInst (line 73) | const CallInst *Node::callInstruction() const {
function string (line 83) | string Node::dump() const {
function string (line 87) | string Node::label() const {
FILE: lib/llvm/ThreadRegions/Nodes/Node.h
function namespace (line 10) | namespace llvm {
type class (line 15) | enum class
type NodeType (line 29) | enum NodeType
FILE: lib/llvm/ThreadRegions/Nodes/NodeIterator.cpp
function NodeIterator (line 26) | NodeIterator &NodeIterator::operator++() {
function NodeIterator (line 42) | NodeIterator NodeIterator::operator++(int) {
function Node (line 66) | Node *NodeIterator::operator*() const {
FILE: lib/llvm/ThreadRegions/Nodes/NodeIterator.h
function class (line 12) | class NodeIterator {
FILE: lib/llvm/ThreadRegions/Nodes/Nodes.h
function GENERAL (line 20) | struct Map<NodeType::GENERAL> {
function FORK (line 26) | struct Map<NodeType::FORK> {
function JOIN (line 32) | struct Map<NodeType::JOIN> {
function LOCK (line 38) | struct Map<NodeType::LOCK> {
function UNLOCK (line 44) | struct Map<NodeType::UNLOCK> {
function ENTRY (line 50) | struct Map<NodeType::ENTRY> {
function EXIT (line 56) | struct Map<NodeType::EXIT> {
function CALL (line 62) | struct Map<NodeType::CALL> {
function CALL_FUNCPTR (line 68) | struct Map<NodeType::CALL_FUNCPTR> {
function CALL_RETURN (line 74) | struct Map<NodeType::CALL_RETURN> {
function RETURN (line 80) | struct Map<NodeType::RETURN> {
FILE: lib/llvm/ThreadRegions/Nodes/ReturnNode.h
function class (line 6) | class ReturnNode : public Node {
FILE: lib/llvm/ThreadRegions/Nodes/UnlockNode.h
function class (line 6) | class UnlockNode : public Node {
FILE: lib/llvm/ThreadRegions/ThreadRegion.cpp
function Node (line 61) | Node *ThreadRegion::foundingNode() const { return foundingNode_; }
FILE: lib/llvm/ValueRelations/GraphBuilder.cpp
type dg (line 9) | namespace dg {
type vr (line 10) | namespace vr {
FILE: lib/llvm/ValueRelations/GraphElements.cpp
type dg (line 17) | namespace dg {
type vr (line 18) | namespace vr {
function VRLocation (line 76) | VRLocation &VRLocation::getTreePredecessor() const {
function VRLocation (line 86) | VRLocation &VRCodeGraph::newVRLocation() {
function VRLocation (line 91) | VRLocation &VRCodeGraph::newVRLocation(const llvm::Instruction *inst) {
function VRLocation (line 103) | VRLocation &VRCodeGraph::getVRLocation(const llvm::Instruction *ptr)...
function VRLocation (line 107) | VRLocation &VRCodeGraph::getEntryLocation(const llvm::Function &f) c...
FILE: lib/llvm/ValueRelations/RelationsAnalyzer.cpp
type dg (line 5) | namespace dg {
type vr (line 6) | namespace vr {
function V (line 114) | V getGEPBase(V val) {
function sameBase (line 120) | bool sameBase(const ValueRelations &graph, V val1, V val2) {
function toChange (line 224) | int toChange(const llvm::GetElementPtrInst *gep) {
function solveNonConstants (line 274) | void solveNonConstants(ValueRelations &graph,
function getParams (line 288) | std::pair<llvm::Value *, llvm::ConstantInt *>
function limitingBorder (line 560) | size_t limitingBorder(const ValueRelations &relations, const llvm::V...
function getParams (line 653) | std::pair<const llvm::LoadInst *, const llvm::Value *>
function getCompared (line 868) | std::pair<V, bool> getCompared(const ValueRelations &graph,
FILE: lib/llvm/ValueRelations/StructureAnalyzer.cpp
type dg (line 17) | namespace dg {
type vr (line 18) | namespace vr {
function BorderValue (line 836) | BorderValue StructureAnalyzer::getBorderValueFor(const llvm::Functio...
FILE: lib/llvm/ValueRelations/ValueRelations.cpp
type dg (line 5) | namespace dg {
type vr (line 6) | namespace vr {
function Relations (line 9) | Relations ValueRelations::_between(Handle lt, Handle rt) const {
function Relations (line 18) | Relations ValueRelations::_between(Handle lt, V rt) const {
function Relations (line 25) | Relations ValueRelations::_between(Handle lt, C cRt) const {
function Relations (line 45) | Relations ValueRelations::_between(V lt, Handle rt) const {
function Relations (line 48) | Relations ValueRelations::_between(C lt, Handle rt) const {
function Relations (line 51) | Relations ValueRelations::_between(V lt, V rt) const {
function Relations (line 69) | Relations ValueRelations::_between(Handle lt, size_t rt) const {
function Relations (line 73) | Relations ValueRelations::_between(V lt, size_t rt) const {
function Relations (line 250) | Relations ValueRelations::compare(C lt, C rt) {
function strip (line 423) | std::string strip(std::string str, size_t skipSpaces) {
FILE: lib/llvm/llvm-utils.h
function namespace (line 14) | namespace dg {
function isPointerOrIntegerTy (line 76) | inline bool isPointerOrIntegerTy(const Type *Ty) {
function CallCompatibility (line 81) | enum class CallCompatibility {
function getPointerBitwidth (line 138) | inline unsigned getPointerBitwidth(const llvm::DataLayout *DL,
function getConstantValue (line 146) | inline uint64_t getConstantValue(const llvm::Value *op) {
function getConstantSizeValue (line 163) | inline uint64_t getConstantSizeValue(const llvm::Value *op) {
function getAllocatedSize (line 173) | inline uint64_t getAllocatedSize(const llvm::AllocaInst *AI,
function getAllocatedSize (line 186) | inline uint64_t getAllocatedSize(llvm::Type *Ty, const llvm::DataLayout ...
function isConstantZero (line 194) | inline bool isConstantZero(const llvm::Value *val) {
function memsetIsZeroInitialization (line 206) | inline bool memsetIsZeroInitialization(const llvm::IntrinsicInst *I) {
function tyContainsPointer (line 212) | inline bool tyContainsPointer(const llvm::Type *Ty) {
function typeCanBePointer (line 224) | inline bool typeCanBePointer(const llvm::DataLayout *DL, llvm::Type *Ty) {
FILE: misc/benchexec/dgtool.py
class Tool (line 15) | class Tool(benchexec.tools.template.BaseTool):
method executable (line 21) | def executable(self):
method version (line 24) | def version(self, executable):
method name (line 27) | def name(self):
method cmdline (line 30) | def cmdline(self, executable, options, tasks, propertyfile, rlimits):
method get_phase (line 34) | def get_phase(self, tool, output):
method determine_result (line 47) | def determine_result(self, returncode, returnsignal, output, isTimeout):
FILE: tests/adt-test.cpp
type mycomp (line 46) | struct mycomp {
function hashMapTest (line 109) | void hashMapTest() {
type MyInt (line 134) | struct MyInt {
method MyInt (line 136) | MyInt() = default;
method MyInt (line 137) | MyInt(int y) : x(y) {}
type std (line 141) | namespace std {
type hash<MyInt> (line 143) | struct hash<MyInt> {
function hashCollisionTest (line 149) | void hashCollisionTest() {
FILE: tests/catch2/catch.hpp
type Catch (line 98) | namespace Catch {
type CaseSensitive (line 486) | struct CaseSensitive { enum Choice {
type Choice (line 486) | enum Choice {
class NonCopyable (line 491) | class NonCopyable {
method NonCopyable (line 492) | NonCopyable( NonCopyable const& ) = delete;
method NonCopyable (line 493) | NonCopyable( NonCopyable && ) = delete;
method NonCopyable (line 494) | NonCopyable& operator = ( NonCopyable const& ) = delete;
method NonCopyable (line 495) | NonCopyable& operator = ( NonCopyable && ) = delete;
type SourceLineInfo (line 502) | struct SourceLineInfo {
method SourceLineInfo (line 504) | SourceLineInfo() = delete;
method SourceLineInfo (line 505) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
method SourceLineInfo (line 510) | SourceLineInfo( SourceLineInfo const& other ) = default;
method SourceLineInfo (line 511) | SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
method SourceLineInfo (line 512) | SourceLineInfo( SourceLineInfo&& ) noexcept = default;
method SourceLineInfo (line 513) | SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
method empty (line 515) | bool empty() const noexcept { return file[0] == '\0'; }
type StreamEndStop (line 534) | struct StreamEndStop {
function T (line 538) | T const& operator + ( T const& value, StreamEndStop ) {
type RegistrarForTagAliases (line 549) | struct RegistrarForTagAliases {
class TestSpec (line 570) | class TestSpec
class Pattern (line 5112) | class Pattern {
class NamePattern (line 5123) | class NamePattern : public Pattern {
class TagPattern (line 5131) | class TagPattern : public Pattern {
class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
type Filter (line 5147) | struct Filter {
type FilterMatch (line 5155) | struct FilterMatch {
type ITestInvoker (line 572) | struct ITestInvoker {
class TestCase (line 577) | class TestCase
type IConfig (line 578) | struct IConfig
type ITestCaseRegistry (line 580) | struct ITestCaseRegistry {
class StringRef (line 606) | class StringRef {
method StringRef (line 618) | constexpr StringRef() noexcept = default;
method StringRef (line 622) | constexpr StringRef( char const* rawChars, size_type size ) noexcept
method StringRef (line 627) | StringRef( std::string const& stdString ) noexcept
method empty (line 648) | constexpr auto empty() const noexcept -> bool {
method size (line 651) | constexpr auto size() const noexcept -> size_type {
method isNullTerminated (line 668) | constexpr auto isNullTerminated() const noexcept -> bool {
method const_iterator (line 673) | constexpr const_iterator begin() const { return m_start; }
method const_iterator (line 674) | constexpr const_iterator end() const { return m_start + m_size; }
type always_false (line 925) | struct always_false : std::false_type {}
type true_given (line 927) | struct true_given : std::true_type {}
type is_callable_tester (line 928) | struct is_callable_tester {
type is_callable (line 936) | struct is_callable
class TestInvokerAsMethod (line 962) | class TestInvokerAsMethod : public ITestInvoker {
method TestInvokerAsMethod (line 965) | TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAs...
method invoke (line 967) | void invoke() const override {
function makeTestInvoker (line 976) | auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInv...
type NameAndTags (line 980) | struct NameAndTags {
type AutoReg (line 986) | struct AutoReg : NonCopyable {
type ResultWas (line 1353) | struct ResultWas { enum OfType {
type OfType (line 1353) | enum OfType {
type ResultDisposition (line 1377) | struct ResultDisposition { enum Flags {
type Flags (line 1377) | enum Flags {
function isFalseTest (line 1388) | inline bool isFalseTest( int flags ) { return ( flags & ResultDisposit...
type AssertionInfo (line 1396) | struct AssertionInfo
class StringRef (line 1431) | class StringRef
method StringRef (line 618) | constexpr StringRef() noexcept = default;
method StringRef (line 622) | constexpr StringRef( char const* rawChars, size_type size ) noexcept
method StringRef (line 627) | StringRef( std::string const& stdString ) noexcept
method empty (line 648) | constexpr auto empty() const noexcept -> bool {
method size (line 651) | constexpr auto size() const noexcept -> size_type {
method isNullTerminated (line 668) | constexpr auto isNullTerminated() const noexcept -> bool {
method const_iterator (line 673) | constexpr const_iterator begin() const { return m_start; }
method const_iterator (line 674) | constexpr const_iterator end() const { return m_start + m_size; }
type IStream (line 1433) | struct IStream {
class ReusableStringStream (line 1440) | class ReusableStringStream : NonCopyable {
method get (line 1454) | auto get() -> std::ostream& { return *m_oss; }
type Detail (line 1465) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type IMutableEnumValuesRegistry (line 1476) | struct IMutableEnumValuesRegistry {
type Detail (line 1552) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker (line 1615) | struct StringMaker {
method convert (line 1617) | static
method convert (line 1628) | static
type Detail (line 1639) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<std::string> (line 1665) | struct StringMaker<std::string> {
type StringMaker<std::string_view> (line 1671) | struct StringMaker<std::string_view> {
type StringMaker<char const *> (line 1677) | struct StringMaker<char const *> {
type StringMaker<char *> (line 1681) | struct StringMaker<char *> {
type StringMaker<std::wstring> (line 1687) | struct StringMaker<std::wstring> {
type StringMaker<std::wstring_view> (line 1693) | struct StringMaker<std::wstring_view> {
type StringMaker<wchar_t const *> (line 1699) | struct StringMaker<wchar_t const *> {
type StringMaker<wchar_t *> (line 1703) | struct StringMaker<wchar_t *> {
type StringMaker<char[SZ]> (line 1711) | struct StringMaker<char[SZ]> {
method convert (line 1712) | static std::string convert(char const* str) {
type StringMaker<signed char[SZ]> (line 1717) | struct StringMaker<signed char[SZ]> {
method convert (line 1718) | static std::string convert(signed char const* str) {
type StringMaker<unsigned char[SZ]> (line 1723) | struct StringMaker<unsigned char[SZ]> {
method convert (line 1724) | static std::string convert(unsigned char const* str) {
type StringMaker<std::byte> (line 1731) | struct StringMaker<std::byte> {
type StringMaker<int> (line 1736) | struct StringMaker<int> {
type StringMaker<long> (line 1740) | struct StringMaker<long> {
type StringMaker<long long> (line 1744) | struct StringMaker<long long> {
type StringMaker<unsigned int> (line 1748) | struct StringMaker<unsigned int> {
type StringMaker<unsigned long> (line 1752) | struct StringMaker<unsigned long> {
type StringMaker<unsigned long long> (line 1756) | struct StringMaker<unsigned long long> {
type StringMaker<bool> (line 1761) | struct StringMaker<bool> {
type StringMaker<char> (line 1766) | struct StringMaker<char> {
type StringMaker<signed char> (line 1770) | struct StringMaker<signed char> {
type StringMaker<unsigned char> (line 1774) | struct StringMaker<unsigned char> {
type StringMaker<std::nullptr_t> (line 1779) | struct StringMaker<std::nullptr_t> {
type StringMaker<float> (line 1784) | struct StringMaker<float> {
type StringMaker<double> (line 1790) | struct StringMaker<double> {
type StringMaker<T*> (line 1796) | struct StringMaker<T*> {
method convert (line 1798) | static std::string convert(U* p) {
type StringMaker<R C::*> (line 1808) | struct StringMaker<R C::*> {
method convert (line 1809) | static std::string convert(R C::* p) {
type StringMaker<T^> (line 1820) | struct StringMaker<T^> {
method convert (line 1821) | static std::string convert( T^ ref ) {
type Detail (line 1827) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<NSString*> (line 1844) | struct StringMaker<NSString*> {
method convert (line 1845) | static std::string convert(NSString * nsstring) {
type StringMaker<NSObject*> (line 1852) | struct StringMaker<NSObject*> {
method convert (line 1853) | static std::string convert(NSObject* nsObject) {
type Detail (line 1858) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<std::pair<T1, T2> > (line 1885) | struct StringMaker<std::pair<T1, T2> > {
method convert (line 1886) | static std::string convert(const std::pair<T1, T2>& pair) {
type StringMaker<std::optional<T> > (line 1903) | struct StringMaker<std::optional<T> > {
method convert (line 1904) | static std::string convert(const std::optional<T>& optional) {
type Detail (line 1921) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<std::monostate> (line 1962) | struct StringMaker<std::monostate> {
method convert (line 1963) | static std::string convert(const std::monostate&) {
type detail (line 1991) | namespace detail {
type void_type (line 1993) | struct void_type {
type is_range_impl (line 1998) | struct is_range_impl : std::false_type {
type is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> (line 2002) | struct is_range_impl<T, typename void_type<decltype(begin(std::declv...
type is_range (line 2007) | struct is_range : detail::is_range_impl<T> {
type is_range<T^> (line 2012) | struct is_range<T^> {
function rangeToString (line 2018) | std::string rangeToString( Range const& range ) {
function rangeToString (line 2024) | std::string rangeToString( std::vector<bool, Allocator> const& v ) {
type StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> (line 2040) | struct StringMaker<R, typename std::enable_if<is_range<R>::value && !:...
method convert (line 2041) | static std::string convert( R const& range ) {
type StringMaker<T[SZ]> (line 2047) | struct StringMaker<T[SZ]> {
method convert (line 2048) | static std::string convert(T const(&arr)[SZ]) {
type ratio_string (line 2064) | struct ratio_string {
type ratio_string<std::atto> (line 2076) | struct ratio_string<std::atto> {
type ratio_string<std::femto> (line 2080) | struct ratio_string<std::femto> {
type ratio_string<std::pico> (line 2084) | struct ratio_string<std::pico> {
type ratio_string<std::nano> (line 2088) | struct ratio_string<std::nano> {
type ratio_string<std::micro> (line 2092) | struct ratio_string<std::micro> {
type ratio_string<std::milli> (line 2096) | struct ratio_string<std::milli> {
type StringMaker<std::chrono::duration<Value, Ratio>> (line 2103) | struct StringMaker<std::chrono::duration<Value, Ratio>> {
method convert (line 2104) | static std::string convert(std::chrono::duration<Value, Ratio> const...
type StringMaker<std::chrono::duration<Value, std::ratio<1>>> (line 2111) | struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
method convert (line 2112) | static std::string convert(std::chrono::duration<Value, std::ratio<1...
type StringMaker<std::chrono::duration<Value, std::ratio<60>>> (line 2119) | struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
method convert (line 2120) | static std::string convert(std::chrono::duration<Value, std::ratio<6...
type StringMaker<std::chrono::duration<Value, std::ratio<3600>>> (line 2127) | struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
method convert (line 2128) | static std::string convert(std::chrono::duration<Value, std::ratio<3...
type StringMaker<std::chrono::time_point<Clock, Duration>> (line 2139) | struct StringMaker<std::chrono::time_point<Clock, Duration>> {
method convert (line 2140) | static std::string convert(std::chrono::time_point<Clock, Duration> ...
type StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> (line 2146) | struct StringMaker<std::chrono::time_point<std::chrono::system_clock, ...
method convert (line 2147) | static std::string convert(std::chrono::time_point<std::chrono::syst...
type ITransientExpression (line 2202) | struct ITransientExpression {
method isBinaryExpression (line 2203) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
method getResult (line 2204) | auto getResult() const -> bool { return m_result; }
method ITransientExpression (line 2207) | ITransientExpression( bool isBinaryExpression, bool result )
class BinaryExpr (line 2224) | class BinaryExpr : public ITransientExpression {
method streamReconstructedExpression (line 2229) | void streamReconstructedExpression( std::ostream &os ) const override {
method BinaryExpr (line 2235) | BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
class UnaryExpr (line 2300) | class UnaryExpr : public ITransientExpression {
method streamReconstructedExpression (line 2303) | void streamReconstructedExpression( std::ostream &os ) const override {
method UnaryExpr (line 2308) | explicit UnaryExpr( LhsT lhs )
function compareEqual (line 2316) | auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return...
function compareEqual (line 2318) | auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == re...
function compareEqual (line 2320) | auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == r...
function compareEqual (line 2322) | auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpr...
function compareEqual (line 2324) | auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterp...
function compareNotEqual (line 2327) | auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return s...
function compareNotEqual (line 2329) | auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs !=...
function compareNotEqual (line 2331) | auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs !...
function compareNotEqual (line 2333) | auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinte...
function compareNotEqual (line 2335) | auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reint...
class ExprLhs (line 2338) | class ExprLhs {
method ExprLhs (line 2341) | explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
method makeUnaryExpr (line 2402) | auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
function handleExpression (line 2410) | void handleExpression( ExprLhs<T> const& expr ) {
type Decomposer (line 2414) | struct Decomposer {
class AssertionResult (line 2439) | class AssertionResult
method AssertionResult (line 5399) | AssertionResult() = delete;
type AssertionInfo (line 2440) | struct AssertionInfo
type SectionInfo (line 2441) | struct SectionInfo
method SectionInfo (line 2866) | SectionInfo
type SectionEndInfo (line 2442) | struct SectionEndInfo
type MessageInfo (line 2443) | struct MessageInfo
type MessageBuilder (line 2444) | struct MessageBuilder
method MessageBuilder (line 2633) | MessageBuilder& operator << ( T const& value ) {
type Counts (line 2445) | struct Counts
type AssertionReaction (line 2446) | struct AssertionReaction
type SourceLineInfo (line 2447) | struct SourceLineInfo
method SourceLineInfo (line 504) | SourceLineInfo() = delete;
method SourceLineInfo (line 505) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
method SourceLineInfo (line 510) | SourceLineInfo( SourceLineInfo const& other ) = default;
method SourceLineInfo (line 511) | SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
method SourceLineInfo (line 512) | SourceLineInfo( SourceLineInfo&& ) noexcept = default;
method SourceLineInfo (line 513) | SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
method empty (line 515) | bool empty() const noexcept { return file[0] == '\0'; }
type ITransientExpression (line 2449) | struct ITransientExpression
method isBinaryExpression (line 2203) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
method getResult (line 2204) | auto getResult() const -> bool { return m_result; }
method ITransientExpression (line 2207) | ITransientExpression( bool isBinaryExpression, bool result )
type IGeneratorTracker (line 2450) | struct IGeneratorTracker
type BenchmarkInfo (line 2453) | struct BenchmarkInfo
type BenchmarkStats (line 2455) | struct BenchmarkStats
type IResultCapture (line 2458) | struct IResultCapture {
type TestFailureException (line 2521) | struct TestFailureException{}
type AssertionResultData (line 2522) | struct AssertionResultData
method AssertionResultData (line 5385) | AssertionResultData() = delete;
type IResultCapture (line 2523) | struct IResultCapture
class RunContext (line 2524) | class RunContext
method RunContext (line 8064) | RunContext( RunContext const& ) = delete;
method RunContext (line 8065) | RunContext& operator =( RunContext const& ) = delete;
class LazyExpression (line 2526) | class LazyExpression {
method LazyExpression (line 2536) | LazyExpression& operator = ( LazyExpression const& ) = delete;
type AssertionReaction (line 2543) | struct AssertionReaction {
class AssertionHandler (line 2548) | class AssertionHandler {
method handleExpr (line 2567) | void handleExpr( ExprLhs<T> const& expr ) {
type MessageInfo (line 2599) | struct MessageInfo {
type MessageStream (line 2616) | struct MessageStream {
method MessageStream (line 2619) | MessageStream& operator << ( T const& value ) {
type MessageBuilder (line 2627) | struct MessageBuilder : MessageStream {
method MessageBuilder (line 2633) | MessageBuilder& operator << ( T const& value ) {
class ScopedMessage (line 2641) | class ScopedMessage {
method ScopedMessage (line 2644) | ScopedMessage( ScopedMessage& duplicate ) = delete;
class Capturer (line 2652) | class Capturer {
method captureValues (line 2663) | void captureValues( size_t index, T const& value ) {
method captureValues (line 2668) | void captureValues( size_t index, T const& value, Ts const&... value...
type Counts (line 2829) | struct Counts {
type Totals (line 2842) | struct Totals {
type SectionInfo (line 2860) | struct SectionInfo {
method SectionInfo (line 2866) | SectionInfo
type SectionEndInfo (line 2876) | struct SectionEndInfo {
class Timer (line 2894) | class Timer {
class Section (line 2911) | class Section : NonCopyable {
class TestCase (line 2952) | class TestCase
type ITestCaseRegistry (line 2953) | struct ITestCaseRegistry
type IExceptionTranslatorRegistry (line 2954) | struct IExceptionTranslatorRegistry
type IExceptionTranslator (line 2955) | struct IExceptionTranslator
type IReporterRegistry (line 2956) | struct IReporterRegistry
type IReporterFactory (line 2957) | struct IReporterFactory
type ITagAliasRegistry (line 2958) | struct ITagAliasRegistry
type IMutableEnumValuesRegistry (line 2959) | struct IMutableEnumValuesRegistry
class StartupExceptionRegistry (line 2961) | class StartupExceptionRegistry
type IRegistryHub (line 2965) | struct IRegistryHub {
type IMutableRegistryHub (line 2976) | struct IMutableRegistryHub {
type IExceptionTranslator (line 3007) | struct IExceptionTranslator
type IExceptionTranslator (line 3010) | struct IExceptionTranslator {
type IExceptionTranslatorRegistry (line 3015) | struct IExceptionTranslatorRegistry {
class ExceptionTranslatorRegistrar (line 3021) | class ExceptionTranslatorRegistrar {
class ExceptionTranslator (line 3023) | class ExceptionTranslator : public IExceptionTranslator {
method ExceptionTranslator (line 3026) | ExceptionTranslator( std::string(*translateFunction)( T& ) )
method translate (line 3030) | std::string translate( ExceptionTranslators::const_iterator it, Ex...
method ExceptionTranslatorRegistrar (line 3052) | ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
type Detail (line 3076) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7885) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7889) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13649) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13654) | StreamBufImpl() {
method overflow (line 13663) | int overflow( int c ) override {
method sync (line 13675) | int sync() override {
type OutputDebugWriter (line 13686) | struct OutputDebugWriter {
class FileStream (line 13695) | class FileStream : public IStream {
method FileStream (line 13698) | FileStream( StringRef filename ) {
class CoutStream (line 13711) | class CoutStream : public IStream {
method CoutStream (line 13716) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13725) | class DebugOutStream : public IStream {
method DebugOutStream (line 13729) | DebugOutStream()
type Endianness (line 15029) | struct Endianness {
type Arch (line 15030) | enum Arch { Big, Little }
method Arch (line 15032) | static Arch which() {
function rawMemoryToString (line 15042) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type literals (line 3179) | namespace literals {
type StringMaker<Catch::Detail::Approx> (line 3185) | struct StringMaker<Catch::Detail::Approx> {
type pluralise (line 3216) | struct pluralise {
type Matchers (line 3236) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11406) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11428) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11563) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11711) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3396) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11406) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11428) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11563) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11711) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3423) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11406) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11428) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11563) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11711) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3487) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11406) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11428) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11563) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11711) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3534) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11406) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11428) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11563) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11711) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3603) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11406) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11428) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11563) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11711) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex,
Condensed preview — 506 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,674K chars).
[
{
"path": ".clang-format",
"chars": 3687,
"preview": "---\nLanguage: Cpp\n# BasedOnStyle: LLVM\nAccessModifierOffset: -2\nAlignAfterOpenBracket: Align\nAlignConsecutiveMac"
},
{
"path": ".clang-tidy",
"chars": 15274,
"preview": "---\n# vim: syntax=yaml\n# we might want to enable llvm-namespace-comment in the future\nChecks: 'clang-diagno"
},
{
"path": ".git-blame-ignore-revs",
"chars": 111,
"preview": "# Reformat the whole project\n2e60545c73a872b95d3c32a097e351ed9bfd8bf6\na69378f4f29a63d28cb79e0d6728d069353b19c8\n"
},
{
"path": ".github/workflows/clang-format.yml",
"chars": 707,
"preview": "---\nname: Find unformatted files\n\non: [push, pull_request]\n\njobs:\n Format:\n name: Find unformatted files\n runs-on"
},
{
"path": ".github/workflows/docker.yml",
"chars": 436,
"preview": "---\nname: Docker Image\n\non:\n [push, pull_request]\n\njobs:\n Docker:\n runs-on: ubuntu-latest\n steps:\n - name: "
},
{
"path": ".github/workflows/hash_map.yml",
"chars": 2995,
"preview": "---\nname: DG + External Hash Maps\non: [push, pull_request]\n\njobs:\n Ubuntu:\n strategy:\n fail-fast: false\n m"
},
{
"path": ".github/workflows/linux.yml",
"chars": 7014,
"preview": "---\nname: Linux CI\non: [push, pull_request]\n\njobs:\n build64:\n name: Ubuntu 64-bit\n strategy:\n fail-fast: fal"
},
{
"path": ".github/workflows/mac.yml",
"chars": 1898,
"preview": "---\nname: macOS CI\non: [push, pull_request]\n\njobs:\n build:\n name: macOS\n strategy:\n fail-fast: false\n m"
},
{
"path": ".github/workflows/svf.yml",
"chars": 4169,
"preview": "---\nname: DG + SVF\non: [push, pull_request]\n\njobs:\n Ubuntu:\n strategy:\n fail-fast: false\n matrix:\n "
},
{
"path": ".gitignore",
"chars": 747,
"preview": "# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dyl"
},
{
"path": ".travis.yml",
"chars": 1061,
"preview": "language: cpp\nsudo: true\n\ndist: trusty\n\ngit:\n depth: 1\n\naddons:\n apt:\n sources:\n # newer gcc and clang\n -"
},
{
"path": "CMakeLists.txt",
"chars": 8218,
"preview": "cmake_minimum_required(VERSION 3.1)\n\n# FIXME: Unfortunately, C is (at least temporarily) required due to a bug\n# in LLVM"
},
{
"path": "Changelog",
"chars": 770,
"preview": "-- 3. 10. 2018\n\n* The project was re-structured from src/ structure to lib/ and include/\n structure. As a consequence, "
},
{
"path": "Dockerfile",
"chars": 1436,
"preview": "# --------------------------------------------------\n# Base container\n# ------------------------------------------------"
},
{
"path": "LICENSE",
"chars": 1094,
"preview": "Copyright (c) 2015-2020 Marek Chalupa\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of t"
},
{
"path": "README.md",
"chars": 1572,
"preview": "# DG\n\n[](https://github.com/mchalupa/dg"
},
{
"path": "dg.spec.rpkg",
"chars": 1525,
"preview": "# vim: syntax=spec\n\n# Do out-of-source build by default on Fedora\n%undefine __cmake_in_source_build\n\nName: {{{ git"
},
{
"path": "doc/CDA.md",
"chars": 6438,
"preview": "# Control Dependence Analysis\n\nIn DG, we implemented several algorithms for the computation of different control depende"
},
{
"path": "doc/DDA.md",
"chars": 2978,
"preview": "# Data Dependence Analysis\n\nDG contains the analysis of data dependencies (also called value-flow)\nbased on constructing"
},
{
"path": "doc/PTA.md",
"chars": 4881,
"preview": "# Pointer Analysis in DG\n\nPointer analysis (PTA) implementation in DG consists of a general part and LLVM\npart. The gen"
},
{
"path": "doc/README.md",
"chars": 1129,
"preview": "# DG library\n\nDG is a C++ library containing bits for building various static program\nanalyses. The main part of the li"
},
{
"path": "doc/SVF.md",
"chars": 1482,
"preview": "# Integration of SVF into DG\n\nDG can use pointer anlysis from the SVF project. This analysis should scale\nmuch more bet"
},
{
"path": "doc/compiling.md",
"chars": 4744,
"preview": "# Compiling DG from sources\n\n## Requirements\n\nDG needs LLVM 3.4 or higher. Further requirements are `cmake`, `make`, `g+"
},
{
"path": "doc/compiling_ubuntu_trusty.md",
"chars": 1595,
"preview": "# The experience with compiling DG on Ubuntu Trusty\n\nThis is my experience with compiling DG on (a clean installation of"
},
{
"path": "doc/compiling_ubuntu_xenial.md",
"chars": 1614,
"preview": "# The experience with compiling DG on Ubuntu Trusty\n\nThis is my experience with compiling DG on (a clean installation of"
},
{
"path": "doc/downloading.md",
"chars": 1115,
"preview": "# Getting pre-compiled DG\n\nYou can obtain pre-compiled DG project in several forms.\n\n## Docker image\n\nYou can download t"
},
{
"path": "doc/llvm-slicer.md",
"chars": 14053,
"preview": "# llvm-slicer\n\nDG project contains a static slicer for LLVM bitcode. The slicer supports backward and forward (experimen"
},
{
"path": "doc/tools.md",
"chars": 3166,
"preview": "## Tools\n\nIn the `tools/` directory, there are a few scripts for convenient manipulation\nwith sliced bitcode. First is a"
},
{
"path": "include/dg/ADT/Bits.h",
"chars": 6212,
"preview": "#ifndef _DG_SPARSE_BITS_H_\n#define _DG_SPARSE_BITS_H_\n\n#include <cassert>\n#include <cstddef> // size_t\n#include <cstdint"
},
{
"path": "include/dg/ADT/Bitvector.h",
"chars": 6065,
"preview": "#ifndef DG_SPARSE_BITVECTOR_H_\n#define DG_SPARSE_BITVECTOR_H_\n\n#include <cassert>\n#include <cstdint>\n\n#include \"HashMap."
},
{
"path": "include/dg/ADT/DGContainer.h",
"chars": 2788,
"preview": "#ifndef DG_CONTAINER_H_\n#define DG_CONTAINER_H_\n\n#include <algorithm>\n#include <cassert>\n#include <set>\n\nnamespace dg {\n"
},
{
"path": "include/dg/ADT/DisjunctiveIntervalMap.h",
"chars": 19714,
"preview": "#ifndef DG_DISJUNCTIVE_INTERVAL_MAP_H_\n#define DG_DISJUNCTIVE_INTERVAL_MAP_H_\n\n#include <algorithm>\n#include <cassert>\n#"
},
{
"path": "include/dg/ADT/HashMap.h",
"chars": 343,
"preview": "#ifndef DG_HASH_MAP_H_\n#define DG_HASH_MAP_H_\n\n#ifdef HAVE_TSL_HOPSCOTCH\n#include \"TslHopscotchHashMap.h\"\nnamespace dg {"
},
{
"path": "include/dg/ADT/HashMapImpl.h",
"chars": 745,
"preview": "#ifndef DG_HASH_MAP_IMPL_H_\n#define DG_HASH_MAP_IMPL_H_\n\nnamespace dg {\n\ntemplate <typename Key, typename Val, typename "
},
{
"path": "include/dg/ADT/IntervalsList.h",
"chars": 3461,
"preview": "#ifndef DG_INTERVALS_LIST_H_\n#define DG_INTERVALS_LIST_H_\n\n#include \"dg/Offset.h\"\n#include <cassert>\n#include <list>\n\nna"
},
{
"path": "include/dg/ADT/Map.h",
"chars": 994,
"preview": "#ifndef DG_MAP_IMPL_H_\n#define DG_MAP_IMPL_H_\n\n#include <cstddef>\n#include <map>\n\nnamespace dg {\n\n// an ordered map with"
},
{
"path": "include/dg/ADT/NumberSet.h",
"chars": 7614,
"preview": "#ifndef _DG_NUMBER_SET_H_\n#define _DG_NUMBER_SET_H_\n\n#include \"Bits.h\"\n#include \"Bitvector.h\"\n\nnamespace dg {\nnamespace "
},
{
"path": "include/dg/ADT/Queue.h",
"chars": 1908,
"preview": "#ifndef DG_ADT_QUEUE_H_\n#define DG_ADT_QUEUE_H_\n\n#include <queue>\n#include <set>\n#include <stack>\n\nnamespace dg {\nnamesp"
},
{
"path": "include/dg/ADT/STLHashMap.h",
"chars": 1928,
"preview": "#ifndef DG_STL_HASH_MAP_H_\n#define DG_STL_HASH_MAP_H_\n\n#include <unordered_map>\n\n#include \"HashMapImpl.h\"\n\nnamespace dg "
},
{
"path": "include/dg/ADT/SetQueue.h",
"chars": 844,
"preview": "#ifndef DG_ADT_SET_QUEUE_H_\n#define DG_ADT_SET_QUEUE_H_\n\n#include \"Queue.h\"\n#include <set>\n\nnamespace dg {\nnamespace ADT"
},
{
"path": "include/dg/ADT/TslHopscotchHashMap.h",
"chars": 300,
"preview": "#ifndef DG_TSL_HOPSCOTCH_MAP_H_\n#define DG_TSL_HOPSCOTCH_MAP_H_\n\n#include <tsl/hopscotch_map.h>\n\n#include \"HashMapImpl.h"
},
{
"path": "include/dg/AnalysisOptions.h",
"chars": 1877,
"preview": "#ifndef DG_ANALYSIS_OPTIONS_H_\n#define DG_ANALYSIS_OPTIONS_H_\n\n#include <cassert>\n#include <map>\n#include <string>\n\n#inc"
},
{
"path": "include/dg/BBlock.h",
"chars": 14136,
"preview": "#ifndef BBLOCK_H_\n#define BBLOCK_H_\n\n#include <cassert>\n#include <list>\n\n#include \"ADT/DGContainer.h\"\n#include \"dg/util/"
},
{
"path": "include/dg/BBlockBase.h",
"chars": 3632,
"preview": "#ifndef DG_BBLOCK_BASE_H_\n#define DG_BBLOCK_BASE_H_\n\n#include <list>\n#include <vector>\n\nnamespace dg {\n\nclass ElemId {\n "
},
{
"path": "include/dg/BBlocksBuilder.h",
"chars": 2384,
"preview": "#ifndef DG_BBLOCKS_BUILDER_H_\n#define DG_BBLOCKS_BUILDER_H_\n\n#include <cassert>\n#include <memory>\n\n#include \"dg/ADT/Queu"
},
{
"path": "include/dg/BFS.h",
"chars": 906,
"preview": "#ifndef DG_BFS_H_\n#define DG_BFS_H_\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/NodesWalk.h\"\n\nusing dg::ADT::QueueFIFO;\n\nnam"
},
{
"path": "include/dg/CallGraph/CallGraph.h",
"chars": 3046,
"preview": "#ifndef DG_GENERIC_CALLGRAPH_H_\n#define DG_GENERIC_CALLGRAPH_H_\n\n#include <map>\n#include <vector>\n\n#include \"dg/util/ite"
},
{
"path": "include/dg/ControlDependence/ControlDependenceAnalysisOptions.h",
"chars": 1974,
"preview": "#ifndef DG_CDA_OPTIONS_H_\n#define DG_CDA_OPTIONS_H_\n\n#include \"dg/AnalysisOptions.h\"\n\nnamespace dg {\n\nstruct ControlDepe"
},
{
"path": "include/dg/DFS.h",
"chars": 906,
"preview": "#ifndef DG_DFS_H_\n#define DG_DFS_H_\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/NodesWalk.h\"\n\nusing dg::ADT::QueueLIFO;\n\nnam"
},
{
"path": "include/dg/DG2Dot.h",
"chars": 18350,
"preview": "#ifndef DG_2_DOT_H_\n#define DG_2_DOT_H_\n\n#include <fstream>\n#include <iostream>\n#include <set>\n\n#include \"dg/DFS.h\"\n#inc"
},
{
"path": "include/dg/DGParameters.h",
"chars": 6483,
"preview": "#ifndef DG_PARAMETERS_H_\n#define DG_PARAMETERS_H_\n\n#include <map>\n#include <memory>\n#include <utility>\n\n#include \"BBlock"
},
{
"path": "include/dg/DataDependence/DataDependence.h",
"chars": 2361,
"preview": "#ifndef DG_DATA_DEPENDENCE_ANALYSIS_H_\n#define DG_DATA_DEPENDENCE_ANALYSIS_H_\n\n#include <cassert>\n#include <memory>\n\n#in"
},
{
"path": "include/dg/DataDependence/DataDependenceAnalysisImpl.h",
"chars": 1953,
"preview": "#ifndef DG_DATA_DEPENDENCE_ANALYSIS_IMPL_H_\n#define DG_DATA_DEPENDENCE_ANALYSIS_IMPL_H_\n\n#include <cassert>\n#include <ut"
},
{
"path": "include/dg/DataDependence/DataDependenceAnalysisOptions.h",
"chars": 4647,
"preview": "#ifndef DG_DATA_DEPENDENCE_ANALYSIS_OPTIONS_H_\n#define DG_DATA_DEPENDENCE_ANALYSIS_OPTIONS_H_\n\n#include <cassert>\n#inclu"
},
{
"path": "include/dg/DependenceGraph.h",
"chars": 12683,
"preview": "#ifndef DEPENDENCE_GRAPH_H_\n#define DEPENDENCE_GRAPH_H_\n\n#include <cassert>\n#include <map>\n#include <memory>\n#include <q"
},
{
"path": "include/dg/Dominators/DominanceFrontiers.h",
"chars": 2005,
"preview": "#ifndef DG_DOMINANCE_FRONTIERS_H_\n#define DG_DOMINANCE_FRONTIERS_H_\n\n#include <vector>\n\n#include \"BBlock.h\"\n#include \"BF"
},
{
"path": "include/dg/Dominators/PostDominanceFrontiers.h",
"chars": 2955,
"preview": "#ifndef DG_POST_DOMINANCE_FRONTIERS_H_\n#define DG_POST_DOMINANCE_FRONTIERS_H_\n\n#include <vector>\n\n#include \"dg/BBlock.h\""
},
{
"path": "include/dg/MemorySSA/Definitions.h",
"chars": 2444,
"preview": "#ifndef DG_MEMORY_SSA_DEFINITIONS_H_\n#define DG_MEMORY_SSA_DEFINITIONS_H_\n\n#include <set>\n#include <vector>\n\n#include \"d"
},
{
"path": "include/dg/MemorySSA/DefinitionsMap.h",
"chars": 5956,
"preview": "#ifndef DG_DEFINITIONS_MAP_H_\n#define DG_DEFINITIONS_MAP_H_\n\n#include <set>\n#include <unordered_map>\n#include <vector>\n#"
},
{
"path": "include/dg/MemorySSA/MemorySSA.h",
"chars": 9922,
"preview": "#ifndef DG_MEMORY_SSA_H_\n#define DG_MEMORY_SSA_H_\n\n#include <cassert>\n#include <set>\n#include <unordered_map>\n#include <"
},
{
"path": "include/dg/MemorySSA/ModRef.h",
"chars": 2846,
"preview": "#ifndef DG_MOD_REF_H_\n#define DG_MOD_REF_H_\n\n#include \"dg/Offset.h\"\n\n#include \"dg/MemorySSA/DefinitionsMap.h\"\n#include \""
},
{
"path": "include/dg/MemoryState.h",
"chars": 2941,
"preview": "#ifndef DG_MEMORY_STATE_H_\n#define DG_MEMORY_STATE_H_\n\n#include \"dg/util/cow_shared_ptr.h\"\n#include <map>\n\nnamespace dg "
},
{
"path": "include/dg/Node.h",
"chars": 14131,
"preview": "#ifndef NODE_H_\n#define NODE_H_\n\n#include \"ADT/DGContainer.h\"\n#include \"DGParameters.h\"\n#include \"legacy/Analysis.h\"\n\nna"
},
{
"path": "include/dg/NodesWalk.h",
"chars": 3716,
"preview": "#ifndef DG_NODES_WALK_H_\n#define DG_NODES_WALK_H_\n\n#include <initializer_list>\n#include <set>\n\nnamespace dg {\n\n// univer"
},
{
"path": "include/dg/Offset.h",
"chars": 3289,
"preview": "#ifndef DG_OFFSET_H_\n#define DG_OFFSET_H_\n\n#include <cstdint>\n\n#ifndef NDEBUG\n#include <iostream>\n#endif // not NDEBUG\n\n"
},
{
"path": "include/dg/PointerAnalysis/MemoryObject.h",
"chars": 2746,
"preview": "#ifndef DG_MEMORY_OBJECT_H_\n#define DG_MEMORY_OBJECT_H_\n\n#include <cassert>\n#include <map>\n#include <set>\n#include <unor"
},
{
"path": "include/dg/PointerAnalysis/PSNode.h",
"chars": 22783,
"preview": "#ifndef DG_PS_NODE_H_\n#define DG_PS_NODE_H_\n\n#include <cassert>\n#include <cstdarg>\n#include <iostream>\n#include <string>"
},
{
"path": "include/dg/PointerAnalysis/Pointer.h",
"chars": 1479,
"preview": "#ifndef DG_POINTER_H_\n#define DG_POINTER_H_\n\n#include \"dg/Offset.h\"\n#include <cassert>\n#include <cstddef>\n\nnamespace dg "
},
{
"path": "include/dg/PointerAnalysis/PointerAnalysis.h",
"chars": 5520,
"preview": "#ifndef DG_POINTER_ANALYSIS_H_\n#define DG_POINTER_ANALYSIS_H_\n\n#include <cassert>\n#include <utility>\n#include <vector>\n\n"
},
{
"path": "include/dg/PointerAnalysis/PointerAnalysisFI.h",
"chars": 2613,
"preview": "#ifndef DG_ANALYSIS_POINTS_TO_FLOW_INSENSITIVE_H_\n#define DG_ANALYSIS_POINTS_TO_FLOW_INSENSITIVE_H_\n\n#include <cassert>\n"
},
{
"path": "include/dg/PointerAnalysis/PointerAnalysisFS.h",
"chars": 8488,
"preview": "#ifndef DG_ANALYSIS_POINTS_TO_FLOW_SENSITIVE_H_\n#define DG_ANALYSIS_POINTS_TO_FLOW_SENSITIVE_H_\n\n#include <cassert>\n#inc"
},
{
"path": "include/dg/PointerAnalysis/PointerAnalysisFSInv.h",
"chars": 16172,
"preview": "#ifndef DG_ANALYSIS_POINTS_TO_WITH_INVALIDATE_H_\n#define DG_ANALYSIS_POINTS_TO_WITH_INVALIDATE_H_\n\n#include \"PointerAnal"
},
{
"path": "include/dg/PointerAnalysis/PointerAnalysisOptions.h",
"chars": 1059,
"preview": "#ifndef DG_POINTER_ANALYSIS_OPTIONS_H_\n#define DG_POINTER_ANALYSIS_OPTIONS_H_\n\n#include \"dg/AnalysisOptions.h\"\n\nnamespac"
},
{
"path": "include/dg/PointerAnalysis/PointerGraph.h",
"chars": 11574,
"preview": "#ifndef DG_POINTER_GRAPH_H_\n#define DG_POINTER_GRAPH_H_\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/BFS.h\"\n#include \"dg/Call"
},
{
"path": "include/dg/PointerAnalysis/PointerGraphOptimizations.h",
"chars": 2978,
"preview": "#ifndef DG_POINTER_SUBGRAPH_OPTIMIZATIONS_H_\n#define DG_POINTER_SUBGRAPH_OPTIMIZATIONS_H_\n\n#include \"PointsToMapping.h\"\n"
},
{
"path": "include/dg/PointerAnalysis/PointerGraphValidator.h",
"chars": 1510,
"preview": "#ifndef DG_POINTER_SUBGRAPH_VALIDATOR_H_\n#define DG_POINTER_SUBGRAPH_VALIDATOR_H_\n\n#include \"dg/PointerAnalysis/PointerG"
},
{
"path": "include/dg/PointerAnalysis/PointsToMapping.h",
"chars": 2136,
"preview": "#ifndef DG_POINTS_TO_MAPPING_H_\n#define DG_POINTS_TO_MAPPING_H_\n\n#include \"PSNode.h\"\n#include <unordered_map>\n\nnamespace"
},
{
"path": "include/dg/PointerAnalysis/PointsToSet.h",
"chars": 718,
"preview": "#ifndef DG_POINTS_TO_SET_H_\n#define DG_POINTS_TO_SET_H_\n\n#include \"dg/PointerAnalysis/PointsToSets/AlignedPointerIdPoint"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/AlignedPointerIdPointsToSet.h",
"chars": 6947,
"preview": "#ifndef DG_ALIGNEDBITVECTORPOINTSTOSET_H\n#define DG_ALIGNEDBITVECTORPOINTSTOSET_H\n\n#include \"dg/ADT/Bitvector.h\"\n#includ"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/AlignedSmallOffsetsPointsToSet.h",
"chars": 7844,
"preview": "#ifndef ALIGNEDOFFSETSPOINTSTOSET_H\n#define ALIGNEDOFFSETSPOINTSTOSET_H\n\n#include \"dg/ADT/Bitvector.h\"\n#include \"dg/Poin"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/LookupTable.h",
"chars": 3506,
"preview": "#ifndef DG_PTSETS_LOOKUPTABLE_H_\n#define DG_PTSETS_LOOKUPTABLE_H_\n\n#include <map>\n#include <vector>\n\n#if defined(HAVE_TS"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/OffsetsSetPointsToSet.h",
"chars": 6354,
"preview": "#ifndef DG_OFFSETS_SET_PTSET_H\n#define DG_OFFSETS_SET_PTSET_H\n\n#include \"dg/ADT/Bitvector.h\"\n#include \"dg/PointerAnalysi"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/PointerIdPointsToSet.h",
"chars": 5092,
"preview": "#ifndef DG_SINGLEBITVECTORPOINTSTOSET_H\n#define DG_SINGLEBITVECTORPOINTSTOSET_H\n\n#include <cassert>\n#include <map>\n#incl"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/SeparateOffsetsPointsToSet.h",
"chars": 5168,
"preview": "#ifndef SEPARATEOFFSETSPOINTSTOSET_H\n#define SEPARATEOFFSETSPOINTSTOSET_H\n\n#include \"dg/ADT/Bitvector.h\"\n#include \"dg/Po"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/SimplePointsToSet.h",
"chars": 4235,
"preview": "#ifndef SIMPLEPOINTSTOSET_H\n#define SIMPLEPOINTSTOSET_H\n\n#include \"dg/ADT/Bitvector.h\"\n#include \"dg/PointerAnalysis/Poin"
},
{
"path": "include/dg/PointerAnalysis/PointsToSets/SmallOffsetsPointsToSet.h",
"chars": 7452,
"preview": "#ifndef DG_SMALLOFFSETSPOINTSTOSET_H\n#define DG_SMALLOFFSETSPOINTSTOSET_H\n\n#include <cassert>\n#include <map>\n#include <s"
},
{
"path": "include/dg/ReadWriteGraph/DefSite.h",
"chars": 5816,
"preview": "#ifndef DG_DEF_SITE_H_\n#define DG_DEF_SITE_H_\n\n#include <cassert>\n#include <list>\n#include <map>\n#include <set>\n\n#includ"
},
{
"path": "include/dg/ReadWriteGraph/RWBBlock.h",
"chars": 3639,
"preview": "#ifndef DG_RWBBLOCK_H_\n#define DG_RWBBLOCK_H_\n\n#include <memory>\n\n#include \"dg/BBlockBase.h\"\n#include \"dg/ReadWriteGraph"
},
{
"path": "include/dg/ReadWriteGraph/RWNode.h",
"chars": 14199,
"preview": "#ifndef DG_RW_NODE_H_\n#define DG_RW_NODE_H_\n\n#include <vector>\n\n#include \"DefSite.h\"\n#include \"dg/Offset.h\"\n#include \"dg"
},
{
"path": "include/dg/ReadWriteGraph/RWSubgraph.h",
"chars": 3011,
"preview": "#ifndef DG_READ_WRITE_SUBRAPH_H_\n#define DG_READ_WRITE_SUBRAPH_H_\n\n#include <memory>\n#include <vector>\n\n#include \"RWBBlo"
},
{
"path": "include/dg/ReadWriteGraph/ReadWriteGraph.h",
"chars": 3355,
"preview": "#ifndef DG_READ_WRITE_GRAPH_H_\n#define DG_READ_WRITE_GRAPH_H_\n\n#include <memory>\n#include <vector>\n\n#include \"dg/BFS.h\"\n"
},
{
"path": "include/dg/SCC.h",
"chars": 4333,
"preview": "#ifndef DG_SCC_H_\n#define DG_SCC_H_\n\n#include <set>\n#include <vector>\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/ADT/STLHas"
},
{
"path": "include/dg/Slicing.h",
"chars": 10646,
"preview": "#ifndef DG_SLICING_H_\n#define DG_SLICING_H_\n\n#include <set>\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/DependenceGraph.h\"\n#"
},
{
"path": "include/dg/SubgraphBase.h",
"chars": 2520,
"preview": "#ifndef DG_SUBGRAPHBASE_H_\n#define DG_SUBGRAPHBASE_H_\n\nnamespace dg {\n\ntemplate <typename SubgraphT, typename BBlockT>\nc"
},
{
"path": "include/dg/SubgraphNode.h",
"chars": 12197,
"preview": "#ifndef SUBGRAPH_NODE_H_\n#define SUBGRAPH_NODE_H_\n\n// This file defines a basis for nodes from\n// PointerGraph and reach"
},
{
"path": "include/dg/SystemDependenceGraph/DGArgumentPair.h",
"chars": 1096,
"preview": "#ifndef DG_DG_ARG_PAIR_H_\n#define DG_DG_ARG_PAIR_H_\n\n#include \"DGNode.h\"\n#include <cassert>\n\nnamespace dg {\nnamespace sd"
},
{
"path": "include/dg/SystemDependenceGraph/DGBBlock.h",
"chars": 1349,
"preview": "#ifndef DG_DGBBLOCK_H_\n#define DG_DGBBLOCK_H_\n\n#include <cassert>\n#include <vector>\n\n#include \"DGNode.h\"\n#include \"DepDG"
},
{
"path": "include/dg/SystemDependenceGraph/DGElement.h",
"chars": 2467,
"preview": "#ifndef DG_DG_ELEMENT_H_\n#define DG_DG_ELEMENT_H_\n\n#include <cassert>\n\n#ifndef NDEBUG\n// FIXME: move this to .cpp file\n#"
},
{
"path": "include/dg/SystemDependenceGraph/DGNode.h",
"chars": 4895,
"preview": "#ifndef DG_DG_NODE_H_\n#define DG_DG_NODE_H_\n\n#include <cassert>\n\n#include \"DepDGElement.h\"\n#include \"dg/ADT/DGContainer."
},
{
"path": "include/dg/SystemDependenceGraph/DGNodeCall.h",
"chars": 1115,
"preview": "#ifndef DG_DG_NODE_CALL_H_\n#define DG_DG_NODE_CALL_H_\n\n#include \"DGNode.h\"\n#include \"DGParameters.h\"\n#include <cassert>\n"
},
{
"path": "include/dg/SystemDependenceGraph/DGParameters.h",
"chars": 3289,
"preview": "#ifndef DG_SDG_PARAMETERS_H_\n#define DG_SDG_PARAMETERS_H_\n\n#include <cassert>\n#include <memory>\n#include <vector>\n\n#incl"
},
{
"path": "include/dg/SystemDependenceGraph/DepDGElement.h",
"chars": 5640,
"preview": "#ifndef DG_DEPENDENCIES_ELEM_H_\n#define DG_DEPENDENCIES_ELEM_H_\n\n#include \"DGElement.h\"\n#include \"dg/ADT/DGContainer.h\"\n"
},
{
"path": "include/dg/SystemDependenceGraph/DependenceGraph.h",
"chars": 5155,
"preview": "#ifndef DG_DEPENDENCE_GRAPH_H_\n#define DG_DEPENDENCE_GRAPH_H_\n\n#include <cassert>\n#include <string>\n#include <vector>\n\n#"
},
{
"path": "include/dg/SystemDependenceGraph/SystemDependenceGraph.h",
"chars": 1843,
"preview": "#ifndef DG_SYSTEM_DEPENDENCE_GRAPH_H_\n#define DG_SYSTEM_DEPENDENCE_GRAPH_H_\n\n#include <memory>\n#include <set>\n#include <"
},
{
"path": "include/dg/ValueRelations/Bucket.h",
"chars": 15190,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_BUCKET_H_\n#define DG_LLVM_VALUE_RELATIONS_BUCKET_H_\n\n#ifndef NDEBUG\n#include <iostream>\n"
},
{
"path": "include/dg/ValueRelations/Relations.h",
"chars": 4022,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_RELATIONS_H_\n#define DG_LLVM_VALUE_RELATIONS_RELATIONS_H_\n\n#ifndef NDEBUG\n#include <iost"
},
{
"path": "include/dg/ValueRelations/RelationsGraph.h",
"chars": 17496,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_RELATIONS_GRAPH_H_\n#define DG_LLVM_VALUE_RELATIONS_RELATIONS_GRAPH_H_\n\n#ifndef NDEBUG\n#i"
},
{
"path": "include/dg/legacy/Analysis.h",
"chars": 1784,
"preview": "#ifndef DG_LEGACY_ANALYSIS_H_\n#define DG_LEGACY_ANALYSIS_H_\n\nnamespace dg {\nnamespace legacy {\n\n// data for analyses, st"
},
{
"path": "include/dg/legacy/BFS.h",
"chars": 2172,
"preview": "#ifndef DG_LEGACY_BFS_H_\n#define DG_LEGACY_BFS_H_\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/legacy/NodesWalk.h\"\n\nnamespace"
},
{
"path": "include/dg/legacy/DFS.h",
"chars": 3960,
"preview": "#ifndef DG_LEGACY_DFS_H_\n#define DG_LEGACY_DFS_H_\n\n#include \"dg/ADT/Queue.h\"\n#include \"dg/legacy/NodesWalk.h\"\n\nnamespace"
},
{
"path": "include/dg/legacy/DataFlowAnalysis.h",
"chars": 4256,
"preview": "#ifndef DG_DATA_FLOW_ANALYSIS_H_\n#define DG_DATA_FLOW_ANALYSIS_H_\n\n#include <set>\n#include <utility>\n\n#include \"dg/legac"
},
{
"path": "include/dg/legacy/NodesWalk.h",
"chars": 11405,
"preview": "#ifndef DG_LEGACY_NODES_WALK_H_\n#define DG_LEGACY_NODES_WALK_H_\n\n#include \"dg/DGParameters.h\"\n#include \"dg/legacy/Analys"
},
{
"path": "include/dg/llvm/CallGraph/CallGraph.h",
"chars": 18654,
"preview": "#ifndef DG_LLVM_CALLGRAPH_H_\n#define DG_LLVM_CALLGRAPH_H_\n\n#include <memory>\n#include <vector>\n\n#include <llvm/IR/Functi"
},
{
"path": "include/dg/llvm/ControlDependence/ControlDependence.h",
"chars": 4171,
"preview": "#ifndef LLVM_DG_CDA_H_\n#define LLVM_DG_CDA_H_\n\n#include <llvm/IR/Constants.h>\n#include <llvm/IR/Instructions.h>\n#include"
},
{
"path": "include/dg/llvm/ControlDependence/LLVMControlDependenceAnalysisImpl.h",
"chars": 2296,
"preview": "#ifndef LLVM_DG_CDA_IMPL_H_\n#define LLVM_DG_CDA_IMPL_H_\n\n#include <set>\n#include <utility>\n\n#include \"dg/llvm/ControlDep"
},
{
"path": "include/dg/llvm/ControlDependence/LLVMControlDependenceAnalysisOptions.h",
"chars": 610,
"preview": "#ifndef DG_LLVM_CDA_OPTIONS_H_\n#define DG_LLVM_CDA_OPTIONS_H_\n\n#include \"dg/ControlDependence/ControlDependenceAnalysisO"
},
{
"path": "include/dg/llvm/DataDependence/DataDependence.h",
"chars": 3483,
"preview": "#ifndef LLVM_DG_DD_H_\n#define LLVM_DG_DD_H_\n\n#include <memory>\n#include <type_traits>\n#include <unordered_map>\n#include "
},
{
"path": "include/dg/llvm/DataDependence/LLVMDataDependenceAnalysisOptions.h",
"chars": 2163,
"preview": "#ifndef DG_LLVM_DATA_DEPENDENCE_ANALYSIS_OPTIONS_H_\n#define DG_LLVM_DATA_DEPENDENCE_ANALYSIS_OPTIONS_H_\n\n#include \"dg/Da"
},
{
"path": "include/dg/llvm/Dominators/Dominators.h",
"chars": 3158,
"preview": "#ifndef _DG_DOMINATORS_H_\n#define _DG_DOMINATORS_H_\n\n#include <llvm/IR/Dominators.h>\n#include <llvm/IR/Function.h>\n\n#inc"
},
{
"path": "include/dg/llvm/LLVMAnalysisOptions.h",
"chars": 413,
"preview": "#ifndef DG_LLVM_ANALYSIS_OPTIONS_H_\n#define DG_LLVM_ANALYSIS_OPTIONS_H_\n\n#include \"dg/AnalysisOptions.h\"\n#include <strin"
},
{
"path": "include/dg/llvm/LLVMDG2Dot.h",
"chars": 9133,
"preview": "#ifndef DG_LLVMDG2DOT_H_\n#define DG_LLVMDG2DOT_H_\n\n#include <iostream>\n#include <ostream>\n#include <sstream>\n#include <s"
},
{
"path": "include/dg/llvm/LLVMDGAssemblyAnnotationWriter.h",
"chars": 11232,
"preview": "#ifndef LLVM_DG_ASSEMBLY_ANNOTATION_WRITER_H_\n#define LLVM_DG_ASSEMBLY_ANNOTATION_WRITER_H_\n\n#include <llvm/Support/Form"
},
{
"path": "include/dg/llvm/LLVMDependenceGraph.h",
"chars": 7809,
"preview": "#ifndef LLVM_DEPENDENCE_GRAPH_H_\n#define LLVM_DEPENDENCE_GRAPH_H_\n\n#include <map>\n#include <unordered_map>\n\n#include \"dg"
},
{
"path": "include/dg/llvm/LLVMDependenceGraphBuilder.h",
"chars": 8241,
"preview": "#ifndef DG_LLVM_DEPENDENCE_GRAPH_BUILDER_H_\n#define DG_LLVM_DEPENDENCE_GRAPH_BUILDER_H_\n\n#include <ctime> // std::clock\n"
},
{
"path": "include/dg/llvm/LLVMNode.h",
"chars": 2288,
"preview": "#ifndef LLVM_NODE_H_\n#define LLVM_NODE_H_\n\n#include <map>\n#include <set>\n#include <utility>\n\n#include <llvm/IR/Type.h>\n#"
},
{
"path": "include/dg/llvm/LLVMSlicer.h",
"chars": 20643,
"preview": "#ifndef LLVM_DG_SLICER_H_\n#define LLVM_DG_SLICER_H_\n\n#include <llvm/Config/llvm-config.h>\n#if ((LLVM_VERSION_MAJOR == 3)"
},
{
"path": "include/dg/llvm/PointerAnalysis/DGPointerAnalysis.h",
"chars": 9085,
"preview": "#ifndef LLVM_DG_POINTS_TO_ANALYSIS_H_\n#define LLVM_DG_POINTS_TO_ANALYSIS_H_\n\n#include <llvm/IR/DataLayout.h>\n#include <l"
},
{
"path": "include/dg/llvm/PointerAnalysis/LLVMPointerAnalysisOptions.h",
"chars": 739,
"preview": "#ifndef DG_LLVM_POINTER_ANALYSIS_OPTIONS_H_\n#define DG_LLVM_POINTER_ANALYSIS_OPTIONS_H_\n\n#include \"dg/PointerAnalysis/Po"
},
{
"path": "include/dg/llvm/PointerAnalysis/LLVMPointsToSet.h",
"chars": 14205,
"preview": "#ifndef LLVM_DG_POINTS_TO_SET_H_\n#define LLVM_DG_POINTS_TO_SET_H_\n\n#include <cassert>\n#include <utility>\n\n#include <llvm"
},
{
"path": "include/dg/llvm/PointerAnalysis/PointerAnalysis.h",
"chars": 12673,
"preview": "#ifndef LLVM_DG_POINTS_TO_ANALYSIS_H_\n#define LLVM_DG_POINTS_TO_ANALYSIS_H_\n\n#include <memory>\n#include <utility>\n\n#incl"
},
{
"path": "include/dg/llvm/PointerAnalysis/PointerGraph.h",
"chars": 18050,
"preview": "#ifndef LLVM_DG_POINTER_SUBGRAPH_H_\n#define LLVM_DG_POINTER_SUBGRAPH_H_\n\n#include <unordered_map>\n\n#include <llvm/IR/Con"
},
{
"path": "include/dg/llvm/PointerAnalysis/SVFPointerAnalysis.h",
"chars": 5532,
"preview": "#ifndef DG_SVF_POINTER_ANALYSIS_H_\n#define DG_SVF_POINTER_ANALYSIS_H_\n\n#include <llvm/IR/DataLayout.h>\n#include <llvm/IR"
},
{
"path": "include/dg/llvm/SystemDependenceGraph/SDG2Dot.h",
"chars": 9370,
"preview": "#ifndef DG_LLVM_SDG2DOT_H_\n#define DG_LLVM_SDG2DOT_H_\n\n#include <fstream>\n#include <iostream>\n#include <sstream>\n#includ"
},
{
"path": "include/dg/llvm/SystemDependenceGraph/SystemDependenceGraph.h",
"chars": 3400,
"preview": "#ifndef DG_LLVM_SYSTEM_DEPENDNECE_GRAPH_H_\n#define DG_LLVM_SYSTEM_DEPENDNECE_GRAPH_H_\n\n#include <map>\n#include <utility>"
},
{
"path": "include/dg/llvm/SystemDependenceGraph/SystemDependenceGraphBuilder.h",
"chars": 7377,
"preview": "#ifndef DG_LLVM_SYSTEM_DEPENDENCE_GRAPH_BUILDER_H_\n#define DG_LLVM_SYSTEM_DEPENDENCE_GRAPH_BUILDER_H_\n\n#include <ctime> "
},
{
"path": "include/dg/llvm/ThreadRegions/ControlFlowGraph.h",
"chars": 1319,
"preview": "#ifndef CONTROLFLOWGRAPH_H\n#define CONTROLFLOWGRAPH_H\n\n#include <memory>\n#include <set>\n\n#include <llvm/IR/Instructions."
},
{
"path": "include/dg/llvm/ThreadRegions/MayHappenInParallel.h",
"chars": 375,
"preview": "#ifndef MAYHAPPENINPARALLEL_H\n#define MAYHAPPENINPARALLEL_H\n\n#include <set>\n\n#include \"ThreadRegion.h\"\n\nclass MayHappenI"
},
{
"path": "include/dg/llvm/ThreadRegions/ThreadRegion.h",
"chars": 1324,
"preview": "#ifndef THREADREGION_H\n#define THREADREGION_H\n\n#include <iosfwd>\n#include <set>\n\nclass Node;\nclass ControlFlowGraph;\n\nna"
},
{
"path": "include/dg/llvm/ValueRelations/GraphBuilder.h",
"chars": 998,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_GRAPH_BUILDER_H_\n#define DG_LLVM_VALUE_RELATIONS_GRAPH_BUILDER_H_\n\n#include \"GraphElemen"
},
{
"path": "include/dg/llvm/ValueRelations/GraphElements.h",
"chars": 11687,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_GRAPH_ELEMENTS_H_\n#define DG_LLVM_VALUE_RELATIONS_GRAPH_ELEMENTS_H_\n\n#include <cassert>\n"
},
{
"path": "include/dg/llvm/ValueRelations/RelationsAnalyzer.h",
"chars": 9349,
"preview": "#ifndef DG_LLVM_VALUE_RELATION_RELATIONS_ANALYZER_H_\n#define DG_LLVM_VALUE_RELATION_RELATIONS_ANALYZER_H_\n\n#include <llv"
},
{
"path": "include/dg/llvm/ValueRelations/StructureAnalyzer.h",
"chars": 5552,
"preview": "#ifndef DG_LLVM_VALUE_RELATION_STRUCTURE_ANALYZER_H_\n#define DG_LLVM_VALUE_RELATION_STRUCTURE_ANALYZER_H_\n\n#include <llv"
},
{
"path": "include/dg/llvm/ValueRelations/StructureElements.h",
"chars": 1904,
"preview": "#ifndef DG_LLVM_VALUE_RELATION_STRUCTURE_ELEMENTS_H_\n#define DG_LLVM_VALUE_RELATION_STRUCTURE_ELEMENTS_H_\n\n#include <llv"
},
{
"path": "include/dg/llvm/ValueRelations/UniquePtrVector.h",
"chars": 2947,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_UNIQUE_PTR_VECTOR_H_\n#define DG_LLVM_VALUE_RELATIONS_UNIQUE_PTR_VECTOR_H_\n\n#include <mem"
},
{
"path": "include/dg/llvm/ValueRelations/ValueRelations.h",
"chars": 17442,
"preview": "#ifndef DG_LLVM_VALUE_RELATIONS_VALUE_RELATIONS_H_\n#define DG_LLVM_VALUE_RELATIONS_VALUE_RELATIONS_H_\n\n#include <llvm/IR"
},
{
"path": "include/dg/llvm/ValueRelations/getValName.h",
"chars": 1304,
"preview": "#ifndef DG_LLVM_GET_VAL_NAME_H_\n#define DG_LLVM_GET_VAL_NAME_H_\n\n#include <fstream>\n#include <iostream>\n#include <llvm/S"
},
{
"path": "include/dg/util/TimeMeasure.h",
"chars": 1240,
"preview": "#ifndef DG_TIME_UTILS_H_\n#define DG_TIME_UTILS_H_\n\n#include <chrono>\n#include <iostream>\n\nnamespace dg {\nnamespace debug"
},
{
"path": "include/dg/util/cow_shared_ptr.h",
"chars": 2022,
"preview": "#ifndef COW_SHARED_PTR_H_\n#define COW_SHARED_PTR_H_\n\n#include <cassert>\n#include <memory>\n\n///\n// Shared pointer with co"
},
{
"path": "include/dg/util/debug.h",
"chars": 3268,
"preview": "#ifndef DG_UTIL_DEBUG_H_\n#define DG_UTIL_DEBUG_H_\n\n#ifdef DEBUG_ENABLED\n#include <cassert>\n#include <ctime>\n#include <io"
},
{
"path": "include/dg/util/iterators.h",
"chars": 958,
"preview": "#ifndef DG_ITERATORS_UTILS_H_\n#define DG_ITERATORS_UTILS_H_\n\n#include <algorithm>\n\nnamespace dg {\n\ntemplate <typename It"
},
{
"path": "lib/BBlockBase.cpp",
"chars": 75,
"preview": "#include \"dg/BBlockBase.h\"\n\nnamespace dg {\n\nunsigned ElemId::idcnt = 0;\n\n}\n"
},
{
"path": "lib/CMakeLists.txt",
"chars": 4987,
"preview": "add_library(dganalysis SHARED\n\tOffset.cpp\n Debug.cpp\n BBlockBase.cpp\n)\n\nadd_library(dgpta SHARED\n\tPointerA"
},
{
"path": "lib/ControlDependence/CDGraph.h",
"chars": 5758,
"preview": "#ifndef DG_LLVM_CDGRAPH_H_\n#define DG_LLVM_CDGRAPH_H_\n\n#include <cassert>\n#include <memory>\n#include <set>\n#include <str"
},
{
"path": "lib/ControlDependence/ControlClosure.h",
"chars": 4655,
"preview": "#ifndef CD_CONTROL_CLOSURE_H_\n#define CD_CONTROL_CLOSURE_H_\n\n#include <set>\n#include <vector>\n\n#include \"CDGraph.h\"\n\n#in"
},
{
"path": "lib/ControlDependence/DOD.h",
"chars": 20537,
"preview": "#ifndef DG_DOD_H_\n#define DG_DOD_H_\n\n#include <functional>\n#include <map>\n#include <set>\n#include <unordered_map>\n\n#incl"
},
{
"path": "lib/ControlDependence/DODNTSCD.h",
"chars": 2028,
"preview": "#ifndef DG_DODNTSCD_H_\n#define DG_DODNTSCD_H_\n\n#include <dg/ADT/Bitvector.h>\n#include <dg/ADT/Queue.h>\n#include <dg/ADT/"
},
{
"path": "lib/ControlDependence/NTSCD.cpp",
"chars": 1,
"preview": "\n"
},
{
"path": "lib/ControlDependence/NTSCD.h",
"chars": 10142,
"preview": "#ifndef DG_NTSCD_H\n#define DG_NTSCD_H\n\n#include <map>\n#include <set>\n#include <unordered_map>\n#include <vector>\n\n#includ"
},
{
"path": "lib/Debug.cpp",
"chars": 147,
"preview": "#ifdef DEBUG_ENABLED\nnamespace dg {\nnamespace debug {\n\nunsigned _debug_lvl = 0;\nunsigned _ind = 0;\n\n} // namespace debug"
},
{
"path": "lib/MemorySSA/Definitions.cpp",
"chars": 2342,
"preview": "#include \"dg/MemorySSA/MemorySSA.h\"\n\n#include \"dg/util/debug.h\"\n\n#ifndef NDEBUG\n#include <iostream>\n#endif\n\nnamespace dg"
},
{
"path": "lib/MemorySSA/MemorySSA.cpp",
"chars": 30399,
"preview": "#include <set>\n#include <vector>\n\n#include \"dg/ADT/Bitvector.h\"\n#include \"dg/MemorySSA/MemorySSA.h\"\n//#include \"dg/BBloc"
},
{
"path": "lib/MemorySSA/ModRef.cpp",
"chars": 2690,
"preview": "#include \"dg/MemorySSA/MemorySSA.h\"\n#include \"dg/util/debug.h\"\n\nnamespace dg {\nnamespace dda {\n\nstatic inline bool canBe"
},
{
"path": "lib/Offset.cpp",
"chars": 162,
"preview": "#include \"dg/Offset.h\"\n\nnamespace dg {\n// set the value of UNKNOWN offset\nconst Offset::type Offset::UNKNOWN = ~(static_"
},
{
"path": "lib/PointerAnalysis/Pointer.cpp",
"chars": 863,
"preview": "#include \"dg/PointerAnalysis/Pointer.h\"\n#include \"dg/PointerAnalysis/PSNode.h\"\n\n#ifndef NDEBUG\n#include <iostream>\n\nname"
},
{
"path": "lib/PointerAnalysis/PointerAnalysis.cpp",
"chars": 19974,
"preview": "#include \"dg/PointerAnalysis/PointerAnalysis.h\"\n#include \"dg/PointerAnalysis/Pointer.h\"\n#include \"dg/PointerAnalysis/Poi"
},
{
"path": "lib/PointerAnalysis/PointerGraph.cpp",
"chars": 3166,
"preview": "#include <cassert>\n\n#include \"dg/PointerAnalysis/PSNode.h\"\n#include \"dg/PointerAnalysis/PointerGraph.h\"\n\n#include \"dg/ut"
},
{
"path": "lib/PointerAnalysis/PointerGraphOptimizations.cpp",
"chars": 4686,
"preview": "#include \"dg/PointerAnalysis/PointerGraphOptimizations.h\"\n#include \"dg/PointerAnalysis/PointerGraph.h\"\n\nnamespace dg {\nn"
},
{
"path": "lib/PointerAnalysis/PointerGraphValidator.cpp",
"chars": 8632,
"preview": "#include <string>\n\n#include \"dg/PointerAnalysis/PointerGraphValidator.h\"\n#include \"dg/PointerAnalysis/PointsToSet.h\"\n#in"
},
{
"path": "lib/PointerAnalysis/PointsToSet.cpp",
"chars": 850,
"preview": "#include <functional>\n#include <map>\n#include <vector>\n\n#include \"dg/PointerAnalysis/PSNode.h\"\n#include \"dg/PointerAnaly"
},
{
"path": "lib/ReadWriteGraph/ReadWriteGraph.cpp",
"chars": 4057,
"preview": "#include <set>\n#include <vector>\n\n#include \"dg/BBlocksBuilder.h\"\n#include \"dg/ReadWriteGraph/ReadWriteGraph.h\"\n\nnamespac"
},
{
"path": "lib/SystemDependenceGraph/DependenceGraph.cpp",
"chars": 1940,
"preview": "#include <cassert>\n\n#include \"dg/SystemDependenceGraph/DGArgumentPair.h\"\n#include \"dg/SystemDependenceGraph/DGNode.h\"\n#i"
},
{
"path": "lib/ValueRelations/Relations.cpp",
"chars": 6788,
"preview": "#include \"dg/ValueRelations/Relations.h\"\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n\nnamespace dg {\nnames"
},
{
"path": "lib/llvm/ControlDependence/ControlClosure.h",
"chars": 4337,
"preview": "#ifndef DG_LLVM_CONTROL_CLOSURE_H_\n#define DG_LLVM_CONTROL_CLOSURE_H_\n\n#include <llvm/IR/Module.h>\n\n#include \"GraphBuild"
},
{
"path": "lib/llvm/ControlDependence/ControlDependence.cpp",
"chars": 2049,
"preview": "#include \"dg/llvm/ControlDependence/ControlDependence.h\"\n#include \"llvm/ControlDependence/ControlClosure.h\"\n#include \"ll"
},
{
"path": "lib/llvm/ControlDependence/DOD.h",
"chars": 11573,
"preview": "#ifndef DG_LLVM_DOD_H_\n#define DG_LLVM_DOD_H_\n\n#include <llvm/IR/Module.h>\n\n#include \"GraphBuilder.h\"\n#include \"IGraphBu"
},
{
"path": "lib/llvm/ControlDependence/GraphBuilder.h",
"chars": 4394,
"preview": "#ifndef DG_CDA_GRAPHBUILDER_H_\n#define DG_CDA_GRAPHBUILDER_H_\n\n#include <unordered_map>\n\n#include \"llvm/IR/CFG.h\"\n\n#incl"
},
{
"path": "lib/llvm/ControlDependence/IGraphBuilder.h",
"chars": 10514,
"preview": "#ifndef DG_CDA_IGRAPHBUILDER_H_\n#define DG_CDA_IGRAPHBUILDER_H_\n\n#include <unordered_map>\n\n#include \"llvm/IR/CFG.h\"\n#inc"
},
{
"path": "lib/llvm/ControlDependence/InterproceduralCD.cpp",
"chars": 6391,
"preview": "#include <llvm/IR/CFG.h>\n#include <llvm/IR/Function.h>\n#include <llvm/IR/Instructions.h>\n#include <llvm/IR/Module.h>\n\n#i"
},
{
"path": "lib/llvm/ControlDependence/InterproceduralCD.h",
"chars": 4312,
"preview": "#ifndef DG_LLVM_INTERPROC_CD_H_\n#define DG_LLVM_INTERPROC_CD_H_\n\n#include <llvm/IR/Module.h>\n\n#include \"dg/llvm/ControlD"
},
{
"path": "lib/llvm/ControlDependence/NTSCD.h",
"chars": 11806,
"preview": "#ifndef DG_LLVM_NTSCD_H_\n#define DG_LLVM_NTSCD_H_\n\n#include <llvm/IR/Module.h>\n\n#include \"GraphBuilder.h\"\n#include \"IGra"
},
{
"path": "lib/llvm/ControlDependence/SCD.cpp",
"chars": 4184,
"preview": "#include \"SCD.h\"\n\n#include <llvm/Analysis/DominanceFrontier.h>\n#include <llvm/Analysis/PostDominators.h>\n#include <llvm/"
},
{
"path": "lib/llvm/ControlDependence/SCD.h",
"chars": 2477,
"preview": "#ifndef DG_LLVM_SCD_H_\n#define DG_LLVM_SCD_H_\n\n#include <llvm/IR/Module.h>\n\n#include \"dg/llvm/ControlDependence/ControlD"
},
{
"path": "lib/llvm/ControlDependence/legacy/Block.cpp",
"chars": 5253,
"preview": "#include \"Block.h\"\n#include \"Function.h\"\n\n#include <sstream>\n\n#include <llvm/IR/Function.h>\n#include <llvm/IR/Instructio"
},
{
"path": "lib/llvm/ControlDependence/legacy/Block.h",
"chars": 2616,
"preview": "#ifndef DG_LEGACY_NTSCD_BLOCK_H\n#define DG_LEGACY_NTSCD_BLOCK_H\n\n#include <iosfwd>\n#include <map>\n#include <set>\n#includ"
},
{
"path": "lib/llvm/ControlDependence/legacy/Function.cpp",
"chars": 1642,
"preview": "#include \"Function.h\"\n#include \"Block.h\"\n\n#include <algorithm>\n#include <ostream>\n\nnamespace dg {\nnamespace llvmdg {\nnam"
},
{
"path": "lib/llvm/ControlDependence/legacy/Function.h",
"chars": 714,
"preview": "#ifndef DG_LEGACY_NTSCD_FUNCTION_H\n#define DG_LEGACY_NTSCD_FUNCTION_H\n\n#include <iosfwd>\n#include <set>\n\nnamespace dg {\n"
},
{
"path": "lib/llvm/ControlDependence/legacy/GraphBuilder.cpp",
"chars": 8933,
"preview": "#include <llvm/Analysis/LoopInfo.h>\n#include <llvm/IR/CFG.h>\n#include <llvm/IR/Function.h>\n#include <llvm/IR/Value.h>\n#i"
},
{
"path": "lib/llvm/ControlDependence/legacy/GraphBuilder.h",
"chars": 2305,
"preview": "#ifndef DG_LEGACY_NTSCD_GRAPHBUILDER_H\n#define DG_LEGACY_NTSCD_GRAPHBUILDER_H\n\n#include <iosfwd>\n#include <map>\n#include"
},
{
"path": "lib/llvm/ControlDependence/legacy/NTSCD.cpp",
"chars": 6296,
"preview": "#include \"NTSCD.h\"\n#include \"Block.h\"\n#include \"Function.h\"\n\nnamespace llvm {\nclass Function;\n}\n\n#include <algorithm>\n#i"
},
{
"path": "lib/llvm/ControlDependence/legacy/NTSCD.h",
"chars": 3887,
"preview": "#ifndef DG_LEGACY_LLVM_NTSCD_H_\n#define DG_LEGACY_LLVM_NTSCD_H_\n\n#include <llvm/IR/Module.h>\n\n#include \"GraphBuilder.h\"\n"
},
{
"path": "lib/llvm/ControlDependence/legacy/TarjanAnalysis.h",
"chars": 5402,
"preview": "#ifndef DG_LEGACY_NTSCD_TARJANANALYSIS_H\n#define DG_LEGACY_NTSCD_TARJANANALYSIS_H\n\n#include <algorithm>\n#include <queue>"
},
{
"path": "lib/llvm/DataDependenceAnalysis/LLVMDataDependenceAnalysis.cpp",
"chars": 3846,
"preview": "#include <llvm/IR/GlobalVariable.h>\n\n#include \"dg/llvm/DataDependence/DataDependence.h\"\n#include \"llvm/ReadWriteGraph/LL"
},
{
"path": "lib/llvm/DefUse/DefUse.cpp",
"chars": 3581,
"preview": "#include <map>\n\n#include <llvm/IR/Constants.h>\n#include <llvm/IR/DataLayout.h>\n#include <llvm/IR/GlobalVariable.h>\n#incl"
},
{
"path": "lib/llvm/DefUse/DefUse.h",
"chars": 1316,
"preview": "#ifndef LLVM_DEF_USE_ANALYSIS_H_\n#define LLVM_DEF_USE_ANALYSIS_H_\n\n#include <vector>\n\n#include <llvm/IR/DataLayout.h>\n#i"
},
{
"path": "lib/llvm/Dominators/PostDominators.cpp",
"chars": 4179,
"preview": "#include <llvm/Analysis/PostDominators.h>\n#include <llvm/IR/Function.h>\n\n#include \"dg/BFS.h\"\n#include \"dg/Dominators/Pos"
},
{
"path": "lib/llvm/ForkJoin/ForkJoin.cpp",
"chars": 1955,
"preview": "#include <cassert>\n\n#include \"ForkJoin.h\"\n\nnamespace dg {\n\nstd::vector<const llvm::Value *>\nForkJoinAnalysis::matchJoin("
},
{
"path": "lib/llvm/ForkJoin/ForkJoin.h",
"chars": 985,
"preview": "#ifndef DG_FORK_JOIN_ANALYSIS_H_\n#define DG_FORK_JOIN_ANALYSIS_H_\n\n#include \"dg/llvm/PointerAnalysis/PointerAnalysis.h\"\n"
},
{
"path": "lib/llvm/GraphBuilder.h",
"chars": 8456,
"preview": "#ifndef DG_GRAPHBUILDER_H_\n#define DG_GRAPHBUILDER_H_\n\n#include <llvm/IR/CFG.h>\n#include <llvm/IR/Constants.h>\n#include "
},
{
"path": "lib/llvm/LLVMDGVerifier.cpp",
"chars": 2763,
"preview": "#include <cstdarg>\n#include <cstdio>\n\n#include <llvm/IR/Function.h>\n#include <llvm/IR/Value.h>\n#include <llvm/Support/ra"
},
{
"path": "lib/llvm/LLVMDGVerifier.h",
"chars": 821,
"preview": "#ifndef LLVM_DG_VERIFIER_H_\n#define LLVM_DG_VERIFIER_H_\n\n#include \"dg/llvm/LLVMDependenceGraph.h\"\n\nnamespace llvm {\nclas"
}
]
// ... and 306 more files (download for full content)
About this extraction
This page contains the full source code of the mchalupa/dg GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 506 files (2.4 MB), approximately 661.9k tokens, and a symbol index with 3012 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.