Vector table relocation in ARM Architecture - Step-by-Step Execution

Concept Flow - Vector table relocation

System Reset

↓

CPU uses default Vector Table Address

↓

Software requests Vector Table Relocation

↓

Set Vector Table Offset Register (VTOR)

↓

CPU uses new Vector Table Address

↓

Interrupts and Exceptions handled using relocated table

The CPU starts with a default vector table address. Software can change this by setting the VTOR register, so interrupts use a new vector table location.

Execution Sample

ARM Architecture

VTOR = 0x20000000;  // Set new vector table address
CPU fetches interrupt vector from VTOR
Interrupt handler runs from new location

This code sets the vector table to a new memory address, so the CPU uses interrupt vectors from there.

Analysis Table

Step	Action	VTOR Register Value	Vector Table Used	Interrupt Handling
1	System Reset	0x00000000 (default)	Default vector table at 0x00000000	Interrupts use default vectors
2	Software sets VTOR	0x20000000	Vector table relocated to 0x20000000	Interrupts use relocated vectors
3	Interrupt occurs	0x20000000	Vector table at 0x20000000	Handler from relocated table runs
4	System continues	0x20000000	Vector table at 0x20000000	All interrupts use relocated vectors

💡 Execution stops here as vector table relocation is complete and active

State Tracker

Variable	Start	After Step 2	After Step 3	Final
VTOR	0x00000000 (default)	0x20000000	0x20000000	0x20000000
Vector Table Address	0x00000000	0x20000000	0x20000000	0x20000000

Key Insights - 3 Insights

Why does the CPU use the default vector table address at reset?

At reset, the VTOR register is set to 0x00000000 by default, so the CPU fetches interrupt vectors from this address as shown in step 1 of the execution_table.

What happens if the VTOR is not updated after reset?

If VTOR is not changed, the CPU continues to use the default vector table at 0x00000000, so interrupts are handled using the original vectors (see step 1 and 4).

How does setting VTOR affect interrupt handling?

Setting VTOR changes the base address for interrupt vectors, so the CPU fetches interrupt handlers from the new location, as shown in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the VTOR value after software sets it?

A 0x10000000

B 0x00000000

C 0x20000000

D Undefined

💡 Hint

Check Step 2 in the execution_table under VTOR Register Value

At which step does the CPU start using the relocated vector table for interrupts?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the Interrupt Handling column in the execution_table

If VTOR was never set, what would the Vector Table Address be after reset?

A 0x00000000

B 0x20000000

C 0x10000000

D 0xFFFFFFFF

💡 Hint

Refer to the Start value in variable_tracker for Vector Table Address

Concept Snapshot

Vector Table Relocation in ARM:
- CPU uses VTOR register to find interrupt vectors
- Default VTOR = 0x00000000 at reset
- Software sets VTOR to new address to relocate vectors
- Interrupts use vectors from VTOR address
- Enables flexible interrupt handling locations

Full Transcript

Vector table relocation in ARM architecture means changing where the CPU looks for interrupt and exception handlers. When the system resets, the CPU uses a default vector table address, usually 0x00000000. Software can change this by writing a new address into the VTOR register. After setting VTOR, the CPU fetches interrupt vectors from the new location. This allows programs to move interrupt handlers to different memory areas, which is useful for bootloaders or operating systems. The execution steps show the VTOR value changing from default to a new address, and interrupts being handled from the relocated vector table.

Practice

1. What is the primary purpose of relocating the vector table in ARM architecture?

easy

A. To increase the processor clock speed

B. To change the base address where interrupt handlers are located

C. To enable floating-point operations

D. To disable interrupts permanently

Solution

1. Step 1: Understand the vector table role

   The vector table contains addresses of interrupt handlers used by the processor.

2. Step 2: Purpose of relocation

   Relocation changes the base address so the processor knows where to find these handlers in memory.

