Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 2,542 papers for “Bytecode”

Java Security Model and Java Security Model and Bytecode Verification Bytecode Verification

Haiping Xu · 2007

State Machine) 6 rules [6] into a SMV program, is missing. In this report, we try to use another method, which was based on labeled state transition graphs. By using the model checker introduced in paper [12], we may verify CTL formulas efficiently. 3.1 Formal Semantics of Java 3.1 Formal Semantics of Java Bytecode Instructions Bytecode Instructions The formal semantic of most Java bytecode instructions has been described in Qian's work [8]. Based on the formalism of Java byte code instructions, a Java bytecode program can be described as an ASM (Abstract State Machine). All variables in a bytecode program plus some additional variables, such as pc (program counter) become the state variables in the ASM, and each instruction is mapped to a state transition in ASM, which could be described as an ASM rule as follows: If pc == i then S I i ; where pc is the program counter, and R Ii is the instantiation of rule schemes for it's corresponding instruction I i . Thus a bytecode pr...

Cited by 0

Compiling scheme to JVM bytecode:

Bernard Serpette, Manuel Serrano · ACM SIGPLAN Notices · 2002

We have added a Java virtual machine (henceforth JVM) bytecode generator to the optimizing Scheme-to-C compiler Bigloo. We named this new compiler BiglooJVM. We have used this new compiler to evaluate how suitable the JVM bytecode is as a target for compiling strict functional languages such as Scheme. In this paper, we focus on the performance issue. We have measured the execution time of many Scheme programs when compiled to C and when compiled to JVM. We found that for each benchmark, at least one of our hardware platforms ran the BiglooJVM version in less than twice the time taken by the Bigloo version. In order to deliver fast programs the generated JVM bytecode must be carefully crafted in order to benefit from the speedup of just-in-time compilers.

Cited by 2

SSA-based Java bytecode verification

Andreas, Probst, Christian W., Franz, Michael · eScholarship (California Digital Library) · 2004

Java bytecode is commonly verified prior to execution. The standard verifier is designed as a black-box component that either accepts or rejects its input. Internally, it uses an iterative data-flow analysis to trace definitions of values to their uses to ensure type safety. The results of the data-flow analysis are discarded once that verification has completed. In many JVMs, this leads to a duplication of work, since definition-use chains will be computed all over again during just-in-time compilation. We introduce a novel bytecode verification algorithm that verifies bytecode via Static Single Assignemnt (SSA) form construction. The resulting SSA representation can immediately be used for optimization and code generation. Our prototype implementation takes less time to transform bytecode into SSA form and verify it than it takes Sun's verifier to merely confirm the validity of Java bytecode, with the added benefit that SSA is available "for free" to later compilation stages.

Cited by 0

Web-based bytecode interpreter visualization

Herber, Tobias · University Library Linz repository (Johannes Kepler Universitat Linz) · 2025

Understanding the intricacies of bytecode generation and interpretation is a fundamental yet challenging aspect of compiler construction education. Traditional teaching methods often rely on theoretical material, which can obscure the dynamic behavior of bytecode interpreters, making it difficult for students to grasp how high-level source code translates into low-level bytecode and how bytecode interpreters execute this low-level code. To address this, we implemented a web-based visualization tool designed to enhance comprehension by allowing users (developers, educators, and students) to interactively step through bytecode execution in an intuitive and visually engaging way. Our tool features a side-by-side display of high-level source code and its corresponding bytecode to clarify code generation for novices. A key component is the animated memory visualization, which illustrates memory changes within the bytecode interpreter. Animations intuitively display operations like data movement, heap object manipulation, and data mutation. Dynamic highlighting of symbol information (such as variable names and types) and control flow structures (such as if or while statements as well as function calls) clearly shows the meaning of bytecode and its effects. Users can navigate forward and backward through the bytecode execution, in addition to leveraging jump-to-position functionality for precise control, enabling in-depth exploration of program behavior. To ensure flexibility, we developed an adaptation framework based on a custom domain-specific language, which allows educators to define visualizations for various bytecode formats, enabling our tool to support different educational contexts. By providing a purpose-built interface for both educators and students, our tool supports live teaching, self-directed learning, and debugging of student-implemented compilers, fostering a deeper understanding of bytecode execution dynamics.

Cited by 0

Bytecode Generation for XQuery Compiler

