A practical framework for the abstract interpretation of logic programs
Journal of Logic Programming
Compile-time derivation of variable dependency using abstract interpretation
Journal of Logic Programming
Experimental evaluation of a generic abstract interpretation algorithm for PROLOG
ACM Transactions on Programming Languages and Systems (TOPLAS)
Fast static analysis of C++ virtual function calls
Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Escape analysis for object-oriented languages: application to Java
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Incremental analysis of constraint logic programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
Effective synchronization removal for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Formal Syntax and Semantics of Java
Formal Syntax and Semantics of Java
GENA - A Tool for Generating Prolog Analyzers from Specifications
SAS '95 Proceedings of the Second International Symposium on Static Analysis
Analysis of Imperative Programs through Analysis of Constraint Logic Programs
SAS '98 Proceedings of the 5th International Symposium on Static Analysis
TVLA: A System for Implementing Static Analyses
SAS '00 Proceedings of the 7th International Symposium on Static Analysis
Java Bytecode Verification: An Overview
CAV '01 Proceedings of the 13th International Conference on Computer Aided Verification
Soot - a Java bytecode optimization framework
CASCON '99 Proceedings of the 1999 conference of the Centre for Advanced Studies on Collaborative research
Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley))
Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley))
Preliminary design of JML: a behavioral interface specification language for java
ACM SIGSOFT Software Engineering Notes
Abstract Interpretation and Object-oriented Programming: Quo Vadis?
Electronic Notes in Theoretical Computer Science (ENTCS)
Program development using abstract interpretation (and the ciao system preprocessor)
SAS'03 Proceedings of the 10th international conference on Static analysis
VMCAI'07 Proceedings of the 8th international conference on Verification, model checking, and abstract interpretation
Abstract interpretation with alien expressions and heap structures
VMCAI'05 Proceedings of the 6th international conference on Verification, Model Checking, and Abstract Interpretation
Information flow analysis for java bytecode
VMCAI'05 Proceedings of the 6th international conference on Verification, Model Checking, and Abstract Interpretation
Pair-sharing analysis of object-oriented programs
SAS'05 Proceedings of the 12th international conference on Static Analysis
Verification of java bytecode using analysis and transformation of logic programs
PADL'07 Proceedings of the 9th international conference on Practical Aspects of Declarative Languages
Test Data Generation of Bytecode by CLP Partial Evaluation
Logic-Based Program Synthesis and Transformation
ICSOC/ServiceWave'09 Proceedings of the 2009 international conference on Service-oriented computing
Interval-Based resource usage verification: formalization and prototype
FOPARA'11 Proceedings of the Second international conference on Foundational and Practical Aspects of Resource Analysis
Disjunctive interpolants for horn-clause verification
CAV'13 Proceedings of the 25th international conference on Computer Aided Verification
Hi-index | 0.00 |
Static analyses of object-oriented programs usually rely on intermediate representations that respect the original semantics while having a more uniform and basic syntax. Most of the work involving object-oriented languages and abstract interpretation usually omits the description of that language or just refers to the Control Flow Graph (CFG) it represents. However, this lack of formalization on one hand results in an absence of assurances regarding the correctness of the transformation and on the other it typically strongly couples the analysis to the source language. In this work we present a framework for analysis of object-oriented languages in which in a first phase we transform the input program into a representation based on Horn clauses. This facilitates on one hand proving the correctness of the transformation attending to a simple condition and on the other allows applying existing analyzers for (constraint) logic programming to automatically derive a safe approximation of the semantics of the original program. The approach is flexible in the sense that the first phase decouples the analyzer from most language-dependent features, and correct because the set of Horn clauses returned by the transformation phase safely approximates the standard semantics of the input program. The resulting analysis is also reasonably scalable due to the use of mature, modular (C)LP-based analyzers. This allows us to report good results for medium-sized programs.