Register Machine Code Format

<Here goes a description of the register machine code format, similar to Section 5.1.5 of SICP JS>

Based on SICP Instruction Summary 5.1.5:

This section is still work in progress.

Treatment of register assignment:

1. Assigning a value from one register to another.

Assigning a value from register 'register-name-from' to 'register-name-to':

assign(register-name-to, reg(register-name-from))

For example, if you assign contents from register D to register C:

assign("C", reg("D"))

2. Assigning a value from one register to another.

Assigns a constant value to 'register-name'. Constant value is predefined.

assign(register-name, constant(constant-value))

Some noteworthy tips:

• "register-name" seen in round brackets are just the actual register names in strings.

3. New instructions:

Even though SICP Instruction Summary 5.1.5 is already listed some instructions, we will remention it here as some instrcution APIs are not consistent.

3.1 Perfrom

Perform an operation:

perform(list(op(operation_name), inputs...))

3.2 Test

Test an operation:

test(list(op(operation_name), inputs...))

3.3 Branch

make a branch with a label:

branch(label(label_name))

3.4 Go_to

Go to corresponding label_name value:

go_to(label(label_name))

Go to corredponding register value:

go_to(reg(register_name))

3.5 save

Save the register value into stack:

save(register_name)

3.6 restore

Restore the value from stack to register:

restore(register_name)

3.7 vector_ref

Get the N_th element of the vector:

vector_ref(vector,n) 

3.8 vector_set

Set the N_th element of the vector with a value:

vector_set(vector, n, value)

Compilation of Source to Register Machine instructions:

Having seen what are some examples of register machine instructions, we can now explore the different register machine instructions that result from compiling Source programs.

We shall discuss the following compilation results:

• self-evaluating expressions
• constant declarations
• variable declarations
• variable assignments
• function definitions
• and more ...

Compiling self-evaluating expressions:

The machine instruction that results in compilation of self-evaluating expression is as follows. The general form is:

assign(val, constant(self-evaluating expr))

Thus, a Source expression such as

true;
4215;

can produce the following machine instructions:

assign(val, constant(true)),
assign(val, constant(4215))

Compiling constant declarations:

Usually constants are defined using a const keyword. The following shows the general form for constant declarations:

const course_number = 4215;
const enrolment_status = true;

The above expressions can produce the following machine instructions:

assign(val, constant(4215)),
perform(op(define_constant), constant(course_number), reg(val), reg(env)),
assign(val, constant(1)),

assign(val, constant(true)),
perform(op(define_constant), constant(enrolment_status), reg(val), reg(env)),
assign(val, constant(1))

Compiling variable declarations:

Should you prefer to declare variables using let instead, the following applies: An expression such as

let x = 1010;

can result in compiled machine instructions:

assign(val, constant(1010)),
perform(op(define_variable), constant(x), reg(val), reg(env)),
assign(val, constant(1))

Compiling variable assignments:

Now, let's say that we are interested in modifying a previously declared variable, we can do this.

let subject_code = 3243; // Just a reminder that we have to use the 'let' keyword instead of 'const' here.
subject_code = 4215;

The above Source program can result in such a machine instruction:

assign(val, constant(3243)),
perform(op(define_variable), constant(subject_code), reg(val), reg(env)),
assign(val, constant(1)),
assign(val, constant(4215)),
perform(op(define_variable), constant(subject_code), reg(val), reg(env)),
assign(val, constant(1))

Compiling function definitions:

Furthermore, we can also compile function expressions and obtain its corresponding machine instructions. The Source program

(x,y) => {x; 1234; return 5678;}

can produce such a register machine instruction after compilation.

assign(val, op(make_compiled_procedure), label(entry1), reg(env)),
go_to(label(after_lambda2)),
entry1,
assign(env, op(compiled_procedure_env), reg(proc)),
assign(env, op(extend_environment), constant([["name", ["x", null]], [["name", ["y", null]], null]]), reg(arg1), reg(env)),
assign(val, op(lookup_variable_value), reg(env), constant(x)),
assign(val, constant(1234)),
assign(val, constant(5678)),
go_to(reg(continue)),
after_lambda2

Whew, there we have it.