book

Programming for the Java™ Virtual Machine

Name: Programming for the Java™ Virtual Machine
Author: Joshua Engel
ISBN: 9780201309720

by Joshua Engel

June 1999

Intermediate to advanced

512 pages

9h 58m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Dedication
Preface
PrerequisitesBooksAcknowledgments
1. Introduction to the Java Virtual Machine
1.1. Java Virtual Machine and Java1.2. What Is the Java Virtual Machine?1.2.1. Instruction Set1.2.2. class File Format1.2.3. Verification1.3. Java Platform1.4. Organization of the Java Virtual Machine1.4.1. Class Area1.4.2. Java Stack1.4.3. Heap1.4.4. Native Method Stacks1.4.5. Example1.5. Garbage Collection1.5.1. Finalization1.5.2. Timing of Garbage Collection1.6. JVM Implementations1.7. Versions of the Virtual Machine1.8. Future of the Java Virtual Machine
2. Oolong
2.1. Hello, World2.1.1. .class and .super Directives2.1.2. main Method2.1.3. Instructions2.2. Structure of an Oolong Program2.3. Defining the Class2.4. Superclasses2.5. Declaring Fields2.6. Declaring Methods2.7. Interfaces
3. Writing Methods
3.1. Some Definitions3.2. Types3.2.1. Numeric Types3.2.2. Object Types3.2.3. Type returnAddress3.3. Mnemonic Naming Conventions3.4. Testing Code Examples3.5. Returns3.6. Constants3.6.1. General Constants3.6.2. Small Constants and null3.7. Local Variables3.7.1. Initializing Variables3.7.2. Local Variables as Method Arguments3.8. Math3.8.1. Arithmetic Operations3.8.2. Nonnumbers and Infinity3.8.3. Bitwise Operations3.8.4. Floating-Point Arithmetic and strictfp3.9. Type Conversions3.9.1. Conversion Example3.9.2. Widening and Narrowing3.10. Stack Manipulations3.11. Arrays of Numbers3.12. Just Biding Your Time
4. Classes and Objects
4.1. What Is an Object?4.1.1. Objects and References4.1.2. Class Names4.1.3. Packages4.2. Creating Objects4.3. Constructors4.4. Using Fields4.4.1. Types and getfield4.4.2. Inheriting Fields4.4.3. Changing Field Values4.5. Invoking Methods on Objects4.5.1. Virtual Invocation4.5.2. Method Inheritance and Overriding4.5.3. Overloading and Method Matching4.5.4. Invoking a Method Directly4.5.5. invokespecial and super4.6. Casting4.7. Casting, Fields, Methods, and Java4.8. Returning Objects4.9. Interfaces4.10. Static Fields and Methods4.11. Class Initialization4.12. Arrays4.12.1. Arrays of Reference4.12.2. Multidimensional Arrays4.12.3. Length of Arrays
5. Control Instructions
5.1. Comparing Integers5.2. Comparing References5.3. Other Comparisons5.4. Switches5.5. Subroutines5.6. Exceptions5.6.1. Multiple Exception Handlers5.6.2. .throws Directive5.6.3. Other Ways to Throw Exceptions5.7. A Gentler Way of Checking Type
6. Verification Process
6.1. How the Verification Algorithm Works6.2. Is It a Structurally Valid class File?6.3. Are All Constant References Correct?6.4. Are All the Instructions Valid?6.5. Will Each Instruction Always Find a Correctly Formed Stack and Local Variable Array?6.5.1. Example 1: Hello, World6.5.2. Example 2: gotos and ifs6.5.3. Example 3: Code That Doesn't Verify6.5.4. Example 4: Dealing with Subclasses6.5.5. Algorithm6.6. Do External References Check Out?6.7. Java Language and Verification Algorithm6.7.1. Fooling the Virtual Machine with a Java Compiler6.7.2. Other Languages and the Verification Algorithm6.8. Other Safety Requirements6.9. Checking Verification
7. Debugging
7.1. Debugging Directives in Oolong7.1.1. .source Directive and .line Directives7.1.2. .var Directive7.2. Debugging Oolong Programs7.3. Runtime Tracing
8. Class Loaders
8.1. How Classes Are Loaded8.1.1. Loading8.1.2. Linking8.2. Loading Classes without a Class Loader8.3. Making Your Own Class Loader8.3.1. Caching Classes8.3.2. Examples8.4. Working with Class Objects8.5. Reflection