Yue Chen, Yuan Fei, Husheng Liao · 2009

This paper represents a compiler for XQuery that obtains a more efficient performance by translating its programs to Java bytecode. It gives an overview of the system design with multi-phase translation structure, and describes the translation algorithm in detail. According to the result of performance experiments, running programs in Java bytecodes generated by the compiler have better performance than the interpretation of their source programs.

Cited by 0

Static Dalvik VM bytecode instrumentation

Eugene Minibaev · arXiv (Cornell University) · 2017

This work proposes a novel approach to restricting the access for blacklisted Android system API calls. Main feature of the suggested method introduced in this paper is that it requires only rootless or (user-mode) access to the system unlike previous works. For that reason this method is valuable for end-users due to the possibility of project distribution via Play Market and it does not require any phone system modifications and/or updates. This paper explains the required background of Android OS necessary for understanding and describes the method for modification Android application. In this paper the proof-of-concept implementation. That is able to block the application's IMEI requests is introduced. Also this paper lists unsuccessful methods that tried to provide the user security. Obviously with those restrictions application may lack some of features that can only be granted in unsecured environment.

Cited by 1Open access

Runtime Bytecode Transformation for Smalltalk

Marcus Denker, Sté́phane Ducasse, Éric Tanter · Bern Open Repository and Information System (University of Bern) · 2017

Transforming programs to alter their semantics is of wide interest, for purposes as diverse as off-the-shelf component adaptation, optimizatiom. trace generation, and experimentation with new language features. The current wave of interest in advanced technologies for better separation of concerns, such as aspect-oriented programming, is a solid testimony of this fact. Strangely enough, almost all proposals are formulated in the context of Java, in which tool providers encounter severe restrictions due to the rigidity of the environment. This paper presents BYTESURGEON, a library to transform binary code in Smalltalk. BYTESURGEON takes full advantage of the flexibility of the Squeak environment to enable bytecode transformation at runtime, thereby allowing dynamic, on-the-fly modification of applications. BYTESURGEON operates on bytecode in order to cope with situations where the source code is not available, while providing appropriate high-level abstractions so that users do not need to program at the bytecode level. We illustrate the use of BYTESURGEON via the implementation of method wrappers and a simple MOP, and report on its efficiency.

Cited by 1Open access

Compiling SML to Java Bytecode

Peter Bertelsen · 1998

instruction JVM instruction Jsconst ldc or ldc w Jaload aload !n?, aload, or wide aload Jastore astore !n?, astore, or wide astore Jdconst dconst !n? or ldc2 w Jdload dload !n?, dload, or wide dload Jdstore dstore !n?, dstore, or wide dstore Jfconst fconst !f?, ldc, or ldc w Jfload fload !n?, fload, or wide fload Jfstore fstore !n?, fstore, or wide fstore Jgoto goto or goto w Jiconst iconst !i?, bipush, sipush, ldc, or ldc w Jiinc iinc or wide iinc Jiload iload !n?, iload, or wide iload Jistore istore !n?, istore, or wide istore Jjsr jsr or jsr w Jlconst lconst !l? or ldc2 w Jlload lload !n?, lload, or wide lload Jlstore lstore !n?, lstore, or wide lstore Jnewarray newarray, anewarray, or multianewarray Jret ret or wide ret Jreturn areturn, dreturn, freturn, ireturn, lreturn, or return The bytecode emitter translates each of the above abstract bytecode instructions into the most compact of the corresponding JVM bytecode instructions. By introducing this level of abstraction over the instruction set of the JVM, the user of the SML-JVM toolkit is relieved from worrying about details in the JVM instruction set, e.g. which of the JVM instructions iconst !i?, bipush, sipush, and ldc should be used for pushing an integer constant onto the operand stack. The user just inserts an abstract Jiconst instruction with an Int32.int argument, and the bytecode emitter then chooses the most compact of the corresponding JVM instructions based on the value of the immediate integer argument. All other abstract bytecode instructions than those listed above are mapped directly to the corresponding JVM instructions. For example, the abstract instruction Jdup simply maps to the JVM instruction dup (represented in binary form as opcode 89). 3.4 Generating A Class File Generation of a physical...

Cited by 0

Formal Certification of Android Bytecode

Hendra Gunadi, Alwen Tiu, Rajeev Goré · arXiv (Cornell University) · 2015

