Chapter 4.2: Assembly Language

Answer:

• Assembly language is a low-level language related to machine code
• Assembly uses mnemonics to represent machine code instructions
• There is a one-to-one relationship between assembly instruction and machine code instruction
• Assembly language must be translated by an assembler into machine code before execution

Additional points for deeper understanding: Machine code is in binary format directly executable by the CPU, while assembly language is human-readable. Each CPU has its own specific machine code and assembly language.

Answer:

• A two-pass assembler translates assembly language into machine code in two stages
• Pass 1: Scans the program looking for symbols, labels, and variables
• Pass 1 creates a symbol table containing labels and their addresses
• Pass 1 maintains a Location Counter to assign addresses to each instruction
• Pass 2: Replaces symbolic addresses with absolute addresses using the symbol table
• Pass 2 replaces symbolic opcodes with binary opcodes to generate machine code

Additional points: Two passes are needed because forward references (jumping to labels defined later in the code) cannot be resolved in a single pass. The symbol table from Pass 1 enables correct address resolution in Pass 2.

Answer:

• Immediate addressing: The operand IS the actual value to be used
• Example: LDM #4 loads the value 4 directly into the accumulator
• Direct addressing: The operand is the memory address where the value is stored
• Example: LDD 200 loads the value stored at memory address 200 into the accumulator

Additional points: Immediate addressing is faster (no memory lookup needed) but limited to constants. Direct addressing requires one memory access but allows dynamic values.

Answer:

• The operand plus the contents of the Index Register (IX) gives the actual address
• Example: If IX = 4 and instruction is LDX 200, the actual address is 200 + 4 = 204
• The value at address 204 is loaded into the accumulator
• Useful for: Accessing arrays or lists - the base address is the operand, and IX acts as the index

Additional points: By incrementing IX in a loop, the program can sequentially access array elements. This is similar to array[i] in high-level languages where 'i' is the index.

Answer:

• In indirect addressing, the operand is the address of the address to be used
• Example: LDI 200 - look at address 200 to find another address (e.g., 20), then use that address to find the actual data
• It is used for pointers and dynamic data structures
• It allows the same instruction to access different data by changing the pointer

Additional points: Indirect addressing provides flexibility - the data location can change without modifying the instruction. Useful for linked lists, parameter passing, and implementing variables in high-level languages.

Answer:

• A symbol table is a table created during Pass 1 of assembly that maps labels to memory addresses
• It contains all symbolic names used in the program and their corresponding addresses
• It is needed because the computer cannot process symbolic addresses directly
• During Pass 2, labels in instructions are replaced with actual addresses from the symbol table

Additional points: Without a symbol table, forward references (jumping to labels not yet defined) would be impossible to resolve. It enables programmers to use meaningful names instead of numeric addresses.

Answer:

• The opcode tells the CPU what operation to perform (e.g., LDD, ADD, STO)
• The operand provides the data or address needed to complete the operation
• Example: In ADD 200, ADD is the opcode (add operation), and 200 is the operand (address of value to add)

Additional points: Some instructions may not require an operand (e.g., HALT). Some may have multiple operands in more complex processors.

Answer:

• Pass 1: The assembler records the label "LOOP" and its address in the symbol table
• The JMP instruction itself is noted but not yet translated
• Pass 2: The assembler looks up "LOOP" in the symbol table to find its address
• The label "LOOP" is replaced with the actual numeric address
• The opcode JMP is translated to its binary equivalent, producing complete machine code

Additional points: If LOOP is defined after the JMP instruction (forward reference), two passes are essential. Pass 1 identifies where LOOP is, Pass 2 uses that information.

Answer:

• A trace table tracks the values of variables as a program executes step by step
• Each row shows the state after each instruction: register values, memory contents, flags
• It helps identify logic errors by showing where values go wrong
• Programmers can compare expected values with actual values at each step

Additional points: Trace tables are essential for exam questions that ask you to trace a program. Always show the starting values and update each column as instructions execute.

Answer:

• CMP compares the contents of the accumulator with a value or memory contents
• It sets flags in the status register based on the comparison result
• The comparison is done by subtraction: ACC - operand (result is discarded, only flags are set)
• JPE (Jump if Previous Equal) jumps if comparison was true (values equal)
• JPN (Jump if Previous Not equal) jumps if comparison was false (values not equal)

Additional points: The CMP instruction must come BEFORE the conditional jump. Multiple conditional jumps can follow one CMP (if checking same comparison). CMP does not change the accumulator value.

Answer:

• Makes programs easier to read and understand - labels like "TOTAL" are more meaningful than addresses like "2345"
• Makes programs easier to modify - if a variable's address changes, only need to change it once in the symbol table
• Reduces errors - programmers don't need to remember and track numeric addresses

Additional point: Self-documenting code - the label names describe the purpose of the data.

Answer:

• The accumulator is a special register used for arithmetic and logic operations
• It holds one of the operands for calculations and stores the result of the operation
• Data must be loaded into the accumulator before it can be processed
• It acts as a temporary storage area during data manipulation

Additional points: In simple processors, the accumulator is the only general-purpose register. Most instructions implicitly use the accumulator - for example, ADD automatically adds to the accumulator contents.

Answer:

• Fetch: The instruction LDD 150 is fetched from memory using the Program Counter (PC)
• The instruction is stored in the Memory Data Register (MDR)
• Decode: The Control Unit decodes the instruction to understand it's a load operation
• The operand 150 is identified as a memory address
• Execute: The address 150 is sent to memory via the address bus
• The data at address 150 is retrieved and stored in the accumulator

Additional points: The PC is incremented after fetch to point to the next instruction. Direct addressing means one memory access during execute phase.

Answer:

• Direct addressing: Uses an absolute memory address specified in the instruction
• Used for accessing fixed data locations or variables at known addresses
• Relative addressing: Calculates the address by adding an offset to the current instruction address
• Used for loops and conditional jumps where code might be relocated

Additional points: Relative addressing produces position-independent code - the program works correctly regardless of where it's loaded in memory. Direct addressing is simpler but less flexible.

Answer:

• Each assembly instruction performs a very simple task (load, store, add)
• High-level language statements must be broken down into many smaller operations
• Example: "result = a + b + c" in high-level language needs multiple loads, adds, and store in assembly

Additional points: High-level languages provide built-in abstractions (loops, functions, objects) that compile to many machine instructions. Assembly programmers must code every detail explicitly.