Rungta, Neha, Pasareanu, Corina S. · NASA STI Repository (National Aeronautics and Space Administration)
Symbolic Pathfinder (SPF) combines symbolic execution with model checking and constraint solving for automated test case generation and error detection in Java programs with unspecified inputs. In this tool, programs are executed on symbolic inputs representing multiple concrete inputs. Values of variables are represented as constraints generated from the analysis of Java bytecode. The constraints are solved using off-the shelf solvers to generate test inputs guaranteed to achieve complex coverage criteria. SPF has been used successfully at NASA, in academia, and in industry.
Cited by 0Open access
Jorge A. Navas, Mario Méndez-Lojo, Manuel V. Hermenegildo · UPM Digital Archive (Technical University of Madrid) · 2008
Abstract. Automatic cost analysis of programs has been traditionally studied in terms of a number of concrete, predefined resources such as execution steps, time, or memory. However, the increasing relevance of analysis applications such as static debugging and/or certification of user-level properties (including for mobile code) makes it interesting to develop analyses for resource notions that are actually applicationdependent. This may include, for example, bytes sent or received by an application, number of files left open, number of SMSs sent or received, number of accesses to a database, money spent, energy consumption, etc. We present a fully automated analysis for inferring upper bounds on the usage that a Java bytecode program makes of a set of application programmer-definable resources. In our context, a resource is defined by programmer-provided annotations which state the basic consumption that certain program elements make of that resource. From these definitions our analysis derives functions which return an upper bound on the usage that the whole program (and individual blocks) make of that resource for any given set of input data sizes. The analysis proposed is independent of the particular resource. We also present some experimental results from a prototype implementation of the approach covering an ample set of interesting resources. 1
Cited by 6
Auri Marcelo Rizzo Vincenzi, Márcio Eduardo Delamaro, José Carlos Maldonado et al. · Software Practice and Experience · 2006
Abstract This paper describes intra‐method control‐flow and data‐flow testing criteria for the Java bytecode language. Six testing criteria are considered for the generation of testing requirements: four control‐flow and two data‐flow based. The main reason to work at a lower level is that, even when there is no source code, structural testing requirements can still be derived and used to assess the quality of a given test set. It can be used, for instance, to perform structural testing on third‐party Java components. In addition, the bytecode can be seen as an intermediate language, so the analysis performed at this level can be mapped back to the original high‐level language that generated the bytecode. To support the application of the testing criteria, we have implemented a tool named JaBUTi (Java Bytecode Understanding and Testing). JaBUTi is used to illustrate the application of the ideas developed in this paper. Copyright © 2006 John Wiley & Sons, Ltd.
Cited by 36
Softw Pract Exper, Christian Collberg, Ginger Myles · 2008
We present a study of the static structure of real Java bytecode programs. A total of 1132 Java jar-files were collected from the Internet and analyzed. In addition to simple counts (number of methods per class, number of bytecode instructions per method, etc.), structural metrics such as the complexity of controlflow and inheritance graphs were computed. We believe this study will be valuable in the design of future programming languages and virtual machine instruction sets, as well as in the efficient implementation of
Cited by 0
Wong, E · LA Referencia (Red Federada de Repositorios Institucionales de Publicaciones Científicas) · 2006
Cited by 0Open access
Zabel, Martin, Spallek, Rainer G. · Qucosa (Saxon State and University Library Dresden) · 2009
Abstract This paper introduces a new embedded Java multi-core architecture which shows a significantly better performance for a large number of cores than the related projects JopCMP and jamuth IP multi-core. The cores gain fast access to the shared heap by a fullduplex bus with pipelined transactions. Each core is equipped with local on-chip memory for the Java operand stack and the method cache to further reduce the memory bandwidth requirements. As opposed to the related projects, synchronization is supported on a per object-basis instead of a single lock. Load balancing is implemented in Java and requires no additional hardware. The multi-port memory manager includes an exact and fully concurrent garbage collector for automatic memory management. The design can be synthesized for a variable number of parallel cores and shows a linear increase in chip-space. Three different benchmarks demonstrate the very good scalability of our architecture. Due to limited chip-space on our evaluation platform, the core count could not be increased further than 8. But, we expect a smooth performance decrease.
Cited by 1Open access
Hidehiko Masuhara, Akinori Yonezawa · 1999
Run-time specialization (RTS) is a technique that e#ciently generates specialized programs with respect to runtime values. For e#ciently generating specialized programs, RTS constructs compiled native code fragments called templates at compile-time, and generates a specialized program by merely copying the templates. The generated programs are, on the other hand, less e#cient, since the technique prevents many optimizations. This study proposes bytecode specialization (BCS), which generates programs in a bytecode language, and then translates the generated bytecode into native code by using Just-In-Time (JIT) compilers. The advantages of BCS are: (1) e#cient specialization processes that are similar to RTS, (2) e#cient specialized programs thanks to the optimizations of JIT compilers, and (3) independence of source-to-bytecode compilers and of bytecode-to-native compilers thanks to our proposed binding-time analysis, which directly handles bytecode programs. Thus far, we have implement...
Cited by 0
Andreas Müller · 2014
When compiling a Java program, too restrictive access modifiers immediately lead to compilation errors. However, developers do not even get informed, if an access modifier could be more restrictive. We developed a tool called AccessModifierAnalyzer (AMA) that reports insufficiently restrictive Java access modifiers based on a static bytecode analysis. AMA analyses fields and methods and reports on visibility modifiers, the static modifier, and the final modifier. It can either be used as a stand-alone application, as part of an Apache Ant script, or as a NetBeans plug-in. In this paper, we motivate the need for a report on insufficiently restrictive access modifiers and give an overview of the architecture and usage of AMA. 1
Cited by 0
Schrammel, Peter · Zenodo (CERN European Organization for Nuclear Research) · 2023
JBMC is a bounded model checking tool for verifying Java bytecode. It is built on top of the CPROVER framework. JBMC processes Java bytecode together with a model of the standard Java libraries. It checks a set of desired properties, such as assertions and absence of uncaught exceptions, under given bounds on loops, recursion and data structures. Internally, it uses the same bounded model checking engine as its sibling tool CBMC and discharges the generated verification conditions with the help of MiniSAT 2.2.1.
Cited by 0Open access
Xavier Leroy · Lecture notes in computer science · 2001
Cited by 35Open access
Gary Meehan, Mike Joy · Software Practice and Experience · 1999
The Java Virtual Machine (JVM) was designed as the target for Java compilers, but there is no reason why it cannot be used as the target for other languages. We describe the implementation of a compiler which translates a lazy, weakly-typed functional program into Java class files. We compare the performance of our compiler to the only other known compiler from a lazy functional language to the JVM. The results are broadly similar, suggesting that to get a significant performance speed-up using this compilation paradigm will come only from increasing the performance of the JVM, rather than enhancing the compiler itself. Copyright © 1999 John Wiley & Sons, Ltd.
Cited by 8
Anonymous · Zenodo (CERN European Organization for Nuclear Research) · 2024
Cited by 0Open access
Manuel Geffken, Peter Thiemann · 2014
A side effect of a method in Java is a read or write operation that the method may perform on an object in the heap. Methods with side effects are more difficult to understand and to reason about than pure methods, in particular in the presence of aliasing. While both, Java and the underlying Java Virtual Machine (JVM), support specifying and checking types statically, neither supports ways of specifying and checking side effects statically or at run time.
Cited by 2
Hua Chen, Tao Zou, Dongxia Wang · 2007
Abstract:- The security of information systems has been the focus because of network applications. Vulnerability analysis is widely used to evaluate the security of a system to assure system security. With the help of vulnerability analysis, the security risk of a system can be predicted so that the countermeasures are arranged in advance. These will promote system security effectively. The object of vulnerability analysis is to find out the unknown security holes in a system. It could be helpful to understand the characteristics of security holes and to assess the security risk of a system. Data-flow based analysis shows its predominance in vulnerability analysis because the vulnerability is data-flow dependent. The paper discusses how to use data-flow analysis in vulnerability analysis. The way to apply data-flow analysis in Java bytecode vulnerability analyzing is presented. Key-Words:- program analysis, vulnerability, Java bytecode, data-flow analysis
Cited by 4
Andreas Gal, Christian W. Probst, Michael Franz · ACM Transactions on Programming Languages and Systems · 2008
Java Virtual Machines (JVMs) traditionally perform bytecode verification by way of an iterative dataflow analysis. Bytecode verification is necessary to ensure type safety because temporary variables in the JVM are not statically typed. We present an alternative verification mechanism that transforms JVM bytecode into Static Single Assignment Form (SSA) and thereby propagates definitions directly to uses. Type checking at control flow merge points can then be performed in a single pass. Our prototype implementation of the new algorithm is faster than the standard JVM bytecode verifier. It has the additional benefit of generating SSA as a side effect, which may be immediately useful for a subsequent dynamic compilation stage.
Cited by 6
Gaowei Bian, Ken Nakayama, Yoshitake Kobayashi et al. · 2008
Since mobile code can migrate from a remote site to a host and can interact with the resources and facilities of the host, security becomes the key to the success of mobile code computation. Existing mobile code security mechanisms such as access control are not able to fully address the import security properties of the host including confidentiality and integrity. And these practices tend to protect the host from potential attacks by confining the mobile code, thus will impair the function of mobile code. Information-flow policy is a technique that can ensure confidentiality, however the analysis of the information flow is practically difficult. This paper describes an innovative approach to provide Java mobile code system security by bytecode analysis. The key technique of the approach is the dependence analysis adapted to information flow analysis. A security model for mobile code system is also proposed in this paper. By this approach, two major properties of the host security – integrity and confidentiality can be protected while the additional restriction on mobile code can be greatly avoided. A prototype has been implemented, which can be applied to analyze Java class file, applet and mobile agent.
Cited by 0
Michael J. Jipping, Cameron Calka, Brian O’Neill et al. · 2007
Assbly language is a valuable subject to teach, yet one of the most underappreciated by students. Students do not see the need for assbly language and they get through it as quickly as possible. Given the time in a computer organization course to teach assbly language, assignments -- either quick-and-easy ones or those contrived-to-teach-a-point -- contribute to this attitude of malaise. This paper documents a project to inject some fun into the teaching of assbly language. First, we switch the language to Java bytecode. Second, we use unique assignments to use Java bytecode with Lego Mindstorms robotics.
Cited by 9
Rasi, Stefano · AMS Degree Thesis (University of Bologna) · 2020
La piattaforma Java è stata introdotta da Sun Microsystem nel 1995 con il motto "write once, run everywhere" (scrivi una volta, esegui ovunque). La macchina virtuale Java o Java Virtual Machine (JVM), insieme al linguaggio omonimo, ha permesso agli sviluppatori di scrivere programmi per dispositivi e sistemi operativi diversi senza dovere modificare il proprio codice, e compilando per tutti questi una sola volta. \nQuesta tecnologia si è rivelata molto utile con la diffusione del web, permettendo l'esecuzione e la condivisione di programmi compilati tra diversi computer in un ottica cross-platform e con la sicurezza fornita da una macchina virtuale. \n \nLa piattaforma Java permette tutto questo grazie al bytecode Java, un linguaggio intermedio simile al linguaggio macchina in cui vengono compilati i programmi Java, e che viene poi interpretato dalla macchina virtuale. \n \nLa libreria ASM è un progetto open source del consorzio OW2--un organizzazione no-profit indipendente--che permette di decomporre, modificare e ricomporre bytecode Java. \nÈ una libreria orientata alla performance, pensata per essere veloce e compatta, \ned usata in progetti come i compilatori dei linguaggi Groovy e Kotlin e il sistema di build Gradle, diventando di fatto lo standard per la modifica di bytecode. \n \nLo scopo di questa libreria è l'analisi, la trasformazione e la generazione di classi Java compilate. Per fare questo fornisce due API, la core API event based. basata sugli eventi, e la tree API object based, basata sugli oggetti. \nLa core API sfrutta il pattern Visitor, evitando di rappresentare tutta la classe come albero, permette di utilizzare molta meno memoria, ma il suo utilizzo può risultare più difficile dell'approccio ad oggetti della tree API.
Cited by 0
Azevedo, Ana, Veidenbaum, Alex, Nicolau, Alex · eScholarship (California Digital Library) · 2002
This paper exploits the concept of optimizing the interpreted execution of Java programs with SuperOperators (SOs). SOs are groups of bytecode operations used to produce interpreter engines with specialized instructions. The present work makes 3 distinguished contributions to this topic.Firstly, we show that less than 20 SOs formed by basic blocks cover more than 50% of all bytecodes executed by an application and are enough to yield the bulk of performance improvement when optimizing interpreters with SOs. We analyze SOs formed by the most frequently executed program basic blocks and SOs formed by special sub-patterns of Java bytecode operations that compose the basic blocks. Such sub-patterns are extensions of PicoJava's stack operation folding (OF) patterns. Unlike SOs formed by basic blocks, we find OF patterns repeat across a wide range of applications.Secondly, we compare techniques for optimizing interpreters with SOs. We show that the number of stack accesses and stack pointer updates, implicit in the bytecode semantics, is more limiting to the interpreter performance than the bytecode dispatch overhead. Our findings suggest that an interpreter that fully optimizes the top SOs formed by basic blocks, reducing both sources of overhead, yields up to fourfold performance improvement compared to previous techniques.Finally we assess the efficiency of a software implementation of the stack operation folding mechanism. We design statically customized interpreter versions that use a limited number of non-patented Java bytecode opcodes to represent SOs formed by OF patterns valuable across applications. We also propose a dynamic scheme that is more flexible in customizing the interpreter for a particular application. Both approaches use annotation attributes in the class files marking occurrences of the most valuable SOs, dispensing with the expensive pattern search and classification at runtime. Our statically customized interpreter versions, deploying a limited subset of SOs, and our dynamically customized version improve the performance of SPEC JVM98 and Java Grande Forum benchmarks by 7% to 39%.
Cited by 0
Le Danny Yang, Huo-jiao He · 2012
The compiled Java class file is not really binary files, it's just a kind of in-between code. This makes it possible for hackers to decompile the java class file, and in fact the decompiled file is almost the same as the original one. So it's very hard to protect the java application program, and there's a big issue about the security of java class file. This paper treated protecting software and using more costly forms of reverse engineering as the target, and deeply researched reverse engineering and code obfuscation about defense and attack. A prototype of Code obfuscation system (JOT) based on Java byte code is realized.
Cited by 4