Android is an operating system that has been used in a majority of mobile devices. Each application in Android runs in an instance of the Dalvik virtual machine, which is a register-based virtual machine (VM). Most applications for Android are developed using Java, compiled to Java bytecode and then translated to DEX bytecode using the dx tool in the Android SDK. In this work, we aim to develop a type-based method for certifying non-interference properties of DEX bytecode, following a methodology that has been developed for Java bytecode certification by Barthe et al. To this end, we develop a formal operational semantics of the Dalvik VM, a type system for DEX bytecode, and prove the soundness of the type system with respect to a notion of non-interference. We then study the translation process from Java bytecode to DEX bytecode, as implemented in the dx tool in the Android SDK. We show that an abstracted version of the translation from Java bytecode to DEX bytecode preserves the non-interference property. More precisely, we show that if the Java bytecode is typable in Barthe et al's type system (which guarantees non-interference) then its translation is typable in our type system. This result opens up the possibility to leverage existing bytecode verifiers for Java to certify non-interference properties of Android bytecode.

Cited by 2Open access

Compiling C to Java Bytecode

Richard L. Apodaca · Front Matter · 2006

In the ideal world for many Java developers, all software would be written in Java. The reality is that a great deal of software is written in other languages, one of the most widespread of which is C. This article discusses a unique approach to working with C code from Java, producing 100% pure Java bytecode that runs anywhere Java does.

Cited by 0Open access

Dynamic linking of polymorphic bytecode

Giovanni Lagorio · 2005

Abstract. In standard compilation of Java-like languages, the bytecode generated for a given source depends on both the source itself and the compilation environment. This latter dependency poses some unnecessary restrictions on which execution environments can be used to run the code. When using polymorphic bytecode, a binary depends only on its source and can be dynamically adapted to run on diverse environments. Dynamic linking is particularly suited to polymorphic bytecode, because it can be adapted to an execution environment as late as possible, maximizing the flexibility of the approach. We analyze how polymorphic bytecode can be dynamically linked presenting a deterministic model of a Java Virtual Machine which interleaves loading and linking steps with execution. In our model, loading and execution phases are basically standard, whereas verification handles also type constraints, which are part of polymorphic bytecode, and resolution blends in verification. 1

Cited by 0

Computational Soundness for Dalvik Bytecode

Michael Backes, Robert Künnemann, Esfandiar Mohammadi · arXiv (Cornell University) · 2016

Automatically analyzing information flow within Android applications that rely on cryptographic operations with their computational security guarantees imposes formidable challenges that existing approaches for understanding an app's behavior struggle to meet. These approaches do not distinguish cryptographic and non-cryptographic operations, and hence do not account for cryptographic protections: f(m) is considered sensitive for a sensitive message m irrespective of potential secrecy properties offered by a cryptographic operation f. These approaches consequently provide a safe approximation of the app's behavior, but they mistakenly classify a large fraction of apps as potentially insecure and consequently yield overly pessimistic results. In this paper, we show how cryptographic operations can be faithfully included into existing approaches for automated app analysis. To this end, we first show how cryptographic operations can be expressed as symbolic abstractions within the comprehensive Dalvik bytecode language. These abstractions are accessible to automated analysis and can be conveniently added to existing app analysis tools using minor changes in their semantics. Second, we show that our abstractions are faithful by providing the first computational soundness result for Dalvik bytecode, i.e., the absence of attacks against our symbolically abstracted program entails the absence of any attacks against a suitable cryptographic program realization. We cast our computational soundness result in the CoSP framework, which makes the result modular and composable.

Cited by 3Open access

Unsupervised Software Categorization Using Bytecode

Javier Escobar-Avila, Mario Linares‐Vásquez, Sonia Haiduc · 2015

Automatic software categorization is the task of assigning software systems or libraries to categories based on their functionality. Correctly assigning these categories is essential to ensure that relevant software can be easily retrieved by developers from large repositories. State of the art approaches either rely on the availability of the source code, or use supervised machine learning approaches, which require a set of already labeled software as training data. These restrictions make current approaches fail when such information is not available. We propose a novel approach, which overcomes these limitations by using semantic information recovered from byte code and an unsupervised algorithm to assign categories to software systems. We evaluated our approach in a study on the Apache Foundation Repository of Java libraries and the results indicate that our approach is able to correctly identify a correct category for 86% of the libraries.

Cited by 6