9. Inside a Java class File
9.1. class File Header9.2. Constant Pool9.2.1. UTF8 Entries9.2.2. Constant Entries9.2.3. Field, Method, and Class Entries9.3. Class Information9.4. Fields and Methods9.5. Class Attributes9.6. Other Attributes9.6.1. ConstantValue Attribute9.6.2. Exceptions Attribute9.6.3. InnerClasses Attribute
10. Compiling Java
10.1. Expressions and Statements10.2. Expression Types10.2.1. Numeric Types10.2.2. Object Types10.2.3. Expression Result Types10.2.4. Compile-Time Types and Type Restrictions10.2.5. Type Safety and Verifiability10.3. Compiling Statements and Expressions10.4. Local Variable Declarations10.5. Fields and Variables10.5.1. Abbreviations10.5.2. Other Assignments10.5.3. Assignments as Expressions10.5.4. Type-Checking in Assignments10.6. Creating New Objects10.7. Class Name Abbreviations10.8. Arithmetic Expressions10.8.1. Numeric Coercions10.8.2. Casting Numeric Values10.8.3. ~ Operator10.9. Method Calls10.9.1. Virtual Method Calls10.9.2. Static Method Calls10.9.3. Example of Method Calls10.9.4. Overriding10.9.5. Overloading10.9.6. Interfaces10.10. Expressions as Statements10.11. Ifs and Booleans10.11.1. Boolean Values10.11.2. if Statements10.11.3. Comparisons10.11.4. Floating-Point Comparisons and NaN10.11.5. Integer Comparisons10.11.6. References and Object Equality10.11.7. Boolean Operators10.12. Other Control Structures10.12.1. Loops10.12.2. Compiling Control Constructs10.12.3. Compound Statements and Verification10.13. Returns10.14. Field Declarations10.15. Method Declarations10.16. Constructors10.16.1. Using Other Constructors in the Same Class10.16.2. Default Constructors10.16.3. Field Initializers and the Constructor10.17. Conclusion
11. Compiling Other Languages
11.1. Java Version 1.111.1.1. Class Literals11.1.2. Inner Classes11.1.3. Variable Scoping with Inner Classes11.2. Regular Expressions11.3. Iterators11.3.1. Iterators in Sather11.3.2. Implementing Iterators11.3.3. Iterators with Arguments11.3.4. Using Iterators11.4. Parameterized Types11.4.1. Implementing Parameterized Types with a Generic Class11.4.2. Implementing Parameterized Types as Templates11.5. Multiple Inheritance11.5.1. Interfaces for Multiple Inheritance11.5.2. Implementing the Interfaces11.5.3. Fields11.6. Conclusion
12. Implementing Scheme
12.1. Scheme Concepts12.2. Compiling Scheme into Bytecodes12.3. Compiling Lambda Expressions12.4. Example12.5. Scheme Library12.6. Optimizing Scheme12.6.1. Static Scoping12.6.2. Using Local Variables12.6.3. Inlining12.6.4. Tail Recursion12.6.5. Using Type Information
13. Implementing Prolog
13.1. Introduction to Prolog13.1.1. Asking Questions13.1.2. Binding Patterns13.1.3. Implications13.1.4. Binding Patterns and Implications13.1.5. Facts as Rules13.1.6. More About Unification13.2. Implementation Basics13.3. Unification13.3.1. Unification Algorithm13.3.2. Managing Bindings13.4. Rules as Programs13.4.1. inside13.4.2. within13.4.3. yield and Backtracking13.5. Implementing Rules13.5.1. Implementing within13.5.2. Implementing Conjunctions13.5.3. Constructing within13.6. Compiling Facts13.7. Case Study
14. Performance
14.1. Fast Virtual Machines14.1.1. Garbage Collection Performance14.1.2. Implementing References14.2. Bytecode Optimization Techniques14.2.1. Warning14.2.2. Constant Propagation14.2.3. Strength Reduction14.2.4. Loop Unrolling14.2.5. Peephole Optimization14.3. Inlining14.3.1. Inlining Fields14.3.2. Separate Compilation
15. Security and the Virtual Machine
15.1. Java Platform and Need for Security15.2. Security Promises of the JVM15.3. Security Architecture and Security Policy15.3.1. Example15.3.2. Basic Applet Security Policy15.3.3. More Sophisticated Policies15.4. Some Potential Attacks15.4.1. Implementation Details15.4.2. Protecting the Security Manager15.4.3. Bypassing Java Security15.4.4. Using Unconstructed Objects15.4.5. Invalid Casts15.4.6. Changing the Class of a Reference15.4.7. Reading Uninitialized Fields15.4.8. Array Bounds Checks15.4.9. Catching Exceptions15.4.10. Hidden Code15.5. Conclusion
16. Threads and Synchronization
16.1. Threads16.1.1. Example: Multithreaded Web Server16.1.2. Exceptions and Threads16.2. Sharing State Between Threads16.2.1. Need for Synchronization16.2.2. Exception: longs and doubles16.3. Monitors and Object Locks16.3.1. Synchronization in Java16.3.2. Synchronized Methods16.4. Scheduling16.4.1. Surrendering Control of the CPU16.4.2. Waiting for Another Thread16.5. Conclusion
A. Tables
A.1. Instructions by OpcodeA.2. Instructions AlphabeticallyA.3. Instructions by CategoryA.3.1. ArithmeticA.3.2. ArrayA.3.3. ConstantA.3.4. ControlA.3.5. Data Type ConversionA.3.6. ObjectA.3.7. Stack ManipulationA.3.8. SynchronizationA.3.9. Variable
B. Oolong Reference
B.1. Using the Oolong AssemblerNameAbbreviated nameSynopsisDescriptionOptionsB.2. GnolooNameAbbreviated nameSynopsisDescriptionOptionsB.3. DumpClassNameAbbreviated nameSynopsisDescriptionB.4. Oolong LanguageB.4.1. CommentsFormatDescriptionExamplesB.4.2. .sourceFormatDescriptionExamplesB.4.3. .classFormatDescriptionExamplesB.4.4. .interfaceFormatDescriptionExampleB.4.5. .end classFormatDescriptionExampleB.4.6. .superFormatDescriptionExamplesB.4.7. .implementsFormatDescriptionExamplesB.4.8. .fieldFormatDescriptionExamplesB.4.9. .methodFormatDescriptionExamplesB.4.10. .limit localsFormatDescriptionExamplesB.4.11. .limit stackFormatDescriptionExamplesB.4.12. .lineFormatDescriptionExampleB.4.13. .varFormatDescriptionExampleB.4.14. .throwsFormatDescriptionExamplesB.4.15. .catchFormatDescriptionExamplesB.4.16. .end methodFormatDescriptionExamplesB.5. InstructionsB.5.1. Instructions with No ArgumentsB.5.2. IntegersB.5.3. LabelsB.5.4. ClassesB.5.5. Fields and MethodsB.5.6. invokeinterfaceB.5.7. multianewarrayB.5.8. ldc, ldc_w, and ldc2_wB.5.9. newarrayB.5.10. tableswitchB.5.11. lookupswitch
C. Answers to Selected Exercises
Further Reading
Java and the JVMNewsgroupOther LanguagesCompilers

