Java Primer: Difference between revisions

The fact that getting the number of arguments is convoluted to perform on the caller's side, we do callee-cleanup using <tt>RET imm</tt> instead of the regular <tt>RET</tt>. Locals is a convoluted issue as well, so we just reserve room for 8 because you're not meant to copy this code anyway.

 

// File: compiler/nl/combuster/minijava/Compiler.java

package nl.combuster.minijava;

}

 

 

Yes, that's a compiler in a magic 256 lines of code. The result is Intel syntax assembly, because there already are decent tools for assembly out there that deal with object formats out there. Of course you can write your own later as well.

Almost no programming language has standard constructs for all the things a processor can do, in particular not languages that were designed to be portable and memory-safe. For that reason we are required to add support for that outside of the language. Fortunately, Java does come with one construct specifically design to wrap the language to platform specifics: <tt>native</tt>

 

// File: os/nl/combuster/minijavaos/Hal.java

package nl.combuster.minijavaos;

public static native void poke(int address, byte data);

}

At some point the OS needs to access memory unsafely, and this is the method we'll use. The native keyword also implies that there is no implementation in java and that it'll come from elsewhere.

 

There are more things that might be difficult to do in straight Java: this example omits memory management in its entirety, but there is still a quirk: Every object subclasses from java.lang.Object. To make matters more complicated, the compiler does not allow us to write java.lang classes in Java. In this case it's a particular chicken-and-egg problem: how would we even compile a class that extends itself? We are in some way forced to treat java.lang.Object special, and basically use its constructor as a terminator for a constructor chain. At a later stage, we might even want to do something more in there, but for now we don't need to. The first piece of native support code deals with these problems:

 

; File: os/hal.asm

section .text

ret 2

 

 

== A primitive kernel ==

"Hello world!" is a very overrated thing. Or is it? Strings are a full-blown object in Java, and passing objects safely is one of the things skipped in the compiler itself. Instead, we can count our numbers to show what we have actually works:

 

package nl.combuster.minijavaos;

 

}

}

This is little more than some simple VGA code, but it demonstrates that we can call Java code, do some calculations, and then call our hardware abstraction layer to complete the little bits Java just couldn't do.

 

==== Multiboot ====

We use GRUB as a bootloader, so the mechanics are the same. The only real difference is that we have to cope with the name mangling and be unable to call something kmain.

; File: os/multiboot.asm

 

;hlt

jmp .hang

 

====Linker script====

Linking also happens with the same script as [[Bare Bones]]

 

/* File: os/linker.ld */

/* The bootloader will look at this image and start execution at the symbol

a segment with the same name. Simply add stuff here as needed. */

}

 

==== GRUB ====

Some configuration files for GRUB legacy. Doing this with a CD is the easiest way, really:

#

# File: os/grub.cfg

root (cd)

kernel (cd)/kernel

 

==== Build instructions ====

 

In this example, GRUB is assumed to be preinstalled in /boot where it resides by default on a linux system that has it installed. We also need mkisofs and the binutils step from the [[GCC Cross-Compiler]]. Of course, at some point in time you can decide to write these tools in Java as well

 

COMPILER_J=$(shell find -L compiler -iname '*.java')

mkisofs -R -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o $@ build/iso

 

 

If you paid attention, you'll notice that the JAR step requires a manifest at <tt>compiler/compiler.manifest</tt>. It only really marks it as runnable so that we can use it easily:

Main-Class: nl.combuster.minijava.Compiler

 

Lastly, the [http://forge.ow2.org/project/download.php?group_id=23&file_id=20549 one library] our compiler uses to do most of its magic. You can just copy the source into the compiler folder and the build script will pick it up.