Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86 · Pelajaran

Asas Pengaturcaraan FPU x87

Pelajari cara menggunakan Unit Titik Apung (FPU) x87 untuk aritmetik titik apung berketepatan tinggi dalam bahasa himpunan.

Pelajaran 1 daripada 411 langkah

Asas Pengaturcaraan FPU x87 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.

Kenali x87 FPU

Unit Titik Terapung x87 (FPU) ialah bahagian khusus CPU yang direka untuk mengendalikan operasi matematik pada nombor nyata, yang juga dikenali sebagai nombor titik terapung.

Berbeza daripada aritmetik integer, matematik titik terapung memerlukan perwakilan dalaman dan pengiraan yang berbeza, dan FPU amat cekap melaksanakannya dengan ketepatan tinggi.

Tindanan Daftar FPU

x87 FPU menggunakan tindanan daftar yang unik, bukannya daftar serba guna. Tindanan ini terdiri daripada lapan daftar 80-bit yang dilambangkan sebagai ST(0) hingga ST(7).

ST(0) sentiasa berada di bahagian atas tindanan.
Operasi menolak nilai baharu ke dalam tindanan atau mengeluarkan nilai daripadanya, sambil mengalihkan nilai sedia ada.
Ia berkelakuan seperti tindanan Masuk Dahulu, Keluar Kemudian (LIFO).

Memuatkan Data dengan FLD

Untuk bekerja dengan nombor titik terapung, anda perlu memuatkannya ke dalam tindanan FPU terlebih dahulu. Arahan FLD menolak nilai titik terapung daripada ingatan ke bahagian atas tindanan FPU, menjadikannya ST(0).

Dalam assembly, kita biasanya mentakrifkan pemalar titik terapung dalam bahagian data. Jenis yang biasa ialah ketepatan tunggal (32-bit, DD) dan ketepatan berganda (64-bit, DQ).

Cuba muatkan nilai ke dalam tindanan:

section .data
  float_val dq 3.1415926535

section .text
  global _start

_start:
  finit                 ; Initialize FPU
  fld qword [float_val] ; Load float_val onto FPU stack (ST(0))

  ; At this point, ST(0) contains 3.1415926535
  ; We just exit as printing floats is complex in basic assembly.

  mov rax, 60           ; syscall number for exit
  xor rdi, rdi          ; exit code 0
  syscall

Menyimpan Hasil FPU

Selepas pengiraan, anda mungkin mahu menyimpan hasil daripada tindanan FPU kembali ke dalam ingatan. Arahan FST dan FSTP digunakan untuk tujuan ini.

FST: Menyalin nilai daripada ST(0) ke lokasi ingatan atau daftar FPU yang lain, tanpa mengubah ST(0).
FSTP: Menyalin nilai daripada ST(0) ke ingatan/daftar, kemudian mengeluarkannya daripada tindanan, lalu mengurangkan penuding tindanan. ST(1) sebelumnya menjadi ST(0).

Mari simpan satu nilai:

section .data
  float_val dq 123.45
  result_val dq 0.0     ; Will store result here

section .text
  global _start

_start:
  finit                 ; Initialize FPU
  fld qword [float_val] ; ST(0) = 123.45

  fstp qword [result_val] ; Store ST(0) to result_val, then pop.
                          ; FPU stack is now empty.

  ; result_val now holds 123.45 in memory.

  mov rax, 60           ; syscall number for exit
  xor rdi, rdi          ; exit code 0
  syscall

Operasi Aritmetik FPU

FPU menyediakan arahan untuk operasi aritmetik biasa. Operasi ini biasanya melibatkan ST(0) dan satu operan lain, sama ada daftar tindanan yang lain atau operan ingatan.

FADD: Tambah (contohnya, FADD ST(1), ST(0) menambahkan ST(0) kepada ST(1)).
FMUL: Darab
FSUB: Tolak
FDIV: Bahagi

