Pith. sign in

REVIEW 3 major objections 4 minor 94 references

Accelerating C/C++ Pointer Analysis via Compiler-Based Offline Simplifications

T0 review · 3 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Applying semantic-preserving compiler optimizations to IR before pointer analysis yields up to 3.14x speedup and 1.94x memory reduction, with precision largely unchanged.

desk verdict A useful, broad empirical study with an honest core finding, but the headline speedup is a best-of-300 oracle number with search cost excluded, so the practical end-to-end claim is not yet established. read the letter →

arxiv 2608.04466 v1 pith:QWG2ZPID submitted 2026-08-05 cs.PL

Zinan Gu , Peisen Yao , Kui Ren This is my paper · ORCID
classification cs.PL
keywords pointeranalysisofflinesimplificationcompileroptimizationsintermediaterepresentationiterativeoptimizationflow-sensitiveAndersenC/C++static
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Semantic-preserving compiler optimizations, run on the intermediate representation before pointer analysis starts, can act as an analysis-agnostic offline simplification. Across 22 open-source C/C++ programs and three pointer analyses, the paper reports up to 3.14x end-to-end analysis speedup and 1.94x peak-memory reduction, with precision mostly stable. The gains vary by program and analysis, and standard O1/O2/O3 optimization levels are usually weaker than configurations picked per program. If the claim holds, static-analysis engineers can harvest scalability from compiler passes without modifying analysis algorithms.

What carries the argument

The central object is the optimization configuration: a sequence of compiler flags applied to the program's IR before analysis. The paper samples 300 random configurations per program-analysis pair, picks the fastest by measured end-to-end time, and then explains the gains by pruning passes and isolating individual passes. Carrying mechanisms include merging or eliminating pointers and instructions (for example, passes that merge semantically equivalent functions, strip metadata, and vectorize load-store pairs), and the observation that these compiler-driven simplifications compose additively with online simplifications already inside the analyses.

What would settle it

Re-run the same 22 benchmarks with the 300-configuration search time included in the reported end-to-end times, or apply a configuration fixed in advance to programs it was not tuned on; if the average speedup collapses below about 1.1x or the 3.14x peak disappears, the headline performance claim fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that ordinary, semantics-preserving compiler transformations applied to IR before analysis are a viable offline simplification strategy for pointer analysis. The authors test this by running three inclusion-based analyses—two flow- and context-insensitive Andersen variants and one flow-sensitive analysis—on 22 real programs, with an all-optimizations-disabled baseline, and report time including optimization overhead. They find up to 3.14x speedup on nginx with the selective-cycle-detection Andersen variant, up to 1.94x memory reduction on nginx with the flow-sensitive analysis, and average speedups of 1.34x and 1.38x for the two Andersen variants, with the flow-sensitive analysis benefiting most. Precision metrics stay largely unchanged, with some programs seeing improvements in points-to set size, alias-pair ratio, callgraph edges, and reachable methods and a few seeing degradations; the paper itself cautions that modifying the IR limits comparability of precision results across configurations.

Load-bearing premise

The headline numbers are the best of 300 random pass sequences chosen per program and analysis using the measured analysis runtime as the fitness function, with search time excluded from end-to-end times; the paper itself also cautions that altering the IR limits comparability of precision results across configurations.

Editorial extensions

If this is right

  • Reusing standard compiler passes can give existing pointer-analysis tools a plug-in speedup without changing the analysis algorithms, so offline simplification no longer has to be custom-built per analysis.
  • Flow-sensitive analysis, being the most time- and memory-hungry, gains the most, so compiler-driven simplification is a practical lever for scaling flow-sensitive points-to analysis to large codebases.
  • Standard optimization levels leave performance on the table: per-program configurations beat O1/O2/O3 in most cases, and pruning removes about a third of passes with little loss, so targeted pass selection rather than a fixed level is the right design.
  • Pass effects are not monotonic or predictably additive; a pass can speed analysis while increasing IR copy counts, and a pass can help one program and hurt another, implying adaptive, analysis-aware optimization selection.
  • Precision is mostly preserved, with some strong precision gains on complex programs, so the approach can also be seen as a way of making analysis results leaner, not just faster.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Because the winning configuration is selected per program using the measured analysis time, the 3.14x figure is an upper bound on what a user would see without paying search or portability costs; a learned or feature-based predictor of good configurations would be needed to make the gains available in practice.
  • The approach should compose with other pre-analyses: a library compiled once under a good configuration could be reused across client programs, multiplying the simplification benefit the paper discusses for library pre-analysis.
  • The non-monotonic precision effects suggest downstream clients that consume pointer-analysis results should re-validate on optimized IR, and that configuration search could be extended to optimize precision or a precision-aware objective.
  • One testable extension is to run the same random-configuration search for demand-driven or storeless pointer analyses; the paper frames this as future work, and its released tooling and data would let a reader check whether the gains transfer.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes applying semantic-preserving LLVM compiler optimizations to IR before running pointer analysis, as a modular and analysis-agnostic offline simplification. Using SVF and three pointer analyses (DW-ander, SCD-ander, VSFS) on 22 C/C++ programs, the authors search over 105 optimization flags by evaluating 300 random sequences per program and analysis, select the best-performing configuration (Opt) per case, and report speedups up to 3.14x, memory reductions up to 1.94x, and mostly stable precision. They also analyze IR metric changes, pass-pruning behavior, context-dependent passes, standard optimization levels, and precision impacts.

