Defining class variables of Java in assembler programming

Review: where does the program store the class variables

Recall that the class variables (of a Java program):

Are created when the Java program is loaded into the computer memory
The class variables are stored at the start of the computer memory (after the instructions of the Java program)

The DS (M68000) assembler directive

Syntax:

label DS.B n

Effect:

The DS directive (= assembler command) tells (= instructs) the assembler to:

Reserve n consecutive bytes memory cells (= mark these n bytes as used)
Equate the symbolic name label to the address of the first memory location of the reserved bytes

Example:

Suppose we are write an assembler program.
Suppose we start storing the instructions and variables at memory address 1000 Hex

Consider the following assembler program:

move.b d0, d1 <----- X move.b d0, d1 A: ds.b 10 move.b d0, d1 <----- Y move.b d0, d1

I will now explain what each line of the assembler program does....

The assembler line move.b d0, d1 (at arrow X) will store the instruction code for move.b d0, d1 into memory

When you store some instruction code in memory, the used memory cells are also (automatically) reserved !!!

Given that the instruction code for move.b d0, d1 is 1200 Hex (= 00010010 00000000 binary), the first 2 lines of the assembler program will store the following in memory (RAM):

The instruction code for first move.b d0, d1 is stored at address 1000 Hex

(Remember that we assumed that we start storing instructions and variables at the address 1000 Hex)

The instruction code for second move.b d0, d1 is stored at address 1002 Hex because the instruction code (1200 Hex) is 2 bytes long

The directive A: ds.b 10 will next reserve 10 consecutive bytes of memory

After processing the assembler directive, content of the memory (RAM) is:

(in Hex) Address Content What is stored Explanation ======================================================================== 001000 1200 move.b d0, d1 (1200 (hex) is the code 001002 1200 move.b d0, d1 for "move.b d0, d1" !) 001004 00 001005 00 001006 00 001007 00 10 bytes are reserved 001008 00 by the directive: 001009 00 00100A 00 A: ds.b 10 00100B 00 00100C 00 00100D 00

Important node:

The label A is equated (= equal to) the value 001004 Hex which is the address of the first reserve byte

Following the A: ds.b 10 line, we have 2 more assembler lines move.b d0, d1 (at arrow Y)

Just like at arrow X, each line will store the instruction code for move.b d0, d1 into memory

The move.b d0, d1 at array Y will be stored in the next available memory cell, which is at address 100E

So after processing the the next 2 lines, the following things are stored in memory (RAM):

Address Content What is stored Explanation ======================================================================== 001000 1200 move.b d0, d1 (1200 (hex) is the code 001002 1200 move.b d0, d1 for "move.b d0, d1" !) 001004 00 001005 00 001006 00 001007 00 10 bytes are reserved 001008 00 by the directive: 001009 00 00100A 00 A: ds.b 10 00100B 00 00100C 00 00100D 00 00100E 1200 move.b d0, d1 (1200 (hex) is the code 001010 1200 move.b d0, d1 for "move.b d0, d1" !)

The instruction code for first move.b d0, d1 is stored at address 100E Hex

(Remember the next available memory cell for storing instructions and variables is located at the address 100E Hex)

The instruction code for second move.b d0, d1 is stored at address 1010 Hex because the instruction code (1210 Hex) is 2 bytes long ---- (100E (Hex) + 2 (Hex) = 1010 (Hex))

Example Program: (Demo above code)

Prog file: click here

How to run the program:

Right click on link and save in a scratch directory
To compile: as255 ds
To see the content: /home/ubuntu16/emacsimdir/bin/m68k-elf-objdump -d ds | more
Also try: /home/ubuntu16/emacsimdir/bin/m68k-elf-objdump -s ds | more to see the full dump

How to define (simple) class variables using the DS directive

Facts:

A byte typed variable requires 1 byte of memory storage space
A short typed variable requires 2 byte of memory storage space
A int typed variable requires 4 byte of memory storage space
A long typed variable requires 8 byte of memory storage space
A float typed variable requires 4 byte of memory storage space
A double typed variable requires 8 byte of memory storage space

How to define (= create) class variables in assembler programming langauge:

To create (= reserve space) Use this directive ================================================================= a byte typed variable ds.b 1 a short typed variable ds.b 2 a int typed variable ds.b 4 a long typed variable ds.b 8 a float typed variable ds.b 4 a double typed variable ds.b 8

Example:

Consider the following assembler program:

move.b d0, d1 <----- X move.b d0, d1 A: ds.b 4 move.b d0, d1 <----- Y move.b d0, d1

(We assume again that the first available memory cell is located at 1000 Hex)

These assembler code lines will store/reserve the following things in memory:

(in Hex) Address Content What is stored Explanation ======================================================================== 001000 1200 move.b d0, d1 (1200 (hex) is the code 001002 1200 move.b d0, d1 for "move.b d0, d1" !) 001004 00 <---- The label A = this address 001005 00 4 bytes are reserved 001006 00 by the DS directive 001007 00 001008 1200 move.b d0, d1 (1200 (hex) is the code 00100A 1200 move.b d0, d1 for "move.b d0, d1" !)

The 4 bytes reserved memory cells reserved by the DS directive are used to store the integer variable A !!!

Notice that:

The label A is equal to the address of the location of this int variable !!!

The use of the label in the DS directive

Fact:

The label used in the DS directive will be equal to the address of the first memory cell of the reserved memory space
Therefore:

Comment:

We need to know the address of memory where a variable is stored in order to use the variable !!!
Therefore:

Later, we will see how to use the label to access (=use) variables: click here

Defining arrays using the DS directive

Arrays:
How to store the elements of an array:

How to define (= create) an array class variables in assembler programming langauge:

To create (= reserve space) Use this directive ================================================================= a byte typed array variable ds.b 1*n a short typed array variable ds.b 2*n a int typed array variable ds.b 4*n a long typed array variable ds.b 8*n a float typed array variable ds.b 4*n a double typed array variable ds.b 8*n

Examples:

To create (= reserve space) Use this directive ================================================================= byte A[10]; A: ds.b 10 short B[10]; B: ds.b 20 int C[10]; C: ds.b 40

Later, we will see how to use the label to access (=use) array variables: click here

Defining object/structured variables using the DS directive

Objects:

Object = a collection of variables that describes different properties of the same thing
Each (individual) variable in the object is called an component

Example:

public class BankAccount { int AccNumber; double balance; // Methods are omitted because they are // not variables }

How to store the components of an object:

How to define (= create) an array class variables in assembler programming langauge:

To create (= reserve memory space) for an object, we must:

Examples: to create a BankAccount object we use:

A: ds.b 12 // 4 bytes to store int AccNum + // 8 bytes to store double balance

Later, we will see how to use the label to access (=use) component variables in objects: click here

Insight into the Java compiler

Recall:

How the Java compiler processes class variables:

When the Java compiler scans and translates a class variable definition, for example:

public class myClass { .... public static int A ; // class variable .... }

The Java compiler will output the following assembler directive:

A: ds.b 4