Content preview from Programming for the Java™ Virtual Machine

Appendix A. Tables

Instructions by Opcode

Mnemonic	Hex	Dec
`nop`	`00`	`0`
`aconst_null`	`01`	`1`
`iconst_m1`	`02`	`2`
`iconst_0`	`03`	`3`
`iconst_1`	`04`	`4`
`iconst_2`	`05`	`5`
`iconst_3`	`06`	`6`
`iconst_4`	`07`	`7`
`iconst_5`	`08`	`8`
`lconst_0`	`09`	`9`
`lconst_1`	`0a`	`10`
`fconst_0`	`0b`	`11`
`fconst_1`	`0c`	`12`
`fconst_2`	`0d`	`13`
`dconst_0`	`0e`	`14`
`dconst_1`	`0f`	`15`
`bipush`	`10`	`16`
`sipush`	`11`	`17`
`ldc`	`12`	`18`
`ldc_w`	`13`	`19`
`ldc2_w`	`14`	`20`
`iload`	`15`	`21`
`lload`	`16`	`22`
`fload`	`17`	`23`
`dload`	`18`	`24`
`aload`	`19`	`25`
`iload_0`	`1a`	`26`
`iload_1`	`1b`	`27`
`iload_2`	`1c`	`28`
`iload_3`	`1d`	`29`
`lload_0`	`1e`	`30`
`lload_1`	`1f`	`31`
`lload_2`	`20`	`32`
`lload_3`	`21`	`33`
`fload_0`	`22`	`34`
`fload_1`	`23`	`35`
`fload_2`	`24`	`36`
`fload_3`	`25`	`37`
`dload_0`	`26`	`38`
`dload_1`	`27`	`39`
`dload_2`	`28`	`40`
`dload_3`	`29`	`41`
`aload_0`	`2a`	`42`
`aload_1`	`2b`	`43`
`aload_2`	`2c`	`44`
`aload_3`	`2d`	`45`
`iaload`	`2e`	`46`
`laload`	`2f`	`47`
`faload`	`30`	`48`
`daload`	`31`	`49`
`aaload`	`32`	`50`
`baload`	`33`	`51`
`caload`	`34`	`52`
`saload`	`35`	`53`
`istore`	`36`	`54`
`lstore`	`37`	`55`
`fstore`	`38`	`56`
`dstore`	`39`	`57`
`astore`	`3a`	`58`
`istore_0`	`3b`	`59`
`istore_1`	`3c`	`60`
`istore_2`	`3d`	`61`
`istore_3`	`3e`	`62`
`lstore_0`	`3f`	`63`
`lstore_1`	`40`	`64`
`lstore_2 ...`

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0201309726Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming for the Java™ Virtual Machine

by Joshua Engel

Appendix A. Tables

Instructions by Opcode

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.