Static Value-Flow Analysis
Loading...
Searching...
No Matches
Options.cpp
Go to the documentation of this file.
1//===- Options.cpp -- Command line options ------------------------//
2
3#include "Util/Options.h"
4#include "Util/CommandLine.h"
6#include "Util/ExtAPI.h"
7#include "MSSA/MemSSA.h"
8#include "WPA/WPAPass.h"
10
11namespace SVF
12{
14 "clock-type",
15 "how time should be measured",
17{
18 {PTAStat::ClockType::Wall, "wall", "use wall time"},
19 {PTAStat::ClockType::CPU, "cpu", "use CPU time"},
20}
21);
22
24 "marked-clocks-only",
25 "Only measure times where explicitly marked",
26 true
27);
28
30 "node-alloc-strat",
31 "Method of allocating (LLVM) values and memory objects as node IDs",
33{
34 {NodeIDAllocator::Strategy::DENSE, "dense", "allocate objects together [0-n] and values together [m-MAX], separately"},
35 {NodeIDAllocator::Strategy::REVERSE_DENSE, "reverse-dense", "like dense but flipped, objects are [m-MAX], values are [0-n]"},
36 {NodeIDAllocator::Strategy::SEQ, "seq", "allocate values and objects sequentially, intermixed (default)"},
37 {NodeIDAllocator::Strategy::DBUG, "debug", "allocate value and objects sequentially, intermixed, except GEP objects as offsets"},
38}
39);
40
42 "field-limit",
43 "Maximum number of fields for field sensitive analysis",
44 512
45);
46
48 "ptd",
49 "Overarching points-to data structure",
51{
52 {BVDataPTAImpl::PTBackingType::Mutable, "mutable", "points-to set per pointer"},
53 {BVDataPTAImpl::PTBackingType::Persistent, "persistent", "points-to set ID per pointer, operations hash-consed"},
54}
55);
56
58 "fs-time-limit",
59 "time limit for main phase of flow-sensitive analyses",
60 0
61);
62
64 "versioning-threads",
65 "number of threads to use in the versioning phase of versioned flow-sensitive analysis",
66 1
67);
68
70 "ander-time-limit",
71 "time limit for Andersen's analyses (ignored when -fs-time-limit set)",
72 0
73);
74
75// ContextDDA.cpp
77 "cxt-bg",
78 "Maximum step budget of context-sensitive traversing",
79 10000
80);
81
82// DDAPass.cpp
84 "max-path",
85 "Maximum path limit for DDA",
86 100000
87);
88
90 "max-cxt",
91 "Maximum context limit for DDA",
92 3
93);
94
96 "max-step",
97 "Maximum steps when traversing on SVFG to identify a memory allocation wrapper",
98 10
99);
100
102 "query",
103 "Please specify queries by inputing their pointer ids",
104 "all"
105);
106
108 "in-recur",
109 "Mark context insensitive SVFG edges due to function recursions",
110 false
111);
112
114 "in-cycle",
115 "Mark context insensitive SVFG edges due to value-flow cycles",
116 false
117);
118
120 "cpts",
121 "Dump conditional points-to set ",
122 false
123);
124
126 "print-query-pts",
127 "Dump queries' conditional points-to set ",
128 false
129);
130
132 "wpa-num",
133 "collect WPA FS number only ",
134 false
135);
136
138//static RegisterAnalysisGroup<AliasAnalysis> AA_GROUP(DDAPA);
140 "Select pointer analysis",
141{
142 {PointerAnalysis::FlowS_DDA, "dfs", "Demand-driven flow sensitive analysis"},
143 {PointerAnalysis::Cxt_DDA, "cxt", "Demand-driven context- flow- sensitive analysis"},
144}
145);
146
147// FlowDDA.cpp
149 "flow-bg",
150 "Maximum step budget of flow-sensitive traversing",
151 10000
152);
153
154
155// Offline constraint graph (OfflineConsG.cpp)
157 "dump-ocg",
158 "Dump dot graph of Offline Constraint Graph",
159 false
160);
161
162
163// Program Assignment Graph for pointer analysis (SVFIR.cpp)
165 "blk",
166 "Handle blackhole edge",
167 false
168);
169
171 "ff-eq-base",
172 "Treat base objects as their first fields",
173 false
174);
175
176
177// SVFG optimizer (SVFGOPT.cpp)
179 "ci-svfg",
180 "Reduce SVFG into a context-insensitive one",
181 false
182);
183
185 "keep-aofi",
186 "Keep formal-in and actual-out parameters",
187 false
188);
189
191 "keep-self-cycle",
192 "How to handle self cycle edges: all, context, none",
193 ""
194);
195
196
197// Sparse value-flow graph (VFG.cpp)
199 "dump-vfg",
200 "Dump dot graph of VFG",
201 false
202);
203
204
205// Base class of pointer analyses (PointerAnalysis.cpp)
207 "print-type",
208 "Print type",
209 false
210);
211
213 "print-fp",
214 "Print targets of indirect call site",
215 false
216);
217
219 "print-pts",
220 "Print points-to set of top-level pointers",
221 false
222);
223
225 "print-field",
226 "Print field object with base object id as the prefix",
227 false
228);
229
231 "print-all-pts",
232 "Print all points-to set of both top-level and address-taken variables",
233 false
234);
235
237 "stat",
238 "Statistic for Pointer analysis",
239 true
240);
241
243 "stat-limit",
244 "Iteration budget for On-the-fly statistics",
245 20
246);
247
249 "dump-pag",
250 "Dump dot graph of SVFIR",
251 false
252);
253
255 "show-ir-value",
256 "Show values of SVFIR (e.g., when generating dot graph)",
257 true
258);
259
261 "dump-icfg",
262 "Dump dot graph of ICFG",
263 false
264);
265
267 "dump-json",
268 "Dump the SVFIR in JSON format",
269 ""
270);
271
273 "read-json",
274 "Read the SVFIR in JSON format",
275 false
276);
277
279 "dump-callgraph",
280 "Dump dot graph of Call Graph",
281 false
282);
283
285 "print-pag",
286 "Print SVFIR to command line",
287 false
288);
289
291 "ind-call-limit",
292 "Indirect solved call edge limit",
293 50000
294);
295
297 "pre-field-sensitive",
298 "Use pre-computed field-sensitivity for later analysis",
299 true
300);
301
303 "alias-check",
304 "Enable alias check functions",
305 true
306);
307
309 "type-check",
310 "Enable type check functions",
311 true
312);
313
315 "enable-tcg",
316 "Enable pointer analysis to use thread call graph",
317 true
318);
319
321 "v-call-cha",
322 "connect virtual calls using cha",
323 false
324);
325
326
327// PointerAnalysisImpl.cpp
329 "inc-data",
330 "Enable incremental DFPTData for flow-sensitive analysis",
331 true
332);
333
335 "cluster-ander",
336 "Stage Andersen's with Steensgard's and cluster based on that",
337 false
338);
339
341 "cluster-fs",
342 "Cluster for FS/VFS with auxiliary Andersen's",
343 false
344);
345
347 "plain-mapping-fs",
348 "Use an explicitly (not null) plain mapping for FS",
349 false
350);
351
353 "pt-type",
354 "points-to set data structure to use in all analyses",
355 PointsTo::Type::SBV,
356{
357 {PointsTo::Type::SBV, "sbv", "sparse bit-vector"},
358 {PointsTo::Type::CBV, "cbv", "core bit-vector (dynamic bit-vector without leading and trailing 0s)"},
359 {PointsTo::Type::BV, "bv", "bit-vector (dynamic bit-vector without trailing 0s)"},
360}
361);
362
364 "cluster-method",
365 "hierarchical clustering method for objects",
367{
368 {HCLUST_METHOD_SINGLE, "single", "single linkage; minimum spanning tree algorithm"},
369 {HCLUST_METHOD_COMPLETE, "complete", "complete linkage; nearest-neighbour-chain algorithm"},
370 {HCLUST_METHOD_AVERAGE, "average", "unweighted average linkage; nearest-neighbour-chain algorithm"},
371 {HCLUST_METHOD_SVF_BEST, "best", "try all linkage criteria; choose best"},
372}
373);
374
376 // Use cluster to "gather" the options closer together, even if it sounds a little worse.
377 "cluster-regioned",
378 "cluster regions separately",
379 true
380);
381
383 "cluster-region-aligned",
384 "align each region's identifiers to the native word size",
385 true
386);
387
389 "cluster-predict-occ",
390 "try to predict which points-to sets are more important in staged analysis",
391 false
392);
393
394// Memory region (MemRegion.cpp)
396 "mssa-ignore-dead-fun",
397 "Don't construct memory SSA for deadfunction",
398 false
399);
400
401
402// Base class of pointer analyses (MemSSA.cpp)
404 "dump-mssa",
405 "Dump memory SSA",
406 false
407);
408
410 "mssa-fun",
411 "Please specify which function needs to be dumped",
412 ""
413);
414
416 "mem-par",
417 "Memory region partition strategies (e.g., for SVFG construction)",
419{
420 {MemSSA::MemPartition::Distinct, "distinct", "memory region per each object"},
421 {MemSSA::MemPartition::IntraDisjoint, "intra-disjoint", "memory regions partitioned based on each function"},
422 {MemSSA::MemPartition::InterDisjoint, "inter-disjoint", "memory regions partitioned across functions"},
423}
424);
425
426
427// SVFG builder (SVFGBuilder.cpp)
429 "svfg-with-ind-call",
430 "Update Indirect Calls for SVFG using pre-analysis",
431 false
432);
433
435 "opt-svfg",
436 "Optimize SVFG to eliminate formal-in and actual-out",
437 false
438);
439
441 "write-svfg",
442 "Write SVFG's analysis results to a file",
443 ""
444);
445
447 "read-svfg",
448 "Read SVFG's analysis results from a file",
449 ""
450);
451
452
454 "intra-lock-td-edge",
455 "Use simple intra-procedural lock for adding SVFG edges",
456 true
457);
458
459
460// LockAnalysis.cpp
462 "print-lock",
463 "Print Thread Interleaving Results",
464 false
465);
466
467
468// MHP.cpp
470 "print-interlev",
471 "Print Thread Interleaving Results",
472 false
473);
474
476 "lock-analysis",
477 "Run Lock Analysis",
478 true
479);
480
481
482// MTAStat.cpp
484 "all-pair-mhp",
485 "All pair MHP computation",
486 false
487);
488
489
490// TCT.cpp
492 "dump-tct",
493 "Dump dot graph of Call Graph",
494 false
495);
496
497
498// LeakChecker.cpp
500 "valid-tests",
501 "Validate memory leak tests",
502 false
503);
504
505
506// Source-sink analyzer (SrcSnkDDA.cpp)
508 "dump-slice",
509 "Dump dot graph of Saber Slices",
510 false
511);
512
514 "cxt-limit",
515 "Source-Sink Analysis Contexts Limit",
516 3
517);
518
519
520// CHG.cpp
522 "dump-cha",
523 "dump the class hierarchy graph",
524 false
525);
526
527
528// DCHG.cpp
530 "print-dchg",
531 "print the DCHG if debug information is available",
532 false
533);
534
535
536// LLVMModule.cpp
538 "graph-txt",
539 "graph txt file to build SVFIR",
540 ""
541);
542
544 "svf-main",
545 "add svf.main()",
546 false
547);
548
550 "model-consts",
551 "Modeling individual constant objects",
552 false
553);
554
556 "model-arrays",
557 "Modeling Gep offsets for array accesses",
558 false
559);
560
562 "cyclic-field-index",
563 "Enable cyclic field index when generating field objects using modulus offset",
564 false
565);
566
568 "print-symbol-table",
569 "Print Symbol Table to command line",
570 false
571);
572
573// Conditions.cpp
575 "max-z3-size",
576 "Maximum size limit for Z3 expression",
577 30
578);
579
580// BoundedZ3Expr.cpp
582 "max-bv-len",
583 "Maximum length limit for Z3 bitvector",
584 64
585);
586
587
588
589// SaberCondAllocator.cpp
591 "print-pc",
592 "Print out path condition",
593 false
594);
595
596
597// SaberSVFGBuilder.cpp
599 "saber-collect-extret-globals",
600 "Don't include pointers returned by external function during collecting globals",
601 true
602);
603
604
605// SVFUtil.cpp
607 "dwarn",
608 "Disable warning",
609 true
610);
611
612
613// Andersen.cpp
615 "dump-constraint-graph",
616 "Dump dot graph of Constraint Graph",
617 false
618);
619
621 "brief-constraint-graph",
622 "Dump dot graph of Constraint Graph",
623 true
624);
625
627 "print-constraint-graph",
628 "Print Constraint Graph to Terminal",
629 false
630);
631
633 "write-ander",
634 "-write-ander=ir_annotator (Annotated IR with Andersen's results) or write Andersen's analysis results to a user-specified text file",
635 ""
636);
637
639 "read-ander",
640 "-read-ander=ir_annotator (Read Andersen's analysis results from the annotated IR, e.g., *.pre.bc) or from a text file",
641 ""
642);
643
645 "diff",
646 "Enable differential point-to set",
647 true
648);
649
651 "merge-pwc",
652 "Enable PWC detection",
653 true
654);
655
656//SVFIRBuilder.cpp
658 "vt-in-ir",
659 "Handle vtable in ConstantArray/ConstantStruct in SVFIRBuilder (already handled in CHA?)",
660 false
661);
662
663//WPAPass.cpp
665 "extapi",
666 "External API extapi.bc",
667 ""
668);
669
671 "svfg",
672 "Generate SVFG after Andersen's Analysis",
673 false
674);
675
677 "saber-full-svfg",
678 "When using SABER for bug detection pass, enable full svfg on top of the pointer-only one",
679 false
680);
681
683 "print-aliases",
684 "Print results for all pair aliases",
685 false
686);
687
689 "Select pointer analysis",
690{
691 {PointerAnalysis::Andersen_WPA, "nander", "Standard inclusion-based analysis"},
692 {PointerAnalysis::AndersenSCD_WPA, "sander", "Selective cycle detection inclusion-based analysis"},
693 {PointerAnalysis::AndersenSFR_WPA, "sfrander", "Stride-based field representation inclusion-based analysis"},
694 {PointerAnalysis::AndersenWaveDiff_WPA, "ander", "Diff wave propagation inclusion-based analysis"},
695 {PointerAnalysis::Steensgaard_WPA, "steens", "Steensgaard's pointer analysis"},
696 // Disabled till further work is done.
697 {PointerAnalysis::FSSPARSE_WPA, "fspta", "Sparse flow sensitive pointer analysis"},
698 {PointerAnalysis::VFS_WPA, "vfspta", "Versioned sparse flow-sensitive points-to analysis"},
699 {PointerAnalysis::TypeCPP_WPA, "type", "Type-based fast analysis for Callgraph, SVFIR and CHA"},
700}
701);
702
703
705 "Select alias check rule",
706{
707 {WPAPass::Conservative, "conservative", "return MayAlias if any pta says alias"},
708 {WPAPass::Veto, "veto", "return NoAlias if any pta says no alias"},
709}
710);
711
713 "show-hidden-nodes",
714 "Show hidden nodes on DOT Graphs (e.g., isolated node on a graph)",
715 false
716);
717
719 "grammar",
720 "<Grammar textfile>",
721 ""
722);
723
725 "cflgraph",
726 "<Dot file as the CFLGraph input>",
727 ""
728);
729
731 "print-cfl",
732 "Print ir, grammar and cflgraph for debug.",
733 false
734);
735
737 "flex-symmap",
738 "Extend exist sym map while read graph from dot if sym not in map.",
739 false
740);
741
743 "peg-transfer",
744 "When explicit to true, cfl graph builder will transfer PAG load and store edges to copy and addr.",
745 false
746);
747
749 "cflsvfg",
750 "When explicit to true, cfl graph builder will transfer SVFG to CFL Reachability.",
751 false
752);
753
755 "pocr-alias",
756 "When explicit to true, cfl data builder will transfer CFL graph to CFLData.",
757 false
758);
759
761 "pocr-hybrid",
762 "When explicit to true, POCRHybridSolver transfer CFL graph to internal hybrid graph representation.",
763 false
764);
765
767 "customized",
768 "When explicit to true, user can use any grammar file.",
769 false
770);
771
773 "loop-analysis",
774 "Analyze every func and get loop info and loop bounds.",
775 true
776);
777
779 "loop-bound",
780 "Maximum number of loop",
781 1
782);
783
785 "widen-delay", "Loop Widen Delay", 3);
787 "handle-recur",
788 "Recursion handling mode in abstract execution (Default -widen-narrow)",
790{
791 {
793 "The return value, and any stored object pointed by q at *q = p in recursive functions will be set to the top value."
794 },
795 {
797 "Only apply widening at the cycle head of recursive functions."
798 },
799 {
801 "Apply both widening and narrowing at the cycle head of recursive functions."
802 }
803}
804);
806 "timeout", "time out (seconds), set -1 (no timeout), default 14400s",14400);
808 "output","output db file","output.db");
810 "overflow","Buffer Overflow Detection",false);
812 "null-deref","Null Pointer Dereference Detection",false);
814 "leak", "Memory Leak Detection",false);
816 "fileck", "File Open/Close Detection",false);
818 "dfree", "Double Free Detection",false);
820 "race", "Data race Detection",false);
822 "gep-unknown-idx","Skip Gep Unknown Index",false);
824 "run-uncall-fun","Skip Gep Unknown Index",false);
826 "icfg-merge-adjnodes","ICFG Simplification - Merge Adjacent Nodes in the Same Basic Block.",false);
827
828
830 "precision",
831 "symbolic abstraction precision for float",
832 0
833);
834
835} // namespace SVF.
@ InterDisjoint
Definition MemSSA.h:117
@ IntraDisjoint
Definition MemSSA.h:116
@ SEQ
Allocate objects objects and values sequentially, intermixed.
static const Option< bool > IgnoreDeadFun
Definition Options.h:136
static const Option< bool > PlainMappingFs
Use an explicitly plain mapping with flow-sensitive (not null).
Definition Options.h:44
static const Option< std::string > ReadSVFG
Definition Options.h:149
static const Option< bool > SVFGWithIndirectCall
Definition Options.h:145
static const Option< bool > KeepAOFI
Definition Options.h:104
static const Option< bool > CallGraphDotGraph
Definition Options.h:123
static const Option< bool > DumpMSSA
Definition Options.h:139
static const Option< bool > InsenCycle
Definition Options.h:86
static const Option< bool > FirstFieldEqBase
Definition Options.h:100
static Option< bool > ModelArrays
Definition Options.h:185
static const Option< bool > Customized
Definition Options.h:236
static const Option< bool > DisableWarn
Definition Options.h:202
static const Option< bool > INCDFPTData
Definition Options.h:133
static const Option< u32_t > LoopBound
Definition Options.h:240
static const Option< bool > PrintInterLev
Definition Options.h:156
static const Option< bool > EnableThreadCallGraph
Definition Options.h:129
static const Option< bool > PAGDotGraph
Definition Options.h:118
static OptionMultiple< u32_t > AliasRule
Definition Options.h:222
static const Option< bool > BriefConsCGDotGraph
Definition Options.h:206
static const Option< std::string > WriteSVFG
Definition Options.h:148
static const OptionMap< u32_t > HandleRecur
recursion handling mode, Default: TOP
Definition Options.h:245
static const OptionMap< enum PTAStat::ClockType > ClockType
Definition Options.h:21
static const Option< std::string > ExtAPIPath
Definition Options.h:217
static const Option< bool > RaceCheck
data race checker, Default: false
Definition Options.h:261
static const Option< bool > POCRAlias
Definition Options.h:234
static const Option< bool > EnableTypeCheck
Definition Options.h:128
static const Option< bool > PrintLockSpan
Definition Options.h:153
static const Option< u32_t > AnderTimeLimit
Time limit for the Andersen's analyses.
Definition Options.h:72
static const OptionMap< SVF::NodeIDAllocator::Strategy > NodeAllocStrat
Definition Options.h:32
static const Option< bool > POCRHybrid
Definition Options.h:235
static const Option< bool > CyclicFldIdx
Definition Options.h:186
static const Option< bool > DFreeCheck
double free checker, Default: false
Definition Options.h:259
static const Option< bool > SVFMain
Definition Options.h:180
static const Option< u32_t > CxtBudget
Definition Options.h:78
static const Option< std::string > DumpJson
Definition Options.h:121
static Option< bool > DetectPWC
Definition Options.h:213
static const Option< u32_t > CxtLimit
Definition Options.h:170
static const Option< bool > PrintFieldWithBasePrefix
Definition Options.h:115
static const Option< bool > ShowSVFIRValue
Definition Options.h:119
static const Option< bool > PTSPrint
Definition Options.h:113
static const Option< std::string > ReadAnder
Definition Options.h:211
static const Option< bool > ClusterAnder
Whether to stage Andersen's with Steensgaard and cluster based on that data.
Definition Options.h:38
static OptionMultiple< PointerAnalysis::PTATY > PASelected
Definition Options.h:221
static const Option< bool > PEGTransfer
Definition Options.h:232
static const Option< u32_t > Timeout
the max time consumptions (seconds). Default: 4 hours 14400s
Definition Options.h:247
static Option< bool > HandBlackHole
Definition Options.h:99
static const Option< bool > SymTabPrint
Definition Options.h:187
static const OptionMap< u32_t > MemPar
Definition Options.h:142
static const Option< std::string > Graphtxt
Definition Options.h:179
static const OptionMap< PointsTo::Type > PtType
Type of points-to set to use for all analyses.
Definition Options.h:47
static const Option< bool > RegionAlign
Align identifiers in each region to a word.
Definition Options.h:59
static Option< bool > ModelConsts
Definition Options.h:184
static const Option< std::string > UserInputQuery
Definition Options.h:84
static const Option< bool > EnableAliasCheck
Definition Options.h:127
static const Option< bool > PrintPathCond
Definition Options.h:196
static const Option< u32_t > MaxContextLen
Definition Options.h:82
static const Option< u32_t > MaxPathLen
Definition Options.h:81
static const Option< bool > GepUnknownIdx
if the access index of gepstmt is unknown, skip it, Default: false
Definition Options.h:263
static const Option< bool > FileCheck
file open close checker, Default: false
Definition Options.h:257
static const Option< u32_t > FsTimeLimit
Time limit for the main phase (i.e., the actual solving) of FS analyses.
Definition Options.h:69
static const Option< u32_t > MaxBVLen
Definition Options.h:193
static const Option< bool > PTSAllPrint
Definition Options.h:114
static const Option< bool > ICFGMergeAdjacentNodes
Definition Options.h:266
static const Option< bool > WPANum
Definition Options.h:89
static const Option< bool > PAGPrint
Definition Options.h:124
static const Option< bool > CFLSVFG
Definition Options.h:233
static const Option< std::string > CFLGraph
Definition Options.h:229
static const Option< bool > TypePrint
Definition Options.h:111
static const Option< bool > ClusterFs
Whether to cluster FS or VFS with the auxiliary Andersen's.
Definition Options.h:41
static const Option< u32_t > MaxZ3Size
Definition Options.h:190
static const Option< bool > VtableInSVFIR
Definition Options.h:214
static const Option< u32_t > FlowBudget
Definition Options.h:93
static const Option< bool > RegionedClustering
Cluster partitions separately.
Definition Options.h:56
static const Option< bool > FlexSymMap
Definition Options.h:231
static const Option< u32_t > AEPrecision
Definition Options.h:269
static Option< bool > UsePreCompFieldSensitive
Definition Options.h:126
static const Option< bool > SABERFULLSVFG
Definition Options.h:219
static const Option< bool > CollectExtRetGlobals
Definition Options.h:199
static const Option< bool > PrintCGGraph
Definition Options.h:207
static const Option< std::string > SelfCycle
Definition Options.h:105
static const Option< bool > PrintCFL
Definition Options.h:230
static const Option< u32_t > IndirectCallLimit
Definition Options.h:125
static const Option< std::string > MSSAFun
Definition Options.h:140
static const Option< bool > AllPairMHP
Definition Options.h:160
static const Option< u32_t > MaxFieldLimit
Maximum number of field derivations for an object.
Definition Options.h:35
static const OptionMap< u32_t > ClusterMethod
Definition Options.h:53
static const Option< u32_t > MaxStepInWrapper
Definition Options.h:83
static const Option< bool > PrintDCHG
Definition Options.h:176
static const Option< std::string > WriteAnder
Definition Options.h:209
static const Option< u32_t > WidenDelay
Definition Options.h:243
static const Option< bool > NullDerefCheck
nullptr dereference checker, Default: false
Definition Options.h:253
static Option< bool > OPTSVFG
Definition Options.h:146
static const Option< bool > DumpSlice
Definition Options.h:169
static const Option< bool > FuncPointerPrint
Definition Options.h:112
static const Option< bool > RunUncallFuncs
Definition Options.h:264
static const Option< bool > MarkedClocksOnly
Definition Options.h:28
static const Option< bool > PrintCPts
Definition Options.h:87
static const Option< bool > ConnectVCallOnCHA
Definition Options.h:130
static const Option< bool > LoopAnalysis
Definition Options.h:239
static const Option< bool > PrintAliases
Definition Options.h:220
static const Option< bool > PStat
Definition Options.h:116
static const Option< bool > ValidateTests
Definition Options.h:166
static const Option< std::string > GrammarFilename
Definition Options.h:228
static const Option< u32_t > StatBudget
Definition Options.h:117
static const Option< bool > OCGDotGraph
Definition Options.h:96
static const Option< bool > ConsCGDotGraph
Definition Options.h:205
static const Option< std::string > OutputName
bug info output file, Default: output.db
Definition Options.h:249
static const Option< bool > TCTDotGraph
Definition Options.h:163
static const Option< bool > ShowHiddenNode
Definition Options.h:225
static const Option< bool > ReadJson
Definition Options.h:122
static const Option< bool > DoLockAnalysis
Definition Options.h:157
static const Option< bool > DumpVFG
Definition Options.h:108
static const OptionMap< BVDataPTAImpl::PTBackingType > ptDataBacking
PTData type.
Definition Options.h:66
static const Option< bool > ContextInsensitive
Definition Options.h:103
static const Option< bool > MemoryLeakCheck
memory leak check, Default: false
Definition Options.h:255
static const Option< bool > DiffPts
Definition Options.h:212
static const Option< bool > DumpICFG
Definition Options.h:120
static const Option< bool > PrintQueryPts
Definition Options.h:88
static const Option< bool > AnderSVFG
Definition Options.h:218
static const Option< bool > InsenRecur
Definition Options.h:85
static const Option< bool > PredictPtOcc
Definition Options.h:63
static const Option< bool > IntraLock
Definition Options.h:152
static OptionMultiple< PointerAnalysis::PTATY > DDASelected
register this into alias analysis group
Definition Options.h:90
static const Option< bool > BufferOverflowCheck
buffer overflow checker, Default: false
Definition Options.h:251
static const Option< bool > DumpCHA
Definition Options.h:173
static const Option< u32_t > VersioningThreads
Number of threads for the versioning phase.
Definition Options.h:75
@ Cxt_DDA
context sensitive DDA
@ VFS_WPA
Versioned sparse flow-sensitive WPA.
@ AndersenSCD_WPA
Selective cycle detection andersen-style WPA.
@ FlowS_DDA
Flow sensitive DDA.
@ Andersen_WPA
Andersen PTA.
@ AndersenWaveDiff_WPA
Diff wave propagation andersen-style WPA.
@ TypeCPP_WPA
Type-based analysis for C++.
@ AndersenSFR_WPA
Stride-based field representation.
@ Steensgaard_WPA
Steensgaard PTA.
@ FSSPARSE_WPA
Sparse flow sensitive WPA.
@ Conservative
return MayAlias if any pta says alias
Definition WPAPass.h:63
@ Veto
return NoAlias if any pta says no alias
Definition WPAPass.h:64
@ HCLUST_METHOD_AVERAGE
Definition fastcluster.h:72
@ HCLUST_METHOD_COMPLETE
Definition fastcluster.h:70
@ HCLUST_METHOD_SVF_BEST
Definition fastcluster.h:76
@ HCLUST_METHOD_SINGLE
Definition fastcluster.h:68
for isBitcode
Definition BasicTypes.h:68