A Framework for Debugging Java Programs in a Bytecode
Dr. Mohammad Riyaz Belgaum2018, 2018 International Conference on Computing, Electronics & Communications Engineering (iCCECE)
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
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.
Related papers
Javadd: a declarative debugger for java
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.
Algorithmic Debugging of Java Programs
In this paper we propose applying the ideas of declarative debugging to the object-oriented language Java as an alternative to traditional trace debuggers used in imperative languages. The declarative debugger builds a suitable computation tree containing information about method invocations occurred during a wrong computation. The tree is then navigated, asking the user questions in order to compare the intended semantics of each method with its actual behavior until a wrong method is found out. The technique has been implemented in an available prototype. We comment the several new issues that arise when using this debugging technique, traditionally applied to declarative languages, to a completely different paradigm and propose several possible improvements and lines of future work.
An algorithmic debugger for Java
2010 IEEE International Conference on Software Maintenance, 2010
This work presents DDJ, an algorithmic debugger for Java. The main advantage of DDJ with respect to previous algorithmic debuggers is its scalability. DDJ has a new architecture based on the use of cache memories that allows it to scale both in time and memory. In addition, it includes new techniques that allow the debugger to start the debugging session even before the execution tree has been produced. We present the new architecture, and describe the main features of this debugger together with a usage scenario.
Dynamic data flow analysis for Java programs
Information and Software Technology, 2000
A large portion of high-level computer programs consists of data declaration. Thus, an increased focus on testing the data¯ow aspects of programs should be considered. In this paper, we consider testing the data¯ow in Java programs dynamically. Data¯ow analysis has been applied for testing procedural and some object-oriented programs. We have extended the dynamic data¯ow analysis technique to test Java programs and show how it can be applied to detect data¯ow anomalies.
Control and Data Flow Execution of Java Programs
ArXiv, 2017
Since decade understanding of programs has become a compulsory task for the students as well as for others who are involved in the process of developing software and providing solutions to open problems. In that aspect showing the problem in a pictorial presentation in a best manner is a key advantage to better understand it. We provide model and structure for Java programs to understand the control and data flow analysis of execution. Especially it helps to understand the static analysis of Java programs, which is an uttermost important phase for software maintenance. We provided information and model for visualization of Java programs that may help better understanding of programs for a learning and analysis purpose. The idea provided for building visualization tool is extracting data and control analysis from execution of Java programs. We presented case studies to prove that our idea is most important for better understanding of Java programs which may help towards static analys...
Debugging of Java programs using a model-based approach
Proceedings of the Tenth …, 1999
Automated debugging in java using OCL and JDI
Arxiv preprint cs/0101002, 2001
Correctness constraints provide a foundation for automated debugging within object-oriented systems. This paper discusses a new approach to incorporating correctness constraints into Java development environments. Our approach uses the Object Constraint Language ("OCL") as a specification language and the Java Debug Interface ("JDI") as a verification API. OCL provides a standard language for expressing object-oriented constraints that can integrate with Unified Modeling Language ("UML") software models. JDI provides a standard Java API capable of supporting type-safe and side effect free runtime constraint evaluation. The resulting correctness constraint mechanism: (1) entails no programming language modifications; (2) requires neither access nor changes to existing source code; and (3) works with standard off-the-shelf Java virtual machines ("VMs"). A prototype correctness constraint auditor is presented to demonstrate the utility of this mechanism for purposes of automated debugging. BoundedStack::push(Object obj):Object Pre: size() < capacity() Post: size() = [email protected]()+1 (where "=" denotes equality) v.lastElement() = obj result = v.lastElement() BoundedStack::pop():Object Pre: not empty() (where "not" denotes logical negation) Post: result = [email protected]() size() = [email protected]()-1 BoundedStack::peek():Object Pre: not empty() Post: result = v.lastElement() v = v@pre BoundedStack::empty():boolean Post: result = (v.size() = 0) BoundedStack::size(): int Post: result = v.size() BoundedStack::capacity(): int Post: result = v.capacity()
Debugging, Advanced Debugging and Runtime Analysis
—This paper discusses debugging and runtime analysis of software and outlines its enormous benefits to software developers and testers. A debugger is usually quite helpful in tracking down many logic problems. However, even with the most advanced debugger at your disposal, it doesn't guarantee that it will be a straightforward task to rid your program of bugs. Debugging techniques might help you in your task of flushing errors out of your program. Some of these will directly involve the debugger but many of them won't. The hope is to add to your debugging repertoire in order to assist your personal debugging quests when things go strangely wrong. Testing is more than just debugging. Testing is not only used to locate defects and correct them. It is also used in validation, verification process, and reliability measurement. Testing is expensive. Automation is a good way to cut down cost and time.When we write software applications, we need to debug them. Software Testing provides an objective, independent view of the software to allow the business to appreciate and understand the risks at implementation of the software. A primary purpose for testing is to detect software failures so that defects may be uncovered and corrected. This is a non-trivial pursuit. Testing cannot establish that a product functions properly under all conditions but can only establish that it does not function properly under specific conditions. Program testing and fault detection can be aided significantly by testing tools and debuggers. Testing and debug tools include features such as program monitors, permitting full or partial monitoring of program code including instruction set simulator, permitting complete instruction level monitoring and trace facilities, program animation, permitting step-by-step execution and conditional breakpoint at source level or in machine code, code coverage reports, formatted dump or symbolic debugging tools allowing inspection of program variables on error or at chosen points. Automated functional GUI testing tools are used to repeat system-level tests through the GUI, benchmarks, allowing run-time performance comparisons to be made, performance analysis that can help to highlight hot spots and resource usage. A runtime tool will allow you to examine the application internals after the run via the recorded runtime analysis data. Runtime analysis removes the guesswork from debugging. It helps to uncover Memory corruption detection, Memory leak detection etc. Runtime analysis is an effort aimed at understanding software component behavior by using data collection during the execution of the component. Run-time analysis is a topic of great interest in Computer Science. A program can take seconds, hours or even years to finish executing, depending on various parameters.
Related topics
Related papers
JavaTA: A Logic-based Debugger for Java
2007
This paper presents a logic based approach to debugging Java programs. In contrast with traditional debugging we propose a debugging methodology for Java programs using logical queries on individual execution states and also over the history of execution. These queries were arrived at by a systematic study of errors in object-oriented programs in our earlier research. We represent the salient events during the execution of a Java program by a logic database, and implement the queries as logic programs. Such an approach allows us to answer a number of useful and interesting queries about a Java program, such as the calling sequence that results in a certain outcome, the state of an object at a particular execution point, etc. Our system also provides the ability to compose new queries during a debugging session. We believe that logic programming offers a significant contribution to the art of object-oriented programs debugging.
Instrumentation of Java Program Code for Control Flow Analysis
In this thesis we describe an approach and introduce a new tool, called JDeTEx, to extract decision tables from Java programs in order to give the maintenance engineer a better understanding of the control flow of the program. Decision tables are a compact, yet precise way to model the control flow of computer programs. In order to extract the decision tables the explicit and implicit control flow of Java programs needs to be analyzed by the tool. Firstly, the tool uses static byte code analysis to automatically extract information about polymorphic method calls that represent implicit control flow in Java programs.Secondly, the tool uses source code analysis to extract information about explicit control flow in the Java program. The main contribution of this thesis is an approach to instrument Java programs in order to extract decision tables from programs. We use the information extracted during byte code and source code analysis to guide the instrumentation process and show that ...
Kex: A Platform For Analysis Of JVM Programs
Information and Control Systems
Introduction: Over the last years program analysis methods were widely used for software quality assurance. Different types of program analysis require various levels of program representation, analysis methods, etc. Platforms that provide utilities to implement different types of analysis on their basis become very important because they allow one to simplify the process of development. Purpose: Development of a platform for analysis of JVM programs. Results: In this paper we present Kex, a platform for building program analysis tools for JVM bytecode. Kex provides three abstraction levels. First is Kfg, which is an SSA-based control flow graph representation for bytecode-level analysis and transformation. Second is a symbolic program representation called Predicate State, which consists of first order logic predicates that represent instructions of the original program, constraints, etc. The final level is SMT integration layer for constraint solving. It currently provides an inte...
An efficient, parametric fixpoint algorithm for analysis of Java bytecode
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.
4D Ariadne the Static Debugger of Java Programs
Periodica Polytechnica Electrical Engineering, 2011
Development environments support the programmer in numerous ways from syntax highlighting to different refactoring and code generating methods. However, there are cases where these tools are limited or not usable, such as getting familiar with large and complex source codes written by a third person; finding the complexities of huge projects or finding semantic errors. In this paper we present our static analyzer tool, called 4D Ariadne, which concentrates on these problems. 4D Ariadne is a static debugger of Object Oriented applications written in Java programming language It calculates data dependencies of objects being able to compute them both forward and backward. As 4D Ariadne provides only the direct influences to the user, it can be considered as an alternative of traditional debuggers, without executing the code. 4D Ariadne also provides dynamic call graphs representing polymorphic properties of objects.
Instrumentation of Java bytecode for runtime analysis
This paper describes JSpy, a system for high-level instrumentation of Java bytecode and its use with JPaX, our system for runtime analysis of Java programs. JPaX monitors the execution of temporal logic formulas and performs predicative analysis of deadlocks and data races. JSpy's input is an instrumentation specification, which consists of a collection of rules, where a rule is a predicate/action pair. The predicate is a conjunction of syntactic constraints on a Java statement, and the action is a description of logging information to be inserted in the bytecode corresponding to the statement. JSpy is built using JTrek an instrumentation package at a lower level of abstraction.
Locating bugs in Java programsfirst results of the Java diagnosis experiments project
Intelligent Problem Solving. …, 2000
Model-Based Debugging of Java Programs
arXiv (Cornell University), 2000
Model-based reasoning is a central concept in current research into intelligent diagnostic systems. It is based on the assumption that sources of incorrect behavior in technical devices can be located and identified via the existence of a model describing the basic properties of components of a certain application domain. When actual data concerning the misbehavior of a system composed from such components is available, a domain-independent diagnosis engine can be used to infer which parts of the system contribute to the observed behavior. This paper describes the application of the model-based approach to the debugging of Java programs written in a subset of Java. We show how a simple dependency model can be derived from a program, demonstrate the use of the model for debugging and reducing the required user interactions, give a comparison of the functional dependency model with program slicing, and finally discuss some current research issues.
Declarative Intraprocedural Flow Analysis of Java Source Code
Electronic Notes in Theoretical Computer Science, 2009
We have implemented intraprocedural control-flow and data-flow analysis of Java source code in a declarative manner, using reference attribute grammars augmented with circular attributes and collection attributes. Our implementation is built on top of the JastAdd Extensible Java Compiler and we have run the analyses on medium-sized Java programs. We show how the analyses can be built using small concise composable modules, and how they provide extensible frameworks for further source code analyses. Preliminary measurements indicate that there is little difference in execution time between our declarative data-flow analysis and an imperative implementation.
Modeling Programs with Unstructured Control Flow for Debugging
Lecture Notes in Computer Science, 2002
Even with modern software development methodologies, the actual debugging of source code, i.e., location and identification of errors in the program when errant behavior is encountered during testing, remains a crucial part of software development. To apply model-based diagnosis techniques, which have long been state of the art in hardware diagnosis, for automatic debugging, a model of a given program must be automatically created from the source code. This work describes a model that reflects the execution semantics of the Java language, including exceptions and unstructured control flow, thereby providing unprecedented scope in the application of model-based diagnosis to programs. Besides the structural model building process, a behavioral description of some of the model components is given. Finally, impacts of the modeling decisions on the diagnostic process are considered.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.