Significance. The underlying idea, that compiler passes can serve as a reusable offline simplification layer for pointer analysis, is genuinely interesting and potentially useful. The paper's strengths include the breadth of the benchmark suite, the use of three different pointer analyses, the detailed catalog of per-pass effects, the release of tools and data, and the reported discovery of twelve SVF bugs. If the performance gains were tied to a reproducible, cost-aware selection procedure, the contribution would be meaningful for the static-analysis community. As it stands, however, the central claim of practical end-to-end speedup is not established, because the reported Opt is a best-of-300 oracle configuration whose search cost is excluded and whose selection procedure is not reusable.

major comments (3)
  1. [§3, §4.1, Table 4] The headline end-to-end speedup claim is not supported by the reported methodology. In §3 the authors state that 300 distinct optimization sequences are evaluated for each program and that Opt is the pass sequence leading to the highest speedup; Table 4 and Figure 1 then report baseline-versus-Opt times. Because Opt is selected per program and per analysis using measured analysis runtime as the fitness function, and because the time spent generating and running the other 299 configurations is excluded from the reported 'end-to-end' times, the gains are best-of-300 oracle results. No reproducible procedure is given by which a user would obtain these configurations for a new program, and Finding 2's own recommendation to use total time as the fitness function is not applied to Table 4. The paper should either report the total cost of the configuration search or evaluate a fixed or learned selection policy on held-out programs before claiming practical end-to-end improvements.
  2. [Table 2] The definitions in Table 2 are internally inconsistent with the rest of the paper: it lists |P|=12 test programs while Table 3 enumerates 22 benchmarks, and |O|=200 configurations while the text in §3 says 300 distinct optimization sequences are evaluated per program. Since s_optimal,p is defined as a maximum over O, this ambiguity affects which speedups are reported and must be resolved for the results to be reproducible.
  3. [Table 4 and §4.1] Table 4 contains cells marked 'OOT1' (e.g., the omnetpp and xalancbmk rows) with no legend explaining the footnote, and the omnetpp row appears to have an OOT baseline for DW-ander while Figure 1 reports a speedup for that same analysis, which requires a baseline time. The paper also states that Table 4 includes the cost of optimization passes, yet the overhead discussion in §4.1 reports that for nginx the optimization process can take up to 100 seconds and that the total time significantly exceeds the best runtime observed. These statements are in tension and need reconciliation, along with explicit handling of timeout runs in all reported speedup and memory-ratio figures.
minor comments (4)
  1. [§4.3] The pruning experiment removes passes one at a time in a random order with a 1% threshold, but no random seeds, number of repetitions, or variance information are reported; the claim that every one of the 105 passes is removed in at least two configurations therefore lacks statistical grounding.
  2. [§3, Platform] The paper reports single measurements with no error bars or repeated-run information for the timing and memory results in Figures 1–3 and Table 4; given the variability visible in the speedup distributions in Figure 2, a statement about run-to-run variance is needed.
  3. [Figures 4 and 5] The heat maps for IR metric changes are extremely dense and the numeric labels are difficult to read at publication size; a table or appendix with the underlying values would improve reproducibility and readability.
  4. [§3, Compiler Optimizations] The exact LLVM version, the full list of the 105 selected optimization flags, and the random-search seed are not specified; these details are necessary for anyone attempting to replicate the configuration search.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; the study is an empirical measurement with the best-of-N configuration choice explicitly labeled as such.

full rationale

The paper contains no derivation chain in which a claimed 'prediction' or 'first-principles result' reduces to its own inputs. The central claims are empirical: compiler optimizations applied to LLVM IR before three SVF pointer analyses yield measured speedups and memory reductions. The optimization configuration 'Opt' is defined in Table 2 as the maximum of 300 random configurations' speedups, and Section 4.1 explicitly reports these as 'maximum speedups' and 'best' values, so the headline 3.14x figure is a best-of-sample statistic, not a fitted parameter renamed as a prediction. The reported 'end-to-end' times in Table 4 are presented as including the cost of the chosen optimization passes, although the cost of the 299 rejected configurations is not included; that is a methodological threat to generalization and a search-cost accounting concern, not a circularity. The paper also acknowledges the limitation in Finding 2 and in Section 5.3, recommending total-time fitness and disclaiming generalization beyond the benchmark suite. Citations to SVF, VSFS, and related analyses are external implementations and prior work, and the only overlapping self-citation (Peisen Yao's co-authored reference [70]) appears in the related-work list and is not load-bearing for the evaluation. No uniqueness theorem, ansatz, or definitional equivalence is imported from the authors' prior work. Hence, no circular step can be exhibited; the honest finding is no significant circularity, score 0.

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The central claims rest on Opt being the best of a sampled set, the correctness of the LLVM passes and the SVF analyses, and the representativeness of the benchmark suite.

