Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 · Pelajaran

Arahan Pergerakan Data (MOV, PUSH, POP)

Kuasai arahan untuk memindahkan data antara daftar, memori dan tindanan, termasuk MOV, PUSH, POP dan LEA.

Pelajaran 1 daripada 410 langkah

Arahan Pergerakan Data (MOV, PUSH, POP) ialah pelajaran Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 merangkumi sejumlah 4 pelajaran.

Data Bergerak

Dalam bahasa pemasangan, atur cara sentiasa mengalihkan data. Data ini berada di tempat yang berbeza: di dalam daftar CPU atau dalam memori.

Memahami cara mengalihkan data ialah asas yang penting. Ia seperti belajar mengangkat dan meletakkan objek sebelum Anda boleh membina sesuatu yang kompleks.

Daftar: Storan kecil dan pantas yang terletak terus di dalam CPU.
Memori: Storan yang lebih besar tetapi lebih perlahan di luar CPU (RAM).
Timbunan: Kawasan khas dalam memori yang digunakan untuk storan sementara dan panggilan fungsi.

Mengalihkan Data dengan MOV

Arahan MOV ialah alat utama Anda untuk menyalin data. Arahan ini bermaksud "alih", tetapi sebenarnya menyalin sumber ke destinasi tanpa mengubah sumber.

Bentuk asasnya ialah MOV destination, source. Destinasi boleh berupa daftar atau lokasi memori, manakala sumber boleh berupa nilai serta-merta, daftar atau lokasi memori.

Berikut ialah cara memasukkan nombor secara langsung ke dalam daftar:

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

Pengalihan Daftar ke Daftar

Anda juga boleh menyalin data daripada satu daftar ke daftar yang lain. Ini ialah operasi yang sangat biasa untuk storan sementara atau menyediakan data bagi operasi lain.

Apabila Anda mengalihkan data antara daftar, nilai daftar asal kekal, manakala daftar destinasi menerima salinannya.

Perhatikan contoh ini:

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

Menyimpan dan Memuatkan dari Memori

Mengalihkan data antara daftar dan memori amat penting untuk bekerja dengan pemboleh ubah. Alamat memori sering diletakkan dalam kurungan siku [].

Untuk menyimpan nilai daftar ke dalam lokasi memori, gunakan MOV [memory_address], register. Untuk memuatkan nilai dari memori ke dalam daftar, gunakan MOV register, [memory_address].

Mari takrifkan pemboleh ubah dalam memori dan berinteraksi dengannya:

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

Memahami Timbunan

Timbunan ialah kawasan memori penting yang digunakan untuk storan sementara. Timbunan beroperasi berdasarkan prinsip "Masuk Terakhir, Keluar Dahulu" (LIFO), seperti timbunan pinggan.

Apabila Anda melakukan PUSH sesuatu ke dalam timbunan, item itu diletakkan di atas.
Apabila Anda melakukan POP sesuatu daripada timbunan, Anda sentiasa mendapat item yang paling baru dimasukkan.

Daftar Penuding Timbunan (ESP) sentiasa menunjuk ke "bahagian atas" timbunan (item terakhir yang dimasukkan).

Menambah Data dengan PUSH

Arahan PUSH menambah data ke bahagian atas timbunan. Apabila Anda melakukan PUSH sesuatu nilai:

Daftar ESP (Penuding Timbunan) dikurangkan sebanyak 4 (untuk nilai 32-bit).
Nilai itu kemudian disimpan pada alamat memori baharu yang ditunjukkan oleh ESP.

Ini bermakna timbunan berkembang ke bawah dalam memori (ke arah alamat yang lebih rendah).

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

Mendapatkan Data dengan POP

Arahan POP mengeluarkan data dari bahagian atas timbunan dan meletakkannya ke dalam destinasi yang ditentukan (biasanya daftar).

Apabila Anda melakukan POP sesuatu nilai:

Nilai pada alamat memori yang ditunjukkan oleh ESP diambil.
Daftar ESP (Penuding Timbunan) kemudian ditambah sebanyak 4.

POP membalikkan kesan PUSH, lalu memastikan Anda mendapatkan semula item terakhir yang dimasukkan.

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: Mendapatkan Alamat

Arahan LEA (Muatkan Alamat Berkesan) agak istimewa. Tidak seperti MOV dengan kurungan, LEA sebenarnya tidak memuatkan kandungan lokasi memori.

Sebaliknya, LEA mengira alamat operan sumber dan menyimpan alamat itu ke dalam daftar destinasi.

Arahan ini amat berguna untuk bekerja dengan penuding atau mengira ofset tatasusunan tanpa menyentuh data dalam memori.

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

Cabaran Pergerakan Data

Perhatikan petikan kod himpunan x86 berikut. Andaikan EAX dan EBX pada awalnya mengandungi 0.

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

Apakah nilai akhir dalam daftar EAX dan EBX?

Jawab dalam pelajaran interaktif

Ringkasan Pergerakan Data

Tahniah! Anda telah mempelajari arahan asas untuk memindahkan data dalam bahasa himpunan x86:

MOV: Menyalin data antara daftar, memori dan nilai serta-merta. Arahan ini digunakan untuk menetapkan dan memuatkan data.
PUSH & POP: Mengurus data pada tindanan mengikut prinsip LIFO. Penting untuk penyimpanan sementara dan panggilan prosedur.
LEA: Mengira dan memuatkan alamat ke dalam daftar tanpa mengubah data pada alamat tersebut. Penting untuk pengiraan penuding.

Arahan ini ialah asas bagi hampir setiap atur cara bahasa himpunan. Seterusnya, kita akan meneroka cara menjalankan operasi aritmetik dan logik pada data ini!

Percuma untuk bermula

Pelajari Assembly dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Arahan Pergerakan Data (MOV, PUSH, POP)” percuma?

Ya — teks penuh “Arahan Pergerakan Data (MOV, PUSH, POP)” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86, tingkat taraf kepada CoddyKit PRO. Kursus Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Arahan Pergerakan Data (MOV, PUSH, POP)”?

Kuasai arahan untuk memindahkan data antara daftar, memori dan tindanan, termasuk MOV, PUSH, POP dan LEA. Anda berlatih Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Arahan Pergerakan Data (MOV, PUSH, POP)” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 ini?

Ya. Setiap pelajaran Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86