Crowdly

A header uses a special record with a different format than the list nodes

A header is useful because it makes it easier to insert a new node

at the beginning of a list

The CommandLoop in the OrderedLists program loads the command code into

a register, and it then compares that register with 0 and the maximum

valid command code. If the command is not valid the program skips the

command. Which statement is correct?

These checks are optional, and they could be omitted.

If the program enters the jump table with an invalid command, it

could jump to a random location and would then malfunction

The OrderedLists program takes in a sequence of commands, and there are

several commands (insert, delete, etc.). The choice of command is

specified by an integer chosen from a sequence of consecutive integers

0, 1, 2, ... Which of the following statements is NOT correct?

An advantage of this representation is that the program can efficiently

jump to the appropriate implemention by using a jump table

It is more efficient to use consecutive integers for the commands, rather

than randomly chosen integers (e.g. insert=371, delete=429, etc.)

It would be more efficient to represent each command by a character

string, and to compare the string with the constants 'Insert', 'Delete', etc.

A linked list consists of nodes, where each node is a record with

a value field (containing an integer) and a next field (containing

a pointer to the next node in the list). Suppose R3 contains a pointer

to the list.

Why should the program compare R3 with nil before it performs R3 := (*R3).next?

If the list is empty, then R3 := (*R3).next would load a garbage pointer

into R3, and the program would likely malfunction later on

After executing R3 := (*R3).next, there is no longer a register that

contains nil

The program will be more efficient if R3 is nil

A linked list consists of nodes, where each node is a record with

a value field (containing an integer) and a next field (containing

a pointer to the next node in the list). Suppose R3 contains a pointer

to a node in the list.

Which of the following will implement R3 := (*R3).next?

   load   R3,1[R3]

   load   R3,0[R3]

   lea    R3,0[R3]

   lea    R3,1[R3]

A linked list consists of nodes, where each node is a record with

a value field (containing an integer) and a next field (containing

a pointer to the next node in the list). Suppose R3 contains a pointer

to a list.

Which of the following will jump to Done if the list is empty?

   jumpnil R3,Done[R0]

   cmp   R3,R0
   jumplt   Done[R0]

   cmp   R3,R0
   jumpeq   Done[R0]

R5 contains a pointer to a record with three fields, called

fieldA, fieldB, fieldC. Suppose fieldA contains an integer,

and fieldB and fieldC contain pointers to lists. Which instruction

puts the value of fieldC into R6?

   load  R6,2[R5]

   lea   R6,0[R5]

   lea   R6,2[R5]

Most of the following statements are correct, but one is not.

Which statement is NOT true?

lea calculates the effective address and puts it into the destination register

load and lea both calculate the effective address exactly the same way

❌✨

lea always puts a pointer into the destination register,

load always puts an integer into the destination register

load copies a word from memory to a register, and that word could

be an integer, a pointer, or some other data type

create a pointer to an element of a record

Most instructions are used for just one purpose, but lea can be used for several purposes. Which one of the following is NOT something you can do with lea?

add a constant to a register

load a constant into a register

create a pointer to a variable: i.e. implement (&x)

follow a pointer: i.e. implement (*p)

increment the stack pointer

if i>=n, don't enter the jump table, but go to an error handler

Suppose R4=i, and we are implementing a jump table to go to jt[i], where jt contains n elements. Several computations should be performed on i before actually making the jump. Which of the following is NOT one of these computations?

Compute 2*i, because each element of the jump table is two words long

If i<0, don't enter the jump table, but go to an error handler

Take the absolute value of i