free parameters (3)
  • Opt optimization configuration (per program and analysis) = not enumerated; typically >50 flags
    Selected as argmax over 300 random configurations of measured analysis runtime; the central speedup and memory claims in Figure 1 and Table 4 depend on this post-hoc selection, and its search cost is not included in end-to-end times.
  • Random search budget = 300 sequences per program
    Hand-chosen budget for optimization search in Section 3; the reported 'Opt' is the best within this budget, so the attainable speedup is relative to this arbitrary budget.
  • Pass pruning threshold = 1%
    Hand-chosen threshold in Section 4.3 for discarding passes during pruning; the reported pass-removal statistics depend on it.
assumptions (3)
  • domain assumption LLVM optimization passes used in the study are semantics-preserving for the pointer-relevant behavior of the program
    The precision claims (Section 4.4) and the framing of optimizations as 'semantic-preserving' (Section 2.2) rely on this. The authors note in Section 5.2 that LLVM's optimizer is not bug-free, which is a direct caveat to this assumption.
  • domain assumption The three SVF analyses correctly implement the pointer analyses and their outputs on transformed IR are comparable to outputs on unoptimized IR
    All timing and precision measurements are obtained from SVF's DW-ander, SCD-ander, and VSFS. The authors report finding twelve bugs in SVF during the study (Section 5.2), which weakens trust in these measurements.
  • domain assumption The 22-program benchmark suite is representative enough to support the paper's general conclusions
    The authors explicitly state in Section 5.3 that they cannot claim generalization beyond the studied benchmarks, so the broader conclusions rest on this unproven representativeness.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Accelerating C/C++ Pointer Analysis via Compiler-Based Offline Simplifications." pith.science (2026). https://pith.science/paper/QWG2ZPID

@misc{pith2026260804466,
  author       = {Pith},
  title        = {Pith review of: Accelerating C/C++ Pointer Analysis via Compiler-Based Offline Simplifications},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QWG2ZPID}},
  note         = {Machine review of arXiv:2608.04466}
}
read the original abstract

Pointer analysis is a cornerstone of numerous static analysis applications, including compiler optimizations, slicing, bug detection, and verification. While offline simplification is a common approach to boosting performance, existing methods are often tightly coupled to specific analysis algorithms and limited to a set of simplification rules. This paper explores a new perspective: applying semantic-preserving compiler optimizations directly to intermediate representation (IR) before pointer analysis. This strategy is modular, analysis-agnostic, and easily integrates with existing tools. We conduct an empirical study using diverse programs and three pointer analyses. The results show substantial performance gains---up to 3.14x speedup and 1.94x memory reduction---while precision remains largely unchanged. We also analyze the trade-offs between optimization overhead and analysis speedup, quantify changes in IR structure, assess the characteristics of optimization configurations, and identify promising directions for future research.

Figures

Figures reproduced from arXiv: 2608.04466 by the authors.

