depends on the mechanism of memory allocation on the run-time stack. A fairly detailed explanation
is given on the details of the memory allocation process for function calls, as this mechanism is
revisited at a lower level of abstraction later in the book.
Level ISA3
Level ISA3 is the instruction set architecture level. Its two chapters describe Pep/9, a virtual
computer designed to illustrate computer concepts. Pep/9 is a small complex instruction set computer
(CISC); a von Neumann machine. The central processing unit (CPU) contains an accumulator, an
index register, a program counter, a stack pointer, and an instruction register. It has eight addressing
modes: immediate, direct, indirect, stack-relative, stack-relative deferred, indexed, stack-indexed,
and stack-deferred indexed. The Pep/9 operating system, in simulated read-only memory (ROM), can
load and execute programs in hexadecimal format from students’ text files. Students run short
programs on the Pep/9 simulator and learn that executing a store instruction to ROM does not change
the memory value.
Students learn the fundamentals of information representation and computer organization at the bit
level. Because a central theme of this book is the relationship of the levels to one another, the Pep/9
chapters show the relationship between the ASCII representation (Level ISA3) and C variables of
type char (Level HOL6). They also show the relationship between two’s complement representation
(Level ISA3) and C variables of type int (Level HOL6).
Level Asmb5
Level Asmb5 is the assembly level. The text presents the concept of the assembler as a translator
between two levels—assembly and machine. It introduces Level Asmb5 symbols and the symbol
table.
The unified approach really comes into play here. Chapters 5 and 6 present the compiler as a
translator from a high-order language to assembly language. Previously, students learned a specific
Level HOL6 language, C, and a specific von Neumann machine, Pep/9. These chapters continue the
theme of relationships between the levels by showing the correspondence between (a) assignment
statements at Level HOL6 and load/store instructions at Level Asmb5, (b) loops and if statements at
Level HOL6 and branching instructions at Level Asmb5, (c) arrays at Level HOL6 and indexed
addressing at Level Asmb5, (d) procedure calls at Level HOL6 and the run-time stack at Level
Asmb5, (e) function and procedure parameters at Level HOL6 and stack-relative addressing at Level
Asmb5, (f) switch statements at Level HOL6 and jump tables at Level Asmb5, and (g) pointers at Level
HOL6 and addresses at Level Asmb5.
The beauty of the unified approach is that the text can implement the examples from the C chapter
at this lower level. For example, the run-time stack illustrated in the recursive examples of Chapter 2
corresponds directly to the hardware stack in Pep/9 main memory. Students gain an understanding of
the compilation process by translating manually between the two levels.
This approach provides a natural setting for the discussion of central issues in computer science.
For example, the book presents structured programming at Level HOL6 versus the possibility of
unstructured programming at Level Asmb5. It discusses the goto controversy and the structured
programming/efficiency tradeoff, giving concrete examples from languages at the two levels.
Chapter 7, “Language Translation Principles,” introduces students to computer science theory.
Now that students know intuitively how to translate from a high-level language to assembly language,