Menggunakan FADDP ST(1), ST(0) menambahkan ST(0) kepada ST(1), menyimpan hasilnya dalam ST(1) dan mengeluarkan ST(0). Ini meninggalkan hasil tambah di bahagian atas tindanan.

Berikut ialah contoh penambahan:

section .data
  val1 dq 10.5
  val2 dq 2.0
  sum_result dq 0.0

section .text
  global _start

_start:
  finit                 ; Initialize FPU
  fld qword [val1]      ; ST(0) = 10.5
  fld qword [val2]      ; ST(0) = 2.0, ST(1) = 10.5

  faddp st(1), st(0)    ; ST(1) = ST(1) + ST(0) (10.5 + 2.0 = 12.5).
                        ; Pop ST(0). Now ST(0) = 12.5.

  fstp qword [sum_result] ; Store 12.5 to sum_result and pop.

  mov rax, 60           ; syscall number for exit
  xor rdi, rdi          ; exit code 0
  syscall

Pemalar Terbina dalam FPU

FPU boleh memuatkan pemalar yang biasa digunakan terus ke dalam tindanannya, jadi anda tidak perlu mentakrifkannya dalam ingatan. Ini meningkatkan kecekapan dan ketepatan.

FLD1: Menolak 1.0 ke dalam tindanan.
FLDZ: Menolak 0.0 ke dalam tindanan.
FLDPI: Menolak nilai Pi (π) ke dalam tindanan.

Mari muatkan Pi:

section .data
  pi_val dq 0.0 ; To store PI

section .text
  global _start

_start:
  finit           ; Initialize FPU
  fldpi           ; ST(0) = PI (approx 3.14159...)

  fstp qword [pi_val] ; Store PI to pi_val and pop.

  mov rax, 60     ; syscall number for exit
  xor rdi, rdi    ; exit code 0
  syscall

Menukar Integer dan Titik Terapung

Kadangkala anda perlu menukar antara jenis integer dan titik terapung. FPU menyediakan arahan untuk tujuan ini:

FILD (Float Integer Load): Memuatkan integer bertanda daripada ingatan, menukarnya kepada format titik terapung dan menolaknya ke dalam tindanan FPU.
FISTP (Float Integer Store and Pop): Menyimpan ST(0) sebagai integer ke dalam ingatan, kemudian mengeluarkannya daripada tindanan. Nilai dipenggal ke arah sifar semasa penukaran.

Mari tukarkan integer kepada nombor titik terapung, tambahkannya, kemudian tukarkan kembali:

section .data
  int_val dd 5
  float_add dq 2.5
  int_result dd 0

section .text
  global _start

_start:
  finit               ; Initialize FPU
  fild dword [int_val] ; ST(0) = 5.0 (from 5)
  fld qword [float_add] ; ST(0) = 2.5, ST(1) = 5.0

  faddp st(1), st(0)  ; ST(1) = 5.0 + 2.5 = 7.5. Pop ST(0).
                      ; Now ST(0) = 7.5.

  fistp dword [int_result] ; Store 7.5 as integer (7) to int_result and pop.

  mov rax, 60         ; syscall number for exit
  xor rdi, rdi        ; exit code 0
  syscall

Membandingkan Nilai Titik Terapung

Membandingkan nombor titik terapung memerlukan arahan FPU khas. Anda tidak boleh menggunakan arahan perbandingan integer seperti CMP secara langsung.

FCOM: Membandingkan ST(0) dengan operan (daftar FPU atau ingatan yang lain) dan menetapkan bendera status FPU.
FCOMP: Sama seperti FCOM, tetapi mengeluarkan ST(0) selepas perbandingan.

Untuk menggunakan bendera ini bagi lompatan bersyarat (seperti JE, JB), anda mesti memindahkannya daripada perkataan status FPU ke daftar CPU EFLAGS:

