AS & A Level Computer Science (9618) - Chapter 6: Introduction to Assembly Language Programming

About this video

• Video Title: AS & A Level Computer Science (9618) - Chapter 6: Introduction to Assembly Language Programming
• Channel: James Gan
• Speakers: James Gan
• Duration: 00:32:45

Overview

This video provides an introduction to Assembly Language programming for AS & A Level Computer Science (9618). It explains the concept of machine code, the necessity and structure of assembly language, different addressing modes, the process of a two-pass assembler, and various assembly language instructions including data movement, input/output, comparison, jumps, arithmetic operations, shift operations, and bitwise logic operations. The video concludes with further considerations on register status and a practical example of tracing assembly language execution.

Key takeaways

• Machine Code vs. Assembly Language: Machine code is the binary language (0s and 1s) that the CPU directly understands, consisting of opcodes and operands. Assembly language is a low-level programming language that uses symbolic instructions (mnemonics) to represent machine code, making it more human-readable.
• Assembler: An assembler is a program that translates assembly language code into machine code. A two-pass assembler processes the source code twice: the first pass gathers information about labels and addresses, and the second pass generates the machine code.
• Addressing Modes: These specify how data or memory locations are accessed. Key modes discussed include:
  • Symbolic Addressing: Uses labels to refer to memory locations.
  • Absolute Addressing: Uses the exact memory address.
  • Relative Addressing: Uses an offset from a base register or current instruction.
  • Immediate Addressing: The operand is the actual data value.
  • Direct Addressing: The operand is the memory address of the data.
  • Indirect Addressing: The operand is the memory address that holds the address of the data.
  • Indexed Addressing: An index register's value is added to a base address to find the data.
• Assembly Language Instructions: The video details various instruction types:
  • Data Movement: Instructions like LDD (Load Direct), LDI (Load Indirect), STO (Store), MOV (Move).
  • Input/Output: Instructions like IN (Input) and OUT (Output).
  • Comparison and Jumps: Instructions like CMP (Compare) and JMP (Jump), which allow for conditional execution based on comparisons, affecting program flow.
  • Arithmetic Operations: Instructions for addition, subtraction, increment, and decrement.
  • Shift Operations: Logical and arithmetic shifts used for multiplication and division.
  • Bitwise Logic Operations: Operations like AND, OR, XOR.
• Register Status and Tracing: The status register (SR) stores flags indicating conditions like carry, zero, negative, and overflow. Tracing assembly language involves tracking the values in registers and memory locations throughout the program's execution, often using a trace table.

Here are some notes extracted from the transcript:

• Machine Code:

  • Binary (0s and 1s).
  • The only language the CPU recognizes.
  • Consists of instructions, each with an opcode (operational code) and an operand(s).
  • Instructions can vary in bit length and structure (e.g., operand location, opcode position).

• Assembly Language:

  • A low-level programming language.
  • Uses symbolic instructions (mnemonics) for opcodes and operands.
  • More human-readable and writable than machine code.
  • Allows direct control over processor actions.
  • Requires an assembler to translate into machine code.
  • Features include commands, symbolic names for constants, labels for addresses, macros (reusable code snippets), and directives (instructions for the assembler).

• Addressing Modes:

  • Symbolic Addressing: Uses labels (e.g., Max, Total) instead of absolute memory addresses.
  • Absolute Addressing: Uses the exact memory address (e.g., 215).
  • Relative Addressing: Calculates address based on a base register (BR) plus an offset (e.g., BR + 15).
  • Immediate Addressing: The operand is the actual data value (e.g., #46, b#1010, h#2A).
  • Direct Addressing: The operand is the memory address containing the data (e.g., count).
  • Indirect Addressing: The operand is an address that contains the address of the data (often indicated by square brackets []).
  • Indexed Addressing: A base address is combined with an index register's value to find the data (e.g., 17 + value in index register).

• Two-Pass Assembler Process:

  • Pass 1: Gathers information about labels and their addresses/offsets. Creates a symbol table.
  • Pass 2: Uses the symbol table and opcode lookup table to generate the final machine code.

• Instruction Categories:

  • Data Movement: LDD (Load Direct), LDI (Load Indirect), STO (Store), MOV (Move).
  • Input/Output: IN (Input from keyboard to accumulator), OUT (Output from accumulator to screen).
  • Comparison and Jumps:
    • CMP (Compare): Compares accumulator with an operand, setting status flags.
    • JMP (Jump): Unconditional jump to a specified address by changing the Program Counter (PC).
    • JP (Jump if True/Positive): Jumps if the comparison result flag is set.
    • JPN (Jump if Not True/Negative): Jumps if the comparison result flag is not set.
  • Arithmetic Operations: Add (ADD), Subtract (SUB), Increment (INC), Decrement (DEC).
  • Shift Operations:
    • LSL (Logical Shift Left): Multiplies by 2 for each shift.
    • LSR (Logical Shift Right): Divides by 2 for each shift.
    • Arithmetic shifts are needed for signed numbers to preserve the sign bit.
    • Cyclic shifts move bits around without losing them.
  • Bitwise Logic Operations: AND, OR, XOR (operate on bits of operands).

• Further Considerations:

  • Status Register (SR): Stores flags (Carry, Zero, Negative, Overflow) resulting from operations, used by conditional jump instructions.
  • Overflow: Occurs when an arithmetic operation results in a value outside the representable range for the data type (e.g., exceeding 127 for an 8-bit signed integer).
  • Tracing: Manually tracking the state (values in registers and memory) of the system throughout program execution using a trace table. Essential for debugging and understanding program flow.