Figure 1
Figure 1. The heat maps of best speedups and best peak memory ratios (thanks to [PITH_FULL_IMAGE:figures/full_fig_p008_1.png] view at source ↗
Figure 2
Figure 2. Distribution of speedups and memory ratios across the benchmarks, where higher values are better. [PITH_FULL_IMAGE:figures/full_fig_p009_2.png] view at source ↗
Figure 3
Figure 3. Speedup comparison of O1, O2, O3, and Opt classified by analyses. points. In some cases (e.g., perl and vim), the optimized counts exceed the baselines, but such a phenomenon is uncommon. Instructions Eliminated. Compiler optimizations also affect the number of instructions in IR. According to the right part of figure 4, instruction counts after optimization are slightly lower than baselines in most cases, but there… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Heat maps of total pointer change rates and total instruction change rates. [PITH_FULL_IMAGE:figures/full_fig_p012_4.png]
Figure 5
Figure 5. Figure 5: The heat map of separate instruction ratios. [PITH_FULL_IMAGE:figures/full_fig_p012_5.png]
Figure 6
Figure 6. Figure 6: Removed and kept passes. DW-ander SCD-ander VSFS tmux povray omnetpp zsh imagick nginx sqlite ctags perl xalancbmk vvenc thrift bash fish trafficserver gcc vim boringssl python php 0.24 0.25 0.25 0.04 0.04 0.03 1.56 0.53 1.32 0.08 0.62 0.06 0.06 -0.01 0.01 0.05 0.06 0.…
Figure 8
Figure 8. Figure 8: Heat maps of precision change rate of O1, O2, O3, and [PITH_FULL_IMAGE:figures/full_fig_p016_8.png]

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

94 extracted references · 50 canonical work pages

  1. [1]

    2023. Retdec. https://github.com/avast/retdec/

    2023

  2. [2]

    Ammons and J.R

    G. Ammons and J.R. Larus. 1998. Improving Data-flow Analysis with Path Profiles. InPLDI

    1998

  3. [3]

    Jason Ansel, Shoaib Kamil, Kalyan Veeramachaneni, Jonathan Ragan-Kelley, Jeffrey Bosboom, Una-May O’Reilly, and Saman Amarasinghe. 2014. Opentuner: An extensible framework for program autotuning. InProceedings of the 23rd international conference on Parallel architectures and compilation. ACM, 303–316. , Vol. 3, No. 1, Article 1. Publication date: October...

    2014

  4. [4]

    Steven Arzt and Eric Bodden. 2016. Stubdroid: automatic inference of precise data-flow summaries for the android framework. InProceedings of the 38th International Conference on Software Engineering. 725–735

    2016

  5. [5]

    Gogul Balakrishnan and Thomas Reps. 2006. Recency-abstraction for heap-allocated storage. InInternational Static Analysis Symposium. Springer, 221–239

    2006

  6. [6]

    Balakrishnan, S

    G. Balakrishnan, S. Sankaranarayanan, F. Ivanči’c, and A. Gupta. 2009. Refining the Control Structure of Loops using Static Analysis. InEMSOFT

    2009

  7. [7]

    Mohamad Barbar, Yulei Sui, and Shiping Chen. 2020. Flow-sensitive type-based heap cloning. In34th European Conference on Object-Oriented Programming (ECOOP 2020). Schloss-Dagstuhl-Leibniz Zentrum für Informatik

    2020

  8. [8]

    Mohamad Barbar, Yulei Sui, and Shiping Chen. 2021. Object versioning for flow-sensitive pointer analysis. In2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE, 222–235

    2021

Show all 94 references
  1. [9]

    Junjie Chen, Wenxiang Hu, Lingming Zhang, Dan Hao, Sarfraz Khurshid, and Lu Zhang. 2018. Learning to accelerate symbolic execution via code transformation. In32nd European Conference on Object-Oriented Programming (ECOOP 2018). Schloss-Dagstuhl-Leibniz Zentrum für Informatik

    2018

  2. [10]

    Junjie Chen and Chenyao Suo. 2022. Boosting compiler testing via compiler optimization exploration.ACM Transactions on Software Engineering and Methodology (TOSEM)31, 4 (2022), 1–33

    2022

  3. [11]

    Junjie Chen, Ningxin Xu, Peiqi Chen, and Hongyu Zhang. 2021. Efficient compiler autotuning via bayesian optimization. In2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). IEEE, 1198–1209

    2021

  4. [12]

    Keith D Cooper, L Taylor Simpson, and Christopher A Vick. 2001. Operator strength reduction.ACM Transactions on Programming Languages and Systems (TOPLAS)23, 5 (2001), 603–625

    2001

  5. [13]

    Cooper, Devika Subramanian, and Linda Torczon

    Keith D. Cooper, Devika Subramanian, and Linda Torczon. 2002. Adaptive Optimizing Compilers for the 21st Century. J. Supercomput.23, 1 (2002), 7–22. doi:10.1023/A:1015729001611

    2002 doi

  6. [14]

    Cousot and R

    P. Cousot and R. Cousot. 2002. Systematic Design of Program Transformation Frameworks by Abstract Interpretation. InProceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL)

    2002

  7. [15]

    Artem Dinaburg and Andrew Ruef. 2014. Mcsema: Static translation of x86 instructions to llvm. InReCon 2014 Conference, Montreal, Canada

    2014

  8. [16]

    Lisa Nguyen Quang Do, Stefan Krüger, Patrick Hill, Karim Ali, and Eric Bodden. 2020. Debugging Static Analysis. IEEE Transactions on Software Engineering46, 7 (2020), 697–709. doi:10.1109/TSE.2018.2868349

    2020

  9. [17]

    Marcus Edvinsson, Jonas Lundberg, and Welf Löwe. 2011. Parallel points-to analysis for multi-core machines. InPro- ceedings of the 6th International Conference on High Performance and Embedded Architectures and Compilers(Heraklion, Greece)(HiPEAC ’11). ACM, New York, NY, USA, ...

    2011

  10. [18]

    Ramalingam, and Emmanuel Geay

    Stephen Fink, Eran Yahav, Nurit Dor, G. Ramalingam, and Emmanuel Geay. 2006. Effective Typestate Verification in the Presence of Aliasing. InProceedings of the 2006 International Symposium on Software Testing and Analysis(Portland, Maine, USA)(ISSTA ’06). ACM, New York, NY, US...

    2006

  11. [19]

    J.A. Fisher. 1981. Trace Scheduling: A Technique for Global Microcode Compaction.IEEE Trans. on ComputersC-30, 7 (1981), 478–490

    1981

  12. [20]

    Flores-Montoya and R

    A. Flores-Montoya and R. Hähnle. 2014. Resource analysis of complex programs with cost equations. InProceedings of the Asian Symposium on Programming Languages and Systems (APLAS)

    2014

  13. [21]

    Foster, Zhendong Su, and Alexander Aiken

    Manuel Fähndrich, Jeffrey S. Foster, Zhendong Su, and Alexander Aiken. 1998. Partial Online Cycle Elimination in Inclusion Constraint Graphs. InProceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation (PLDI ’98). ACM. doi:10.1145/277650.277667

    1998

  14. [22]

    Karthik Gargi. 2002. A sparse algorithm for predicated global value numbering. InProceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation. 45–56

    2002

  15. [23]

    Gulwani, S

    S. Gulwani, S. Jain, and E. Koskinen. 2009. Control-flow Refinement and Progress Invariants for Bound Analysis. In PLDI

    2009

  16. [24]

    Gurfinkel, T

    A. Gurfinkel, T. Kahsai, A. Komuravelli, and J.A. Navas. 2015. The SeaHorn Verification Framework. InCA V

    2015

  17. [25]

    Arie Gurfinkel and Jorge A Navas. 2017. A context-sensitive memory model for verification of C/C++ programs. In Static Analysis: 24th International Symposium, SAS 2017, New York, NY, USA, August 30–September 1, 2017, Proceedings

    2017

  18. [26]

    Brian Hackett and Alex Aiken. 2006. How is aliasing used in systems software?. InProceedings of the 14th ACM SIGSOFT International Symposium on Foundations of Software Engineering(Portland, Oregon, USA)(SIGSOFT ’06/FSE-14). ACM, New York, NY, USA, 69–80. doi:10.1145/1181775.1181785

    2006

  19. [28]

    Ben Hardekopf and Calvin Lin. 2007. Exploiting pointer and location equivalence to optimize pointer analysis. In Proceedings of the 14th International Conference on Static Analysis(Kongens Lyngby, Denmark)(SAS’07). Springer-Verlag, Berlin, Heidelberg, 265–280. http://dl.acm.or...

    2007

  20. [29]

    Ben Hardekopf and Calvin Lin. 2011. Flow-sensitive pointer analysis for millions of lines of code. InProceedings of the 9th Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO ’11). IEEE Computer Society, Washington, DC, USA, 289–298

    2011

  21. [30]

    Nevin Heintze and Olivier Tardieu. 2001. Demand-driven pointer analysis. InProceedings of the ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation(Snowbird, Utah, USA)(PLDI ’01). ACM, New York, NY, USA, 24–34. doi:10.1145/378795.378802

    2001

  22. [31]

    Minseok Jeon, Sehun Jeong, and Hakjoo Oh. 2018. Precise and scalable points-to analysis via data-driven context tunneling.Proc. ACM Program. Lang.2, OOPSLA, Article 140 (Oct. 2018), 29 pages. doi:10.1145/3276510

    2018 doi

  23. [32]

    Haoxiang Jia, Ming Wen, Zifan Xie, Xiaochen Guo, Rongxin Wu, Maolin Sun, Kang Chen, and Hai Jin. 2023. Detecting JVM JIT compiler bugs via exploring two-dimensional input spaces. In2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 43–55

    2023

  24. [33]

    Vineet Kahlon. 2008. Bootstrapping: a technique for scalable flow and context-sensitive pointer alias analysis. In Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation(Tucson, AZ, USA)(PLDI ’08). ACM, New York, NY, USA, 249–259. doi:...

    2008

  25. [34]

    Vini Kanvar and Uday P Khedker. 2016. Heap abstractions for static analysis.ACM Comput. Surv.49, 2, Article 29 (June 2016), 47 pages. doi:10.1145/2931098

    2016 doi

  26. [35]

    George Kastrinis and Yannis Smaragdakis. 2013. Hybrid context-sensitivity for points-to analysis. InProceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation(Seattle, Washington, USA) (PLDI ’13). ACM, New York, NY, USA, 423–434. doi:10.11...

    2013

  27. [36]

    Jakub Křoustek, Peter Matula, and Petr Zemek. 2017. Retdec: An open-source machine-code decompiler. InJuly 2018

    2017

  28. [37]

    C LATTNER. 2005. Automatic pool allocation: Improving performance by controlling data structure layout in the heap. InProc. 2005 ACM SIGPLAN Conf. on Programming Language Design and Implementation (PLDI 2005). ACM, 129–142

    2005

  29. [39]

    Yuxiang Lei and Yulei Sui. 2019. Fast and Precise Handling of Positive Weight Cycles for Field-Sensitive Pointer Analysis. InStatic Analysis Symposium (SAS 2019) (Lecture Notes in Computer Science, Vol. 11822). Springer, 27–47

    2019

  30. [40]

    Yuxiang Lei, Yulei Sui, Shin Hwei Tan, and Qirun Zhang. 2023. Recursive State Machine Guided Graph Folding for Context-Free Language Reachability.Proceedings of the ACM on Programming Languages(2023). doi:10.1145/3591233

    2023 doi

  31. [41]

    Yue Li, Tian Tan, Anders Moller, and Yannis Smaragdakis. 2018. Scalability-First Pointer Analysis with Self-Tuning Context-Sensitivity. InProceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Eng...

    2018

  32. [42]

    Yue Li, Tian Tan, Yifei Zhang, and Jingling Xue. 2016. Program tailoring: Slicing by sequential criteria. In30th European Conference on Object-Oriented Programming (ECOOP 2016) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 56), Shriram Krishnamurthi and Benj...

    2016 doi

  33. [43]

    Yuanbo Li, Qirun Zhang, and Thomas Reps. 2020. Fast Graph Simplification for Interleaved Dyck-Reachability. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’20). ACM. doi:10.1145/3385412.3386021

    2020

  34. [44]

    Bozhen Liu and Jeff Huang. 2018. D4: fast concurrency debugging with parallel differential analysis. InProceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation(Philadelphia, PA, USA) (PLDI 2018). ACM, New York, NY, USA, 359–373. doi:10.1...

    2018

  35. [45]

    Hongzhi Liu, Jie Luo, Ying Li, and Zhonghai Wu. 2021. Iterative Compilation Optimization Based on Metric Learning and Collaborative Filtering.ACM Trans. Archit. Code Optim.19, 1, Article 2, 25 pages. doi:10.1145/3480250

    2021 doi

  36. [46]

    Zhibo Liu, Yuanyuan Yuan, Shuai Wang, and Yuyan Bao. 2022. Sok: Demystifying binary lifters through the lens of downstream applications. In2022 IEEE Symposium on Security and Privacy (SP). IEEE, 1100–1119

    2022

  37. [47]

    John Lu and Keith D Cooper. 1997. Register promotion in C programs. InProceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation. 308–319

    1997

  38. [48]

    Yi Lu, Lei Shang, Xinwei Xie, and Jingling Xue. 2013. An incremental points-to analysis with CFL-reachability. In Proceedings of the 22Nd International Conference on Compiler Construction(Rome, Italy)(CC’13). Springer-Verlag, Berlin, Heidelberg, 61–81. doi:10.1007/978-3-642-37051-9_4

    2013 doi

  39. [49]

    Rahim Mammadli, Ali Jannesari, and Felix Wolf. 2020. Static Neural Compiler Optimization via Deep Reinforcement Learning. arXiv:2008.08951 [cs.LG]

    2020 arXiv

  40. [50]

    Augustine Mathew and Keshav Pingali. 2010. Parallel inclusion-based points-to analysis. InProceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications(Reno/Tahoe, Nevada, , Vol. 3, No. 1, Article 1. Publication date: October...

    2010

  41. [51]

    D.G. Melski. 2002.Interprocedural Path Profiling and the Interprocedural Express-Lane Transformation. Ph. D. Dissertation. Comp. Sci. Dept., Univ. of Wisconsin, Madison, WI. Tech. Rep. 1435

    2002

  42. [52]

    Mario Mendez-Lojo, Martin Burtscher, and Keshav Pingali. 2012. A GPU Implementation of Inclusion-based Points-to Analysis. InProceedings of the 17th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming(New Orleans, Louisiana, USA)(PPoPP ’12). ACM, New York,...

    2012

  43. [53]

    C Mendis, C Yang, Y Pu, S Amarasinghe, and M Carbin. 2019. Compiler Auto-Vectorization with Imitation Learning. In NeurIPS’19, Vol. 32

    2019

  44. [54]

    Nomair A Naeem and Ondrej Lhoták. 2009. Efficient alias set analysis using SSA form. InProceedings of the 2009 International Symposium on Memory Management(Dublin, Ireland)(ISMM ’09). ACM, New York, NY, USA, 79–88. doi:10.1145/1542431.1542443

    2009

  45. [55]

    Nagaraj and R

    V. Nagaraj and R. Govindarajan. 2013. Parallel flow-sensitive pointer analysis by graph-rewriting. InProceedings of the 22Nd International Conference on Parallel Architectures and Compilation Techniques(Edinburgh, Scotland, UK)(PACT ’13). IEEE Press, Piscataway, NJ, USA, 19–28...

    2013

  46. [56]

    K. S. Namjoshi and Z. Pavlinovic. 2018. The Impact of Program Transformations on Static Program Analysis. InStatic Analysis, A. Podelski (Ed.). Springer International Publishing, Cham, 306–325

    2018

  47. [57]

    Alessandro Orso, Taweesup Apiwattanapong, James Law, Gregg Rothermel, and Mary Jean Harrold. 2004. An Empirical Comparison of Dynamic Impact Analysis Algorithms. InProceedings of the 26th International Conference on Software Engineering (ICSE ’04). IEEE Computer Society, Washi...

    2004

  48. [58]

    EunJung Park, John Cavazos, and Marco A. Alvarez. 2012. Using graph-based program characterization for predictive modeling. InProceedings of the 10th International Symposium on Code Generation and Optimization. ACM, 196–206

    2012

  49. [59]

    Eunjung Park, Sameer Kulkarni, and John Cavazos. 2011. An evaluation of different modeling techniques for iterative compilation. InProceedings of the 14th International Conference on Compilers, Architectures and Synthesis for Embedded Systems. ACM, 65–74

    2011

  50. [60]

    Pearce, Paul H

    David J. Pearce, Paul H. J. Kelly, and Chris Hankin. 2003. Online Cycle Detection and Difference Propagation for Pointer Analysis. InProceedings of the Third IEEE International Workshop on Source Code Analysis and Manipulation. IEEE, 3–12

    2003

  51. [61]

    Fernando Magno Quintao Pereira and Daniel Berlin. 2009. Wave propagation and deep propagation for pointer analysis. In2009 International Symposium on Code Generation and Optimization. IEEE, 126–135

    2009

  52. [62]

    Suresh Purini and Lakshya Jain. 2013. Finding good optimization sequences covering program space.ACM Transactions on Architecture and Code Optimization (TACO)9, 4 (2013), 56

    2013

  53. [63]

    Xavier Rival and Laurent Mauborgne. 2007. The trace partitioning abstract domain.ACM Transactions on Programming Languages and Systems (TOPLAS)29, 5 (2007), 26–es

    2007

  54. [64]

    Barry K Rosen, Mark N Wegman, and F Kenneth Zadeck. 1988. Global value numbers and redundant computations. In Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. 12–27

    1988

  55. [65]

    Atanas Rountev and Satish Chandra. 2000. Off-Line Variable Substitution for Scaling Points-to Analysis. InProceedings of the ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI ’00). ACM. doi:10. 1145/349299.349310

    2000

  56. [66]

    Atanas Rountev, Mariana Sharp, and Guoqing Xu. 2008. IDE dataflow analysis in the presence of large object-oriented libraries. InInternational Conference on Compiler Construction. Springer, 53–68

    2008

  57. [67]

    Sriram Sankaranarayanan, Franjo Ivancic, Ilya Shlyakhter, and Aarti Gupta. 2006. Static analysis in disjunctive numerical domains. InSAS (LNCS, Vol. 4134). Springer, 3–17

    2006

  58. [68]

    Lei Shang, Xinwei Xie, and Jingling Xue. 2012. On-demand dynamic summary-based points-to analysis. InProceedings of the Tenth International Symposium on Code Generation and Optimization(San Jose, California)(CGO ’12). ACM, New York, NY, USA, 264–274. doi:10.1145/2259016.2259050

    2012

  59. [69]

    Sharma, I

    R. Sharma, I. Dillig, T. Dillig, and A. Aiken. 2011. Simplifying Loop Invariant Generation Using Splitter Predicates. In CA V

    2011

  60. [70]

    Qingkai Shi, Yongchao Wang, Peisen Yao, and Charles Zhang. 2022. Indexing the extended dyck-cfl reachability for context-sensitive program analysis.Proceedings of the ACM on Programming Languages6, OOPSLA2 (2022), 1438–1468

    2022

  61. [71]

    Qingkai Shi, Xiao Xiao, Rongxin Wu, Jinguo Zhou, Gang Fan, and Charles Zhang. 2018. Pinpoint: fast and precise sparse value flow analysis for million lines of code. InProceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation(Philadelphia,...

    2018

  62. [72]

    Yannis Smaragdakis, George Kastrinis, and George Balatsouras. 2014. Introspective analysis: context-sensitivity, across the board. InProceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (Edinburgh, United Kingdom)(PLDI ’14). ACM, New...

    2014

  63. [73]

    Manu Sridharan and Rastislav Bodík. 2006. Refinement-based context-sensitive points-to analysis for Java. InProceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation(Ottawa, Ontario, Canada) (PLDI ’06). ACM, New York, NY, USA, 387–400. do...

    2006

  64. [74]

    Manu Sridharan, Stephen J Fink, and Rastislav Bodik. 2007. Thin slicing. InProceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation(San Diego, California, USA)(PLDI ’07). ACM, New York, NY, USA, 112–122. doi:10.1145/1250734.1250748

    2007

  65. [75]

    Manu Sridharan, Denis Gopan, Lexin Shan, and Rastislav Bodík. 2005. Demand-driven points-to analysis for Java. In Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications(San Diego, CA, USA)(OOPSLA ’05). ACM, Ne...

    2005

  66. [76]

    Mark Stephenson, Saman Amarasinghe, Martin Martin, and Una-May O’Reilly. 2003. Meta Optimization: Improving Compiler Heuristics with Machine Learning. InProceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation (PLDI ’03)

    2003

  67. [77]

    Yulei Sui, Peng Di, and Jingling Xue. 2016. Sparse flow-sensitive pointer analysis for multithreaded programs. In Proceedings of the 2016 International Symposium on Code Generation and Optimization(Barcelona, Spain)(CGO ’16). ACM, New York, NY, USA, 160–170. doi:10.1145/285403...

    2016

  68. [78]

    Yulei Sui and Jingling Xue. 2016. On-demand strong update analysis via value-flow refinement. InProceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering(Seattle, WA, USA)(FSE 2016). ACM, New York, NY, USA, 460–473. doi:10.1145/295...

    2016

  69. [79]

    Yulei Sui and Jingling Xue. 2016. SVF: interprocedural static value-flow analysis in LLVM. InProceedings of the 25th International Conference on Compiler Construction(Barcelona, Spain)(CC 2016). ACM, New York, NY, USA, 265–266. doi:10.1145/2892208.2892235

    2016

  70. [80]

    Sui and J

    Y. Sui and J. Xue. 2018. Value-Flow-Based Demand-Driven Pointer Analysis for C and C++.IEEE Transactions on Software Engineering(2018), 1–1. doi:10.1109/TSE.2018.2869336

    2018

  71. [81]

    Yulei Sui, Ding Ye, and Jingling Xue. 2012. Static memory leak detection using full-sparse value-flow analysis. In Proceedings of the 2012 International Symposium on Software Testing and Analysis(Minneapolis, MN, USA)(ISSTA 2012). ACM, New York, NY, USA

    2012

  72. [82]

    Sundaresan, L

    V. Sundaresan, L. Hendren, C. Razafimahefa, R. Vallee-Rai, P. Lam, E. Gagnon, and C. Godin. 2000. Practical Virtual Method Call Resolution for Java. InProceedings of the 15th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OO...

    2000

  73. [83]

    Omer Tripp, Marco Pistoia, Stephen J Fink, Manu Sridharan, and Omri Weisman. 2009. TAJ: effective taint analysis of web applications. InProceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation(Dublin, Ireland)(PLDI ’09). ACM, New York, N...

    2009

  74. [84]

    Mircea Trofin, Yundi Qian, Eugene Brevdo, Zinan Lin, Krzysztof Choromanski, and David Li. 2021. MLGO: a Machine Learning Guided Compiler Optimizations Framework.CoRRabs/2101.04808 (2021). arXiv:2101.04808

    2021 arXiv

  75. [85]

    Hans Vandierendonck, Sean Rul, and Koen De Bosschere. 2010. The paralax infrastructure: Automatic parallelization with a helping hand. InProceedings of the 19th international conference on Parallel architectures and compilation techniques. 389–400

    2010

  76. [86]

    Huanting Wang, Zhanyong Tang, Cheng Zhang, Jiaqi Zhao, Chris Cummins, Hugh Leather, and Zheng Wang. 2022. Automating reinforcement learning architecture design for code optimization

    2022

  77. [87]

    Kai Wang, Aftab Hussain, Zhiqiang Zuo, Guoqing Xu, and Ardalan Amiri Sani. 2017. Graspan: A Single-Machine Disk-Based Graph System for Interprocedural Static Analyses of Large-Scale Systems Code. InProceedings of the 22nd ACM International Conference on Architectural Support f...

    2017

  78. [88]

    Wei Wang, Clark Barrett, and Thomas Wies. 2017. Partitioned memory models for program analysis. InVerification, Model Checking, and Abstract Interpretation: 18th International Conference, VMCAI 2017. Springer, 539–558

    2017

  79. [89]

    Xiao Xiao, Qirun Zhang, Jinguo Zhou, and Charles Zhang. 2014. Persistent pointer information. InProceedings of the 35th ACM SIGPLAN conference on Programming Language Design and Implementation. 463–474

    2014

  80. [90]

    Dacong Yan, Guoqing Xu, and Atanas Rountev. 2011. Demand-driven context-sensitive alias analysis for Java. In Proceedings of the 2011 International Symposium on Software Testing and Analysis(Toronto, Ontario, Canada)(ISSTA ’11). ACM, New York, NY, USA, 155–165. doi:10.1145/200...

    2011

  81. [91]

    Hua Yan, Yulei Sui, Shiping Chen, and Jingling Xue. 2018. Spatio-temporal context reduction: a pointer-analysis-based static approach for detecting use-after-free vulnerabilities. InProceedings of the 40th International Conference on Software Engineering(Gothenburg, Sweden)(IC...

    2018

  82. [92]

    Zhenyu Yan, Xin Zhang, and Peng Di. 2024. Scaling Abstraction Refinement for Program Analyses in Datalog using Graph Neural Networks.Proceedings of the ACM on Programming Languages8, OOPSLA2 (2024), 1532–1560

    2024

  83. [93]

    Jisheng Zhao, Michael G Burke, and Vivek Sarkar. 2018. Parallel sparse flow-sensitive points-to analysis. InProceedings of the 27th International Conference on Compiler Construction(Vienna, Austria)(CC 2018). ACM, New York, NY, USA, 59–70. doi:10.1145/3178372.3179517 , Vol. 3,...

    2018

  84. [94]

    Xin Zheng and Radu Rugina. 2008. Demand-driven alias analysis for C. InProceedings of the 35th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages(San Francisco, California, USA)(POPL ’08). ACM, New York, NY, USA, 197–208. doi:10.1145/1328438.1328464

    2008

  85. [95]

    Anshunkang Zhou, Chengfeng Ye, Heqing Huang, Yuandao Cai, and Charles Zhang. 2024. Plankton: Reconciling Binary Code and Debug Information. InProceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2...

    2024

  86. [96]

    Zhiqiang Zuo, Yiyu Zhang, Qiuhong Pan, Shenming Lu, Yue Li, Linzhang Wang, Xuandong Li, and Guoqing Harry Xu. 2021. Chianina: An evolving graph system for flow-and context-sensitive analyses of million lines of C code. In Proceedings of the 42nd ACM SIGPLAN International Confe...

    2021

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.