Assembly Language

Low-level languages use the specific instruction set of a processor. The instruction set for each processor is defined by its manufacturer, so a low-level program can only be executed by the type of processor it was written for. For this reason, code written in a low-level language is non-portable: it will not run on a computer with a different processor.

There are two types of low-level programming language: machine code and assembly language (also called assembly code).

When designing a processor, the manufacturer has to decide which operations the processor will be able to carry out. Some examples of processor operations are:

• adding two numbers together
• storing data in registers
• loading data from main memory

The manufacturer then defines an instruction set: the set of instructions that lets a programmer use those operations. An instruction set only works with that particular processor, or with a group of processors that share the same operations, called a processor family.

Every instruction set gives the low-level programmer commands to move data into and out of the processor, and to use the processor’s internal registers so that data transfer is kept to a minimum. This means a low-level programmer must understand the design and abilities of the processor well. A programmer who understands a processor well enough can write extremely efficient programs that make the most of the processing power and memory available.

Low-level languages have a 1:1 relationship with processor instructions. This gives a programmer fine control over how a program is executed, which allows extremely efficient programs.

When a programmer uses a low-level language, they can optimise a program to make the best use of the processor’s resources. For example, low-level languages let programmers use specific registers. A skilled programmer can precisely control the movement of data in and out of the processor, which improves the program’s efficiency.

Like everything inside a computer, a processor can only understand instructions given in binary. These binary instructions are called machine code.

Machine code is the only type of programming language that does not need to be translated before it is run, because it is already in binary. Every other programming language must first be translated into machine code instructions before a processor can execute them.

Writing machine code is very difficult for humans: a program made of nothing but 0s and 1s is hard to read and write, and very hard to debug.

Where people do need to see and work with machine code, it is usually shown in hexadecimal instead of binary, because hexadecimal is easier for humans to read and understand.

Each low-level instruction has two parts: an opcode and an operand.

• The opcode (short for operation code) is the part of the instruction that says which operation the processor should carry out, for example loading or storing data.
• The operand holds a value, or set of values, that the opcode works with. It can be the actual data, or a reference to the memory location of the data. For example, when the opcode is a “store” instruction, the operand holds the memory location where the data should be stored.

For example, a 16-bit instruction could be made of a 6-bit opcode followed by a 10-bit operand:

Assembly language lets programmers write machine code instructions using mnemonics: short codes made of letters that stand for the binary opcodes. (A mnemonic is a system of letters that helps you remember something. It is pronounced “neh-monic”.) The mnemonics are an English-like way of writing the operation the machine will carry out.

Here are two possible machine code opcodes and their assembly language equivalents. Every processor has its own machine code, instruction set and assembly language, so these are only an illustration.

Assembly language has to be converted into machine code before it can run. The assembly language source code is translated into its machine code equivalent. This process is called assembling, and it is done by a program called an assembler.

Assembly language is low-level, so it works directly with main memory. In the example below, the numbers 8, 9 and 10 in the assembly language are memory locations: location 8 holds 5, location 9 holds 2, and the result is stored in location 10.

Each machine code instruction here is 8 bits: a 4-bit opcode (0101 for LDD, 0001 for ADD, 0011 for STO) followed by a 4-bit operand, the memory address (1000 is 8, 1001 is 9, 1010 is 10).

A program written in assembly language has to be translated into machine code by an assembler before the processor can execute it. Assembly language is easier to write than machine code, and the assembler also lets the programmer use some special features in an assembly language program, for example:

• comments
• symbolic names for constants
• labels for addresses
• macros
• directives

A macro is a sequence of instructions that is used more than once in a program. A directive is an instruction to the assembler about how it should build the final executable machine code. For example, a directive might say how memory should be used, or define the files or procedures that will be used.

High-level languages also have to be translated into machine code, but the programmer has little or no say in how this is done. With assembly language, the programmer can optimise the program. For example, low-level languages can use specific registers, so a skilled programmer can directly control the movement of data in and out of the processor.

Before a program written in assembly language (the source code) can be executed, it has to be translated into machine code by an assembler. The assembler translates each assembly language instruction into one machine code instruction.

The assembler also checks the syntax of the assembly language program, to make sure that only opcodes from the processor’s instruction set are used. This speeds up development, because some errors are found during translation, before the program is executed.

There are two types of assembler:

• A single pass assembler puts the machine code instructions straight into the computer’s memory to be executed.
• A two pass assembler produces an object program in machine code that can be stored, then loaded and executed later. This needs another program, called a loader. A two pass assembler has to read (scan) the source program twice, so that it can replace the labels in the assembly program with memory addresses in the machine code program.

For example, the assembly language instruction LDD Total uses the label Total. In the machine code (shown in hexadecimal) the label has been replaced by a memory address:

The second pass is needed because a label may be used before its address is known. In the program below, Found is a forward reference: the JPN instruction uses it before the line labelled Found: has been reached.

Label       Opcode   Operand
Notfound:   LDD      200
            CMP      #0
            JPN      Found
            JPE      Notfound
Found:      OUT

If the program is loaded at memory address 100, and each memory location holds 16 bits (one instruction), the symbol table for this small section of program is:

An exam question may give you a short program with labels and ask you to complete the symbol table, or to show the code after the second pass. Remember the syllabus rule <label>: <data>: a label in front of a data value gives that memory location a symbolic address.

Assembly language and machine code programs use different addressing modes, depending on what the program needs. The addressing mode says how the operand is used to find the data.

