Instrumentation of Java Program Code for Control Flow Analysis

… on Advancing the State-of-the- …, 2003

Program analysis plays a key role in many areas of software development, such as performance tuning, testing, debugging, and maintenance. Program analysis can be carried out statically or dynamically, and these two approaches are generally seen as being complementary to each other. In this paper, we will focus on runtime data analysis for object oriented systems in general and the Java 2 platform in particular. More specifically, we are investigating various runtime approaches to monitor the access and modification of variables in a Java program in order to keep track of the their usage history, being of particular interest for dynamic data flow analysis. Our results indicate that the Java 2 platform does not provide sufficient tools to enable comprehensive runtime data analysis in this context, especially when the complete source code of an application under investigation is unavailable.

2007

interpretation has been widely used for the analysis of object-oriented languages and, in particular, Java source and bytecode. However, while most existing work deals with the problem of finding expressive abstract domains that track accurately the characteristics of a particular concrete property, the underlying fixpoint algorithms have received comparatively less attention. In fact, many existing (abstract interpretation based-) fixpoint algorithms rely on relatively inefficient techniques for solving inter-procedural call graphs or are specific and tied to particular analyses. We also argue that the design of an efficient fixpoint algorithm is pivotal to supporting the analysis of large programs. In this paper we introduce a novel algorithm for analysis of Java bytecode which includes a number of optimizations in order to reduce the number of iterations. The algorithm is parametric-in the sense that it is independent of the abstract domain used and it can be applied to different domains as "plug-ins"-, multivariant, and flow-sensitive. Also, is based on a program transformation, prior to the analysis, that results in a highly uniform representation of all the features in the language and therefore simplifies analysis. Detailed descriptions of decompilation solutions are given and discussed with an example. We also provide some performance data from a preliminary implementation of the analysis.

2018 International Conference on Computing, Electronics & Communications Engineering (iCCECE), 2018

In the domain of Software Engineering, program analysis and understanding has been considered to be a very challenging task since decade, as it demands dedicated time and efforts. The analysis of source code may occasionally be comparatively easier due to its static nature, however, the back-end code (Bytecode), especially in terms of Java programming, is complicated to be analysed. In this paper, we present a methodological approach towards understanding the Bytecode of Java programs. We put forward a framework for the debugging process of Java Bytecode. Furthermore, we discuss the debugging process of Bytecode understanding from simple to multiple statements with regards to data flow analysis. Finally, we present a comparative analysis of Bytecode along with the simulation of the proposed framework for the debugging process.

Electronic Notes in Theoretical Computer Science, 2005

In Java bytecode, intra-method subroutines are employed to represent code in "finally" blocks. The use of such polymorphic subroutines within a method makes bytecode analysis very difficult. Fortunately, such subroutines can be eliminated through recompilation or inlining. Inlining is the obvious choice since it does not require changing compilers or access to the source code. It also allows transformation of legacy bytecode. However, the combination of nested, non-contiguous subroutines with overlapping exception handlers poses a difficult challenge. This paper presents an algorithm that successfully solves all these problems without producing superfluous instructions.

Proceedings of the 5th international symposium on Principles and practice of programming in Java - PPPJ '07, 2007

Bytecode instrumentation is a valuable technique for transparently enhancing virtual execution environments for purposes such as monitoring or profiling. Current approaches to bytecode instrumentation either exclude some methods from instrumentation, severely restrict the ways certain methods may be instrumented, or require the use of native code. In this paper we compare different approaches to bytecode instrumentation in Java and come up with a novel instrumentation framework that goes beyond the aforementioned limitations. We evaluate our approach with an instrumentation for profiling which generates calling context trees of various platform-independent dynamic metrics.