FSTSW AX: Menyimpan Perkataan Status FPU ke dalam daftar AX.
SAHF: Memindahkan daftar AH (yang kini mengandungi bendera FPU yang berkaitan) ke dalam daftar CPU EFLAGS, khususnya bendera ZF, PF dan CF.

Menggabungkan Semuanya: (A + B) * C

Mari gabungkan perkara yang telah kita pelajari untuk melakukan pengiraan mudah: (A + B) * C. Kita akan memuatkan tiga nilai, menambah dua daripadanya, mendarabkannya dengan nilai ketiga dan menyimpan hasil integer akhir.

Contoh ini menunjukkan manipulasi tindanan dan operasi aritmetik.

section .data
  val_A dq 3.0
  val_B dq 1.5
  val_C dq 2.0
  final_int_result dd 0

section .text
  global _start

_start:
  finit           ; Initialize FPU

  fld qword [val_A] ; ST(0) = 3.0
  fld qword [val_B] ; ST(0) = 1.5, ST(1) = 3.0

  faddp st(1), st(0) ; Add ST(0) (1.5) to ST(1) (3.0), store in ST(1).
                     ; Pop ST(0). Now ST(0) = 4.5 (sum of A+B)

  fld qword [val_C] ; ST(0) = 2.0, ST(1) = 4.5 (A+B)

  fmulp st(1), st(0) ; Multiply ST(0) (2.0) by ST(1) (4.5), store in ST(1).
                     ; Pop ST(0). Now ST(0) = 9.0 ((A+B)*C)

  fistp dword [final_int_result] ; Store 9.0 as integer (9) to final_int_result and pop.

  mov rax, 60     ; syscall number for exit
  xor rdi, rdi    ; exit code 0
  syscall

Cabaran Tindanan FPU

Perhatikan petikan kod assembly x87 FPU berikut. Apakah nilai ST(0) selepas pelaksanaannya?

section .data
  val_X dq 10.0
  val_Y dq 3.0

section .text
  finit
  fld qword [val_X] ; ST(0) = 10.0
  fld qword [val_Y] ; ST(0) = 3.0, ST(1) = 10.0
  faddp st(1), st(0) ; ST(0) = 13.0
  fld1              ; ST(0) = 1.0, ST(1) = 13.0
  fsub              ; ST(0) = ST(0) - ST(1) (1.0 - 13.0 = -12.0)

Jawab dalam pelajaran interaktif

Ringkasan x87 FPU

Anda telah mengambil langkah pertama dalam pengaturcaraan x87 FPU! Kita merangkumi:

Tindanan FPU dengan 8 daftar (ST(0)ST(7)).
Memuatkan nilai dengan FLD dan menyimpannya dengan FST/FSTP.
Aritmetik asas: FADD, FSUB, FMUL, FDIV.
Menggunakan pemalar terbina dalam seperti FLD1, FLDZ, FLDPI.
Menukar antara integer dan nombor titik terapung dengan FILD dan FISTP.
Cara menyediakan hasil perbandingan FPU untuk lompatan bersyarat.

x87 FPU berkuasa untuk pengiraan tepat, walaupun sistem moden sering menggunakan sambungan SIMD seperti SSE/AVX untuk kelajuan, yang akan anda terokai seterusnya!

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 “Asas Pengaturcaraan FPU x87” percuma?

Ya — teks penuh “Asas Pengaturcaraan FPU x87” 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 “Asas Pengaturcaraan FPU x87”?

Pelajari cara menggunakan Unit Titik Apung (FPU) x87 untuk aritmetik titik apung berketepatan tinggi dalam bahasa himpunan. 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 “Asas Pengaturcaraan FPU x87” 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

Asas Pengaturcaraan FPU x87
Pengenalan Set Arahan SSE/AVX
Mervektorkan Kod dengan SIMD
Ketepatan Titik Apung, Pembundaran dan Pengecualian

← Kembali ke Bahasa Himpunan & Pengaturcaraan Sistem Aras Rendah x86