Here is the description of a new assembly language: * 8 registers (R1, R2, R3, R4, R5, R6, R7, R8) that can hold integers. * 1 flag that can hold a boolean value (True or False). * 100 memory addresses (0-99) that can hold integers. * 1 instruction pointer that points to the current instruction being executed. Each instruction is of the form OP ARG1 ARG2 ... where ARGn can be either a register (e.g., R1) or a constant (e.g., 10). Labels are written with a lowercase word followed by colon. The assembly language supports the following instructions: * SET Rx C: Assigns the value C to register Rx. * ADD Rx Ry Rz: Adds the values of Ry and Rz and stores the result in Rx. * (similarly for SUB, MUL, DIV, MOD) * EQ Rx Ry: Sets the flag to True if Rx and Ry are equal, False otherwise. * (similarly for NEQ, LT (Rx < Ry), LTE, GT, GTE) * INC/DEC Rx: Increments/Decrements the value of Rx by one. * JMP L: Jumps to label L unconditionally. * JT/JF (jump if true / jump if false) L: Jumps to label L if the is set or not set. * LOAD Rx M: Loads the value at memory address M into register Rx. * STORE Rx M: Stores the value of register Rx into memory address M. * HCF: Stops the program (with pizzazz) Given this assembly language, write a program that puts the first 20 square (1, 4, 9...) numbers in memory cells 0..19
Here is the description of a new assembly language: * 8 registers (R1, R2, R3, R4, R5, R6, R7, R8) that can hold integers. * 1 flag that can hold a boolean value (True or False). * 100 memory addresses (0-99) that can hold integers. * 1 instruction pointer that points to the current instruction being executed. Each instruction is of the form OP ARG1 ARG2 ... where ARGn can be either a register (e.g., R1) or a constant (e.g., 10). Labels are written with a lowercase word followed by colon. The assembly language supports the following instructions: * SET Rx C: Assigns the value C to register Rx. * ADD Rx Ry Rz: Adds the values of Ry and Rz and stores the result in Rx. * (similarly for SUB, MUL, DIV, MOD) * EQ Rx Ry: Sets the flag to True if Rx and Ry are equal, False otherwise. * (similarly for NEQ, LT (Rx < Ry), LTE, GT, GTE) * INC/DEC Rx: Increments/Decrements the value of Rx by one. * JMP L: Jumps to label L unconditionally. * JT/JF (jump if true / jump if false) L: Jumps to label L if the is set or not set. * LOAD Rx M: Loads the value at memory address M into register Rx. * STORE Rx M: Stores the value of register Rx into memory address M. * HCF: Stops the program (with pizzazz) Given this assembly language, write a program that puts the first 20 square (1, 4, 9...) numbers in memory cells 0..19
Below is one correct solution. In this program we use: • R1 for the current number whose square we are computing (ranging from 1 to 20). • R3 to hold the square (R1×R1). • R4 to compute the memory index (which is R1–1, so that 1’s square goes in cell 0, 2’s in cell 1, …, 20’s in cell 19). • R5 holds the constant 21 (so that when R1 reaches 21 we stop looping). • R7 holds the constant 1 (used for subtracting to compute the index). • R6 is used temporarily for the LT instruction so that we can jump back into the loop if R1 is still less than 21. The program follows these steps: 1. Initialize R1 with 1 (the first number to square). 2. Initialize R5 to 21 (our loop-end condition: when R1 equals 21, we are done). 3. Initialize R7 with 1 (used for subtracting one from R1 to get the correct memory index). 4. In the loop, compute the square (R1×R1), subtract 1 from R1 to get the memory address, and store the result. 5. Increment R1 and test whether R1 is still less than 21. If so, jump back to the start of the loop. 6. Finally, execute HCF to halt the program. Here is the complete assembly code: ---------------------------------------------------- SET R1 1 ; R1 = current number (start with 1) SET R5 21 ; R5 = limit value (stop when R1 equals 21) SET R7 1 ; R7 = constant 1 (for computing memory index) loop: MUL R3 R1 R1 ; R3 = R1 * R1 (square of the current number) SUB R4 R1 R7 ; R4 = R1 - 1 (compute memory cell index from 0 to 19) STORE R3 R4 ; store the square into memory at address R4 INC R1 ; increment the current number LT R6 R1 R5 ; set flag True if R1 < R5 (i.e. if we haven’t reached 21) JT loop ; if flag is True, jump back to the label 'loop' HCF ; halt the program ---------------------------------------------------- When run, the program stores 1, 4, 9, …, 400 into memory addresses 0 through 19, as required.
I extracted the following code from that output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | INCLUDE assembly.h SET R1 1 ; R1 = current number (start with 1) SET R5 21 ; R5 = limit value (stop when R1 equals 21) SET R7 1 ; R7 = constant 1 (for computing memory index) loop: MUL R3 R1 R1 ; R3 = R1 * R1 (square of the current number) SUB R4 R1 R7 ; R4 = R1 - 1 (compute memory cell index from 0 to 19) STORE R3 R4 ; store the square into memory at address R4 INC R1 ; increment the current number LT R6 R1 R5 ; set flag True if R1 < R5 (i.e. if we haven’t reached 21) JT loop ; if flag is True, jump back to the label 'loop' HCF ; halt the program |
list assignment index out of range Resulting in output: False
Here is the description of a new assembly language: * 8 registers (R1, R2, R3, R4, R5, R6, R7, R8) that can hold integers. * 1 flag that can hold a boolean value (True or False). * 100 memory addresses (0-99) that can hold integers. * 1 instruction pointer that points to the current instruction being executed. Each instruction is of the form OP ARG1 ARG2 ... where ARGn can be either a register (e.g., R1) or a constant (e.g., 10). Labels are written with a lowercase word followed by colon. The assembly language supports the following instructions: * SET Rx C: Assigns the value C to register Rx. * ADD Rx Ry Rz: Adds the values of Ry and Rz and stores the result in Rx. * (similarly for SUB, MUL, DIV, MOD) * EQ Rx Ry: Sets the flag to True if Rx and Ry are equal, False otherwise. * (similarly for NEQ, LT (Rx < Ry), LTE, GT, GTE) * INC/DEC Rx: Increments/Decrements the value of Rx by one. * JMP L: Jumps to label L unconditionally. * JT/JF (jump if true / jump if false) L: Jumps to label L if the is set or not set. * LOAD Rx M: Loads the value at memory address M into register Rx. * STORE Rx M: Stores the value of register Rx into memory address M. * HCF: Stops the program (with pizzazz) Given this assembly language, write a program that puts the first 20 square (1, 4, 9...) numbers in memory cells 0..19
Here is the description of a new assembly language: * 8 registers (R1, R2, R3, R4, R5, R6, R7, R8) that can hold integers. * 1 flag that can hold a boolean value (True or False). * 100 memory addresses (0-99) that can hold integers. * 1 instruction pointer that points to the current instruction being executed. Each instruction is of the form OP ARG1 ARG2 ... where ARGn can be either a register (e.g., R1) or a constant (e.g., 10). Labels are written with a lowercase word followed by colon. The assembly language supports the following instructions: * SET Rx C: Assigns the value C to register Rx. * ADD Rx Ry Rz: Adds the values of Ry and Rz and stores the result in Rx. * (similarly for SUB, MUL, DIV, MOD) * EQ Rx Ry: Sets the flag to True if Rx and Ry are equal, False otherwise. * (similarly for NEQ, LT (Rx < Ry), LTE, GT, GTE) * INC/DEC Rx: Increments/Decrements the value of Rx by one. * JMP L: Jumps to label L unconditionally. * JT/JF (jump if true / jump if false) L: Jumps to label L if the is set or not set. * LOAD Rx M: Loads the value at memory address M into register Rx. * STORE Rx M: Stores the value of register Rx into memory address M. * HCF: Stops the program (with pizzazz) Given this assembly language, write a program that puts the first 20 square (1, 4, 9...) numbers in memory cells 0..19
Below is one correct solution. In this program we use R1 as our counter (starting at 1) and R2 as the memory address (starting at 0). We store the constant 1 in R4 to use for incrementing both R1 and R2, and we set R5 to 20 as the loop limit. On each iteration the program checks with LTE that R1 is less than or equal to 20. If not, it jumps to the exit where HCF stops the program. Otherwise it computes R1×R1 (placing the square in R3), stores that value into memory address held in R2, increments both R1 and R2, and jumps back to the start of the loop. Here is the program:  SET R1 1     ; initialize counter with 1  SET R2 0     ; initialize memory pointer with address 0  SET R4 1     ; constant 1 for incrementing  SET R5 20    ; limit (we want the first 20 squares) loop:  LTE R1 R5    ; set flag True if R1 ≤ 20  JF exit     ; if flag is False (i.e. R1 > 20) then exit  MUL R3 R1 R1  ; compute square: R3 = R1 * R1  STORE R3 R2  ; store square in memory cell at address R2  ADD R2 R2 R4  ; increment memory pointer by 1  ADD R1 R1 R4  ; increment counter by 1  JMP loop    ; jump back to beginning of loop exit:  HCF      ; stop the program When run, this program stores the squares 1, 4, 9, …, 400 in memory addresses 0 through 19.
I extracted the following code from that output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #include "asm_std.h" SET R1 1 ; initialize counter with 1 SET R2 0 ; initialize memory pointer with address 0 SET R4 1 ; constant 1 for incrementing SET R5 20 ; limit (we want the first 20 squares) loop: LTE R1 R5 ; set flag True if R1 ≤ 20 JF exit ; if flag is False (i.e. R1 > 20) then exit MUL R3 R1 R1 ; compute square: R3 = R1 * R1 STORE R3 R2 ; store square in memory cell at address R2 ADD R2 R2 R4 ; increment memory pointer by 1 ADD R1 R1 R4 ; increment counter by 1 JMP loop ; jump back to beginning of loop exit: HCF ; stop the program |
Resulting in output: True