• Immediate addressing: the operand is the value to be used. For example, LDM #200 stores 200 in the accumulator.
• Direct addressing: the operand is the address of the data; the contents of that memory location are used. For example, if the memory location with address 200 holds 20, LDD 200 stores 20 in the accumulator. Absolute addressing is the same as direct addressing.
• Indirect addressing: the operand is an address that holds the address of the data, so the contents of the contents of the memory location are used. For example, if address 200 holds 20 and address 20 holds 5, LDI 200 stores 5 in the accumulator.
• Indexed addressing: the address of the data is found by adding the contents of the Index Register (IX) to the address in the operand. For example, if IX holds 4 and address 204 holds 17, LDX 200 stores 17 in the accumulator.
• Relative addressing: the address used is the address of the current instruction plus the operand (an offset). For example, an instruction such as JMR #5 would transfer control to the instruction 5 locations after the current instruction.
• Symbolic addressing: used only in assembly language programming. A label is used in place of an address. For example, if the memory location labelled MyStore holds 20, LDD MyStore stores 20 in the accumulator.

Note JMR is not in the Cambridge instruction set. It only shows the idea. Relative addressing is useful because the code still works wherever it is loaded in memory: the jump is a distance from the current instruction, not a fixed address.

In the exam you will be given part of this instruction set. These rules apply to every question:

• There is only one general purpose register, the Accumulator (ACC).
• IX is the Index Register.
• <address> can be an absolute or a symbolic address.
• # shows a denary number, for example #123.
• B shows a binary number, for example B01001010.
• & shows a hexadecimal number, for example &4A.

Each table row gives the opcode, the operand it takes (if any) and what the instruction does. The instructions are grouped by what they do. These are the instruction groups:

Data movement

Arithmetic operations

Input and output of data

Unconditional and conditional instructions (jumps)

Compare instructions

The bit manipulation instructions (AND, OR, XOR, LSL, LSR) and labels are covered in 4.3.

Note JPE and JPN only make sense straight after a compare instruction: the compare sets the result (True or False) that the jump tests.

The values stored in the status register can show that a calculation has gone wrong. Three flags are used:

• the carry flag, C, is set to 1 if there is a carry out of the most significant bit
• the negative flag, N, is set to 1 if the result is negative
• the overflow flag, V, is set to 1 if overflow is detected

Consider adding two positive values whose sum is too large to be stored correctly in the number of bits available. Using 8-bit two’s complement integers, add denary 66 and denary 68:

   0100 0010     (66)
 + 0100 0100     (68)
   ---------
   1000 0110     (−122)

 Flags: N = 1, V = 1, C = 0

The answer produced is denary −122: two positive numbers have been added to give a negative number. This impossible result is detected because the negative flag and the overflow flag are both set to 1. The processor examines the flags, identifies the problem and generates an interrupt.

Now use the same 8-bit representation to add two negative numbers, −66 and −68:

    1011 1110     (−66)
  + 1011 1100     (−68)
    ---------
 (1)0111 1010     (+122)

 Flags: N = 0, V = 1, C = 1

The answer is +122, which is impossible for two negative numbers. This is detected because the negative flag is not set while both the overflow flag and the carry flag are set to 1.

One way to check whether an assembly language program has errors is a dry run (a practice run by hand). The main thing to check is how the contents of the accumulator change as the program runs. You record this in a trace table.

For this example the trace table needs a column for the accumulator, two columns for memory locations and one for the output. The three IN instructions put the values 15, 27 and 31 into the ACC, in that order.

Note OUT outputs the character whose ASCII value is in the ACC, so the output is J (ASCII 74), not the number 74. In the same way, IN stores the ASCII value of the key pressed. In the exam, use the ASCII table you are given to turn values into characters.

Here a new row is used for each instruction, which helps with checking. Another correct method is to write each value in the first free position in its column: for example, the Memory location 200 column could have 15 and 46 in its first two rows.

If an instruction does not change a column, you do not need to write the value again. A trace table only needs to show changes; it does not have to record every value at every step.

Some instructions for part of a program are stored in memory locations 100 upwards, and some 4-bit binary data values are stored in locations 200 upwards. The instructions are shown in assembly language. At the start, memory holds:

Because the program contains a jump instruction, the trace table records the program counter (PC) as well as the accumulator.

The rows of the table can be explained like this:

• The first row shows the values before this part of the program runs. The accumulator holds a value left by an earlier instruction.
• The second row shows the result of the instruction in location 100, which loads 0001 into the ACC. The PC is then automatically incremented to 101.
• The next two rows show the ACC being changed by the instructions in 101 (add 1, giving 0010) and 102 (add 0011, giving 0101), with the PC incremented each time.
• The fifth row has no new value in the ACC, because the instruction in 103 only compares (0101 with 0101), but the PC is still incremented.
• The sixth row shows a new value in the PC, 106, because the jump instruction in 104 tested for equality and found it to be True. The instruction in 105 is skipped.
• The seventh row shows the result of the instruction in 106, which increments the ACC to 0110.
• The final row shows the value 0110 stored in location 203.

Exam trace questions often use the Index Register to step through a list of values in memory, and OUT to output characters. Each time round the loop, INC IX moves on to the next memory location, so LDX loads the next value. A trace table for this kind of program usually has a column for the instruction address, the ACC, IX and the output.

In this program, memory locations 200 to 203 hold 75, 72, 73 and 0. In ASCII, 72 is H, 73 is I and 75 is K.

100  LDR  #0
101  LDX  200
102  CMP  #0
103  JPE  107
104  OUT
105  INC  IX
106  JMP  101
107  END

Note Only record a value when it changes, and only trace as far as the question asks (for example, “stop when line 90 is executed for a second time”).