JOANA (Java Object-sensitive Analysis) and Java SDG API are analysis frameworks available for analyzing Java programs for different applications. Now a days, the continuous evolution of the customer expectations and requirements has resulted in the increase of size of the software. Due to which the difficulties in maintaining software are increasing. Both Joana and Java SDG API consist of a variety of analysis techniques based on dependence graph generation and computation of slices of an input program. In this paper, we make a comparative analysis study on the effectiveness and efficiency of both these above mentioned analysis frameworks in generating the corresponding intermediate dependence graph and computing slices. The analysis is based on the bytecode of the program under consideration. The experimental analysis shows that Joana can be extended for various diverse applications.

This paper describes research on visualising Java software at runtime in order to enable the identification of structural features. The aim is to highlight both the static and dynamic structure of the software and aid software engineers in tasks requiring program comprehension of the code. The paper takes the position that this type of analysis and visualisation for object oriented languages must be carried out with dynamic runtime information and that it cannot, in general, be obtained by static analysis alone. A case study is worked through to demonstrate the approach.

2007

Resumo. Embora seja de alto custo, a atividade de teste é de fundamental importância no processo de desenvolvimento de software. Técnicas e ferramentas são essenciais para a melhoria da qualidade e da produtividade na atividade de teste. A técnica de teste estrutural usa estruturas de fluxo de controle e de dados para derivar requisitos de testes. Buscando exercitar tais requisitos o testador supostamente fornece casos de teste que melhoram a qualidade do software. O teste estrutural requer a execução de várias atividades que exigem a análise de código que, em geral, é realizada no código fonte do produto em teste. Com o advento da linguagem Java tornou-se usual a realização da análise diretamente no código objeto (bytecode) o que traz algumas vantagens. Neste artigo, é discutido como usar as características da análise de bytecode Java e como estendê-la para a implementação de critérios de teste estruturais para dois domínios específicos: programas orientados a aspectos e aplicações de banco de dados.

Future Generation Computer Systems, 2001

Java makes easier the coding phase of concurrent applications and provides friendly mechanisms for the information exchange among threads and different processes. The nature of communication and synchronization mechanisms and the actual parallelism of a distributed environment introduce potential sources of non-deterministic behavior in concurrent applications. In order to investigate on undesired effects related to non-deterministic behaviors, tracing and replay capabilities can be added to the programming environment. Such capabilities are useful for testing, debugging, monitoring, performance evaluation and program profiling purposes. This paper presents a solution for providing tracing and replay capabilities to a number of Java concurrent applications. Such a solution addresses portability and it is based on the automatic instrumentation of the original source code. Some transformation schemes have been applied to some classes in the standard Java packages in order to make easier and more efficient the automatic instrumentation task. It is shown how the object-oriented structure of Java can be exploited in a deep and efficient way both in the instrumentation and in the tracing and replay phases. (A. Bechini), [email protected] (C.A. Prete). 0167-739X/01/$ -see front matter © 2001 Elsevier Science B.V. All rights reserved. PII: S 0 1 6 7 -7 3 9 X ( 0 0 ) 0 0 0 9 5 -9

Higher-Order and Symbolic Computation, 2010

Static analyses based on denotational semantics can naturally model functional behaviours of the code in a compositional and completely context and flow sensitive way. But they only model the functional i.e., input/output behaviour of a program P , not enough if one needs P 's internal behaviours i.e., from the input to some internal program points. This is, however, a frequent requirement for a useful static analysis. In this paper, we overcome this limitation, for the case of mono-threaded Java bytecode, with a technique used up to now for logic programs only. Namely, we define a program transformation that adds new magic blocks of code to the program P , whose functional behaviours are the internal behaviours of P . We prove the transformation correct w.r.t. an operational semantics and define an equivalent denotational semantics, devised for abstract interpretation, whose denotations for the magic blocks are hence the internal behaviours of P . We implement our transformation and instantiate it with abstract domains modelling sharing of two variables, non-cyclicity of variables, nullness of variables, class initialisation information and size of the values bound to program variables. We get a static analyser for full mono-threaded Java bytecode that is faster and scales better than another operational pair-sharing analyser. It has the same speed but is more precise than a constraint-based nullness analyser. It makes a polyhedral size analysis of Java bytecode scale up to 1300 methods in a couple of minutes and a zone-based size analysis scale to still larger applications.

