0Pricing
Assembly Language & x86 Low-Level Systems Programming · レッスン

データ移動命令（MOV、PUSH、POP）

MOV、PUSH、POP、LEAなど、レジスター、メモリ、スタック間でデータを移動する命令を使いこなします。

「データ移動命令（MOV、PUSH、POP）」はCoddyKit上の無料Assembly Language & x86 Low-Level Systems Programmingレッスンです。 これはレッスン1/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはAssembly Language & x86 Low-Level Systems Programming学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Assembly Language & x86 Low-Level Systems Programmingコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Data on the Move

In assembly language, programs constantly move data around. This data lives in different places: inside the CPU's registers or in memory.

Understanding how to move data is fundamental. It's like learning to pick up and place objects before you can build anything complex.

  • Registers: Fast, small storage directly inside the CPU.
  • Memory: Slower, larger storage outside the CPU (RAM).
  • Stack: A special area in memory used for temporary storage and function calls.

Moving Data with MOV

The MOV instruction is your primary tool for copying data. It stands for "move," but it actually copies the source to the destination, leaving the source unchanged.

Its basic form is MOV destination, source. The destination can be a register or a memory location, and the source can be an immediate value, a register, or a memory location.

Here's how to put a number directly into a register:

section .text
    global _start

_start:
    mov eax, 123    ; Copy the immediate value 123 into the EAX register
    mov ebx, 456    ; Copy 456 into EBX

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Register to Register Moves

You can also copy data from one register to another. This is a very common operation for temporary storage or preparing data for other operations.

When you move data between registers, the original register's value remains, and the destination register gets a copy.

Consider this example:

section .text
    global _start

_start:
    mov eax, 10     ; EAX = 10
    mov ebx, eax    ; EBX gets a copy of EAX (EBX = 10), EAX is still 10
    mov ecx, 20     ; ECX = 20
    mov edx, ecx    ; EDX gets a copy of ECX (EDX = 20), ECX is still 20

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Storing and Loading from Memory

Moving data between registers and memory is crucial for working with variables. Memory addresses are often enclosed in square brackets [].

To store a register's value into a memory location, you use MOV [memory_address], register. To load a value from memory into a register, it's MOV register, [memory_address].

Let's define a variable in memory and interact with it:

section .data
    my_var dd 50    ; Define a double-word (4-byte) variable 'my_var' and initialize it to 50

section .text
    global _start

_start:
    mov eax, [my_var] ; Load the value from 'my_var' (50) into EAX
    mov ebx, 100      ; EBX = 100
    mov [my_var], ebx ; Store the value of EBX (100) into 'my_var'.
                      ; Now 'my_var' holds 100, EAX still holds 50.

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Understanding the Stack

The stack is a crucial area of memory used for temporary storage. It operates on a "Last-In, First-Out" (LIFO) principle, like a stack of plates.

  • When you "push" something onto the stack, it goes on top.
  • When you "pop" something off, you always get the item that was most recently pushed.

The Stack Pointer (ESP) register always points to the "top" of the stack (the last item pushed).

Adding Data with PUSH

The PUSH instruction adds data to the top of the stack. When you PUSH a value:

  1. The ESP (Stack Pointer) register is decremented by 4 (for 32-bit values).
  2. The value is then stored at the new memory address pointed to by ESP.

This means the stack grows downwards in memory (towards lower addresses).

section .text
    global _start

_start:
    mov eax, 10     ; EAX = 10
    mov ebx, 20     ; EBX = 20

    push eax        ; Push EAX's value (10) onto the stack
    push ebx        ; Push EBX's value (20) onto the stack (now on top of 10)
    push 30         ; Push the immediate value 30 onto the stack (now on top of 20)

    ; At this point, the stack contains 30, then 20, then 10 (from top to bottom).

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Retrieving Data with POP

The POP instruction removes data from the top of the stack and places it into a specified destination (usually a register).

When you POP a value:

  1. The value at the memory address pointed to by ESP is retrieved.
  2. The ESP (Stack Pointer) register is then incremented by 4.

POP reverses the effect of PUSH, ensuring you get back the last item you pushed.

section .text
    global _start

_start:
    mov eax, 10
    mov ebx, 20

    push eax        ; Stack: [10]
    push ebx        ; Stack: [20, 10]

    pop ecx         ; ECX = 20. Stack: [10]
    pop edx         ; EDX = 10. Stack: []

    ; EAX = 10, EBX = 20, ECX = 20, EDX = 10.
    ; Notice ECX got EBX's original value because EBX was pushed last.

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

LEA: Getting an Address

The LEA instruction (Load Effective Address) is a bit special. Unlike MOV with brackets, LEA doesn't actually load the content of a memory location.

Instead, LEA calculates the address of the source operand and stores that address into the destination register.

It's super useful for working with pointers or calculating array offsets without touching memory data.

section .data
    my_array dd 10, 20, 30 ; An array of double-words

section .text
    global _start

_start:
    mov ebx, 0      ; EBX will be our index (0 for first element)
    mov ecx, 4      ; ECX will be our scale (4 bytes per double-word)

    lea eax, [my_array + ebx*ecx] ; Calculate address of my_array[0] and put it in EAX
                                  ; EAX now holds the memory address of 'my_array'

    ; If we used MOV EAX, [my_array + ebx*ecx], EAX would hold the value 10.
    ; With LEA, EAX holds the *address* where 10 is stored.

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Data Movement Challenge

Consider the following x86 assembly code snippet. Assume EAX and EBX initially contain 0.

mov eax, 5
push eax
mov ebx, 10
push ebx
pop eax
pop ebx

What will be the final values in the EAX and EBX registers?

Summary of Data Movement

Great job! You've learned the fundamental instructions for moving data in x86 assembly:

  • MOV: Copies data between registers, memory, and immediate values. It's your workhorse for assigning and loading data.
  • PUSH & POP: Manage data on the stack, following a LIFO principle. Essential for temporary storage and procedure calls.
  • LEA: Calculates and loads an address into a register, without touching the data at that address. Crucial for pointer arithmetic.

These instructions are the building blocks for almost every assembly program. Next, we'll explore how to perform arithmetic and logical operations on this data!

よくある質問

「データ移動命令（MOV、PUSH、POP）」レッスンは無料ですか？

はい。「データ移動命令（MOV、PUSH、POP）」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Assembly Language & x86 Low-Level Systems Programmingコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Assembly Language & x86 Low-Level Systems Programmingコースには全4レッスンが含まれています。

「データ移動命令（MOV、PUSH、POP）」で何を学びますか？

MOV、PUSH、POP、LEAなど、レジスター、メモリ、スタック間でデータを移動する命令を使いこなします。 ブラウザで直接実行するハンズオンコードでAssembly Language & x86 Low-Level Systems Programmingを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Assembly Language & x86 Low-Level Systems Programmingを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのAssembly Language & x86 Low-Level Systems Programmingは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン1/4です。

「データ移動命令（MOV、PUSH、POP）」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このAssembly Language & x86 Low-Level Systems Programmingレッスンでコードを書いて実行できますか？

はい。すべてのAssembly Language & x86 Low-Level Systems Programmingレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. データ移動命令（MOV、PUSH、POP）
  2. 算術演算と論理演算
  3. 条件分岐とループ
  4. ビット演算とシフト命令
← Assembly Language & x86 Low-Level Systems Programmingに戻る