内存寻址模式
探索使用直接、间接、基址、变址和比例变址等不同寻址模式访问内存位置的方法。
内存寻址模式 是 CoddyKit 上的免费 Assembly Language & x86 Low-Level Systems Programming 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Assembly Language & x86 Low-Level Systems Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Assembly Language & x86 Low-Level Systems Programming 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Memory's Many Paths
Welcome! Today, we'll learn how your CPU finds data in memory. This is crucial for understanding how programs work at a low level.
Memory addressing modes are the different ways a CPU can calculate the effective memory address of an operand.
- They allow flexible access to data.
- They're key for arrays, structures, and dynamic data.
Direct Addressing: Fixed Spots
Direct addressing is the simplest way to access memory. You provide the exact, fixed address of the data you want.
Think of it like going to a specific house number on a street. It's straightforward but not very flexible if you need to access different houses dynamically.
Try running this example:
section .data
; Define a word (2-byte) variable at a specific label
my_data dw 0x1234
section .text
global _start
_start:
; Move the content of 'my_data' into the AX register
; The CPU directly accesses the address associated with 'my_data'
mov ax, [my_data]
; Exit program (Linux specific syscall)
mov eax, 1 ; syscall number for exit
xor ebx, ebx ; exit code 0
int 0x80 ; call kernelRegister Indirect: Flexible Pointers
Register indirect addressing uses a general-purpose register (like EBX, ESI, or EDI) to hold the memory address.
Instead of a fixed address, the register acts as a 'pointer' to the data. This is much more flexible, as you can change the register's value to point to different memory locations.
Here's an example:
section .data
; Define some data in memory
value1 dw 0xAABB
value2 dw 0xCCDD
section .text
global _start
_start:
; Load the address of 'value1' into EBX
mov ebx, value1
; Move the content pointed to by EBX into AX
mov ax, [ebx] ; AX now holds 0xAABB
; Change EBX to point to 'value2'
mov ebx, value2
; Move the content pointed to by EBX into DX
mov dx, [ebx] ; DX now holds 0xCCDD
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Base Addressing: Structured Access
Base addressing combines a base register (often EBX or EBP) with a fixed numerical displacement (offset).
This is extremely useful for accessing fields within a data structure or elements of an array when the base address of the structure/array is in the register.
Example:
section .data
; A 'structure' with two word members
my_struct:
member1 dw 0x1111
member2 dw 0x2222
section .text
global _start
_start:
; Load the base address of 'my_struct' into EBX
mov ebx, my_struct
; Access 'member1' (offset 0 from base)
mov ax, [ebx + 0] ; AX now holds 0x1111
; Access 'member2' (offset 2 bytes from base, as words are 2 bytes)
mov dx, [ebx + 2] ; DX now holds 0x2222
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Index Addressing: Array Iteration
Index addressing uses an index register (like ESI or EDI) plus a displacement.
This mode is perfect for iterating through array elements, where the displacement can be the starting address of the array and the index register holds the current element's offset.
Consider this:
section .data
; An array of words
my_array dw 10h, 20h, 30h, 40h
section .text
global _start
_start:
; Set ESI to 0 (first element offset)
mov esi, 0
; Access first element: my_array[0]
mov ax, [my_array + esi] ; AX = 10h
; Increment ESI to point to the next word (2 bytes)
add esi, 2
; Access second element: my_array[1]
mov bx, [my_array + esi] ; BX = 20h
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Base-Index: 2D Arrays & More
Base-index addressing combines a base register and an index register (with an optional displacement).
This is powerful for accessing elements in two-dimensional arrays, or arrays of structures. The base register might hold the start of a row, and the index register the column offset.
It looks like [base + index] or [displacement + base + index].
section .data
; A 2x2 array of words (each row is 4 bytes: 2 words * 2 bytes/word)
matrix dw 1, 2 ; Row 0
dw 3, 4 ; Row 1
section .text
global _start
_start:
; EBX holds the base address of the matrix
mov ebx, matrix
; Access element [0][0]: (EBX + ESI)
mov esi, 0 ; Index for column 0
mov ax, [ebx + esi] ; AX = 1
; Access element [0][1]: (EBX + ESI)
mov esi, 2 ; Index for column 1 (1 word * 2 bytes/word)
mov bx, [ebx + esi] ; BX = 2
; Access element [1][0]: (EBX + displacement for row 1 + ESI)
; Row 1 starts 4 bytes after row 0
mov esi, 0
mov cx, [ebx + 4 + esi] ; CX = 3
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Scaled-Index: Data Type Friendly
Scaled-index addressing is an extension of base-index, allowing you to multiply the index register by a scale factor (1, 2, 4, or 8).
This is incredibly useful when working with arrays of different data sizes (bytes, words, double words, quad words) because the CPU automatically calculates the correct offset.
Format: [base + index*scale + displacement]
section .data
; An array of double words (4 bytes each)
d_array dd 100h, 200h, 300h
section .text
global _start
_start:
; EBX holds the base address of the array
mov ebx, d_array
; Access d_array[0] (index 0, scale 4 for dword)
mov esi, 0
mov eax, [ebx + esi*4] ; EAX = 100h
; Access d_array[1] (index 1, scale 4 for dword)
mov esi, 1
mov ebx, [ebx + esi*4] ; EBX = 200h
; Access d_array[2] (index 2, scale 4 for dword)
mov esi, 2
mov ecx, [ebx + esi*4] ; ECX = 300h
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80The Constant: Displacement
You've seen the term 'displacement' pop up in several modes. A displacement is a constant, signed 8-bit, 16-bit, or 32-bit value that's added to the calculated address.
- It provides a fixed offset from a base or index.
- It's often used to access specific members within a structure or to jump to a certain point in an array.
- It can be positive or negative.
It acts like a fixed street number offset from a known starting point.
Choosing Your Addressing Mode
Which mode should you use?
- Direct: For fixed, known memory locations (e.g., global variables).
- Register Indirect: For pointers, dynamic memory access.
- Base/Index: For array iteration, accessing structure members.
- Scaled-Index: Best for arrays of different-sized data types, letting the CPU handle scaling.
Understanding these modes gives you powerful control over memory!
Addressing Mode Challenge
Test your knowledge on memory addressing modes!
Memory Paths Mastered
Great job! You've explored the fundamental x86 memory addressing modes:
- Direct: Fixed addresses.
- Register Indirect: Register as a pointer.
- Base: Base register + displacement.
- Index: Index register + displacement.
- Base-Index: Base + Index + optional displacement.
- Scaled-Index: Base + Index * Scale + optional displacement.
These modes are the building blocks for how your programs interact with data in memory. Keep practicing!
常见问题解答
「内存寻址模式」课时是免费的吗？
是的 — 「内存寻址模式」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Assembly Language & x86 Low-Level Systems Programming 课程的其余内容，请升级到 CoddyKit PRO。 Assembly Language & x86 Low-Level Systems Programming 课程共包含 4 节课。
「内存寻址模式」这节课中我会学到什么？
探索使用直接、间接、基址、变址和比例变址等不同寻址模式访问内存位置的方法。 你通过在浏览器中直接运行的动手代码来练习 Assembly Language & x86 Low-Level Systems Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Assembly Language & x86 Low-Level Systems Programming 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Assembly Language & x86 Low-Level Systems Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。
「内存寻址模式」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Assembly Language & x86 Low-Level Systems Programming 课中编写并运行代码吗？
能。每节 Assembly Language & x86 Low-Level Systems Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。