To see the other types of publications on this topic, follow the link: Java bytecode.
Dissertations / Theses on the topic 'Java bytecode'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Java bytecode.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Batchelder, Michael Robert. "Java bytecode obfuscation." Thesis, McGill University, 2007. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=18300.
Full textAbstract:
Programs written for machine execution will always be susceptible to information theft. This information can include trademarked algorithms, data embedded in the program, or even data the program accesses. As technology advances computer scientists are building more and more powerful tools for reverse-engineering such as decompilers.The Java programming language is particularly open to reverse-engineering attacks because of its well-defined, open, and portable binary format. We examine one area of better-securing the intellectual property of a Java program; obfuscation. Obfuscation of a program involves transforming the code of the program into a more complex, but semantically equivalent representation. This can include the addition of confusing control flow, the removal of certain information embedded in the program which is not explicitly required for execution, or the cloaking of data.Obfuscation is one of the only techniques available other than cryptological options. While many approaches to obfuscation are ultimately reversible, it nevertheless seriously hinders those attempting to steal information by increasing the computing time and power required by software to reverse-engineer the program and also severely increases the complexity of any source code that is recovered by the reverse-engineering.In this thesis we present a number of obfuscating transformations implemented within a new automatic tool we name the Java Bytecode Obfuscator (JBCO). We present empirical measures of the performance costs of these transformations in terms of execution speed and program size. Complexity measurements that gauge the effectiveness of the obfuscations are also given. Finally, we review the feasibility of each transformation by looking at source code generated from obfuscated bytecode by various decompilers.Les programmes écrits pour l'exécution d'ordinateur seront toujours susceptibles au vol d'information. Cette information peut inclure des algorithmes de marque de commerce, des données incluses dans le programme, ou même des données concernant les accès de programme. Suivant les avancées technologiques, les informaticiens construisent des outils de plus en plus puissants pour l'ingénierie inverse telle que le décompilateur. Le langage de programmation de Java est particulièrement ouvert aux attaques de l'ingénierie inverse en raison de son format binaire bien défini, ouvert, et portatif. Nous recherches portent sur un domaine permettant de mieux sécuriser fixer la propriété intellectuelle des programmes en Java; obscurcissement. L'obscurcissement d'un programme implique de transformer le code du programme en une représentation plus complexe mais sémantiquement équivalente. Ceci peut inclure l'addition de l'écoulement embrouillant de commande, de la supression de certaines informations incluses dans les programmes dont l'exécution n'est pas spécifiquement exigée, ou de la dissimulation des données. Excepté les techniques cryptologique s, l'obscurcissement est l'une des seules techniques disponibles. Même si beaucoup de stratégies de l'obscurissment sont finalement réversibles, il gêne sérieusement ceux qui essayent de voler l'information en augmentant la durée de calcul et la puissance exigées par les logicels d'ingénierie inverse et augmente considérablement la complexité de n'importe quel code source récupere par cette technique. Dans cette thèse nous présentons un certain nombre de transformations d'obscurcissement mises en application dans un outil automatique que nous appelons le Java Bytecode Obfuscator (JBCO). Nous présentons des mesures empiriques des coûts d'exécution de ces transformations en termes de vitesse d'exécution et taille de programme. Des mesures de complexité qui mesurent l'efficacité des obscurc
2
Klein, Gerwin. "Verified Java bytecode verification." [S.l. : s.n.], 2003. http://deposit.ddb.de/cgi-bin/dokserv?idn=967128749.
Full text
3
Shah, Rahul Arvind. "Vulnerability assessment of Java bytecode." Auburn, Ala., 2005. http://repo.lib.auburn.edu/Send%2012-16-07/SHAH_RAHUL_44.pdf.
Full text
4
Ochani, Vidit. "Java bytecode to Pilar translator." Kansas State University, 2013. http://hdl.handle.net/2097/16987.
Full textAbstract:
Master of ScienceDepartment of Computing and Information Sciences
Robby
Software technology is the pivot around which all modern industries revolve. It is not surprising that industries of diverse nature such as finance, business, engineering, medicine, defense, etc. have assimilated sophisticated software in every step of functioning. Subsequently, with larger reach of application, software technology has evolved intricately; thereby thwarting the desirable testing of software. Companies are investing millions of dollars in manual and automated testing, however, software bugs continue to persist. It is well known that even a trivial bug can ultimately cost the company millions of dollars. Therefore, we need smarter tools to help eliminate bugs. Sireum is a research project to develop a software analysis platform that incorporates various tools and techniques. Symbolic execution, model checking, deductive reasoning and control flow graph are few examples of the aforementioned techniques. The Sireum platform is based on previous projects like the Indus static analysis framework, the Bogor model checking framework and the Bandera Java model checker. It uses the Pilar language as intermediate representation. Any language which can be translated to Pilar can be analyzed by Sireum. There exists translator for Spark - a verifiable subset of Ada for building high-integrity systems. In this report, we are presenting one such translator for Java Bytecode - A frontend which can generate Pilar from Java intermediate representation. The translator emulates the working of the Java Virtual Machine(JVM), by simulating a stack-based virtual machine. It will help us analyse JVM based softwares, such as, mobile applications for Android. We also evaluate and report statistics on the efficiency and speed of translation.
5
Doyon, Stéphane. "On the security of Java, the Java bytecode verifier." Thesis, National Library of Canada = Bibliothèque nationale du Canada, 1999. http://www.collectionscanada.ca/obj/s4/f2/dsk1/tape7/PQDD_0004/MQ41890.pdf.
Full text
6
Vallee-Rai, Raja. "Soot : a java bytecode optimization framework." Thesis, McGill University, 2000. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=30836.
Full textAbstract:
Java provides many attractive features such as platform independence, execution safety, garbage collection and object orientation. These features facilitate application development but are expensive to support; applications written in Java are often much slower than their counterparts written in C or C++. To use these features without having to pay a great performance penalty, sophisticated optimizations and runtime systems are required.We present SOOT, a framework for optimizing Java bytecode. The framework is implemented in Java and supports three intermediate representations for representing Java bytecode: BAF, a streamlined representation of bytecode which is simple to manipulate; JIMPLE, a typed 3-address intermediate representation suitable for optimization; and GRIMP an aggregated version of JIMPLE suitable for decompilation. SOOT also contains a set of transformations between these intermediate representations, and an application programming interface (API) is provided to write optimizations and analyses on Java bytecode in these forms.
In order to demonstrate the usefulness of the framework, we have implemented intraprocedural and whole program optimizations. To show that whole program bytecode optimization can give performance improvements, we provide experimental results for 10 large benchmarks, including 8 SPECjvm98 benchmarks running on JDK 1.2. These results show a speedup of up to 38%.
7
Pinto, Camara Tarcisio. "Otimização bytecode Java na plataforma J2ME." Universidade Federal de Pernambuco, 2004. https://repositorio.ufpe.br/handle/123456789/2567.
Full textAbstract:
Made available in DSpace on 2014-06-12T15:59:18Z (GMT). No. of bitstreams: 2
arquivo5023_1.pdf: 1253051 bytes, checksum: 0bb4a72739c259711e027e24c5f3659f (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2004Conselho Nacional de Desenvolvimento Científico e Tecnológico
Aplicações para os dispositivos móveis, como telefones celulares e pagers, implementadas em J2ME (Java 2 Micro Edition) são desenvolvidas sob severas restrições de tamanho e desempenho do código. A indústria tem adotado ferramentas de otimização, como obfuscators e shrinkers, que aplicam otimizações de programa inteiro (Whole Program Optimizations) considerando que o código gerado não será estendido ou usado por outras aplicações. Infelizmente, os desenvolvedores freqüentemente não conhecem suficientemente nestas ferramentas e continuam sacrificando a qualidade do código na tentativa de otimizar suas aplicações. Este trabalho apresenta um estudo original identificando a efetividade das otimizações mais comuns nos obfuscators. Este estudo mostra também que a otimização de Method Inlining, conhecida pelos benefícios de desempenho, tem sido negligenciada por estas ferramentas por normalmente esperarse que ela tenha efeito negativo sobre o tamanho de código. Assim, este trabalho contribui com uma implementação de method inlining entre classes e fundada no princípio de otimização de programa inteiro, capaz de melhorar tanto o tamanho do código como o desempenho da aplicação, ao remover cerca de 50% dos métodos alcançáveis. Finalmente, na tentativa de ajudar os desenvolvedores a tirar o melhor proveito destas ferramentas, o estudo inclui também um guia de boas práticas de programação considerando as otimizações implementadas pelos obfuscators
8
Modesto, Francisco. "Development of a Java Bytecode Front-End." Thesis, Växjö University, School of Mathematics and Systems Engineering, 2009. http://urn.kb.se/resolve?urn=urn:nbn:se:vxu:diva-6210.
Full textAbstract:
The VizzAnalyzer is a powerful software analysis tool. It is able to extract information from various software representations like source code but also other specifications like UML. The extracted information is input to static analysis of these software projects. One programming language the VizzAnalyzer can extract information from is Java source code.
Analyzing the source code is sufficient for most of the analysis. But, sometimes it is necessary to analyze compiled classes either because the program is only available in byte-code, or the scope of analysis includes libraries that exist usually in binary form. Thus, being able to extract information from Java byte-code is paramount for the extension of some analyses, e.g., studying the dependecy structure of a project and the libraries it uses.
Currently, the VizzAnalyzer does not feature information extraction from Java byte-code. To allow, e.g., the analysis of the project dependency structure, we extend the VizzAnalyzer tool with a bytecode front-end that will allow the extraction of information from Java bytecode.
This thesis describes the design and implementation of the bytecode front-end. After we implemented and integrated the new front-end with the VizzAnalyzer, we are now able to perform new analyses that work on data extracted from both, source- and bytecode.
9
Zabel, Martin. "Effiziente Mehrkernarchitektur für eingebettete Java-Bytecode-Prozessoren." Doctoral thesis, Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2012. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-84156.
Full textAbstract:
Die Java-Plattform bietet viele Vorteile für die schnelle Entwicklung komplexer Software. Für die Ausführung des Java-Bytecodes auf eingebetteten Systemen eignen sich insbesondere Java-(Bytecode)-Prozessoren, die den Java-Bytecode als nativen Befehlssatz unterstützen. Die vorliegende Arbeit untersucht detailliert die Gestaltung einer Mehrkernarchitektur für Java-Prozessoren zur effizienten Nutzung der auf Thread-Ebene ohnehin vorhandenen Parallelität eines Java-Programms. Für die Funktionalitäts- und Leistungsbewertung eines Prototyps wird eine eigene Trace-Architektur eingesetzt. Es wird eine hohe Leistungssteigerung bei nur geringem zusätzlichem Hardwareaufwand erzielt sowie eine höhere Leistung als bekannte alternative Ansätze erreicht.
10
Zabel, Martin, and Rainer G. Spallek. "SHAP — Scalable Multi-Core Java Bytecode Processor." Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2012. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-97619.
Full textAbstract:
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.
11
Quigley, Claire Louise. "A programming logic for Java bytecode programs." Thesis, University of Glasgow, 2004. http://theses.gla.ac.uk/3030/.
Full textAbstract:
One significant disadvantage of interpreted bytecode languages, such as Java, is their low execution speed in comparison to compiled languages like C. The mobile nature of bytecode adds to the problem, as many checks are necessary to ensure that downloaded code from untrusted sources is rendered as safe as possible. But there do exist ways of speeding up such systems. One approach is to carry out static type checking at load time, as in the case of the Java Bytecode Verifier. This reduces the number of runtime checks that must be done and also allows certain instructions to be replaced by faster versions. Another approach is the use of a Just In Time (JIT) Compiler, which takes the bytecode and produces corresponding native code at runtime. Some JIT compilers also carry out some code optimization. There are, however, limits to the amount of optimization that can safely be done by the Verifier and JITs; some operations simply cannot be carried out safely without a certain amount of runtime checking. But what if it were possible to prove that the conditions the runtime checks guard against would never arise in a particular piece of code? In this case it might well be possible to dispense with these checks altogether, allowing optimizations not feasible at present. In addition to this, because of time constraints, current JIT compilers tend to produce acceptable code as quickly as possible, rather than producing the best code possible. By removing the burden of analysis from them it may be possible to change this. We demonstrate that it is possible to define a programming logic for bytecode programs that allows the proof of bytecode programs containing loops. The instructions available to use in the programs are currently limited, but the basis is in place to extend these. The development of this logic is non-trivial and addresses several difficult problems engendered by the unstructured nature of bytecode programs.
12
Zabel, Martin, and Rainer G. Spallek. "SHAP — Scalable Multi-Core Java Bytecode Processor." Technische Universität Dresden, 2009. https://tud.qucosa.de/id/qucosa%3A26171.
Full textAbstract:
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.
13
Žamberský, Zdeněk. "Zpětný překladač jazyka Java." Master's thesis, Vysoké učení technické v Brně. Fakulta strojního inženýrství, 2015. http://www.nusl.cz/ntk/nusl-232034.
Full textAbstract:
The goal was to create decompiler for Java programing language. Decompiler should reconstruct original Java source code from class files, representing its compiled form. First part of thesis focuses on Java langage, its compilation and structure of class file. Then Java Virtual Machine and its instruction set is discussed. After that thesis focuses on decompilation and algoritms designed and used for decompiler realization. Examples of decompiled code are presented.
14
Rasi, Stefano. "Manipolazione di Bytecode Java con la libreria ASM." Bachelor's thesis, Alma Mater Studiorum - Università di Bologna, 2020.
Find full textAbstract:
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.
Questa 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.
La 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.
La libreria ASM è un progetto open source del consorzio OW2--un organizzazione no-profit indipendente--che permette di decomporre, modificare e ricomporre bytecode Java.
È una libreria orientata alla performance, pensata per essere veloce e compatta,
ed 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.
Lo 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.
La 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.
15
Lagerkvist, Mikael Zayenz. "Machine Assisted Reasoning for Multi-Threaded Java Bytecode." Thesis, KTH, Electronic, Computer and Software Systems, ECS, 2005. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-9512.
Full textAbstract:
In this thesis an operational semantics for a subset of the Java Virtual Machine (JVM) is developed and presented. The subset contains standard operations such as control flow, computation, and memory management. In addition, the subset contains a treatment of parallel threads of execution.
The operational semantics are embedded into a $µ$-calculus based proof assistant, called the VeriCode Proof Tool (VCPT). VCPT has been developed at the Swedish Institute of Computer Science (SICS), and has powerful features for proving inductive assertions.
Some examples of proving properties of programs using the embedding are presented.
I det här examensarbetet presenteras en operationell semantik för en delmängd av Javas virtuella maskin. Den delmängd som hanteras innehåller kontrollflöde, beräkningar och minneshantering. Vidare beskrivs semantiken för parallella exekveringstrådar.
Den operationella semantiken formaliseras i en bevisassistent for $µ$-kalkyl, VeriCode Proof Tool (VCPT). VCPT har utvecklats vid Swedish Institiute of Computer Science (SICS), och har kraftfulla tekniker för att bevisa induktiva påståenden.
Några exempel på bevis av egenskaper hos program användandes formaliseringen presenteras också.
16
HILLERT, EMILIA. "Obfuscate Java bytecode: an evaluation ofobfuscating transformations using JBCO." Thesis, KTH, Skolan för datavetenskap och kommunikation (CSC), 2014. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-153909.
Full textAbstract:
Today, software is one of the most complex and intriguing technologies around us. Software development companies must be able to protect their products in order to stay strong against its competitors and against other threats. One solution to this problem is code obfuscation. This master’s thesis investigates how to protect Java source codeagainst reverse engineering. Three obfuscating transformations was successfully implemented and evaluated within a specific obfuscator named JBCO. The conclusion is that in many cases, code obfuscation provides a higher level of obscurity to a program, which makes code obfuscation a good supplement to complicate the reverse engineering process.Obfuskera Java bytekod: en utvärdering av obfuskeringstransformationer med JBCO. För att ett företag ska vara konkurrenskraftigt krävs det ofta att företaget skyddar sina produkter. Det kan vara förödande för ett företag om en konkurrent får tillgång till deras produkthemligheter och leda till företagets undergång.Detta gäller framförallt företag som utvecklar mjukvara. En lösning på detta problem är kodobfuskering. Detta examensarbete undersöker hur man skyddar Java källkod mot dekompilatorer.Tre stycken obfuskeringstransformationer implementerades och evaluerades i obfuskeraren JBCO. Slutsatsenär att kodobfuskering i många fall leder till att ett program blir svårare att tyda för en människa. Detta gör obfuskering till ett bra komplement för att försvåra processen att dekompilera ett program.
17
Mbhambhu, Tsakani Joseph. "A Java bytecode compiler for the 8051 micro-controller." Thesis, Stellenbosch : Stellenbosch University, 2002. http://hdl.handle.net/10019.1/52645.
Full textAbstract:
Thesis (MScEng)--Stellenbosch University, 2002.ENGLISH ABSTRACT: This report describes the development of a Java Bytecode Compiler (JBC) for the 8051 micro-controller. Bytecodes are found in the class file generated when a Java source file is compiled with the java compiler (javac). On Java platforms, the Java Virtual Machine (JVM) interprets and executes the bytecodes. Currently existing Java platforms do not support programming the 8051 using Java. As an 8-bit micro-controller with only 64 KB of total memory, the 8051's word size and memory is too limited to implement a NM. Moreover, full applications of the 8051 require that it handles hardware interrupts and access 110 ports and special registers. This thesis proposes a JBC to compile the standard bytecodes found in the class file and generate equivalent assembly code that can run on the 8051. The JBC was tested on the 8051 compatible AT89C52*44 micro-controller with a program that simulates an irrigation controller. The code generated by the JBC executes correctly but is large in size and runs slower than code of a program written in assembly. Conclusions drawn are that the JBC can be used to compile Java programs intended for the 8051 and its family of micro-controllers. In particular, it is especially a good tool for people who prefer Java to other languages. The JBC is suitable for smaller programs that do not have efficiency as a major requirement.
AFRIKAANSE OPSOMMING: Hierdie tesis beskryf die ontwikkeling van 'n Java "Bytecode" samesteller (Java Bytecode Compiler, JBC) vir die 8051 mikro beheerder argitektuur. "Bytecodes" is die produk van die standaard Java samesteller "javac" en word deur 'n platform spesifieke Java Virtuele Masjien gelees en uitgevoer. Geen NM is huidig beskikbaar vir die 8051 argitektuur nie. Die gekose 8-bis 8051 mikro beheerder het 'n beperkte interne geheue van 64kB. Hierdie beperking maak dit nie geskik vir 'n IVM nie. Daar moet ook voorsiening gemaak word om hardeware onderbrekings te hantering en te kan kommunikeer met die poorte en spesiale registers van die mikro beheerder. JBC word ontwikkel wat die standaard "Bytecode" kompileer na geskikte masjien kode wat dan op die mikro beheerder gebruik kan word. Die JBC is ontwikkel en toets en 'n eenvoudige besproeiing program is geskryf om op 'n Atmel AT89C52*44 te loop. Die kode werk goed maar is nog nie geoptimeer nie en loop onnodig stadig. Optimerings metodes word aanbeveel en bespreek. Die gevolgtrekking is dat die huidige JBC kan gebruik word om Java kode te skryfvir die 8051 beheerder. Dit maak die hardeware platform nou beskikbaar aan Java programmeerders. Daar moet wel gelet word dat die JBC op die oomblik net geskik is vir klein programme en waar spoed nie die primêre vereiste is nie.
18
de, Carvalho Gomes Pedro. "Sound Modular Extraction of Control Flow Graphs from Java Bytecode." Licentiate thesis, KTH, Teoretisk datalogi, TCS, 2012. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-105275.
Full textAbstract:
Control flow graphs (CFGs) are abstract program models that preserve the control flow information. They have been widely utilized for many static analyses in the past decades. Unfortunately, previous studies about the CFG construction from modern languages, such as Java, have either neglected advanced features that influence the control flow, or do not provide a correctness argument. This is a bearable issue for some program analyses, but not for formal methods, where the soundness of CFGs is a mandatory condition for the verification of safety-critical properties. Moreover, when developing open systems, i.e., systems in which at least one component is missing, one may want to extract CFGs to verify the available components. Soundness is even harder to achieve in this scenario, because of the unknown inter-dependencies involving missing components. In this work we present two variants of a CFG extraction algorithm from Java bytecode considering precise exceptional flow, which are sound w.r.t to the JVM behavior. The first algorithm extracts CFGs from fully-provided (closed) programs only. It proceeds in two phases. Initially the Java bytecode is translated into a stack-less intermediate representation named BIR, which provides explicit representation of exceptions, and is more compact than the original bytecode. Next, we define the transformation from BIR to CFGs, which, among other features, considers the propagation of uncaught exceptions within method calls. We then establish its correctness: the behavior of the extracted CFGs is shown to be a sound over-approximation of the behavior of the original programs. Thus, temporal safety properties that hold for the CFGs also hold for the program. We prove this by suitably combining the properties of the two transformations with those of a previous idealized CFG extraction algorithm, whose correctness has been proven directly. The second variant of the algorithm is defined for open systems. We generalize the extraction algorithm for closed systems for a modular set-up, and resolve inter-dependencies involving missing components by using user-provided interfaces. We establish its correctness by defining a refinement relation between open systems, which constrains the instantiation of missing components. We prove that if the relation holds, then the CFGs extracted from the components of the original open system are sound over-approximations of the CFGs for the same components in the refined system. Thus, temporal safety properties that hold for an open system also hold for closed systems that refine it. We have implemented both algorithms as the ConFlEx tool. It uses Sawja, an external library for the static analysis of Java bytecode, to transform bytecode into BIR, and to resolve virtual method calls. We have extended Sawja to support open systems, and improved its exception type analysis. Experimental results have shown that the algorithm for closed systems generates more precise CFGs than the modular algorithm. This was expected, due to the heavy over-approximations the latter has to perform to be sound. Also, both algorithms are linear in the number of bytecode instructions. Therefore, ConFlEx is efficient for the extraction of CFGs from either open, or closed Java bytecode programs.QC 20121122
19
Isber, Elias. "A compiler for all context-free grammars generating Java bytecode." Thesis, National Library of Canada = Bibliothèque nationale du Canada, 1997. http://www.collectionscanada.ca/obj/s4/f2/dsk2/ftp04/mq25612.pdf.
Full text
20
Arte, Ashish Sturgill David Brian. "Java bytecode compilation for high-performance, platform-independent logical inference." Waco, Tex. : Baylor University, 2005. http://hdl.handle.net/2104/2887.
Full text
21
Gagnon, Etienne. "A portable research framework for the execution of Java bytecode /." Thesis, McGill University, 2002. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=82876.
Full textAbstract:
Compilation to bytecode paired with interpretation is often used as a technique to easily build prototypes for new programming languages. Some languages, including Java, push this further and use the bytecode layer to isolate programs from the underlying platform. Current state-of-the-art commercial and research Java virtual machines implement advanced just-in-time and adaptive compilation techniques to deliver high-performance execution of Java bytecode. Yet, experimenting with new features such as adding new bytecodes or redesigning the type system can be a daunting task within these complex systems, when new features invalidate assumptions on which the internal dynamic optimizing compiler depends. On the other hand, simpler existing Java bytecode interpreters, written purely in high-level languages, deliver poor performance. The main motivation behind this thesis was to answer the question: How fast can a portable, easily modifiable Java bytecode interpreter be? In order to address this question, we have designed and developed the Sable VM research framework, a portable interpreter-based Java virtual machine written in portable C.In this thesis we introduce innovative techniques for implementing an efficient, yet portable Java bytecode interpreter. These techniques address three areas: instruction dispatch, memory management, and synchronization. Specifically, we show how to implement an inline-threaded engine in the presence of lazy code preparation, without incurring a high synchronization penalty. We then introduce a logical partitioning of runtime system memory that simplifies memory management, and a related sparse interface virtual table design for fast interface-method invocation. We show how to efficiently compute space-efficient garbage collection maps for verifiable bytecode. We also present a bidirectional object layout that simplifies garbage collection. Finally, we introduce an improvement to thin locks, eliminating busy-wait in case of contention. Our experiments within the Sable VM framework show that inline-threading [PR98] Java delivers significant performance improvement over switch and direct-threading, that sparse interface tables cause no memory loss, and that our map computation algorithm delivers a very small number of distinct garbage collection maps. Our overall performance measurements show that, using our techniques, a portable interpreter can deliver competitive interpretation performance, and even surpass that of a less-portable state-of-the-art interpreter on some benchmarks.
22
de, Carvalho Gomes Pedro, and Attilio Picoco. "Sound Extraction of Control-Flow Graphs from open Java Bytecode Systems." KTH, Teoretisk datalogi, TCS, 2012. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-104076.
Full textAbstract:
Formal verification techniques have been widely deployed as means to ensure the quality of software products. Unfortunately, they suffer with the combinatorial explosion of the state space. That is, programs have a large number of states, sometimes infinite. A common approach to alleviate the problem is to perform the verification over abstract models from the program. Control-flow graphs (CFG) are one of the most common models, and have been widely studied in the past decades. Unfortunately, previous works over modern programming languages, such as Java, have either neglected features that influence the control-flow, or do not provide a correctness argument about the CFG construction. This is an unbearable issue for formal verification, where soundness of CFGs is a mandatory condition for the verification of safety-critical properties. Moreover, one may want to extract CFGs from the available components of an open system. I.e., a system whose at least one of the components is missing. Soundness is even harder to achieve in this scenario, because of the unknown inter-dependences between software components. In the current work we present a framework to extract control-flow graphs from open Java Bytecode systems in a modular fashion. Our strategy requires the user to provide interfaces for the missing components. First, we present a formal definition of open Java bytecode systems. Next, we generalize a previous algorithm that performs the extraction of CFGs for closed programs to a modular set-up. The algorithm uses the user-provided interfaces to resolve inter-dependences involving missing components. Eventually the missing components will arrive, and the open system will become closed, and can execute. However, the arrival of a component may affect the soundness of CFGs which have been extracted previously. Thus, we define a refinement relation, which is a set of constraints upon the arrival of components, and prove that the relation guarantees the soundness of CFGs extracted with the modular algorithm. Therefore, the control-flow safety properties verified over the original CFGs still hold in the refined model. We implemented the modular extraction framework in the ConFlEx tool. Also, we have implemented the reusage from previous extractions, to enable the incremental extraction of a newly arrived component. Our technique performs substantial over-approximations to achieve soundness. Despite this, our test cases show that ConFlEx is efficient. Also, the extraction of the CFGs gets considerable speed-up by reusing results from previous analyses.QC 20121029
Verification of Control-Flow Properties of Programs with Procedures(CVPP)
23
Urquhart, Luke Dominic Mark. "Worst-case resource-usage analysis of Java Card classic editions application bytecode." Thesis, Imperial College London, 2016. http://hdl.handle.net/10044/1/42538.
Full textAbstract:
Java Card is the dominant smartcard technology in use today, with over 12 billion Java Card smartcards having shipped globally in the last 15 years. Almost exclusively, the deployed Java Card smartcards are instances of a Classic edition for which garbage collection is an optional component in even the most recent Classic edition. Poorly written or malicious Java Card applications may drain the available memory of a Java Card Virtual Machine to the point the card becomes unusable, and undisciplined use of the transaction mechanism may exhaust the available transaction buffers, resulting in programmatic abort by the Java Card Runtime Environment and so limit the range of services a Java Card application may successfully be able to offer. Given the size and global nature of the user base, and the commercial importance of Java Card, there is a stunning lack of tools supporting analysis or certification of the memory, transactional or CPU usage of Java Card applications. In this thesis we present a worst-case resource-usage analysis tool for Java Card which is capable of producing worst-case memory usage and worst-case execution-time estimates for Java Card applications (also known as applets). Our main theoretical contribution is a static analysis for Java Card applets at the bytecode level which conservatively approximates properties of interest affecting memory usage, input-output/APDU usage and transaction usage. Our static analysis provides the high-level information for subsequent worst-case resource-usage analysis in our tool which exploits well-known results and techniques from hard real-time systems. We generate a resource usage graph per registered applet lifecycle method entry point as the start node and the control-flow returning to the Java Card Runtime Environment as the final node. We use the Implicit Path Enumeration Technique to generate and solve Integer Linear Programming problems representing the worst-case memory-usage and worst-case execution-time.
24
Vittoria, Claude. "Études et principes de conception d'une machine langage Java : le processeur bytecode." Rennes 1, 2008. ftp://ftp.irisa.fr/techreports/theses/2008/vittoria.pdf.
Full textAbstract:
La démocratisation d'Internet facilite aujourd'hui le téléchargement des applications. Mais en contrepartie, le risque de corruption de ces applications à des fins malveillantes peut mettre en péril l'intégrité du système qui les exécute et la sécurité des données. Le langage Java apporte des propriétés telles que la vérification de l'intégrité du code, et la sûreté d'exécution des applications pour palier à ces risques. Nous avons cherché à utiliser le langage Java pour construire une plateforme minimale dédiée à son exécution : le processeur bytecode. Nous avons isolé les éléments manquants au sein d'une JVM pour écrire un système d'exploitation, tel l'impossibilité de manipuler nativement des ressources matérielles, ainsi que les fonctionnalités déjà présentes, nécessaires au fonctionnement d'un système d'exploitation, et donc dépendantes d'une implémentation spécifique, comme la gestion de flots d'exécutionNowadays the democratization of the Internet facilitates the downloading of applications. However, the risk of corruption of these applications with malicious intents could affect the integrity of the system that executes them and data security. The Java language provides properties such as checking the integrity of the code, and safety enforcement applications to prevent these risks. We tried to use the Java language to build a minimum platform dedicated to enforce the bytecode processor. We isolated the missing elements in a JVM to write an operating system, such as the inability to handle natively material resources, as well as the features already provided and required by an operating system, and therefore dependent on a specific implementation, such as managing workflows
25
Charreteur, Florence. "Modélisation par contraintes de programmes en bytecode Java pour la génération automatique de tests." Phd thesis, Université Européenne de Bretagne, 2010. http://tel.archives-ouvertes.fr/tel-00497785.
Full textAbstract:
La vérification des programmes est indispensable pour maintenir un certain niveau de qualité et de fiabilité. Le test est à ce jour le moyen de vérification des logiciels le plus utilisé dans l¤industrie. La programmation par contraintes est vue comme un moyen efficace pour automatiser la génération de données de test. Dans cette thèse nous proposons une modélisation par contraintes de la sémantique du bytecode Java, ainsi qu¤une méthode, basée sur cette modélisation, pour générer automatiquement des données de test. Notre modèle à contraintes de la sémantique d¤un programme en bytecode Java permet de faire des déductions efficaces, y compris en présence de structures de données complexes ou d¤héritage. En particulier, l¤utilisation de variables de type permet de prendre en compte l¤héritage et les appels de méthodes polymorphes. Notre méthode de génération de données de test exploite le modèle à contraintes pour couvrir des instructions particulières du programme sous test. Elle se base sur un parcours en arrière du graphe de flot de contrôle pour énumérer des chemins menant aux instructions cibles. Elle est en particulier adaptée à la couverture d¤instructions non couvertes par les autres méthodes de génération de données de test. Enfin cette méthode est mise en application dans un prototype, JAUT (Java Automatic Unit Testing). Les expériences montrent que le prototype permet d¤augmenter la couverture des instructions obtenue avec les autres outils disponibles.
26
Charreteur, Schadle Florence. "Modélisation par contraintes de programmes en bytecode java pour la génération automatique de tests." Rennes 1, 2010. http://www.theses.fr/2010REN1S019.
Full textAbstract:
La vérification des programmes est indispensable pour maintenir un certain niveau de qualité et de fiabilité. Le test est à ce jour le moyen de vérification des logiciels le plus utilisé dans l’industrie. La programmation par contraintes est vue comme un moyen efficace pour automatiser la génération de données de test. Dans cette thèse nous proposons une modélisation par contraintes de la sémantique du bytecode Java, ainsi qu’une méthode, basée sur cette modélisation, pour générer automatiquement des données de test. Notre modèle à contraintes de la sémantique d’un programme en bytecode Java permet de faire des déductions efficaces, y compris en présence de structures de données complexes ou d’héritage. En particulier, l’utilisation de variables de type permet de prendre en compte l’héritage et les appels de méthodes polymorphes. Notre méthode de génération de données de test exploite le modèle à contraintes pour couvrir des instructions particulières du programme sous test. Elle se base sur un parcours en arrière du graphe de flot de contrôle pour énumérer des chemins menant aux instructions cibles. Elle est en particulier adaptée à la couverture d’instructions non couvertes par les autres méthodes de génération de données de test. Enfin cette méthode est mise en application dans un prototype, JAUT (Java Automatic Unit Testing). Les expériences montrent que le prototype permet d’augmenter la couverture des instructions obtenue avec les autres outils disponiblesProgram verification is essential to maintain a certain level of quality and reliability. Testing is to date the most used software verification mean in industry. Constraint programming is seen as an effective way to automate test data generation. In this thesis we propose a constraint modeling of the Java bytecode semantics, and a method, based on this modeling, to automatically generate test data. Ourconstraint model of the semantics of a Java bytecode program allows to make effective deductions, including the presence of complex data structures or inheritance. In particular, the use of type variables can take into account inheritance and polymorphic method calls. Our method of test data generation uses the constraint model to cover specific instructions. This method is in particular a good way to cover instructions that are not reached by other methods of test data generation. Finally this method is implemented in a prototype named JAUT (Java Automatic Unit Testing). The experiments show that the prototype can increase the statements coverage obtained with the other available tools
27
Hubert, Laurent. "Foundations and implementation of a tool bench for static analysis of Java bytecode programs." Rennes 1, 2010. http://www.theses.fr/2010REN1S122.
Full textAbstract:
In this thesis we study the static analysis of Java bytecode and its semantics foundations. The initialization of an information system is a delicate operation where security properties are enforced and invariants installed. Initialization of fields, objects and classes in Java are difficult operations. These difficulties may lead to security breaches and to bugs, and make the static verification of software more difficult. This thesis proposes static analyses to better master initialization in Java. Hence, we propose a null pointer analysis that finely tracks initialization of fields. It allows proving the absence of dereferencing of null pointers (NullPointerException) and refining the intra-procedural control flow graph. We present another analysis to refine the inter-procedural control flow due to class initialization. This analysis directly allows inferring more precise information about static fields. Finally, we propose a type system that allows enforcer secure object initialization, hence offering a sound and automatic solution to a known security issue. We formalize these analyses, their semantic foundations, and prove their soundness. Furthermore, we also provide implementations. We developed several tools from our analyses, with a strong focus at having sound but also efficient tools. To ease the adaptation of such analyses, which have been formalized on idealized languages, to the full-featured Java bytecode, we have developed a library that have been made available to the community and is now used in other research labs across EuropeDans cette thèse, nous nous intéressons à l’analyse statique du bytecode Java. L’initialisation d’un système d’information est une phase délicate où des propriétés de sécurité sont vérifiées et des invariants installés. L’initialisation en Java pose des difficultés, que ce soit pour les champs, les objets ou les classes. De ces difficultés peuvent résulter des failles de sécurité, des erreurs d’exécution (bugs), ou une plus grande difficulté à valider statiquement ces logiciels. Cette thèse propose des analyses statiques répondant aux problèmes d’initialisation de champs, d’objets et de classes. Ainsi, nous décrivons une analyse de pointeurs nuls qui suit finement l’initialisation des champs et permet de prouver l’absence d’exception de pointeur nuls (NullPointerException) et de raffiner le graphe de flot de contrôle intra-procédural. Nous proposons aussi une analyse pour raffiner le graphe de flot de contrôle inter-procédural liée à l’initialisation de classe et permettant de modéliser plus finement le contenu des champs statiques. Enfin, nous proposons un système de type permettant de garantir que les objets manipulés sont complètement initialisés, et offrant ainsi une solution formelle et automatique à un problème de sécurité connu. Les fondations sémantiques de ces analyses sont données. Les analyses sont décrites formellement et prouvées correctes. Pour pouvoir adapter ces analyses, formalisées sur de petits langages, au bytecode, nous avons développé une bibliothèque logicielle. Elle nous a permis de produire des prototypes efficaces gérant l’intégralité du bytecode Java
28
Žárský, Jan. "Instrumentace Java programů, kontrakty pro paralelismus." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2021. http://www.nusl.cz/ntk/nusl-445489.
Full textAbstract:
Contracts for concurrency describe required atomicity of method sequences in concurrent programs. This work proposes a dynamic analyzer to verify programs written in Java against contracts for concurrency. The analyzer was designed to detect violations of parametric contracts with spoilers. The proposed analyzer was implemented as an extension to the RoadRunner framework. Support for accessing the method arguments and return values was added to RoadRunner as a part of the solution. The analyzer was fully implemented and verified on a set of testing programs.
29
Zabel, Martin [Verfasser], Rainer G. [Akademischer Betreuer] Spallek, and Djamshid [Akademischer Betreuer] Tavangarian. "Effiziente Mehrkernarchitektur für eingebettete Java-Bytecode-Prozessoren / Martin Zabel. Gutachter: Rainer G. Spallek ; Djamshid Tavangarian. Betreuer: Rainer G. Spallek." Dresden : Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2012. http://d-nb.info/1067731520/34.
Full text
30
Rose, Eva. "Vérification de code d'octet de la machine virtuelle Java : formalisation et implantation." Paris 7, 2002. http://www.theses.fr/2002PA077166.
Full text
31
Poncová, Vendula. "Optimalizace velikosti bajtkódu Javy." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2016. http://www.nusl.cz/ntk/nusl-255348.
Full textAbstract:
This paper deals with the Java bytecode size optimization. It describes the Java Virtual Machine and the Java class file format. It also presents some tools for the bytecode manipulation. Using these tools, I have analyzed selected data and found sequences of instructions, that could be optimized. Based on the results of the analysis, I have designed and implemented methods for bytecode size optimization. The bytecode size of the selected data was reduced by roughly 25%.
32
Mrázek, Petr. "Generický zpětný překlad programů v bajtkódu do vyšší formy reprezentace." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2013. http://www.nusl.cz/ntk/nusl-236178.
Full textAbstract:
The work describes methods and principles of decompilation, basic information about reverse engineering and its use in both software engineering and engineering in general. Furthermore, it introduces the decompiler developed within the Lissom project at BUT FIT. The goal of the work is to design and implement a retargetable decompiler for bytecode, which extends the original decompiler.
33
Savary, Aymerick. "Détection de vulnérabilités appliquée à la vérification de code intermédiaire de Java Card." Thèse, Université de Sherbrooke, 2016. http://hdl.handle.net/11143/9584.
Full textAbstract:
La vérification de la résistance aux attaques des implémentations embarquées des vérifieurs de code intermédiaire Java Card est une tâche complexe. Les méthodes actuelles n'étant pas suffisamment efficaces, seule la génération de tests manuelle est possible. Pour automatiser ce processus, nous proposons une méthode appelée VTG (Vulnerability Test Generation, génération de tests de vulnérabilité). En se basant sur une représentation formelle des comportements fonctionnels du système sous test, un ensemble de tests d'intrusions est généré. Cette méthode s'inspire des techniques de mutation et de test à base de modèle. Dans un premier temps, le modèle est muté selon des règles que nous avons définies afin de représenter les potentielles attaques. Les tests sont ensuite extraits à partir des modèles mutants. Deux modèles Event-B ont été proposés. Le premier représente les contraintes structurelles des fichiers d'application Java Card. Le VTG permet en quelques secondes de générer des centaines de tests abstraits. Le second modèle est composé de 66 événements permettant de représenter 61 instructions Java Card. La mutation est effectuée en quelques secondes. L'extraction des tests permet de générer 223 tests en 45 min. Chaque test permet de vérifier une précondition ou une combinaison de préconditions d'une instruction. Cette méthode nous a permis de tester différents mécanismes d'implémentations de vérifieur de code intermédiaire Java Card. Bien que développée pour notre cas d'étude, la méthode proposée est générique et a été appliquée à d'autres cas d'études.
34
Gisel, Daniel. "Eiffel library to generate Java bytecodes." Zürich : ETH, Eidgenössische Technische Hochschule Zürich, Professur für Software Engineering /Chair of Software Engineering, 2003. http://e-collection.ethbib.ethz.ch/show?type=dipl&nr=196.
Full text
35
Mathewson, Nicholas A. (Nicholas Albert) 1977. "Verifying information flow control in Java bytecodes." Thesis, Massachusetts Institute of Technology, 2000. http://hdl.handle.net/1721.1/86523.
Full textAbstract:
Thesis (M.Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2000.Includes bibliographical references (p. 49).
by Nicholas A. Mathewson.
M.Eng.
36
Lima, Willian dos Santos [UNESP]. "Compilação de bytecodes Java para um ambiente de arquitetura reconfigurável." Universidade Estadual Paulista (UNESP), 2009. http://hdl.handle.net/11449/98650.
Full textAbstract:
Made available in DSpace on 2014-06-11T19:29:39Z (GMT). No. of bitstreams: 0
Previous issue date: 2009-02-27Bitstream added on 2014-06-13T20:39:05Z : No. of bitstreams: 1
lima_ws_me_sjrp.pdf: 1076568 bytes, checksum: 2b137d2ad2832d04670f7d9c091eb474 (MD5)Conselho Nacional de Desenvolvimento Científico e Tecnológico (CNPq)
Durante esta pesquisa, foram investigados conceitos relacionados à computação reconfigurável, processo de compilação e funcionamento da compilação Java, especialmente no que se refere à manipulação de bytecodes. O principal objetivo é a elaboração conceitual de um compilador capaz de traduzir bytecodes de um aplicativo Java para código binário obediente ao conjunto de instruções do processador Nios II da Altera®, acompanhada de algumas implementações. Com este compilador, será possível a construção de programas para dispositivos que utilizem o processador Nios II, como dispositivos de sistemas embarcados, a partir da linguagem Java. Isto proporciona uma forma ágil para a elaboração de aplicativos para sistemas desse tipo. Implementações relevantes foram desempenhadas de forma a comprovar o funcionamento do referido compilador. Tais implementações abrangeram suporte de bytecodes referentes a um subconjunto da linguagem Java, bem como a criação de estruturas de representação intermediária e mecanismos para geração de código final. Além disso, foram desenvolvidos um simulador e um montador de instruções do Nios II de forma a auxiliar no andamento do trabalho. Como resultado, pôde-se verificar que é possível o desenvolvimento de tal ferramenta e que sua existência contribui para o desenvolvimento de outras ferramentas ou aplicativos inseridos no contexto de computação reconfigurável.
During this research, concepts concerning about reconfigurable computing, compiling process and Java compilation were investigated, especially relating to bytecode generation. The goal of this research is twofold: first, the conceptual development of a compiler that is able to translate bytecodes from a Java application to binary code compliant with Altera™ Nios II processor instruction set, and second, provide a set of appropriate implementations for the proposed compiler. With this compiler, it will be possible to construct programs for devices that use Nios II processor, as embedded systems devices, from Java language, providing an agile manner for applications’ building for this kind of systems. Relevant implementations were performed to prove compiler’s functionalities. Such implementations covered bytecodes’ support to a Java language subset, as well as intermediate structures and final code generation mechanisms. Besides, a simulator and an assembler for Nios II instructions were developed to help this work’s evolution. As result, it was possible to verify that the development of such tool is feasible and contributes to the generation of other tools and applications inserted in the context of reconfigurable computing.
37
Lima, Willian dos Santos. "Compilação de bytecodes Java para um ambiente de arquitetura reconfigurável /." São José do Rio Preto : [s.n.], 2009. http://hdl.handle.net/11449/98650.
Full textAbstract:
Orientador: Renata Spolon LobatoBanca: Eduardo Marques
Banca: Aleardo Manacero Junior
Resumo: Durante esta pesquisa, foram investigados conceitos relacionados à computação reconfigurável, processo de compilação e funcionamento da compilação Java, especialmente no que se refere à manipulação de bytecodes. O principal objetivo é a elaboração conceitual de um compilador capaz de traduzir bytecodes de um aplicativo Java para código binário obediente ao conjunto de instruções do processador Nios II da Altera®, acompanhada de algumas implementações. Com este compilador, será possível a construção de programas para dispositivos que utilizem o processador Nios II, como dispositivos de sistemas embarcados, a partir da linguagem Java. Isto proporciona uma forma ágil para a elaboração de aplicativos para sistemas desse tipo. Implementações relevantes foram desempenhadas de forma a comprovar o funcionamento do referido compilador. Tais implementações abrangeram suporte de bytecodes referentes a um subconjunto da linguagem Java, bem como a criação de estruturas de representação intermediária e mecanismos para geração de código final. Além disso, foram desenvolvidos um simulador e um montador de instruções do Nios II de forma a auxiliar no andamento do trabalho. Como resultado, pôde-se verificar que é possível o desenvolvimento de tal ferramenta e que sua existência contribui para o desenvolvimento de outras ferramentas ou aplicativos inseridos no contexto de computação reconfigurável.
Abstract: During this research, concepts concerning about reconfigurable computing, compiling process and Java compilation were investigated, especially relating to bytecode generation. The goal of this research is twofold: first, the conceptual development of a compiler that is able to translate bytecodes from a Java application to binary code compliant with Altera™ Nios II processor instruction set, and second, provide a set of appropriate implementations for the proposed compiler. With this compiler, it will be possible to construct programs for devices that use Nios II processor, as embedded systems devices, from Java language, providing an agile manner for applications' building for this kind of systems. Relevant implementations were performed to prove compiler's functionalities. Such implementations covered bytecodes' support to a Java language subset, as well as intermediate structures and final code generation mechanisms. Besides, a simulator and an assembler for Nios II instructions were developed to help this work's evolution. As result, it was possible to verify that the development of such tool is feasible and contributes to the generation of other tools and applications inserted in the context of reconfigurable computing.
Mestre
38
"Otimização bytecode Java na plataforma J2ME." Tese, Biblioteca Digital de Teses e Dissertações da UFPE, 2004. http://www.bdtd.ufpe.br/tedeSimplificado//tde_busca/arquivo.php?codArquivo=1319.
Full text
39
Klein, Gerwin [Verfasser]. "Verified Java bytecode verification / Gerwin Klein." 2003. http://d-nb.info/967128749/34.
Full text
40
Wang, Yi-Chieh, and 王繹傑. "Instruction Set Extension for Java Bytecode." Thesis, 2009. http://ndltd.ncl.edu.tw/handle/41889087975284590298.
Full textAbstract:
碩士國立成功大學
工程科學系碩博士班
97
This thesis is to define a subset of Java bytecodes that are suitable for instruction set extension as the basis of CPU executing Java bytecode directly. The first step is to analyze the usage of each Java bytecode from benchmark programs, and then identify the bytecodes suitable for instruction set extension. These experiments are performed on the open-source Java Virtual Machine, the JamVM and GNU Classpath. These experiments collect the usage of Java bytecodes of the DaCapo benchmark suite. We implemented a profiler inside the JVM to help tracing and analyzing Java bytecodes executed. This thesis used ARM instruction’s clock cycles to evaluate each Java bytecode cycle counts. The evaluation method is to multiply the execution times of each bytecode by the implementation’s clock cycles. After evaluation, we propose 28 Java bytecodes for instruction set extension. The cycle counts of these 28 bytecodes are accounted for all of the 81.42% of the benchmark programs.
41
Šafařík, Tomáš. "Preprocesor Java bytecode pro verifikační nástroje." Master's thesis, 2016. http://www.nusl.cz/ntk/nusl-347971.
Full textAbstract:
Both J2BP and PANDA tools verify compiled Java programs. By now, these tools are not able to process some programs with specific JVM bytecode instruction sequences in the correct way. We described these instruction sequences and proposed their transformations. We developed the new application, called BytecodeTransformer, based on these propositions. This application transforms compiled Java programs and replaces the problematic instruction sequences with some others. Usage of BytecodeTransformer enlarges the set of programs that can be verified by both J2BP and PANDA. We also evaluated BytecodeTransformer on several Java programs, including own tests and well-known open-source programs. These tests demonstrated the correct functionality of BytecodeTransformer. Powered by TCPDF (www.tcpdf.org)
42
Tsai, Pao-Chin, and 蔡寶進. "Java Bytecode Obfuscator Using Exception Handling Mechanism." Thesis, 2000. http://ndltd.ncl.edu.tw/handle/62949161489806889919.
Full textAbstract:
碩士國立清華大學
資訊工程學系
88
Recently, mobile computing and enterprise computing are more and more popular over computer networks. In mobile computing, it has become common to distribute mobile programs to the clients at the time when they needed. Because the client platforms are of many types, mobile programs have to be platform-independent. To ensure that, these mobile programs should be in high-level forms and be quite similar to the original source codes. Thus, the common platform-independent codes are easy to be decompiled, and hence they may trap into the risk of malicious reverse engineering attacks. Nowadays, Java bytecode is the most widely-used platform-independent code and many Java programs have been developed and distributed. To get these programs as the form of source code, some Java decompilers, such as SourceAgain and JAD, are developed. To protect those Java bytecodes from being decompiled, the most feasible way is to obfuscate it. Normally, obfuscated code has logically the same behavior in execution as the original one, but much more difficult to be decompiled. Most of the obfuscators today concentrate on attaching many redundant links to complicate program control flow; thus, confuse the decompilers. In this thesis, we propose an effective method, which is based on the Java exception handling mechanism, to extend the obfuscation capability. We hide links in exception tables, and replace original links with redundant and fake links. We replace some branch-like instructions with the so-called exception-generating instructions whose exception handlers are the original blocks. The simplest way is to hide the links in the exception tables directly. But we can strengthen this with several indirect exception links, which make it more robust from being decompiled. Another effective way is to add some fake branches in the control flow to confuse the decompiler. The obfuscated code with faking links can be decompilable but the program logic is no longer meaningful, or even cannot be decompiled because of violating the Java language. In our experiments, the codes obfuscated using our approach are successfully protected from all of the decompilers and unobfuscators that we have found.
43
Zabel, Martin. "Effiziente Mehrkernarchitektur für eingebettete Java-Bytecode-Prozessoren." Doctoral thesis, 2011. https://tud.qucosa.de/id/qucosa%3A24907.
Full textAbstract:
Die Java-Plattform bietet viele Vorteile für die schnelle Entwicklung komplexer Software. Für die Ausführung des Java-Bytecodes auf eingebetteten Systemen eignen sich insbesondere Java-(Bytecode)-Prozessoren, die den Java-Bytecode als nativen Befehlssatz unterstützen. Die vorliegende Arbeit untersucht detailliert die Gestaltung einer Mehrkernarchitektur für Java-Prozessoren zur effizienten Nutzung der auf Thread-Ebene ohnehin vorhandenen Parallelität eines Java-Programms. Für die Funktionalitäts- und Leistungsbewertung eines Prototyps wird eine eigene Trace-Architektur eingesetzt. Es wird eine hohe Leistungssteigerung bei nur geringem zusätzlichem Hardwareaufwand erzielt sowie eine höhere Leistung als bekannte alternative Ansätze erreicht.
44
Wu, Jian-Zhi, and 吳劍智. "Bytecode Optimizations on Frame Allocations for Java Processors." Thesis, 2000. http://ndltd.ncl.edu.tw/handle/94953313918078119090.
Full textAbstract:
碩士國立清華大學
資訊工程學系
88
In this thesis, we describe two techniques to optimize hardware stack machine performances on Java environments. Our hardware model basically is a Java processor with a fixed-size stack cache, which directly implements the method frame activation allocations of a software Java virtual machine (JVM). In the first category, we present a technique to solve the problem about the stack allocations for intra-procedural methods in the Java processor. We put emphasis on the issue with the local variable allocation of the method frame. A structure or object unfolding technique can be used to transform heap accesses into stack accesses. The composite object in Java is accessed via heap in memory, while object unfolding transforms heap access to scalar and stack references. For Java processors with a fixed-size stack cache, unlimited employment of structure unfolding techniques however will result in the size of local variables excelling the size of the stack cache. Thus it will reduce the performance gains. For example, ITRI-made Java processor experiences performance penalty in this scenario. To solve this problem, we propose a mechanism, reverse object-unfolding, to report an allocation scheme for a given size of the stack allocation according to our cost model. In the second category of this problem, we also extend our framework for stack allocations to deal with inter-procedural cases. We model this problem into equations and propose a heuristic algorithm based on the domain decomposition of the call graphs of a program to solve the stack allocation problems for inter-procedural cases. Our solution deals with the reduction of both memory references and stack flushes. Our experiment is performed on the ITRI-made Java processor architecture and Kaffe VM simulator. The ITRI-made Java processor is with a fixed-size stack cache and directly allocates the method frames on the stack cache. We report experimental results and profiling data for both intra-procedural and inter-procedural cases. The experiments indicate our proposed methods are promising in speedup Java programs on the Java processor with a fixed-size stack cache.
45
Chen, Chien-Chung, and 陳建忠. "Instruction Level Parallelism Analysis of Java Bytecode with Folding." Thesis, 1998. http://ndltd.ncl.edu.tw/handle/46868680981727304642.
Full textAbstract:
碩士國立交通大學
資訊工程學系
86
The performance of a stack machine is limited mainly by sequential stackacceses. A performance enhancement mechanism - Stack Operations Folding -was used in Sun Microelectronics' picoJava design. There are another twofolding techniques: fixed- pattern folding and POC model beyond Sun'.In thisthesis, we use the Java bytecode language as the target machine language, analyze the factors affecting ILP, and extract parallelism among bytecodesafter folding using POC model.Five factors: stack pointer renaming, localvariable renaming, finite operations, finite scheduling window size andlimited foldable numbers were simulated and evaluated. Statistical data showthat the ILP can be doubled as compared to original figure of POC model. Andwithout stack pointer renaming, the performance gain is only half oftheoretical upper bound. From the experiments, we observe that 4 operationsfor each PIG (Parallel Instruction Group) is enough to approximate thetheoretical upper bound. With a 32-byte or a 64-byte window size, theperformance can reach 82% or 93% as compared to the infinite window size.Finally, we conclude that stack operations folding and stack pointer renamingare the most important mechanisms in designing higher-end stack machines.
46
Chen, Hsiang-Yang, and 陳湘揚. "Control Flow Obfuscation and Protection of Java Bytecode Programs." Thesis, 2009. http://ndltd.ncl.edu.tw/handle/13096136575698138666.
Full textAbstract:
博士國立成功大學
工程科學系碩博士班
97
Software piracy is the unauthorized copying or distribution of copyrighted software. The money loss for software piracy is still very high in this world now. Software protection is used to against software piracy. Software protection techniques disable part or all the functions of a program upon detecting any unwanted modifications. There are many software protection techniques, such as obfuscation, tamper-proofing, software watermarking, cryptography, etc. Java programs can be easily decompiled and reverse engineered from Java bytecode to Java source code by decompilers. So, Java programs are prone to be pirated. Our studies focus on software protection techniques for Java programs. The major contributions are that we develop four methods to protect Java programs by obfuscation, tamper-proofing and software watermarking technologies. Obfuscation is to transfer a source code into a form that is not easy to understand for decompilers. We develop three novel control flow obfuscation methods for protecting Java class files. They are basic block fission obfuscation, intersecting loop obfuscation, and replacing goto obfuscation. Multi-level exit obfuscation and single-level exit obfuscation are also implemented for comparison. Tamper-proofing techniques will disable some or all of the program functionality once they detect any unwanted modifications during run time. First, we propose a tamper-proofing software technology on basis paths for stack-machine based languages, such as Java, by improving oblivious hashing. Our approach is based on a new dynamic stack-tracing approach which inserts hash instructions to monitor the top of the stack to check whether the running program has been tampered with or not. Second, we propose an approach to robustly protect the data of a dominant path in a method of a Java bytecode program by integrating oblivious hashing, guards network, and control flow obfuscation. A dominator tree based on the basic blocks of the target method is first built. Then the dominant path of the dominator tree is selected. The bytecodes of the dominant path are then transformed by the oblivious hashing, guards network, and control flow obfuscation. Software watermarking protects software through embedding some secret information into software as an identifier of the ownership of copyright for this software. We use the propose obfuscation and tamper-proofing techniques to make software watermarks hard to find and to protect the program(s). In summary, this dissertation presents obfuscation, tamper-proofing and software watermarking technologies to protect Java bytecode programs based on our enhanced oblivious hashing, guards network, and control flow obfuscation and to reach the goal to protect Java programs.
47
TANG, CHING HUI, and 鄭秦輝. "The Study and Implementation of the Java Bytecode Compiler." Thesis, 1998. http://ndltd.ncl.edu.tw/handle/67329828531522416740.
Full textAbstract:
碩士國立清華大學
資訊工程學系
86
Java虛擬機器(virtual machine)是由昇陽公司提出的一種支援Java程式 語言的執行環境，具有嚴格安全檢查，跨平台支援等優點。當時昇陽公司 以Java語言發展HotJava WWW Browser來展示Java程式和Applet，結果在 網際網路(Internet)上造成一股流行風潮，加上後來各個公司的WWW Browser都納入Java虛擬機器，因而將Java系統推上了流行的高峰。雖然 Java程式語言本身具有很多的優點，但Java虛擬機器的執行速度過慢，無 法做為大量科學計算，大架構(large-scale)程式，及發展embedding系統 等等的平台。昇陽公司為了解決這個問題，同時採取幾種方法，包括使用 硬體來加速位元組碼的執行，如執行Java Bytecode的CPU(picoJava)及軟 體上更進，如即時編譯(JIT)等技巧。在本論文中，我們研究與實作Java 位元組碼(bytecode)的靜態編譯器。主要的目的是實作一個具有最佳化的 Java位元組碼靜態編譯器(Java Bytecode Native Compiler)，希望可以 使得Java的應用擴充到需要具有高速運算的領域。我們採取的做法是以自 由軟體基金會(Free Software Foundation)的GCC系統做為基本骨幹，設 計並實作了Java 位元組的驗證器和轉譯器，可讀進Java的類別檔，處理 後產生組合語言碼。但由於缺少執行環境，所以無法連結成執行檔，未來 ，可和其他虛擬機器做整合，才算完成系統的建立。
48
Gopinadhan, Gautam V. S. "Architecture for using Java bytecode for processing Digital Items." 2003. http://www.lib.ncsu.edu/theses/available/etd-12182003-061448/unrestricted/etd.pdf.
Full text
49
Lin, You-Chen, and 林祐辰. "Implementation of Java 8-compliant InvokeDynamic Bytecode for CVM." Thesis, 2019. http://ndltd.ncl.edu.tw/handle/5g5md9.
Full textAbstract:
碩士國立交通大學
資訊科學與工程研究所
107
CVM (the J2ME/CDC JIT-capable VM) is a Java virtual machine released by Sun Microsystems for connected devices. Compare with other JVMs, CVM has some features that are suitable for embedded systems, such as, smaller code size, a high performance Just-in-time compiler, and a small 126-class core library for minimal Java application execution. Most importantly, it has been ported to the largest number of different CPU architecture. However, the open-source version of CVM only supports Java 2 Micro Edition (J2ME). After the acquisition of Sun by Oracle, they stop releasing the new source code of CVM. The goal of this paper is to modify the open-source version of CVM to support the InvokeDynamic bytecode, which was added to the JVM specification since Java 7. The InvokeDynamic instruction provides a cleaner interface for method invocations. In particular, starting in Java 8, Lambda expressions are extensively used for method invocation. Java source code with Lambda expressions will be compiled to InvokeDynamic bytecodes. In addition to adding the bytecode support for InvokeDynamic to CVM, we will also extend the CVM classes library with the Java classes required by InvokeDynamic. In this thesis, the OpenJDK lambda expression tests will be used to verify the proposed implementation. We will also use some large open-source Java programs that contain lambda expressions to verify the correctness of the modified CVM.
50
Ascott, Robert John. "JavaFlow : a Java DataFlow Machine." Thesis, 2014. http://hdl.handle.net/2152/28390.
Full textAbstract:
The JavaFlow, a Java DataFlow Machine is a machine design concept implementing a Java Virtual Machine aimed at addressing technology roadmap issues along with the ability to effectively utilize and manage very large numbers of processing cores. Specific design challenges addressed include: design complexity through a common set of repeatable structures; low power by featuring unused circuits and ability to power off sections of the chip; clock propagation and wire limits by using locality to bring data to processing elements and a Globally Asynchronous Locally Synchronous (GALS) design; and reliability by allowing portions of the design to be bypassed in case of failures. A Data Flow Architecture is used with multiple heterogeneous networks to connect processing elements capable of executing a single Java ByteCode instruction. Whole methods are cached in this DataFlow fabric, and the networks plus distributed intelligence are used for their management and execution. A mesh network is used for the DataFlow transfers; two ordered networks are used for management and control flow mapping; and multiple high speed rings are used to access the storage subsystem and a controlling General Purpose Processor (GPP). Analysis of benchmarks demonstrates the potential for this design concept. The design process was initiated by analyzing SPEC JVM benchmarks which identified a small number methods contributing to a significant percentage of the overall ByteCode operations. Additional analysis established static instruction mixes to prioritize the types of processing elements used in the DataFlow Fabric. The overall objective of the machine is to provide multi-threading performance for Java Methods deployed to this DataFlow fabric. With advances in technology it is envisioned that from 1,000 to 10,000 cores/instructions could be deployed and managed using this structure. This size of DataFlow fabric would allow all the key methods from the SPEC benchmarks to be resident. A baseline configuration is defined with a compressed dataflow structure and then compared to multiple configurations of instruction assignments and clock relationships. Using a series of methods from the SPEC benchmark running independently, IPC (Instructions per Cycle) performance of the sparsely populated heterogeneous structure is 40% of the baseline. The average ratio of instructions to required nodes is 3.5. Innovative solutions to the loading and management of Java methods along with the translation from control flow to DataFlow structure are demonstrated.text