3. Final Answer:

   To change the base address where interrupt handlers are located -> Option B

4. Quick Check:

   Vector table relocation = changing interrupt handler base address [OK]

Hint: Vector table relocation changes interrupt handler address base [OK]

Common Mistakes:

• Confusing relocation with clock speed changes
• Thinking relocation disables interrupts
• Assuming relocation enables floating-point

2. Which ARM register is used to relocate the vector table base address?

easy

A. VTOR (Vector Table Offset Register)

B. SP (Stack Pointer)

C. LR (Link Register)

D. PC (Program Counter)

Solution

1. Step 1: Identify the register for vector table base

   The VTOR register holds the base address of the vector table in ARM processors.

2. Step 2: Confirm other registers' roles

   PC controls instruction flow, LR stores return address, SP manages stack; none relocate vector table.

3. Final Answer:

   VTOR (Vector Table Offset Register) -> Option A

4. Quick Check:

   VTOR = vector table base register [OK]

Hint: VTOR register sets vector table base address [OK]

Common Mistakes:

• Confusing PC with VTOR
• Using LR or SP for vector table relocation
• Not knowing VTOR purpose

3. Given the following code snippet in ARM assembly, what is the effect of the instruction?
MOV R0, #0x20000000
STR R0, [VTOR]

medium

A. Enables interrupts globally

B. Resets the processor

C. Sets the vector table base address to 0x20000000

D. Clears the vector table

Solution

1. Step 1: Analyze MOV instruction

   MOV R0, #0x20000000 loads the address 0x20000000 into register R0.

2. Step 2: Analyze STR instruction

   STR R0, [VTOR] stores the value in R0 into the VTOR register, relocating the vector table base.

3. Final Answer:

   Sets the vector table base address to 0x20000000 -> Option C

4. Quick Check:

   STR to VTOR = relocate vector table base [OK]

Hint: STR to VTOR sets new vector table base address [OK]

Common Mistakes:

• Thinking it resets the processor
• Assuming it enables interrupts
• Believing it clears the vector table

4. A developer tries to relocate the vector table by writing to VTOR but the interrupts still point to the old addresses. What is the most likely cause?

medium

A. The stack pointer is incorrectly set

B. The processor clock is too slow

C. The interrupt handlers are missing

D. VTOR register is write-protected or not enabled for writing

Solution

1. Step 1: Understand VTOR write requirements

   VTOR may be write-protected or require special permissions to update its value.

2. Step 2: Check other options

   Clock speed or stack pointer issues do not affect vector table relocation; missing handlers cause faults but not relocation failure.

3. Final Answer:

   VTOR register is write-protected or not enabled for writing -> Option D

4. Quick Check:

   VTOR write protection blocks relocation [OK]

Hint: Check VTOR write permissions if relocation fails [OK]

Common Mistakes:

• Blaming clock speed for relocation issues
• Confusing stack pointer with vector table base
• Assuming missing handlers prevent relocation

5. In a system with multiple memory regions, how can vector table relocation improve system flexibility?

hard

A. By allowing the vector table to be moved to RAM for dynamic interrupt handler updates

B. By increasing the processor's clock frequency automatically

C. By disabling unused interrupts permanently

D. By encrypting the interrupt handlers for security

Solution

1. Step 1: Understand relocation benefits

   Relocating the vector table to RAM allows changing interrupt handlers at runtime, improving flexibility.

2. Step 2: Evaluate other options

   Clock frequency changes, disabling interrupts, or encryption are unrelated to vector table relocation.

3. Final Answer:

   By allowing the vector table to be moved to RAM for dynamic interrupt handler updates -> Option A

4. Quick Check:

   Relocation enables dynamic interrupt handler updates [OK]

Hint: Relocate vector table to RAM for flexible interrupt updates [OK]

Common Mistakes:

• Thinking relocation changes clock speed
• Assuming relocation disables interrupts
• Believing relocation encrypts handlers