• Li T, Bai J, Sui Y and Hu S. (2024). SPATA: Effective OS Bug Detection with Summary-Based, Alias-Aware, and Path-Sensitive Typestate Analysis. ACM Transactions on Computer Systems. 42:3-4. (1-40). Online publication date: 30-Nov-2024.

    https://doi.org/10.1145/3695250

  • Venev H, Gehr T, Dimitrov D and Vechev M. (2024). Modular Synthesis of Efficient Quantum Uncomputation. Proceedings of the ACM on Programming Languages. 8:OOPSLA2. (2097-2124). Online publication date: 8-Oct-2024.

    https://doi.org/10.1145/3689785

  • Li J, Gao W, Li Y and Han L. (2024). An Improved Method for Control Dependency in LLVM 2024 5th International Conference on Intelligent Computing and Human-Computer Interaction (ICHCI). 10.1109/ICHCI63580.2024.10808046. 979-8-3503-6828-4. (291-294).

    https://ieeexplore.ieee.org/document/10808046/

  • Högberg J. Modeling Erlang Compiler IR as SMT Formulas. Proceedings of the 23rd ACM SIGPLAN International Workshop on Erlang. (45-54).

    https://doi.org/10.1145/3677995.3678193

  • Li K, Xue Y, Chen S, Liu H, Sun K, Hu M, Wang H, Liu Y and Chen Y. (2024). Static Application Security Testing (SAST) Tools for Smart Contracts: How Far Are We?. Proceedings of the ACM on Software Engineering. 1:FSE. (1447-1470). Online publication date: 12-Jul-2024.

    https://doi.org/10.1145/3660772

  • Lesbre D and Lemerre M. (2024). Compiling with Abstract Interpretation. Proceedings of the ACM on Programming Languages. 8:PLDI. (368-393). Online publication date: 20-Jun-2024.

    https://doi.org/10.1145/3656392

  • McMichen T, Greiner N, Zhong P, Sossai F, Patel A and Campanoni S. Representing Data Collections in an SSA Form. Proceedings of the 2024 IEEE/ACM International Symposium on Code Generation and Optimization. (308-321).

    https://doi.org/10.1109/CGO57630.2024.10444817

  • Sugita S, Koizumi T, Shioya R, Irie H and Sakai S. A Sound and Complete Algorithm for Code Generation in Distance-Based ISA. Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. (73-84).

    https://doi.org/10.1145/3578360.3580263

  • Herklotz Y, Demange D and Blazy S. Mechanised Semantics for Gated Static Single Assignment. Proceedings of the 12th ACM SIGPLAN International Conference on Certified Programs and Proofs. (182-196).

    https://doi.org/10.1145/3573105.3575681

  • Lemerre M. (2023). SSA Translation Is an Abstract Interpretation. Proceedings of the ACM on Programming Languages. 7:POPL. (1895-1924). Online publication date: 9-Jan-2023.

    https://doi.org/10.1145/3571258

  • Yanase Y and Sumikawa Y. (2023). Lazy Demand-driven Partial Redundancy Elimination. Journal of Information Processing. 10.2197/ipsjjip.31.459. 31:0. (459-468).

    https://www.jstage.jst.go.jp/article/ipsjjip/31/0/31_459/_article

  • Bhagyanath A and Schneider K. (2022). Buffer Allocation for Exposed Datapath Architectures 2022 IEEE 15th International Symposium on Embedded Multicore/Many-core Systems-on-Chip (MCSoC). 10.1109/MCSoC57363.2022.00013. 978-1-6654-6499-4. (18-25).

    https://ieeexplore.ieee.org/document/10008420/

  • Kapila D, Dileep Kumar Y, Pant B, Jayapratha T, Kakoli Rao A and Gehlot A. (2022). Design and analysis of the Chameleon scheduling algorithm for reconfigurable computing 2022 2nd International Conference on Technological Advancements in Computational Sciences (ICTACS). 10.1109/ICTACS56270.2022.9987765. 978-1-6654-7657-7. (811-816).

    https://ieeexplore.ieee.org/document/9987765/

  • Frenkel H, Grumberg O, Păsăreanu C and Sheinvald S. (2022). Assume, guarantee or repair: a regular framework for non regular properties. International Journal on Software Tools for Technology Transfer. 10.1007/s10009-022-00669-9. 24:5. (667-689). Online publication date: 1-Oct-2022.

    https://link.springer.com/10.1007/s10009-022-00669-9

  • Hedenborg M, Lundberg J, Löwe W and Trapp M. (2022). A Framework for Memory Efficient Context-Sensitive Program Analysis. Theory of Computing Systems. 10.1007/s00224-022-10093-w. 66:5. (911-956). Online publication date: 1-Oct-2022.

    https://link.springer.com/10.1007/s00224-022-10093-w

  • Fischer A, Fuhry B, Kußmaul J, Janneck J, Kerschbaum F and Bodden E. (2022). Computation on Encrypted Data Using Dataflow Authentication. ACM Transactions on Privacy and Security. 25:3. (1-36). Online publication date: 31-Aug-2022.

    https://doi.org/10.1145/3513005

  • Rocha R, Petoumenos P, Franke B, Bhatotia P and O'Boyle M. Loop rolling for code size reduction. Proceedings of the 20th IEEE/ACM International Symposium on Code Generation and Optimization. (217-229).

    https://doi.org/10.1109/CGO53902.2022.9741256

  • Frenkel H, Grumberg O, Rothenberg B and Sheinvald S. (2022). Automated Program Repair Using Formal Verification Techniques. Principles of Systems Design. 10.1007/978-3-031-22337-2_25. (511-534).

    https://link.springer.com/10.1007/978-3-031-22337-2_25

  • Mirliaz S and Pichardie D. (2022). A Flow-Insensitive-Complete Program Representation. Verification, Model Checking, and Abstract Interpretation. 10.1007/978-3-030-94583-1_10. (197-218).

    https://link.springer.com/10.1007/978-3-030-94583-1_10

  • Singer J. (2022). Introduction. SSA-based Compiler Design. 10.1007/978-3-030-80515-9_1. (3-12).

    https://link.springer.com/10.1007/978-3-030-80515-9_1

  • Koizumi T, Sugita S, Shioya R, Kadomoto J, Irie H and Sakai S. (2021). Compiling and Optimizing Real-world Programs for STRAIGHT ISA 2021 IEEE 39th International Conference on Computer Design (ICCD). 10.1109/ICCD53106.2021.00070. 978-1-6654-3219-1. (400-408).

    https://ieeexplore.ieee.org/document/9643774/

  • Deworetzki N and Meyer U. Program analysis for reversible languages. Proceedings of the 10th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. (13-18).

    https://doi.org/10.1145/3460946.3464314

  • Chen D, Lim W, Bakhshalipour M, Gibbons P, Hoe J and Parno B. HerQules: securing programs via hardware-enforced message queues. Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. (773-788).

    https://doi.org/10.1145/3445814.3446736

  • Kutrib M, Meyer U, Deworetzki N and Schuster M. (2021). Compiling Janus to RSSA. Reversible Computation. 10.1007/978-3-030-79837-6_4. (64-78).

    https://link.springer.com/10.1007/978-3-030-79837-6_4

  • Reissmann N, Meyer J, Bahmann H and Själander M. (2020). RVSDG. ACM Transactions on Embedded Computing Systems. 10.1145/3391902. 19:6. (1-28). Online publication date: 1-Dec-2020.

    https://dl.acm.org/doi/10.1145/3391902

  • Banerjee S, Devecsery D, Chen P and Narayanasamy S. (2020). Sound garbage collection for C using pointer provenance. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-28). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428244

  • Schuiki F, Kurth A, Grosser T and Benini L. LLHD: a multi-level intermediate representation for hardware description languages. Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. (258-271).

    https://doi.org/10.1145/3385412.3386024

  • Fischer A, Fuhry B, Kerschbaum F and Bodden E. (2020). Computation on Encrypted Data using Dataflow Authentication. Proceedings on Privacy Enhancing Technologies. 10.2478/popets-2020-0002. 2020:1. (5-25). Online publication date: 1-Jan-2020.. Online publication date: 1-Jan-2020.

    https://petsymposium.org/popets/2020/popets-2020-0002.php

  • Frenkel H, Grumberg O, Pasareanu C and Sheinvald S. (2020). Assume, Guarantee or Repair. Tools and Algorithms for the Construction and Analysis of Systems. 10.1007/978-3-030-45190-5_12. (211-227).

    http://link.springer.com/10.1007/978-3-030-45190-5_12

  • Borzacchiello L, Coppa E, Cono D'Elia D and Demetrescu C. (2019). Memory models in symbolic execution: key ideas and new thoughts. Software Testing, Verification and Reliability. 10.1002/stvr.1722. 29:8. Online publication date: 1-Dec-2019.

    https://onlinelibrary.wiley.com/doi/10.1002/stvr.1722

  • Sun H, Fey F, Zhao J and Gorlatch S. WCCV. Proceedings of the ACM International Conference on Supercomputing. (319-329).

    https://doi.org/10.1145/3330345.3331059

  • Banerjee S, Devecsery D, Chen P and Narayanasamy S. (2019). Iodine: Fast Dynamic Taint Tracking Using Rollback-free Optimistic Hybrid Analysis 2019 IEEE Symposium on Security and Privacy (SP). 10.1109/SP.2019.00043. 978-1-5386-6660-9. (490-504).

    https://ieeexplore.ieee.org/document/8835304/

  • Mathur U, Madhusudan P and Viswanathan M. (2019). Decidable verification of uninterpreted programs. Proceedings of the ACM on Programming Languages. 3:POPL. (1-29). Online publication date: 2-Jan-2019.

    https://doi.org/10.1145/3290359

  • Babu J, Murali Krishnan K and Paleri V. (2019). A Fix-Point Characterization of Herbrand Equivalence of Expressions in Data Flow Frameworks. Logic and Its Applications. 10.1007/978-3-662-58771-3_15. (160-172).

    https://link.springer.com/10.1007/978-3-662-58771-3_15

  • Borrego D and Gómez-López M. (2019). Diagnosing Business Processes. Fault Diagnosis of Dynamic Systems. 10.1007/978-3-030-17728-7_16. (389-408).

    http://link.springer.com/10.1007/978-3-030-17728-7_16

  • Koizumi T, Nakae S, Fukuda A, Irie H and Sakai S. (2018). Reduction of Instruction Increase Overhead by STRAIGHT Compiler 2018 Sixth International Symposium on Computing and Networking Workshops (CANDARW). 10.1109/CANDARW.2018.00026. 978-1-5386-9184-7. (92-98).

    https://ieeexplore.ieee.org/document/8590880/

  • Irie H, Koizumi T, Fukuda A, Akaki S, Nakae S, Bessho Y, Shioya R, Notsu T, Yoda K, Ishihara T and Sakai S. STRAIGHT. Proceedings of the 51st Annual IEEE/ACM International Symposium on Microarchitecture. (121-133).

    https://doi.org/10.1109/MICRO.2018.00019

  • Maalej M, Paisante V, Magno Quinto Pereira F and Gonnord L. (2018). Combining range and inequality information for pointer disambiguation. Science of Computer Programming. 152:C. (161-184). Online publication date: 15-Jan-2018.

    https://doi.org/10.1016/j.scico.2017.10.014

  • Chandra K and Bodik R. (2017). Bonsai: synthesis-based reasoning for type systems. Proceedings of the ACM on Programming Languages. 2:POPL. (1-34). Online publication date: 1-Jan-2018.

    https://doi.org/10.1145/3158150

  • Zhang Y and Zuck L. (2018). Formal Verification of Optimizing Compilers. Distributed Computing and Internet Technology. 10.1007/978-3-319-72344-0_3. (50-65).

    http://link.springer.com/10.1007/978-3-319-72344-0_3

  • Tsai M, Wang B and Yang B. Certified Verification of Algebraic Properties on Low-Level Mathematical Constructs in Cryptographic Programs. Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security. (1973-1987).

    https://doi.org/10.1145/3133956.3134076

  • Roy T and Hsiao M. (2017). Reachability analysis in RTL circuits using k-induction bounded model checking 2017 IEEE International High-Level Design Validation and Test Workshop (HLDVT). 10.1109/HLDVT.2017.8167457. 978-1-5090-3997-5. (9-16).

    http://ieeexplore.ieee.org/document/8167457/

  • Torrens P, Vasconcellos C and Gonçalves J. A hybrid intermediate language between SSA and CPS. Proceedings of the 21st Brazilian Symposium on Programming Languages. (1-3).

    https://doi.org/10.1145/3125374.3125377

  • Sekiyama T and Igarashi A. (2017). Stateful manifest contracts. ACM SIGPLAN Notices. 52:1. (530-544). Online publication date: 11-May-2017.

    https://doi.org/10.1145/3093333.3009875

  • Ansar K and Saleena N. (2017). Redundancy elimination using Global Value Numbering 2017 Second International Conference on Electrical, Computer and Communication Technologies (ICECCT). 10.1109/ICECCT.2017.8117875. 978-1-5090-3239-6. (1-5).

    http://ieeexplore.ieee.org/document/8117875/

  • Quiroga J and Ortin F. (2017). SSA Transformations to Facilitate Type Inference in Dynamically Typed Code. The Computer Journal. 10.1093/comjnl/bxw108.

    https://academic.oup.com/comjnl/article-lookup/doi/10.1093/comjnl/bxw108

  • Sekiyama T and Igarashi A. Stateful manifest contracts. Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages. (530-544).

    https://doi.org/10.1145/3009837.3009875

  • Pai R. (2016). Detection of redundant expressions. Computer Languages, Systems and Structures. 46:C. (167-181). Online publication date: 1-Nov-2016.

    https://doi.org/10.1016/j.cl.2016.07.006

  • Grosser T and Hoefler T. Polly-ACC Transparent compilation to heterogeneous hardware. Proceedings of the 2016 International Conference on Supercomputing. (1-13).

    https://doi.org/10.1145/2925426.2926286

  • Backes M, Bugiel S, Derr E, Gerling S and Hammer C. R-Droid. Proceedings of the 11th ACM on Asia Conference on Computer and Communications Security. (129-140).

    https://doi.org/10.1145/2897845.2897927

  • Buchwald S, Lohner D and Ullrich S. Verified construction of static single assignment form. Proceedings of the 25th International Conference on Compiler Construction. (67-76).

    https://doi.org/10.1145/2892208.2892211

  • Mogensen T. (2016). RSSA: A Reversible SSA Form. Perspectives of System Informatics. 10.1007/978-3-319-41579-6_16. (203-217).

    http://link.springer.com/10.1007/978-3-319-41579-6_16

  • (2015). MEDIC. Information and Software Technology. 68:C. (1-17). Online publication date: 1-Dec-2015.

    https://doi.org/10.1016/j.infsof.2015.07.009

  • Ko Y, Burgstaller B and Scholz B. (2015). LaminarIR: compile-time queues for structured streams. ACM SIGPLAN Notices. 50:6. (121-130). Online publication date: 7-Aug-2015.

    https://doi.org/10.1145/2813885.2737994

  • GANGE G, NAVAS J, SCHACHTE P, SØNDERGAARD H and STUCKEY P. (2015). Horn clauses as an intermediate representation for program analysis and transformation. Theory and Practice of Logic Programming. 10.1017/S1471068415000204. 15:4-5. (526-542). Online publication date: 1-Jul-2015.

    http://www.journals.cambridge.org/abstract_S1471068415000204

  • Ko Y, Burgstaller B and Scholz B. LaminarIR: compile-time queues for structured streams. Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. (121-130).

    https://doi.org/10.1145/2737924.2737994

  • Bagri S, Gent K and Hsiao M. (2015). Signal domain based reachability analysis in RTL circuits 2015 16th International Symposium on Quality Electronic Design (ISQED). 10.1109/ISQED.2015.7085434. 978-1-4799-7581-5. (250-256).

    http://ieeexplore.ieee.org/document/7085434/

  • Cuervo Parrino B, Galeotti J, Garbervetsky D and Frias M. (2015). TacoFlow. Software and Systems Modeling (SoSyM). 14:1. (45-63). Online publication date: 1-Feb-2015.

    https://doi.org/10.1007/s10270-014-0401-9

  • Aichernig B, Jöbstl E and Tiran S. (2015). Model-based mutation testing via symbolic refinement checking. Science of Computer Programming. 97:P4. (383-404). Online publication date: 1-Jan-2015.

    https://doi.org/10.1016/j.scico.2014.05.004

  • Demange D, Pichardie D and Stefanesco L. (2015). Verifying Fast and Sparse SSA-Based Optimizations in Coq. Compiler Construction. 10.1007/978-3-662-46663-6_12. (233-252).

    http://link.springer.com/10.1007/978-3-662-46663-6_12

  • Pai R. (2015). Detection of Redundant Expressions: A Complete and Polynomial-Time Algorithm in SSA. Programming Languages and Systems. 10.1007/978-3-319-26529-2_4. (49-65).

    http://link.springer.com/10.1007/978-3-319-26529-2_4

  • Holt B, Briggs P, Ceze L and Oskin M. (2014). Alembic. ACM SIGPLAN Notices. 49:10. (879-894). Online publication date: 31-Dec-2015.

    https://doi.org/10.1145/2714064.2660194

  • Anger E, Yalamanchili S, Pakin S and McCormick P. Architecture-independent modeling of intra-node data movement. Proceedings of the 2014 LLVM Compiler Infrastructure in HPC. (29-39).

    https://doi.org/10.1109/LLVM-HPC.2014.6

  • Chen Y, Hsu C, Lin H, Schwabe P, Tsai M, Wang B, Yang B and Yang S. Verifying Curve25519 Software. Proceedings of the 2014 ACM SIGSAC Conference on Computer and Communications Security. (299-309).

    https://doi.org/10.1145/2660267.2660370

  • Holt B, Briggs P, Ceze L and Oskin M. Alembic. Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications. (879-894).

    https://doi.org/10.1145/2660193.2660194

  • Collingbourne P, Cadar C and Kelly P. (2014). Symbolic Crosschecking of Data-Parallel Floating-Point Code. IEEE Transactions on Software Engineering. 40:7. (710-737). Online publication date: 1-Jul-2014.

    https://doi.org/10.1109/TSE.2013.2297120

  • Rafael de Assis Costa I, Nazaré Santos H, Rafael Alves P and Magno Quintão Pereira F. (2014). Just-in-time value specialization. Computer Languages, Systems & Structures. 10.1016/j.cl.2013.11.001. 40:2. (37-52). Online publication date: 1-Jul-2014.

    https://linkinghub.elsevier.com/retrieve/pii/S1477842413000286

  • Liu C, Huang Y, Shi E, Katz J and Hicks M. Automating Efficient RAM-Model Secure Computation. Proceedings of the 2014 IEEE Symposium on Security and Privacy. (623-638).

    https://doi.org/10.1109/SP.2014.46

  • Kintis M and Malevris N. Using Data Flow Patterns for Equivalent Mutant Detection. Proceedings of the 2014 IEEE International Conference on Software Testing, Verification, and Validation Workshops. (196-205).

    https://doi.org/10.1109/ICSTW.2014.21

  • Saleena N and Paleri V. Global value numbering for redundancy detection. Proceedings of the 29th Annual ACM Symposium on Applied Computing. (1609-1611).

    https://doi.org/10.1145/2554850.2555120

  • Barthe G, Demange D and Pichardie D. (2014). Formal Verification of an SSA-Based Middle-End for CompCert. ACM Transactions on Programming Languages and Systems. 36:1. (1-35). Online publication date: 1-Mar-2014.

    https://doi.org/10.1145/2579080

  • Ahn W, Duan Y and Torrellas J. (2013). DeAliaser. ACM SIGPLAN Notices. 48:4. (167-180). Online publication date: 23-Apr-2013.

    https://doi.org/10.1145/2499368.2451136

  • Ahn W, Duan Y and Torrellas J. (2013). DeAliaser. ACM SIGARCH Computer Architecture News. 41:1. (167-180). Online publication date: 29-Mar-2013.

    https://doi.org/10.1145/2490301.2451136

  • Ahn W, Duan Y and Torrellas J. DeAliaser. Proceedings of the eighteenth international conference on Architectural support for programming languages and operating systems. (167-180).

    https://doi.org/10.1145/2451116.2451136

  • Santos H, Alves P, Costa I and Quintao Pereira F. Just-in-time value specialization. Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). (1-11).

    https://doi.org/10.1109/CGO.2013.6495006

  • Nowotka D and Traub J. (2013). Formal Verification of Concurrent Embedded Software. Embedded Systems: Design, Analysis and Verification. 10.1007/978-3-642-38853-8_20. (218-227).

    http://link.springer.com/10.1007/978-3-642-38853-8_20

  • Hung M, Chen P, Hwang Y, Ju R and Lee J. (2012). Support of Probabilistic Pointer Analysis in the SSA Form. IEEE Transactions on Parallel and Distributed Systems. 23:12. (2366-2379). Online publication date: 1-Dec-2012.

    https://doi.org/10.1109/TPDS.2012.73

  • Dias R, Pessanha V and Lourenço J. Precise detection of atomicity violations. Proceedings of the 8th international conference on Hardware and Software: verification and testing. (8-23).

    https://doi.org/10.1007/978-3-642-39611-3_8

  • Bloem R, Drechsler R, Fey G, Finder A, Hofferek G, Könighofer R, Raik J, Repinski U and Sülflow A. FoREnSiC. Proceedings of the 8th international conference on Hardware and Software: verification and testing. (260-265).

    https://doi.org/10.1007/978-3-642-39611-3_24

  • Alves P, de Assis Costa I, Pereira F and Figueiredo E. Parameter based constant propagation. Proceedings of the 16th Brazilian conference on Programming Languages. (57-71).

    https://doi.org/10.1007/978-3-642-33182-4_6

  • Aichernig B and Jobstl E. Efficient Refinement Checking for Model-Based Mutation Testing. Proceedings of the 2012 12th International Conference on Quality Software. (21-30).

    https://doi.org/10.1109/QSIC.2012.58

  • Model-based diagnosis versus error explanation. Proceedings of the Tenth ACM/IEEE International Conference on Formal Methods and Models for Codesign. (43-52).

    https://doi.org/10.1109/MEMCOD.2012.6292299

  • Boissinot B, Brisk P, Darte A and Rastello F. (2012). SSI Properties Revisited. ACM Transactions on Embedded Computing Systems. 11S:1. (1-23). Online publication date: 1-Jun-2012.

    https://doi.org/10.1145/2180887.2180898

  • Costa C, Moreira J, Januário G and Barreto P. Dynamic method to evaluate code optimization effectiveness. Proceedings of the 15th International Workshop on Software and Compilers for Embedded Systems. (62-71).

    https://doi.org/10.1145/2236576.2236583

  • Aichernig B and Jobstl E. Towards Symbolic Model-Based Mutation Testing. Proceedings of the 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation. (752-757).

    https://doi.org/10.1109/ICST.2012.169

  • Barthe G, Demange D and Pichardie D. A formally verified SSA-Based middle-end. Proceedings of the 21st European conference on Programming Languages and Systems. (47-66).

    https://doi.org/10.1007/978-3-642-28869-2_3

  • Hou C, Vulov G, Quinlan D, Jefferson D, Fujimoto R and Vuduc R. A new method for program inversion. Proceedings of the 21st international conference on Compiler Construction. (81-100).

    https://doi.org/10.1007/978-3-642-28652-0_5

  • Lippmeier B and Keller G. (2011). Efficient parallel stencil convolution in Haskell. ACM SIGPLAN Notices. 46:12. (59-70). Online publication date: 12-Jan-2012.

    https://doi.org/10.1145/2096148.2034684

  • Vulov G, Hou C, Vuduc R, Fujimoto R, Quinlan D and Jefferson D. The Backstroke framework for source level reverse computation applied to parallel discrete event simulation. Proceedings of the Winter Simulation Conference. (2965-2979).

    /doi/10.5555/2431518.2431870

  • Flexeder A, Müller-olm M, Petter M and Seidl H. (2012). Fast interprocedural linear two-variable equalities. ACM Transactions on Programming Languages and Systems. 33:6. (1-33). Online publication date: 1-Dec-2011.

    https://doi.org/10.1145/2049706.2049710

  • Vulov G, Hou C, Vuduc R, Fujimoto R, Quinlan D and Jefferson D. (2011). The Backstroke framework for source level reverse computation applied to parallel discrete event simulation 2011 Winter Simulation Conference - (WSC 2011). 10.1109/WSC.2011.6147998. 978-1-4577-2109-0. (2960-2974).

    http://ieeexplore.ieee.org/document/6147998/

  • Wang C and Wu Y. Modeling and Performance Evaluation of TSO-Preserving Binary Optimization. Proceedings of the 2011 International Conference on Parallel Architectures and Compilation Techniques. (383-392).

    https://doi.org/10.1109/PACT.2011.69

  • Lippmeier B and Keller G. Efficient parallel stencil convolution in Haskell. Proceedings of the 4th ACM symposium on Haskell. (59-70).

    https://doi.org/10.1145/2034675.2034684

  • Jimenez-Ramirez A, Gasca R and Varela-Vaca A. (2011). Contract-based test generation for data flow of business processes using constraint programming 2011 IEEE Fifth International Conference on Research Challenges in Information Science (RCIS). 10.1109/RCIS.2011.6006841. 978-1-4244-8670-0. (1-12).

    http://ieeexplore.ieee.org/document/6006841/

  • Collingbourne P, Cadar C and Kelly P. Symbolic crosschecking of floating-point and SIMD code. Proceedings of the sixth conference on Computer systems. (315-328).

    https://doi.org/10.1145/1966445.1966475

  • Karrenberg R and Hack S. Whole-function vectorization. Proceedings of the 9th Annual IEEE/ACM International Symposium on Code Generation and Optimization. (141-150).

    /doi/10.5555/2190025.2190061

  • Cong J, Liu B, Neuendorffer S, Noguera J, Vissers K and Zhang Z. (2011). High-Level Synthesis for FPGAs. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems. 30:4. (473-491). Online publication date: 1-Apr-2011.

    https://doi.org/10.1109/TCAD.2011.2110592

  • Karrenberg R and Hack S. (2011). Whole-function vectorization 2011 9th Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 10.1109/CGO.2011.5764682. 978-1-61284-356-8. (141-150).

    http://ieeexplore.ieee.org/document/5764682/

  • Tate R, Stepp M, Tatlock Z and Lerner S. (2011). Equality Saturation: A New Approach to Optimization. Logical Methods in Computer Science. 10.2168/LMCS-7(1:10)2011. Volume 7, Issue 1.

    https://lmcs.episciences.org/1016

  • Joyner M, Budimlić Z and Sarkar V. Subregion analysis and bounds check elimination for high level arrays. Proceedings of the 20th international conference on Compiler construction: part of the joint European conferences on theory and practice of software. (246-265).

    /doi/10.5555/1987237.1987256

  • Geuns S, Bekooij M, Bijlsma T and Corporaal H. (2011). Parallelization of while loops in nested loop programs for shared-memory multiprocessor systems 2011 Design, Automation & Test in Europe. 10.1109/DATE.2011.5763118. 978-3-9810801-8-6. (1-6).

    http://ieeexplore.ieee.org/document/5763118/

  • Hatanaka A and Bagherzadeh N. (2011). A scheduling approach for distributed resource architectures with scarce communication resources. International Journal of High Performance Systems Architecture. 3:1. (12-22). Online publication date: 1-Jan-2011.

    https://doi.org/10.1504/IJHPSA.2011.038054

  • Krishnan S and Asokan S. (2011). An Extension to Global Value Numbering. Advances in Computing and Communications. 10.1007/978-3-642-22726-4_8. (63-69).

    http://link.springer.com/10.1007/978-3-642-22726-4_8

  • Mansky W and Gunter E. A framework for formal verification of compiler optimizations. Proceedings of the First international conference on Interactive Theorem Proving. (371-386).

    https://doi.org/10.1007/978-3-642-14052-5_26

  • Fournet C, Le Guernic G and Rezk T. A security-preserving compiler for distributed programs. Proceedings of the 16th ACM conference on Computer and communications security. (432-441).

    https://doi.org/10.1145/1653662.1653715

  • Reichenbach C, Burke M, Peshansky I and Raghavachari M. (2009). Analysis of imperative XML programs. Information Systems. 34:7. (624-642). Online publication date: 1-Nov-2009.

    https://doi.org/10.1016/j.is.2009.03.013

  • Wang D, Zender C and Jenks S. (2009). Efficient clustered server-side data analysis workflows using SWAMP. Earth Science Informatics. 10.1007/s12145-009-0021-z. 2:3. (141-155). Online publication date: 1-Sep-2009.

    http://link.springer.com/10.1007/s12145-009-0021-z

  • Naeem N and Lhoták O. Efficient alias set analysis using SSA form. Proceedings of the 2009 international symposium on Memory management. (79-88).

    https://doi.org/10.1145/1542431.1542443

  • Ravitch T, Jackson S, Aderhold E and Liblit B. Automatic generation of library bindings using static analysis. Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation. (352-362).

    https://doi.org/10.1145/1542476.1542516

  • Ravitch T, Jackson S, Aderhold E and Liblit B. (2009). Automatic generation of library bindings using static analysis. ACM SIGPLAN Notices. 44:6. (352-362). Online publication date: 28-May-2009.

    https://doi.org/10.1145/1543135.1542516

  • Peng S, Gu Q and Chen D. (2009). Static Detection of Un-Trusted Variables in PHP Web Applications 2009 International Conference on E-Business and Information System Security (EBISS). 10.1109/EBISS.2009.5138078. 978-1-4244-4589-9. (1-5).

    https://ieeexplore.ieee.org/document/5138078/

  • (2009). References. Data Flow Analysis. 10.1201/9780849332517.bmatt. (371-378). Online publication date: 27-Mar-2009.

    http://www.crcnetbase.com/doi/10.1201/9780849332517.bmatt

  • Boissinot B, Darte A, Rastello F, de Dinechin B and Guillon C. Revisiting Out-of-SSA Translation for Correctness, Code Quality and Efficiency. Proceedings of the 7th annual IEEE/ACM International Symposium on Code Generation and Optimization. (114-125).

    https://doi.org/10.1109/CGO.2009.19

  • Tate R, Stepp M, Tatlock Z and Lerner S. (2009). Equality saturation. ACM SIGPLAN Notices. 44:1. (264-276). Online publication date: 21-Jan-2009.

    https://doi.org/10.1145/1594834.1480915

  • Tate R, Stepp M, Tatlock Z and Lerner S. Equality saturation. Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (264-276).

    https://doi.org/10.1145/1480881.1480915

  • Lhoták O and Hendren L. (2008). Evaluating the benefits of context-sensitive points-to analysis using a BDD-based implementation. ACM Transactions on Software Engineering and Methodology. 18:1. (1-53). Online publication date: 1-Sep-2008.

    https://doi.org/10.1145/1391984.1391987

  • D'Silva V, Kroening D and Weissenbacher G. (2008). A Survey of Automated Techniques for Formal Software Verification. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems. 27:7. (1165-1178). Online publication date: 1-Jul-2008.

    https://doi.org/10.1109/TCAD.2008.923410

  • Joyner M, Budimlic Z, Sarkar V and Rui Zhang . (2008). Array optimizations for parallel implementations of high productivity languages Distributed Processing Symposium (IPDPS). 10.1109/IPDPS.2008.4536185. 978-1-4244-1693-6. (1-8).

    http://ieeexplore.ieee.org/document/4536185/

  • Müller-Olm M and Seidl H. Upper adjoints for fast inter-procedural variable equalities. Proceedings of the Theory and practice of software, 17th European conference on Programming languages and systems. (178-192).

    /doi/10.5555/1792878.1792898

  • Groce A and Joshi R. (2008). Exploiting traces in static program analysis: better model checking through $${{\tt printf}}$$ s. International Journal on Software Tools for Technology Transfer. 10.1007/s10009-007-0058-6. 10:2. (131-144). Online publication date: 1-Mar-2008.

    http://link.springer.com/10.1007/s10009-007-0058-6

  • Müller-Olm M and Seidl H. Upper Adjoints for Fast Inter-procedural Variable Equalities. Programming Languages and Systems. 10.1007/978-3-540-78739-6_15. (178-192).

    http://link.springer.com/10.1007/978-3-540-78739-6_15

  • Srikant Y, Prakash Prabhu J and Shankar P. (2007). The Static Single Assignment Form. The Compiler Design Handbook. 10.1201/9781420043839.ch11. (11-1-11-54). Online publication date: 7-Dec-2007.

    http://www.crcnetbase.com/doi/10.1201/9781420043839.ch11

  • Nie J and Cheng X. An efficient SSA-based algorithm for complete global value numbering. Proceedings of the 5th Asian conference on Programming languages and systems. (319-334).

    /doi/10.5555/1784774.1784806

  • Johannes J. Source Code Composition with the Reuseware Composition Framework. Proceedings of the Seventh IEEE International Working Conference on Source Code Analysis and Manipulation. (159-160).

    https://doi.org/10.1109/SCAM.2007.26

  • Burke M, Peshansky I, Raghavachari M and Reichenbach C. Analysis of imperative XML programs. Proceedings of the 11th international conference on Database programming languages. (216-230).

    /doi/10.5555/1783534.1783556

  • Tiwari A and Gulwani S. Logical Interpretation. Proceedings of the 21st international conference on Automated Deduction: Automated Deduction. (147-166).

    https://doi.org/10.1007/978-3-540-73595-3_11

  • Amme W, Ronne J and Franz M. (2007). SSA-based mobile code. ACM Transactions on Architecture and Code Optimization. 4:2. (13-es). Online publication date: 1-Jun-2007.

    https://doi.org/10.1145/1250727.1250733

  • Brisk P and Sarrafzadeh M. Interference graphs for procedures in static single information form are interval graphs. Proceedingsof the 10th international workshop on Software & compilers for embedded systems. (101-110).

    https://doi.org/10.1145/1269843.1269858

  • Gulwani S and Tiwari A. Computing procedure summaries for interprocedural analysis. Proceedings of the 16th European Symposium on Programming. (253-267).

    /doi/10.5555/1762174.1762199

  • Agarwal S, Barik R, Sarkar V and Shyamasundar R. May-happen-in-parallel analysis of X10 programs. Proceedings of the 12th ACM SIGPLAN symposium on Principles and practice of parallel programming. (183-193).

    https://doi.org/10.1145/1229428.1229471

  • Nie J and Cheng X. An Efficient SSA-Based Algorithm for Complete Global Value Numbering. Programming Languages and Systems. 10.1007/978-3-540-76637-7_22. (319-334).

    http://link.springer.com/10.1007/978-3-540-76637-7_22

  • Burke M, Peshansky I, Raghavachari M and Reichenbach C. Analysis of Imperative XML Programs. Database Programming Languages. 10.1007/978-3-540-75987-4_15. (216-230).

    http://link.springer.com/10.1007/978-3-540-75987-4_15

  • Siebert F. Proving the absence of RTSJ related runtime errors through data flow analysis. Proceedings of the 4th international workshop on Java technologies for real-time and embedded systems. (152-161).

    https://doi.org/10.1145/1167999.1168025

  • Jhala R, Majumdar R and Xu R. Structural invariants. Proceedings of the 13th international conference on Static Analysis. (71-87).

    https://doi.org/10.1007/11823230_6

  • Chang B, Harren M and Necula G. Analysis of low-level code using cooperating decompilers. Proceedings of the 13th international conference on Static Analysis. (318-335).

    https://doi.org/10.1007/11823230_21

  • Matsuno Y and Ohori A. A type system equivalent to static single assignment. Proceedings of the 8th ACM SIGPLAN international conference on Principles and practice of declarative programming. (249-260).

    https://doi.org/10.1145/1140335.1140365

  • Groce A, Chaki S, Kroening D and Strichman O. (2005). Error explanation with distance metrics. International Journal on Software Tools for Technology Transfer. 10.1007/s10009-005-0202-0. 8:3. (229-247). Online publication date: 1-Jun-2006.

    http://link.springer.com/10.1007/s10009-005-0202-0

  • Mori A, Izumida T, Sawada T and Inoue T. A tool for analyzing and detecting malicious mobile code. Proceedings of the 28th international conference on Software engineering. (831-834).

    https://doi.org/10.1145/1134285.1134426

  • Cooper K, Grosul A, Harvey T, Reeves S, Subramanian D, Torczon L and Waterman T. (2006). Exploring the structure of the space of compilation sequences using randomized search algorithms. The Journal of Supercomputing. 36:2. (135-151). Online publication date: 1-May-2006.

    https://doi.org/10.1007/s11227-006-7954-5

  • Gulwani S and Tiwari A. Assertion checking over combined abstraction of linear arithmetic and uninterpreted functions. Proceedings of the 15th European conference on Programming Languages and Systems. (279-293).

    https://doi.org/10.1007/11693024_19

  • Gregor D and Schupp S. (2006). STLlint: lifting static checking from languages to libraries. Software—Practice & Experience. 36:3. (225-254). Online publication date: 1-Mar-2006.

    /doi/10.5555/1122568.1122569

  • Gregor D and Schupp S. (2005). STLlint: lifting static checking from languages to libraries. Software: Practice and Experience. 10.1002/spe.683. 36:3. (225-254). Online publication date: 1-Mar-2006.

    https://onlinelibrary.wiley.com/doi/10.1002/spe.683

  • Leino K and Logozzo F. Loop invariants on demand. Proceedings of the Third Asian conference on Programming Languages and Systems. (119-134).

    https://doi.org/10.1007/11575467_9

  • Ceballos R, Gasca R, Del Valle C and Borrego D. Diagnosing errors in dbc programs using constraint programming. Proceedings of the 11th Spanish association conference on Current Topics in Artificial Intelligence. (200-210).

    https://doi.org/10.1007/11881216_22

  • Probst C, Gal A and Franz M. Average case vs. worst case. Proceedings of the 2005 workshop on New security paradigms. (25-32).

    https://doi.org/10.1145/1146269.1146279

  • Narasamdya I and Voronkov A. Finding basic block and variable correspondence. Proceedings of the 12th international conference on Static Analysis. (251-267).

    https://doi.org/10.1007/11547662_18

  • Cooper K, Grosul A, Harvey T, Reeves S, Subramanian D, Torczon L and Waterman T. (2005). ACME. ACM SIGPLAN Notices. 40:7. (69-77). Online publication date: 12-Jul-2005.

    https://doi.org/10.1145/1070891.1065921

  • Cooper K, Grosul A, Harvey T, Reeves S, Subramanian D, Torczon L and Waterman T. ACME. Proceedings of the 2005 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems. (69-77).

    https://doi.org/10.1145/1065910.1065921

  • Minamide Y. Static approximation of dynamically generated Web pages. Proceedings of the 14th international conference on World Wide Web. (432-441).

    https://doi.org/10.1145/1060745.1060809

  • Müller-Olm M, Seidl H and Steffen B. Interprocedural herbrand equalities. Proceedings of the 14th European conference on Programming Languages and Systems. (31-45).

    https://doi.org/10.1007/978-3-540-31987-0_4

  • Le A, Lhoták O and Hendren L. Using inter-procedural side-effect information in JIT optimizations. Proceedings of the 14th international conference on Compiler Construction. (287-304).

    https://doi.org/10.1007/11406921_22

  • Pechtchanski I and Sarkar V. (2005). Immutability specification and its applications. Concurrency and Computation: Practice and Experience. 10.1002/cpe.853. 17:5-6. (639-662). Online publication date: 1-Apr-2005.

    https://onlinelibrary.wiley.com/doi/10.1002/cpe.853

  • Müller-Olm M, Rüthing O and Seidl H. Checking herbrand equalities and beyond. Proceedings of the 6th international conference on Verification, Model Checking, and Abstract Interpretation. (79-96).

    https://doi.org/10.1007/978-3-540-30579-8_6

  • Gulwani S, Tiwari A and Necula G. Join algorithms for the theory of uninterpreted functions. Proceedings of the 24th international conference on Foundations of Software Technology and Theoretical Computer Science. (311-323).

    https://doi.org/10.1007/978-3-540-30538-5_26

  • Chaki S, Groce A and Strichman O. (2004). Explaining abstract counterexamples. ACM SIGSOFT Software Engineering Notes. 29:6. (73-82). Online publication date: 1-Nov-2004.

    https://doi.org/10.1145/1041685.1029908

  • Chaki S, Groce A and Strichman O. Explaining abstract counterexamples. Proceedings of the 12th ACM SIGSOFT twelfth international symposium on Foundations of software engineering. (73-82).

    https://doi.org/10.1145/1029894.1029908

  • Odaira R and Hiraki K. Partial value number redundancy elimination. Proceedings of the 17th international conference on Languages and Compilers for High Performance Computing. (409-423).

    https://doi.org/10.1007/11532378_29

  • Almagor L, Cooper K, Grosul A, Harvey T, Reeves S, Subramanian D, Torczon L and Waterman T. (2004). Finding effective compilation sequences. ACM SIGPLAN Notices. 39:7. (231-239). Online publication date: 11-Jul-2004.

    https://doi.org/10.1145/998300.997196

  • Almagor L, Cooper K, Grosul A, Harvey T, Reeves S, Subramanian D, Torczon L and Waterman T. Finding effective compilation sequences. Proceedings of the 2004 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems. (231-239).

    https://doi.org/10.1145/997163.997196

  • von Ronne J, Wang N and Franz M. Interpreting programs in static single assignment form. Proceedings of the 2004 workshop on Interpreters, virtual machines and emulators. (23-30).

    https://doi.org/10.1145/1059579.1059585

  • Gulwani S and Necula G. Global value numbering using random interpretation. Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (342-352).

    https://doi.org/10.1145/964001.964030

  • Gulwani S and Necula G. (2004). Global value numbering using random interpretation. ACM SIGPLAN Notices. 39:1. (342-352). Online publication date: 1-Jan-2004.

    https://doi.org/10.1145/982962.964030

  • Teifel J and Manohar R. Static tokens: using data .ow to automate concurrent pipeline synthesis 10th International Symposium on Asynchronous Circuits and Systems, 2004.. 10.1109/ASYNC.2004.1299284. 0-7695-2133-9. (17-27).

    http://ieeexplore.ieee.org/document/1299284/

  • Stoutchinin A and Gao G. (2004). If-Conversion in SSA Form. Euro-Par 2004 Parallel Processing. 10.1007/978-3-540-27866-5_43. (336-345).

    http://link.springer.com/10.1007/978-3-540-27866-5_43

  • Gulwani S and Necula G. (2004). A Polynomial-Time Algorithm for Global Value Numbering. Static Analysis. 10.1007/978-3-540-27864-1_17. (212-227).

    http://link.springer.com/10.1007/978-3-540-27864-1_17

  • Groce A. (2004). Error Explanation with Distance Metrics. Tools and Algorithms for the Construction and Analysis of Systems. 10.1007/978-3-540-24730-2_8. (108-122).

    http://link.springer.com/10.1007/978-3-540-24730-2_8

  • VanDrunen T and Hosking A. (2004). Value-Based Partial Redundancy Elimination. Compiler Construction. 10.1007/978-3-540-24723-4_12. (167-184).

    http://link.springer.com/10.1007/978-3-540-24723-4_12

  • Marinov D and O'Callahan R. (2003). Object equality profiling. ACM SIGPLAN Notices. 38:11. (313-325). Online publication date: 26-Nov-2003.

    https://doi.org/10.1145/949343.949333

  • Marinov D and O'Callahan R. Object equality profiling. Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications. (313-325).

    https://doi.org/10.1145/949305.949333

  • Cooper K and Xu L. (2002). An efficient static analysis algorithm to detect redundant memory operations. ACM SIGPLAN Notices. 38:2 supplement. (97-107). Online publication date: 15-Feb-2003.

    https://doi.org/10.1145/773039.773049

  • Gulwani S and Necula G. (2003). Discovering affine equalities using random interpretation. ACM SIGPLAN Notices. 38:1. (74-84). Online publication date: 15-Jan-2003.

    https://doi.org/10.1145/640128.604138

  • Gulwani S and Necula G. Discovering affine equalities using random interpretation. Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (74-84).

    https://doi.org/10.1145/604131.604138

  • Hwang_cor Y and Saltz J. (2003). Interprocedural definition-use chains of dynamic pointer-linked data structures. Scientific Programming. 11:1. (3-37). Online publication date: 1-Jan-2003.

    https://doi.org/10.1155/2003/154169

  • Franz M, Amme W, Beers M, Dalton N, Frohlich P, Haldar V, Hartmann A, Housel P, Reig F, von Ronne J, Stork C and Zhenochin S. Making mobile code both safe and efficient Foundations of Intrusion Tolerant Systems, 2003 [Organically Assured and Survivable Information Systems]. 10.1109/FITS.2003.1264941. 0-7695-2057-X. (337-356).

    http://ieeexplore.ieee.org/document/1264941/

  • Pechtchanski I and Sarkar V. Immutability specification and its applications. Proceedings of the 2002 joint ACM-ISCOPE conference on Java Grande. (202-211).

    https://doi.org/10.1145/583810.583833

  • Srikant Y. (2002). Scalar Compiler Optimizations on the Static Single Assignment Form and the Flow Graph. The Compiler Design Handbook. 10.1201/9781420040579.ch3. Online publication date: 25-Sep-2002.

    http://www.crcnetbase.com/doi/10.1201/9781420040579.ch3

  • Luk C, Muth R, Patil H, Weiss R, Lowney P and Cohn R. Profile-guided post-link stride prefetching. Proceedings of the 16th international conference on Supercomputing. (167-178).

    https://doi.org/10.1145/514191.514217

  • Gargi K. A sparse algorithm for predicated global value numbering. Proceedings of the ACM SIGPLAN 2002 conference on Programming language design and implementation. (45-56).

    https://doi.org/10.1145/512529.512536

  • Cooper K and Xu L. An efficient static analysis algorithm to detect redundant memory operations. Proceedings of the 2002 workshop on Memory system performance. (97-107).

    https://doi.org/10.1145/773146.773049

  • Gargi K. (2002). A sparse algorithm for predicated global value numbering. ACM SIGPLAN Notices. 37:5. (45-56). Online publication date: 17-May-2002.

    https://doi.org/10.1145/543552.512536

  • Stoutchinin A and de Ferriere F. Efficient static single assignment form for predication. Proceedings of the 34th annual ACM/IEEE international symposium on Microarchitecture. (172-181).

    /doi/10.5555/563998.564022

  • Chakrabarti D and Banerjee P. Global optimization techniques for automatic parallelization of hybrid applications. Proceedings of the 15th international conference on Supercomputing. (166-180).

    https://doi.org/10.1145/377792.377827

  • Das R, Hwang Y, Saltz J and Sussman A. Runtime and compiler support for irregular computations. Compiler optimizations for scalable parallel systems. (751-778).

    /doi/10.5555/380466.380487

  • Tu P and Padua D. Automatic array privatization. Compiler optimizations for scalable parallel systems. (247-281).

    /doi/10.5555/380466.380474

  • Hosking A, Nystrom N, Whitlock D, Cutts Q and Diwan A. (2001). Partial redundancy elimination for access path expressions. Software—Practice & Experience. 31:6. (577-600). Online publication date: 1-May-2001.

    https://doi.org/10.1002/spe.371

  • Chakrabarti D and Banerjee P. (2001). Static Single Assignment Form for Message-Passing Programs. International Journal of Parallel Programming. 29:2. (139-184). Online publication date: 1-Apr-2001.

    https://doi.org/10.1023/A:1007633018973

  • Flanagan C and Saxe J. (2001). Avoiding exponential explosion. ACM SIGPLAN Notices. 36:3. (193-205). Online publication date: 1-Mar-2001.

    https://doi.org/10.1145/373243.360220

  • Flanagan C and Saxe J. Avoiding exponential explosion. Proceedings of the 28th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (193-205).

    https://doi.org/10.1145/360204.360220

  • Stoutchinin A and de Ferriere F. Efficient static single assignment form for predication 34th ACM/IEEE International Symposium on Microarchitecture. 10.1109/MICRO.2001.991116. 0-7695-1369-7. (172-181).

    http://ieeexplore.ieee.org/document/991116/

  • Amme W, Dalton N, Frohlich P, Haldar V, Housel P, von Ronne J, Stork C, Zhenochin S and Franz M. Project TRANSPROSE: reconciling mobile-code security with execution efficiency DARPA Information Survivability Conference and Exposition II. DISCEX'01. 10.1109/DISCEX.2001.932172. 0-7695-1212-7. (196-210).

    http://ieeexplore.ieee.org/document/932172/

  • Beringer L. (2001). Typing Assembly Programs with Explicit Forwarding. Theoretical Aspects of Computer Software. 10.1007/3-540-45500-0_26. (514-534).

    http://link.springer.com/10.1007/3-540-45500-0_26

  • Tu P and Padua D. (2001). Automatic Array Privatization. Compiler Optimizations for Scalable Parallel Systems. 10.1007/3-540-45403-9_8. (247-281).

    http://link.springer.com/10.1007/3-540-45403-9_8

  • Das R, Hwang Y, Saltz J and Sussman A. (2001). Runtime and Compiler Support for Irregular Computations. Compiler Optimizations for Scalable Parallel Systems. 10.1007/3-540-45403-9_21. (751-778).

    http://link.springer.com/10.1007/3-540-45403-9_21

  • Sarkar V and Fink S. (2001). Efficient Dependence Analysis for Java Arrays. Euro-Par 2001 Parallel Processing. 10.1007/3-540-44681-8_39. (273-277).

    http://link.springer.com/10.1007/3-540-44681-8_39

  • Bodík R, Gupta R and Sarkar V. ABCD. Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation. (321-333).

    https://doi.org/10.1145/349299.349342

  • Ramsey N and Peyton Jones S. A single intermediate language that supports multiple implementations of exceptions. Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation. (285-298).

    https://doi.org/10.1145/349299.349337

  • Bodík R, Gupta R and Sarkar V. (2000). ABCD. ACM SIGPLAN Notices. 35:5. (321-333). Online publication date: 1-May-2000.

    https://doi.org/10.1145/358438.349342

  • Ramsey N and Peyton Jones S. (2000). A single intermediate language that supports multiple implementations of exceptions. ACM SIGPLAN Notices. 35:5. (285-298). Online publication date: 1-May-2000.

    https://doi.org/10.1145/358438.349337

  • Fink S, Knobe K and Sarkar V. (2000). Unified Analysis of Array and Object References in Strongly Typed Languages. Static Analysis. 10.1007/978-3-540-45099-3_9. (155-174).

    http://link.springer.com/10.1007/978-3-540-45099-3_9

  • Kim J and Boult T. (2000). Efficient Run Time Optimization with Static Single Assignment. Distributed and Parallel Systems. 10.1007/978-1-4615-4489-0_9. (67-76).

    http://link.springer.com/10.1007/978-1-4615-4489-0_9

  • Aycock J and Horspool N. (2000). Simple Generation of Static Single-Assignment Form. Compiler Construction. 10.1007/3-540-46423-9_8. (110-125).

    http://link.springer.com/10.1007/3-540-46423-9_8

  • Lee J, Padua D and Midkiff S. (1999). Basic compiler algorithms for parallel programs. ACM SIGPLAN Notices. 34:8. (1-12). Online publication date: 1-Aug-1999.

    https://doi.org/10.1145/329366.301105

  • Lee J, Padua D and Midkiff S. Basic compiler algorithms for parallel programs. Proceedings of the seventh ACM SIGPLAN symposium on Principles and practice of parallel programming. (1-12).

    https://doi.org/10.1145/301104.301105

  • Collard J. (1999). The Advantages of Instance-Wise Reaching Definition Analyses in Array (S)SA. Languages and Compilers for Parallel Computing. 10.1007/3-540-48319-5_22. (338-352).

    http://link.springer.com/10.1007/3-540-48319-5_22

  • Rüthing O, Knoop J and Steffen B. (1999). Detecting Equalities of Variables: Combining Efficiency with Precision. Static Analysis. 10.1007/3-540-48294-6_15. (232-247).

    http://link.springer.com/10.1007/3-540-48294-6_15

  • Creusillet B and Irigoin F. (1998). Interprocedural analyses of Fortran programs. Parallel Computing. 24:3-4. (629-648). Online publication date: 1-May-1998.

    https://doi.org/10.1016/S0167-8191(98)00028-3

  • Gotlieb A, Botella B and Rueher M. (1998). Automatic test data generation using constraint solving techniques. ACM SIGSOFT Software Engineering Notes. 23:2. (53-62). Online publication date: 1-Mar-1998.

    https://doi.org/10.1145/271775.271790

  • Gotlieb A, Botella B and Rueher M. Automatic test data generation using constraint solving techniques. Proceedings of the 1998 ACM SIGSOFT international symposium on Software testing and analysis. (53-62).

    https://doi.org/10.1145/271771.271790

  • Bodík R and Anik S. Path-sensitive value-flow analysis. Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (237-251).

    https://doi.org/10.1145/268946.268966

  • Knobe K and Sarkar V. Array SSA form and its use in parallelization. Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (107-120).

    https://doi.org/10.1145/268946.268956

  • Koschke R, Girard J and Wurthner M. An intermediate representation for integrating reverse engineering analyses Fifth Working Conference on Reverse Engineering. 10.1109/WCRE.1998.723194. 0-8186-8967-6. (241-250).

    http://ieeexplore.ieee.org/document/723194/

  • Beckmann O and Kelly P. (1998). Data distribution at run-time: Re-using execution plans. Euro-Par’98 Parallel Processing. 10.1007/BFb0057884. (413-421).

    http://link.springer.com/10.1007/BFb0057884

  • Knoop J, Rüthing O and Steffen B. (1998). Code motion and code placement: Just synonyms?. Programming Languages and Systems. 10.1007/BFb0053569. (154-169).

    http://link.springer.com/10.1007/BFb0053569

  • Lapkowski C and Hendren L. (1998). Extended SSA mumbering: Introducing SSA properties to languages with multi-level pointers. Compiler Construction. 10.1007/BFb0026427. (128-143).

    http://link.springer.com/10.1007/BFb0026427

  • Chow F, Chan S, Kennedy R, Liu S, Lo R and Tu P. (1997). A new algorithm for partial redundancy elimination based on SSA form. ACM SIGPLAN Notices. 32:5. (273-286). Online publication date: 1-May-1997.

    https://doi.org/10.1145/258916.258940

  • Chow F, Chan S, Kennedy R, Liu S, Lo R and Tu P. A new algorithm for partial redundancy elimination based on SSA form. Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation. (273-286).

    https://doi.org/10.1145/258915.258940

  • Ferrante R and Allard J. (1996). Introducing a CPS style optimizer into an existing compiler. ACM SIGPLAN Notices. 31:12. (73-79). Online publication date: 1-Dec-1996.

    https://doi.org/10.1145/242604.242621

  • Lapkowski C and Hendren L. Extended SSA numbering. Proceedings of the 1996 conference of the Centre for Advanced Studies on Collaborative research.

    /doi/10.5555/782052.782075

  • Auslander J, Philipose M, Chambers C, Eggers S and Bershad B. (1996). Fast, effective dynamic compilation. ACM SIGPLAN Notices. 31:5. (149-159). Online publication date: 1-May-1996.

    https://doi.org/10.1145/249069.231409

  • Auslander J, Philipose M, Chambers C, Eggers S and Bershad B. Fast, effective dynamic compilation. Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation. (149-159).

    https://doi.org/10.1145/231379.231409

  • Chow F, Chan S, Liu S, Lo R and Streich M. (1996). Effective representation of aliases and indirect memory operations in SSA form. Compiler Construction. 10.1007/3-540-61053-7_66. (253-267).

    http://link.springer.com/10.1007/3-540-61053-7_66

  • Choi J, Sarkar V and Schonberg E. (1996). Incremental computation of static single assignment form. Compiler Construction. 10.1007/3-540-61053-7_64. (223-237).

    http://link.springer.com/10.1007/3-540-61053-7_64

  • Das R, Havlak P, Saltz J and Kennedy K. Index array flattening through program transformation. Proceedings of the 1995 ACM/IEEE conference on Supercomputing. (70-es).

    https://doi.org/10.1145/224170.224420

  • Tu P and Padua D. Gated SSA-based demand-driven symbolic analysis for parallelizing compilers. Proceedings of the 9th international conference on Supercomputing. (414-423).

    https://doi.org/10.1145/224538.224648

  • Das M, Reps T and van Hentenryck P. Semantic foundations of binding-time analysis for imperative programs. Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. (100-110).

    https://doi.org/10.1145/215465.215569

  • Click C. Global code motion/global value numbering. Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation. (246-257).

    https://doi.org/10.1145/207110.207154

  • Tu P and Padua D. Efficient building and placing of gating functions. Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation. (47-55).

    https://doi.org/10.1145/207110.207115

  • Click C. (1995). Global code motion/global value numbering. ACM SIGPLAN Notices. 30:6. (246-257). Online publication date: 1-Jun-1995.

    https://doi.org/10.1145/223428.207154

  • Tu P and Padua D. (1995). Efficient building and placing of gating functions. ACM SIGPLAN Notices. 30:6. (47-55). Online publication date: 1-Jun-1995.

    https://doi.org/10.1145/223428.207115

  • Click C and Paleczny M. (1995). A simple graph-based intermediate representation. ACM SIGPLAN Notices. 30:3. (35-49). Online publication date: 1-Mar-1995.

    https://doi.org/10.1145/202530.202534

  • Berson D, Gupta R and Soffa M. (1995). GURRR. ACM SIGPLAN Notices. 30:3. (23-34). Online publication date: 1-Mar-1995.

    https://doi.org/10.1145/202530.202533

  • Sreedhar V, Gao G and Lee Y. (1995). Incremental computation of dominator trees. ACM SIGPLAN Notices. 30:3. (1-12). Online publication date: 1-Mar-1995.

    https://doi.org/10.1145/202530.202531

  • Click C and Paleczny M. A simple graph-based intermediate representation. Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations. (35-49).

    https://doi.org/10.1145/202529.202534

  • Berson D, Gupta R and Soffa M. GURRR. Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations. (23-34).

    https://doi.org/10.1145/202529.202533

  • Sreedhar V, Gao G and Lee Y. Incremental computation of dominator trees. Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations. (1-12).

    https://doi.org/10.1145/202529.202531

  • Sreedhar V and Gao G. A linear time algorithm for placing φ-nodes. Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (62-73).

    https://doi.org/10.1145/199448.199464

  • Baker B. On finding duplication and near-duplication in large software systems 2nd Working Conference on Reverse Engineering. 10.1109/WCRE.1995.514697. 0-8186-7111-4. (86-95).

    http://ieeexplore.ieee.org/document/514697/

  • Briggs P and Cooper K. Effective partial redundancy elimination. Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation. (159-170).

    https://doi.org/10.1145/178243.178257

  • Briggs P and Cooper K. (1994). Effective partial redundancy elimination. ACM SIGPLAN Notices. 29:6. (159-170). Online publication date: 1-Jun-1994.

    https://doi.org/10.1145/773473.178257

  • Weise D, Crew R, Ernst M and Steensgaard B. Value dependence graphs. Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (297-310).

    https://doi.org/10.1145/174675.177907

  • Goubault J. (1994). Generalized boxings, congruences and partial inlining. Static Analysis. 10.1007/3-540-58485-4_38. (147-161).

    http://link.springer.com/10.1007/3-540-58485-4_38

  • Duesterwald E, Gupta R and Soffa M. (1994). Reducing the cost of data flow analysis by congruence partitioning. Compiler Construction. 10.1007/3-540-57877-3_24. (357-373).

    http://link.springer.com/10.1007/3-540-57877-3_24

  • Tu P and Padua D. (1994). Automatic array privatization. Languages and Compilers for Parallel Computing. 10.1007/3-540-57659-2_29. (500-521).

    http://link.springer.com/10.1007/3-540-57659-2_29

  • Havlak P. (1994). Construction of thinned gated single-assignment form. Languages and Compilers for Parallel Computing. 10.1007/3-540-57659-2_28. (477-499).

    http://link.springer.com/10.1007/3-540-57659-2_28

  • Cytron R and Ferrante J. (1994). Efficiently computing φ-nodes on-the-fly. Languages and Compilers for Parallel Computing. 10.1007/3-540-57659-2_27. (461-476).

    http://link.springer.com/10.1007/3-540-57659-2_27

  • Chung I and Kwon Y. (2006). A semantics‐based method for revalidating modified programs. Journal of Software Maintenance: Research and Practice. 10.1002/smr.4360060103. 6:1. (15-33). Online publication date: 1-Jan-1994.

    https://onlinelibrary.wiley.com/doi/10.1002/smr.4360060103

  • Kennedy K, McKinley K and Tseng C. (2006). Analysis and transformation in an interactive parallel programming tool. Concurrency: Practice and Experience. 10.1002/cpe.4330050705. 5:7. (575-602). Online publication date: 1-Oct-1993.

    https://onlinelibrary.wiley.com/doi/10.1002/cpe.4330050705

  • Grove D and Torczon L. Interprocedural constant propagation. Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation. (90-99).

    https://doi.org/10.1145/155090.155099

  • Cytron R and Gershbein R. Efficient accommodation of may-alias information in SSA form. Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation. (36-45).

    https://doi.org/10.1145/155090.155094

  • Grove D and Torczon L. (1993). Interprocedural constant propagation. ACM SIGPLAN Notices. 28:6. (90-99). Online publication date: 1-Jun-1993.

    https://doi.org/10.1145/173262.155099

  • Cytron R and Gershbein R. (1993). Efficient accommodation of may-alias information in SSA form. ACM SIGPLAN Notices. 28:6. (36-45). Online publication date: 1-Jun-1993.

    https://doi.org/10.1145/173262.155094

  • Srinivasan H, Hook J and Wolfe M. Static single assignment for explicitly parallel programs. Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (260-272).

    https://doi.org/10.1145/158511.158644

  • O'Donnell C. High Level Compiling for Low Level Machines. Proceedings of the IFIP WG10.3. Working Conference on Architectures and Compilation Techniques for Fine and Medium Grain Parallelism. (309-320).

    /doi/10.5555/647025.714363

  • Cooper K, Hall M, Hood R, Kennedy K, McKinley K, Mellor-Crummey J, Torczon L and Warren S. (1993). The ParaScope parallel programming environment. Proceedings of the IEEE. 10.1109/5.214549. 81:2. (244-263). Online publication date: 1-Jan-1993.

    http://ieeexplore.ieee.org/document/214549/

  • Haghighat M and Polychronopoulos C. (1993). Symbolic program analysis and optimization for parallelizing compilers. Languages and Compilers for Parallel Computing. 10.1007/3-540-57502-2_69. (538-562).

    http://link.springer.com/10.1007/3-540-57502-2_69

  • Wolfe M. (1992). Beyond induction variables. ACM SIGPLAN Notices. 27:7. (162-174). Online publication date: 1-Jul-1992.

    https://doi.org/10.1145/143103.143131

  • Wolfe M. Beyond induction variables. Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation. (162-174).

    https://doi.org/10.1145/143095.143131

  • Horwitz S and Reps T. The use of program dependence graphs in software engineering. Proceedings of the 14th international conference on Software engineering. (392-411).

    https://doi.org/10.1145/143062.143156

  • Bernstein D, Rodeh M and Sagiv M. (1992). Proving safety of speculative load instructions at compile-time. ESOP '92. 10.1007/3-540-55253-7_4. (56-72).

    http://link.springer.com/10.1007/3-540-55253-7_4

  • Wegman M and Zadeck F. (1991). Constant propagation with conditional branches. ACM Transactions on Programming Languages and Systems. 13:2. (181-210). Online publication date: 1-Apr-1991.

    https://doi.org/10.1145/103135.103136

  • Cai J and Paige R. Look ma, no hashing, and no arrays neither. Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (143-154).

    https://doi.org/10.1145/99583.99605

  • Choi J, Cytron R and Ferrante J. Automatic construction of sparse data flow evaluation graphs. Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (55-66).

    https://doi.org/10.1145/99583.99594

  • Yang W, Horwitz S and Reps T. (1990). A program integration algorithm that accommodates semantics-preserving transformations. ACM SIGSOFT Software Engineering Notes. 15:6. (133-143). Online publication date: 1-Dec-1990.

    https://doi.org/10.1145/99278.99290

  • Yang W, Horwitz S and Reps T. A program integration algorithm that accommodates semantics-preserving transformations. Proceedings of the fourth ACM SIGSOFT symposium on Software development environments. (133-143).

    https://doi.org/10.1145/99277.99290

  • Cytron R, Ferrante J and Sarkar V. (1990). Compact representations for control dependence. ACM SIGPLAN Notices. 25:6. (337-351). Online publication date: 1-Jun-1990.

    https://doi.org/10.1145/93548.93592

  • Ottenstein K, Ballance R and MacCabe A. (1990). The program dependence web: a representation supporting control-, data-, and demand-driven interpretation of imperative languages. ACM SIGPLAN Notices. 25:6. (257-271). Online publication date: 1-Jun-1990.

    https://doi.org/10.1145/93548.93578

  • Horwitz S. (1990). Identifying the semantic and textual differences between two versions of a program. ACM SIGPLAN Notices. 25:6. (234-245). Online publication date: 1-Jun-1990.

    https://doi.org/10.1145/93548.93574

  • Cytron R, Ferrante J and Sarkar V. Compact representations for control dependence. Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation. (337-351).

    https://doi.org/10.1145/93542.93592

  • Ottenstein K, Ballance R and MacCabe A. The program dependence web: a representation supporting control-, data-, and demand-driven interpretation of imperative languages. Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation. (257-271).

    https://doi.org/10.1145/93542.93578

  • Horwitz S. Identifying the semantic and textual differences between two versions of a program. Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation. (234-245).

    https://doi.org/10.1145/93542.93574

  • Cytron R, Ferrante J, Rosen B, Wegman M and Zadeck F. An efficient method of computing static single assignment form. Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (25-35).

    https://doi.org/10.1145/75277.75280

  • Steffen B and Knoop J. (1989). Finite constants: Characterizations of a new decidable set of constants. Mathematical Foundations of Computer Science 1989. 10.1007/3-540-51486-4_94. (481-491).

    http://link.springer.com/10.1007/3-540-51486-4_94

  • Lisper B. (1989). Single-assignment semantics for imperative programs. PARLE '89 Parallel Architectures and Languages Europe. 10.1007/3-540-51285-3_49. (321-334).

    http://link.springer.com/10.1007/3-540-51285-3_49

  • Rosen B, Wegman M and Zadeck F. Global value numbers and redundant computations. Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (12-27).

    https://doi.org/10.1145/73560.73562