Pseudo Assembly Language

• Preliminaries
• Background
• Exercises
  • Exercise 1: PAL Basics
  • Exercise 2: A Sum Program
  • Exercise 3: Your Own PAL Program
  • Exercise 4: Extending PAL

Preliminaries

Summary: In today's lab, you will explore PAL, the pseduo-assembly language that I've written (okay, started to write) as an intermediate language for your compilers.

Warning: Both PAL and this lab are under development. Both probably have many bugs. Let me know which ones you notice.

Collaboration: Feel free to work on this lab in pairs or trios.

Turning It In: Save your answers in a plain text file and submit it using the ECA.

Grading: I expect that you will gain more from doing this lab than from me grading this lab. I may simply scan through your answers to see if you had any particularly valuable insights.

Supporting Files:

• TestPAL.java
• SumPAL.java
• The pal library

Setup:

1. Make copies of TestPAL.java and SumPAL.java.

2. Make a copy of the pal library in a directory on your $CLASSPATH. For example, you could execute the following two instructions.

% cp -r /home/rebelsky/Web/Courses/CS362/2002F/Examples/pal .
% export CLASSPATH="`pwd`:$CLASSPATH"

Background

PAL, the pseudo-assembly language, is a set of Java classes intended to provide a simple assembly-language-like intermediate code. PAL consists of a model of a computer, Computer, a number of Container subclasses that hold values, and a number of Instruction implementations that represent instructions.

The Computer class provides four key methods.

• The constuctor, Computer(int memsize), which builds a computer whose memeory holds memsize non-code values.
• setCode(InstructionSequence code), which sets the program code for the machine.
• dump(java.io.PrintWriter out), which prints the program to the selected destination.
• run(boolean trace), which runs the program (starting at instruction 0). If trace is true, it also prints out each instruction as it executes it.

Each Container subclass provides four key procedures:

• iget(Computer hal) gets the integer associated with the container.
• fget(Computer hal) gets the float associated with the container. (PAL is untyped, so each container can store either kind of value.)
• iset(Computer hal, int newval) tells the container to store a new integer value.
• fset(Computer hal, int newval) tells the container to store a new float value.

There are many kinds of containers.

• IConstant containers store integer constants. Once created, they cannot change.
• Register containers refer to the key registers. You cannot create new registers. Instead, you must use the built-in registers, Register.sp, Register.fp, and Register,pc.
• Temporary containers are temporary locations. You should eventually eliminate all temporaries from the program.
• MemLoc containers are positions in memory. Each has an index (which can be any kind of container) which specifies where in memory the location resides.
• Label objects are also treated as containers because it simplifies the implementation.

Instructions provide one key method,

• execute(Computer hal), which executes the given instruction on that particular computer.

As you may have noted, a number of the methods take Computer objects as parameters. I've made that choice so that they can access or modify the state of the computer.

PAL provides an ever-growing set of instructions which you can identify by looking at the source code.

Note that the InstructionSequence instruction is a special instruction designed for building trees of instructions, as you would create while traversing a parse tree.

Exercises

Exercise 1: PAL Basics

a. Scan through TestPAL.java. See if you can determine what it does.

b. Compile and execute TestPAL.java. Observe its output.

c. Why was the program able to use FWrite on t1? What was the output?

d. Turn off program tracing and execute the program again.

e. Update TestPAL.java to count down from 5 to 1 (instead of up from 1 to 10).

Exercise 2: A Sum Program

a. Scan through SumPAL.java. As you can see, the program repeatedly reads values and shoves them on the stack. When 0 is entered, it repeatedly pops values off of the stack and adds them to the counter.

b. Run the program and enter three non-zero values followed by zero. Does it do what you expect?

c. Add an instruction to print the stack pointer at each step and rerun the program with three non-zero values. Does it do what you expect? When you're done observing the stack pointer, you can either keep or remove the line to print the stack pointer.

d. Run the program and enter seven non-zero values followed by zero. What does it do? WHy?

e. Run the program and enter five non-zero values followed by zero. What does it do? Why?

f. Run the program and enter four non-zero values followed by zero. What does it do? Why?

Exercise 3: Your Own PAL Program

Write a PAL program that reads three numbers, initial, step, and final, and counts (by printing results) from initial to final using increments of step.

Exercise 4: Extending PAL

Add new FMultiply and IMultiply instructions to PAL.