Assembly

An assembly language is used as a middle man between higher level-languages like Rust or C and machine code. This is done by first compiling these higher level languages into assembly, which then gets translated into binary by an assembler.

Assembler and their respective assembly languages are hardware specific; you need to write different assembly for different CPU architectures because they use different instruction sets.

Practical example

The following code represents a program that adds two numbers together:

LDA 100
ADA 101
STA 102

LDA 100: LoaD Accumulator 100 => loads the value stored at memory address 100 into the accumulator.

ADA 101: ADd Accumulator 101 => add the value from the accumulator and the memory address 101 together.

STA 102: STore Accumulator 102 => writes the resulting value from the accumulator into the memory address 102.

The control unit is responsible for the fetch, decode, fetch operands, execute and write back cycle during the execution. This cycle happens for each individual instruction.

Decoding Machine Code

To represent machine code we need to implement some sort of encoding. A simple way of encoding could look like this:

Instruction Table

Opcode Encoding

Number Bit

Addressing commands

If we address byte wise; which means that every byte gets its own address, we would need two bytes per address (16 bit). Since our command is 12 bit long and we can only access every second bit, adding 4 bytes of padding after every command.

In practice this would look like:

1. 0000
2. 0010
3. 0100
4. 0110
5. ...

Assembling for RISC and CISC

To illustrate how converting assembly works, we first need to understand the differences between both architectures.

• RISC: Uses simpler, fixed-length instructions; faster execution per instruction, but may need more instructions.

• CISC: Uses complex, variable-length instructions; can do more in a single instruction, but may be slower per instruction.

Out of these differences, the following properties emerge. The assembler can encode RISC instructions into fixed lengths (often 32 bit) binary instructions, which are in a very predictable format. When it comes to CISC the assembler has to encode more complex instructions, which results in corresponding binary that has instructions that are 3-6 bytes long depending on the specifies.