Vector table structure in ARM Architecture - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a vector table in ARM architecture?

A vector table is a special memory area that holds the addresses of exception handlers. It helps the processor know where to jump when an interrupt or exception occurs.

beginner

Where is the vector table usually located in ARM systems?

The vector table is usually located at a fixed memory address, often at the start of the memory (address 0x00000000) or at a configurable location depending on the system design.

intermediate

What types of exceptions are listed in the ARM vector table?

The vector table lists exceptions such as reset, undefined instruction, software interrupt (SWI), prefetch abort, data abort, IRQ (interrupt request), and FIQ (fast interrupt request).

intermediate

How does the ARM processor use the vector table during an exception?

When an exception occurs, the ARM processor looks up the vector table to find the address of the corresponding handler and jumps to that address to execute the handler code.

beginner

Why is the vector table important for system stability?

The vector table ensures that exceptions and interrupts are handled properly by directing the processor to the correct handler. Without it, the system could crash or behave unpredictably.

What does the ARM vector table contain?

A Data variables

B User application code

C Addresses of exception handlers

D Processor registers

The vector table contains addresses of exception handlers so the processor knows where to jump when an exception occurs.

Where is the ARM vector table typically located?

A In the stack memory

B At the end of memory

C In the cache memory

D At the start of memory (0x00000000)

The vector table is usually located at the start of memory, often at address 0x00000000.

Which exception is NOT part of the ARM vector table?

A Reset

B Page fault

C Software interrupt (SWI)

D Undefined instruction

Page fault is not an ARM exception listed in the vector table; it is common in other architectures like x86.

What happens when an ARM processor encounters an IRQ?

A It jumps to the IRQ handler address in the vector table

B It resets the system

C It ignores the interrupt

D It halts execution

On IRQ, the processor uses the vector table to find and jump to the IRQ handler.

Why must the vector table be correctly set up?

A To ensure exceptions are handled properly

B To speed up arithmetic operations

C To store user data

D To increase memory size

Correct setup of the vector table ensures exceptions and interrupts are handled properly, maintaining system stability.

Explain the purpose and role of the vector table in ARM architecture.

Think about how the processor knows where to go when something unexpected happens.

Describe what happens step-by-step when an interrupt occurs in an ARM system using the vector table.

Focus on how the vector table guides the processor during an interrupt.

Practice

1. What is the first entry in the ARM vector table?

easy

A. Program counter start address

B. Reset handler address

C. Initial stack pointer address

D. Interrupt service routine address

Solution

1. Step 1: Understand vector table structure

   The ARM vector table begins with the initial stack pointer value to set up the stack.

2. Step 2: Identify the first entry

   The first entry is the initial stack pointer address, followed by the reset handler address.

3. Final Answer:

   Initial stack pointer address -> Option C

4. Quick Check:

   First entry = Initial stack pointer address [OK]

Hint: Remember: stack pointer comes before reset handler [OK]

Common Mistakes:

• Confusing reset handler as first entry
• Thinking program counter is first
• Assuming interrupt routine is first

2. Which of the following correctly describes the second entry in the ARM vector table?

easy

A. Reset handler address

B. Initial stack pointer address

C. Undefined instruction handler

D. Non-maskable interrupt handler

Solution

1. Step 1: Recall vector table order

   The first entry is the initial stack pointer, so the second entry is the reset handler.

2. Step 2: Confirm second entry role

   The reset handler is the address where the processor starts executing after reset.

3. Final Answer:

   Reset handler address -> Option A

4. Quick Check:

   Second entry = Reset handler address [OK]

Hint: Second entry always points to reset handler [OK]

Common Mistakes:

• Mixing up with interrupt handlers
• Choosing stack pointer again
• Confusing with exception handlers

3. Given the following vector table snippet:

0x00000000: 0x20001000  (Initial SP)
0x00000004: 0x00001005  (Reset Handler)
0x00000008: 0x00001010  (NMI Handler)
0x0000000C: 0x00001020  (HardFault Handler)

Which address will the processor jump to on a HardFault exception?

medium

A. 0x20001000

B. 0x00001005

C. 0x00001010

D. 0x00001020

Solution

1. Step 1: Locate HardFault entry in vector table

   The HardFault handler address is at offset 0x0C in the vector table.

2. Step 2: Identify the address at 0x0000000C

   The address at 0x0000000C is 0x00001020, which is the HardFault handler.

3. Final Answer:

   0x00001020 -> Option D

4. Quick Check:

   HardFault handler = 0x00001020 [OK]

Hint: Match exception to its vector table offset [OK]

Common Mistakes:

• Choosing reset handler address
• Confusing NMI and HardFault handlers
• Selecting initial stack pointer

4. A developer sets the vector table's first entry to 0x00000000 instead of the initial stack pointer. What issue will most likely occur?

medium

A. Stack pointer will be invalid causing a crash

B. Processor will reset normally

C. Reset handler will not execute

D. Interrupts will be ignored

Solution

1. Step 1: Understand role of first vector entry

   The first entry sets the initial stack pointer address for the processor.

2. Step 2: Analyze effect of setting it to zero

   Setting it to 0x00000000 means the stack pointer points to an invalid memory location, causing a crash.

3. Final Answer:

   Stack pointer will be invalid causing a crash -> Option A

4. Quick Check:

   Invalid stack pointer = Crash [OK]

Hint: First vector must be valid stack pointer [OK]

Common Mistakes:

• Thinking reset handler won't run
• Assuming interrupts are disabled
• Believing processor resets normally

5. You want to add a custom interrupt handler for a new peripheral. Where in the ARM vector table should you place this handler's address?

hard

A. At the first entry replacing the initial stack pointer

B. At the specific interrupt vector slot assigned to that peripheral

C. At the second entry replacing the reset handler

D. At the end of the vector table after all default handlers

Solution

1. Step 1: Understand vector table layout

   The vector table has fixed slots for each exception and interrupt type.

2. Step 2: Identify correct slot for custom interrupt

   Custom peripheral interrupts must be placed at their assigned interrupt vector slot, not at stack pointer or reset handler entries.

3. Final Answer:

   At the specific interrupt vector slot assigned to that peripheral -> Option B

4. Quick Check:

   Custom handler = Assigned interrupt vector slot [OK]

Hint: Place handlers in their assigned vector slots only [OK]

Common Mistakes:

• Replacing stack pointer or reset handler
• Appending handler at vector table end
• Ignoring fixed vector slot assignments