2010

Computer systems are verified to check the correctness or validated to check the performance of the software system with respect to specific security properties such as Integrity, Availability and Confidentiality. that is made available by the end users of the software is achievable only to a limited degree using static verification techniques. The more sensitive the information, such as credit card data, government intelligence or personal medical information being processed by software, the more important it is to ensure the confidentiality of this information. Monitoring untrusted programs during execution in an environment where sensitive information is present is difficult and unnerving. The issues is how to control the confidential information flow during untrusted program execution. In this paper we present one component of our novel framework for supporting user interaction with running program to modify the way information flow or to change program behaviour. We present prototype of our runtime verification framework of controlling information flow with more focus on Assertion points.

Springer eBooks, 2007

Denotational static analysis of Java bytecode has a nice and clean compositional definition and an efficient implementation with binary decision diagrams. But it models only the functional i.e., input/output behaviour of a program P , not enough if one needs P 's internal behaviours i.e., from the input to some internal program points. We overcome this limitation with a technique used up to now for logic programs only. It adds new magic blocks of code to P , whose functional behaviours are the internal behaviours of P. We prove this transformation correct with an operational semantics. We define an equivalent denotational semantics, whose denotations for the magic blocks are hence the internal behaviours of P. We implement our transformation and instantiate it with abstract domains modelling sharing of two variables and non-cyclicity of variables. We get a static analyser for full Java bytecode that is faster and scales better than another operational pair-sharing analyser and a constraint-based pointer analyser.

2006

This paper presents a declarative approach to the debugging of object-oriented programs and illustrates the methodology through an extension of a novel interactive visualization system for Java developed in our previous research. Unlike traditional "procedural" debugging, we use the term "declarative debugging" to refer to a flexible set of queries on individual execution states and also over the entire history of execution (or portion of the history). Examples include queries to find all values assigned to a variable over its lifetime ; which variable has a certain value; the calling sequence that results in a certain outcome; whether a certain statement was executed; etc. These queries were arrived at by a systematic study of errors in objectoriented programs in our previous research. Our proposed system, JavaDD, maintains the execution history as a relational database of salient events, such as method call/return, thread start/end, variable assignment, etc. An important property of our approach is that these queries can be posed interactively (at any step of execution), and there is no need to develop a compiler to instrument the source code, as in related research projects. Furthermore, we also sketch a visual interface so that both queries and answers can be composed using inituitive object and sequence diagrams. We believe such an approach is a significant contribution to the art of program debugging. We present the architecture of JavaDD, a detailed catalog of our queries and their translation, and several examples illustrating the approach. We also compare our approach related research efforts in the area of query-based analysis of object-oriented programs.

RePEc: Research Papers in Economics, 2016

Die Dokumente auf EconStor dürfen zu eigenen wissenschaftlichen Zwecken und zum Privatgebrauch gespeichert und kopiert werden. Sie dürfen die Dokumente nicht für öffentliche oder kommerzielle Zwecke vervielfältigen, öffentlich ausstellen, öffentlich zugänglich machen, vertreiben oder anderweitig nutzen. Sofern die Verfasser die Dokumente unter Open-Content-Lizenzen (insbesondere CC-Lizenzen) zur Verfügung gestellt haben sollten, gelten abweichend von diesen Nutzungsbedingungen die in der dort genannten Lizenz gewährten Nutzungsrechte. Terms of use: Documents in EconStor may be saved and copied for your personal and scholarly purposes. You are not to copy documents for public or commercial purposes, to exhibit the documents publicly, to make them publicly available on the internet, or to distribute or otherwise use the documents in public. If the documents have been made available under an Open Content Licence (especially Creative Commons Licences), you may exercise further usage rights as specified in the indicated licence.