Pengenalan kepada Assembler. Bekerja dengan daftar. Arahan alamat dan pemindahan data. Operasi aritmetik dengan integer. Kaedah Pengalamatan Operand

Operand – objek di mana arahan mesin dilaksanakan.

Operan bahasa himpunan diterangkan dengan ungkapan dengan pemalar angka dan teks, label dan pengecam pembolehubah menggunakan tanda operator dan beberapa perkataan terpelihara.

Operan boleh digabungkan dengan operator aritmetik, logik, bitwise dan atribut untuk mengira beberapa nilai atau menentukan lokasi memori yang akan terjejas perintah ini atau arahan.

Kaedah Pengalamatan Operand

Kaedah menangani merujuk kepada kaedah sedia ada untuk menentukan alamat storan operan:


Operan ditetapkan pada tahap perisian tegar (operand lalai): Dalam kes ini, arahan tidak mengandungi operan secara eksplisit, algoritma pelaksanaan perintah menggunakan beberapa objek lalai (daftar, atribut, dll.).

mul ebx ; eax = eax*ebx, secara tersirat menggunakan daftar eax


Operan dinyatakan dalam arahan itu sendiri (operand segera): Operan adalah sebahagian daripada kod arahan. Untuk menyimpan operan sedemikian, medan sehingga 32 bit panjang diperuntukkan dalam arahan. Operan segera hanya boleh menjadi operan kedua (sumber). Operan destinasi boleh sama ada dalam ingatan atau dalam daftar.

mov eax, 5; eax = 5;
tambah ebx, 2; ebx = ebx + 2;


Operan berada dalam salah satu daftar (operan daftar): Dalam kod, arahan ditunjukkan oleh nama daftar. Daftar berikut boleh digunakan:

  • Mendaftar 32-bit EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP;
  • Daftar 16-bit AX, BX, CX, DX, SI, DI, SP, BP;
  • Daftar 8-bit AN, AL, BH, BL, CH, CL, DH, DL;
  • segmen mendaftar CS, DS, SS, ES, FS, GS.

tambah eax, ebx ; eax = eax + ebх
dec esi ; esi = esi - 1

Operan terletak dalam ingatan. Kaedah ini membolehkan anda melaksanakan dua jenis pengalamatan utama:

  • pengalamatan langsung;
  • pengalamatan tidak langsung.

Alamat langsung : Alamat berkesan ditentukan secara langsung oleh medan offset arahan mesin, yang boleh bersaiz 8, 16, atau 32 bit.

mov eax, jumlah; eax = jumlah

Penghimpun menggantikan jumlah dengan alamat sepadan yang disimpan dalam segmen data (dialamatkan oleh daftar ds secara lalai) dan meletakkan nilai yang disimpan pada jumlah dalam daftar eax.

Pengalamatan tidak langsung pula mempunyai jenis berikut:

  • pengalamatan asas (daftar) tidak langsung;
  • pengalamatan pangkalan tidak langsung (daftar) dengan offset;
  • pengalamatan indeks tidak langsung;
  • pengalamatan indeks asas tidak langsung.

Pengalamatan asas (daftar) tidak langsung. Dengan pengalamatan ini, alamat berkesan operan boleh didapati dalam mana-mana daftar tujuan umum, kecuali sp/esp dan bp/ebp (ini adalah daftar khusus untuk bekerja dengan segmen tindanan). Secara sintaksis dalam arahan, mod pengalamatan ini dinyatakan dengan melampirkan nama daftar dalam kurungan segi empat sama.

mov eax ; eax = *esi; *nilai esi di alamat esi

Kaedah pengalamatan ini membolehkan anda menetapkan alamat operan secara dinamik untuk arahan mesin tertentu dan digunakan semasa mengatur pengiraan kitaran dan apabila bekerja dengan struktur dan tatasusunan data.

Pengalamatan pangkalan tidak langsung (daftar) dengan offset direka untuk mengakses data dengan offset yang diketahui berbanding beberapa alamat pangkalan, digunakan untuk mengakses elemen struktur apabila offset elemen diketahui lebih awal, pada peringkat pembangunan program, dan alamat asas (mula) struktur mesti dikira secara dinamik, pada peringkat pelaksanaan program. Mengubah suai kandungan daftar asas membolehkan anda mengakses elemen yang dinamakan sama bagi contoh yang berbeza bagi jenis struktur data yang sama.

mov eax , ; eax = *(esi+4)

Pengalamatan indeks tidak langsung. Untuk membentuk alamat yang berkesan, salah satu daftar tujuan umum digunakan, tetapi mempunyai keupayaan untuk menskalakan kandungan daftar indeks.

mov eax, mas

Alamat berkesan operan kedua dikira oleh mas+(esi *4) dan merupakan offset dari permulaan segmen data.

Mempunyai keupayaan untuk menskala sangat membantu dalam menyelesaikan masalah pengindeksan, dengan syarat saiz elemen tatasusunan adalah malar dan ialah 1, 2, 4 atau 8 bait.

Jenis pengalamatan ini juga boleh digunakan dengan offset.

Pengalamatan indeks asas tidak langsung. Alamat berkesan dibentuk sebagai jumlah kandungan dua daftar tujuan umum: asas dan indeks. Daftar ini boleh menjadi sebarang daftar tujuan umum, dan selalunya menskalakan kandungan daftar indeks.

mov eax

Alamat berkesan operan kedua dibentuk sebagai esi+edx . Nilai di alamat ini diletakkan dalam daftar eax.

Apabila menggunakan pengalamatan indeks asas tidak langsung dengan offset, alamat berkesan dibentuk sebagai jumlah tiga komponen: kandungan daftar asas, kandungan daftar indeks, dan nilai medan offset dalam arahan.


Operan ialah port I/O.
Selain ruang alamat RAM Mikropemproses mengekalkan ruang alamat I/O, yang digunakan untuk mengakses peranti I/O. Ruang alamat I/O ialah 64 KB. Alamat diperuntukkan untuk mana-mana peranti komputer dalam ruang ini. Nilai alamat khusus dalam ruang ini dipanggil port I/O. Secara fizikal, port I/O sepadan dengan daftar perkakasan (jangan dikelirukan dengan daftar mikropemproses), yang diakses menggunakan pasukan khas pemasang masuk dan keluar.

dalam al ,60j ; masukkan bait dari port 60h

Daftar yang dialamatkan oleh port I/O boleh mempunyai lebar 8, 16, atau 32 bit, tetapi lebar daftar ditetapkan untuk port tertentu. Daftar akumulator eax, ax, al digunakan sebagai sumber maklumat atau penerima. Pilihan daftar ditentukan oleh saiz bit port. Nombor port boleh ditentukan sebagai operan segera dalam arahan masuk dan keluar atau sebagai nilai dalam daftar dx. Kaedah terakhir membolehkan anda menentukan nombor port dalam program secara dinamik.

mov dx ,20j ; tulis nombor port 20h ke daftar dx
mov al ,21j ; tulis nilai 21h pada daftar al
keluar dx,al ; keluarkan nilai 21j ke port 20j


Kaunter alamat– jenis operan tertentu. Ia dilambangkan dengan tanda $. Kekhususan operan ini ialah apabila penterjemah penghimpun bertemu program asal aksara ini, ia menggantikan nilai semasa kaunter alamat (daftar EIP) sebaliknya. Nilai kaunter alamat mewakili offset arahan mesin semasa berbanding permulaan segmen kod yang dialamatkan oleh daftar segmen CS. Apabila penterjemah memproses arahan pemasang seterusnya, kaunter alamat ditambah dengan panjang arahan mesin yang dihasilkan. Memproses arahan pemasang tidak mengubah kaunter. Contoh menggunakan nilai kaunter alamat dalam arahan ialah serpihan berikut:

jmp$+3 ;lompat tanpa syarat ke arahan mov
tidak ; panjang arahan nop ialah 1 bait
mov al ,1

Apabila menggunakan ungkapan sedemikian untuk melompat, seseorang tidak boleh melupakan panjang arahan itu sendiri di mana ungkapan ini digunakan, kerana nilai pembilang alamat sepadan dengan offset dalam segmen kod ini, dan bukan arahan seterusnya. Dalam contoh di atas, arahan jmp mengambil 2 bait. Panjang arahan ini dan beberapa arahan lain mungkin bergantung pada operan yang digunakan. Arahan dengan operan daftar akan lebih pendek daripada arahan dengan salah satu operannya terletak dalam ingatan. Dalam kebanyakan kes, maklumat ini boleh diperolehi dengan mengetahui format arahan mesin.


Operan struktur digunakan untuk mengakses unsur tertentu jenis data kompleks yang dipanggil struktur.

Catatan(serupa dengan jenis struktur) digunakan untuk mengakses medan bit beberapa rakaman. Untuk mengakses medan bit rekod, gunakan arahan RECORD.

Operator dalam bahasa himpunan

Operand ialah komponen asas yang membentuk sebahagian daripada arahan mesin yang menetapkan objek di mana operasi dilakukan. Dalam kes yang lebih umum, operan boleh dimasukkan sebagai komponen dalam formasi yang lebih kompleks dipanggil ungkapan . Ungkapan ialah gabungan operan dan pengendali , dipertimbangkan secara keseluruhan. Hasil daripada menilai ungkapan boleh menjadi alamat beberapa sel memori atau beberapa nilai tetap (mutlak).
Pelaksanaan operator pemasang semasa menilai ungkapan dijalankan mengikut keutamaan mereka. Operasi dengan keutamaan yang sama dilaksanakan secara berurutan dari kiri ke kanan. Mengubah susunan pelaksanaan boleh dilakukan dengan meletakkan kurungan yang mempunyai keutamaan tertinggi.

Keutamaan Operator
1 panjang, saiz, lebar, topeng, (), ,< >
2 .
3 :
4 ptr, mengimbangi, seg, ini
5 tinggi, rendah
6 +, — (tidak biasa)
7 *, /, mod, shl, shr
8 +, -, (perduaan)
9 eq, ne, lt, le, gt, ge
10 bukan
11 dan
12 atau, xor
13 pendek, taip

Ciri-ciri pengendali utama.

Operator aritmetik. Ini termasuk operator unary + Dan , binari + Dan , pengendali pendaraban * , pembahagian integer / , mendapatkan baki bahagian mod. Sebagai contoh,

saiz bersamaan 48 ;saiz tatasusunan dalam bait
el equ 4 ; saiz unsur
;bilangan elemen dikira
mov ecx , saiz / el ;operator /

Operator Syif alihkan ungkapan dengan bilangan bit yang ditentukan. Sebagai contoh,

msk equ 10111011 ; tetap
mov al, msk shr 3; al=00010111 /

Operator Perbandingan (nilai pulangan benar atau berbohong) bertujuan untuk membentuk ungkapan logik. Nilai Boolean benar sepadan dengan logik, dan berbohong– sifar logik. Logik adalah nilai bit sama dengan 1, sifar logik ialah nilai bit sama dengan 0.

saiz equ 30 ;saiz meja

mov al , tab_size ge 50 ;al = 0
cmp al , 0 ;jika saiz< 50, то
je m1 ;pergi ke m1

m1: ...

Jika nilai saiz lebih besar daripada atau sama dengan 50, maka keputusan dalam al ialah 1, jika tidak ia adalah 0. Perintah cmp membandingkan nilai al dengan sifar dan menetapkan bendera yang sesuai dalam EFLAGS. Perintah je, berdasarkan analisis bendera ini, memindahkan atau tidak memindahkan kawalan ke label m1.

Tujuan pengendali perbandingan diberikan dalam jadual

Operator keadaan
eq ==
tidak !=
lt <
le <=
GT >
ge >=

Pengendali logik melakukan operasi bitwise pada ungkapan. Ungkapan mesti tetap. Sebagai contoh,

L1 bersamaan 10010011

mov al , L1
xor al , 01j ;al=10010010

Pengendali indeks. Penterjemah mentafsirkan kehadiran kurungan segi empat sama sebagai arahan untuk menambah nilai ungkapan kerana dengan makna ungkapan, disertakan dalam kurungan. Sebagai contoh,

mov eax , mas ;eax=*(mas+(esi))

Kehadiran pengendali indeks menunjukkan kepada penterjemah bahawa ia perlu mendapatkan nilai di alamat yang dikira.

Jenis operator definisi semula ptr digunakan untuk mentakrifkan semula atau melayakkan jenis label atau pembolehubah yang ditakrifkan oleh ungkapan. Jenis boleh mengambil salah satu daripada nilai berikut.

taip Penjelasan Tujuan
bait 1 bait pembolehubah
perkataan 2 bait pembolehubah
dword 4 bait pembolehubah
qword 8 bait pembolehubah
kedua 10 bait pembolehubah
dekat berhampiran penunjuk fungsi
jauh penunjuk jauh fungsi

Sebagai contoh,

str1 db "Hello", 0

lea esi, str1

cmp bait ptr, 0; ==0?

Dalam contoh, untuk membandingkan nilai pada alamat esi dengan pemalar, anda mesti menyatakan secara eksplisit jenis data yang akan dibandingkan.

Operator Override Segmen : (kolon) mengira alamat fizikal berkenaan dengan komponen segmen yang ditentukan secara khusus, yang boleh:

  • nama daftar segmen,
  • nama segmen daripada arahan SEGMEN yang sepadan
  • nama kumpulan.

Untuk memilih untuk melaksanakan arahan seterusnya, mikropemproses menganalisis kandungan CS daftar segmen, yang mengandungi alamat fizikal permulaan segmen kod. Untuk mendapatkan alamat arahan tertentu, mikropemproses menambah nilai berskala (didarab dengan 16) bagi daftar segmen CS dengan kandungan daftar EIP. Entri CS:EIP mengandungi alamat arahan yang sedang dilaksanakan. Operan dalam arahan mesin diproses dengan cara yang sama.

Operator penamaan jenis struktur . (titik) juga menyebabkan pengkompil melakukan pengiraan tertentu jika ia berlaku dalam ungkapan.

Operator untuk mendapatkan komponen segmen alamat ungkapan seg mengembalikan alamat fizikal segmen untuk ungkapan, yang boleh menjadi label, pembolehubah, nama segmen, nama kumpulan atau beberapa nama simbolik.

Operator offset ungkapan mengimbangi membolehkan anda mendapatkan nilai mengimbangi ungkapan dalam bait berbanding dengan permulaan segmen di mana ungkapan itu ditakrifkan. Sebagai contoh,

Data
str1 db "Hello", 0
.kod
mov esi, mengimbangi str1
mov al, ; al = 'P'

Operator panjang tatasusunan panjang mengembalikan bilangan elemen yang ditentukan oleh operan dup. Jika tiada operan dup, maka operator panjang mengembalikan nilai 1. Contohnya,

tabl dw 10 dup (?)

mov edx, jadual panjang; edx=10

Operator taip mengembalikan bilangan bait yang sepadan dengan definisi pembolehubah yang ditentukan:

fldb db ?
tabl dw 10 dup (?)

mov eax , taip fldb ;eax = 1
mov eax , taip jadual ;eax = 2

Operator saiz mengembalikan hasil darab panjang dan jenis jenis dan digunakan apabila merujuk pembolehubah dengan operan dup.
Untuk contoh sebelum ini

mov edx , jadual saiz ;edx = 20 bait

Operator pendek– pengubahsuaian atribut berdekatan dalam arahan jmp jika peralihan tidak melebihi sempadan +127 dan -128 bait. Sebagai contoh,

label pendek jmp

Akibatnya, pemasang mengurangkan kod mesin operan daripada dua kepada satu bait. Ciri ini berguna untuk lompatan ke hadapan pendek, kerana dalam kes ini pemasang tidak dapat menentukan sendiri jarak ke alamat lompatan dan menyimpan dua bait tanpa adanya operator pendek.

Operator lebar mengembalikan saiz dalam bit objek RECORD atau medannya.

Matlamat:

    menyatukan pengetahuan tentang daftar tujuan umum pemproses INTEL 32-bit;

    belajar menggunakan pengalamatan tidak langsung untuk bekerja dengan RAM;

    belajar menggunakan arahan untuk mendarab dan membahagi integer.

Beban utama semasa mengendalikan komputer jatuh pada pemproses dan memori. Pemproses melaksanakan arahan yang disimpan dalam ingatan. Data juga disimpan dalam ingatan. Terdapat pertukaran maklumat yang berterusan antara pemproses dan memori. Pemproses mempunyai memori kecil sendiri yang terdiri daripada daftar. Perintah pemproses yang menggunakan data dalam daftar dilaksanakan lebih cepat daripada arahan serupa pada data dalam ingatan. Oleh itu, selalunya untuk melaksanakan apa-apa arahan, data untuknya pertama kali diletakkan dalam daftar. Hasil arahan boleh diletakkan semula ke dalam ingatan jika perlu. Pertukaran data antara memori dan daftar dijalankan arahan pemajuan. Di samping itu, anda boleh bertukar-tukar data antara daftar, menghantar dan menerima data daripada peranti luaran. Anda juga boleh menghantar mesej terus ke daftar atau sel memori. operan- nombor. Selain itu, terdapat arahan yang boleh digunakan untuk memasukkan dan mengambil data daripada timbunankawasan khas memori yang digunakan untuk menyimpan alamat pemulangan daripada fungsi yang dihantar ke fungsi untuk parameter dan pembolehubah tempatan.

Pengalamatan memori dan peruntukan

Untuk pemproses, semua memori ialah urutan sel satu bait, setiap satunya mempunyai alamatnya sendiri. Untuk beroperasi dengan jumlah yang besar, pasangan sel digabungkan menjadi perkataan, pasangan kata menjadi kata ganda, pasangan kata ganda menjadi empat kata. Selalunya dalam program yang mereka kendalikan bait, perkataan Dan kata ganda(mengikut daftar pemproses satu, dua dan empat bait). Alamat perkataan dan kata ganda ialah alamat bait rendahnya.

Penyenaraian 1 menunjukkan contoh capaian memori menggunakan pengalamatan tidak langsung. Mari kita lihat secara terperinci. Pertama sekali, ambil perhatian bahawa program ini termasuk fail pengepala , yang mengandungi pengepala semua major Fungsi API OS Windows, serta definisi kuantiti yang banyak struktur, jenis pembolehubah (khususnya, definisi jenis DWORD, yang hanya bermuara kepada int yang tidak ditandatangani). Arahan pemasangan menggunakan pembolehubah yang ditakrifkan oleh bahasa C. Ini disebabkan oleh fakta bahawa pemasang yang dibina ke dalam C tidak membenarkan tempahan memori. Menangani memori menggunakan pembolehubah juga dipanggil pengalamatan langsung. Pengalamatan tidak langsung adalah seperti berikut. Jika alamat sel terkandung dalam daftar, contohnya, EAX, maka untuk menghantar nombor 100 ke sana, anda perlu menulis MOV BYTE PTR, 100. Awalan BYTE PTR menunjukkan bahawa operasi melibatkan sel memori satu bait (anda boleh menggunakan PERKATAAN PTR, DWORD PTR– ini akan sepadan dengan operan dua dan empat bait). Untuk mendapatkan alamat sel memori, gunakan arahan LEA.

/* termasuk fail pengepala */ #termasuk #termasuk #termasuk /* pembolehubah global */ BYTE a= 10 ; // Integer tidak bertanda 8-bit alamat DWORDRet; // pembolehubah untuk menyimpan alamat /* fungsi utama */ batal utama // (dalam OS 32-bit, alamat sel memori mengambil masa 4 bait, // oleh itu, untuk menyimpan alamat yang anda perlukan untuk menggunakan extended// registers) MOV addressRet, EAX; // letakkan alamat pembolehubah dalam pembolehubah addressRet // a, disimpan dalam daftar EAX. Sila ambil perhatian: // alamat ini berubah setiap kali program dimulakan MOV BYTE PTR [EAX], 100; // letakkannya di alamat yang disimpan dalam daftar EAX // nombor 100 - sebenarnya, kami menetapkannya kepada pembolehubah a// nilai 100); printf("alamat pembolehubah a ialah %u\n " , alamatRet);// cetak alamat pembolehubah a printf("nilai pembolehubah a = %u\n " , a);// paparkan nilai pembolehubah a

_getch();

) Penyenaraian 1. Ini menggunakan akses berubah-ubah seperti BYTE mengikut struktur indeks

BYTE PTR

    . Sebentar lagi kita akan lihat bagaimana teknik ini digunakan semasa menulis program. Tugasan. Cuba tulis ke alamat berubah A, disimpan dalam daftar 260 EAH

    , nombor . Apakah jawapan yang anda terima? kenapa? Tetapkan Pembolehubah b taip PERKATAAN Tetapkan Pembolehubah DWORD dan pembolehubah 1023 Dan 70000 c

    . Menggunakan pengalamatan tidak langsung, tulis nombor kepada pembolehubah ini , masing-masing. Letakkannya dalam pembolehubah 70000 Dengan Penyenaraian 1.:

nombor

, menggunakan penunjuk jenis b.

    LEA EAX, c; MOV BYTE PTR [EAX], 70000; Terangkan keputusan anda (ingat bahawa alamat perkataan atau kata ganda ialah alamat bait rendahnya). Lakukan perkara yang sama menggunakan penunjuk jenis Penyenaraian 2 ialah program yang menggambarkan cara untuk mengakses pembolehubah menggunakan penunjuk. Taip program ini. Susun komen. Cuba ubah elemen tatasusunan. Cuba keluarkan hasil dalam perenambelasan (bukannya%u dalam baris format fungsi).

printf() #termasuk guna #termasuk %x #termasuk /* gunakan pengalamatan tidak langsung */// diperlukan untuk printf berfungsi // // diperlukan untuk kerja _getch();// mengandungi takrif jenis BYTE, WORD, DWORD; BYTE ar[ 6 ] = ( 1 , 12 , 128 , 50 , 200 , 10 ) ; tatasusunan statik taip BYTE BYTE a1, a2, a3, a4, a5;// Nombor tidak bertanda 8-bit PERKATAAN b1, b2;// Nombor tidak bertanda 16-bit DWORD c; // Nombor tidak bertanda 32-bit batal utama // ar untuk mendaftar EAX MOV AL, BYTE PTR [ EBX] ;// letak nombor (taip BYTE) dalam daftar AL // nombor yang ditulis pada alamat yang disimpan // dalam daftar EBX, iaitu, elemen pertama tatasusunan MOV a1, AL; // tulis kandungan daftar AL kepada pembolehubah a/*letak dalam pembolehubah a2 nombor yang ditulis pada alamat "permulaan tatasusunan ditambah 1 bait", iaitu, pada alamat elemen kedua tatasusunan*/ /* letakkan dalam pembolehubah a4 nombor yang ditulis di alamat "nombor yang disimpan dalam daftar EDX, bermula dengan nombor yang ditulis dalam daftar EBX," iaitu elemen kedua tatasusunan */ MOV EDX, 1 ; MOV AL, BYTE PTR [EBX] [EDX]; MOV a4, AL; /* letakkan dalam pembolehubah a5 nombor yang ditulis di alamat "jumlah nombor yang ditulis dalam daftar EBX dan EDX", iaitu elemen kedua tatasusunan */ MOV AL, BYTE PTR [ EBX+ EDX] ; MOV a5, AL;/*letakkan 2 dan 1 elemen tatasusunan ke dalam pembolehubah b1*/ MOV AX, WORD PTR [ EBX] ; MOV b1, AX; /*letak 4 dan 3 elemen tatasusunan ke dalam pembolehubah b2*/ MOV AX, WORD PTR [ EBX] + 2 ; MOV b2, AX;/*letakkan elemen tatasusunan 6, 5, 4 dan 3 ke dalam pembolehubah*/ MOV EAX, DWORD PTR [ EBX] + 2 ; MOV c, EAX; ); printf( "elemen pertama tatasusunan a1 = %u \n ", a1); printf("elemen kedua tatasusunan a2 = %u \n " , a2); printf( "elemen kedua tatasusunan (cara lain) a3 = %u \n ", a3);

printf(

"elemen kedua tatasusunan (pengalamatan asas) a4 = %u \n ", a4); printf("elemen kedua tatasusunan (tambah asas - cara lain) a5 = %u \n "

, a5); printf( "1, 2 elemen tatasusunan b1 = %u \n ", b1); printf("3, 4 elemen tatasusunan b2 = %u \n " , b2); printf( "3, 4, 5, 6 elemen tatasusunan c = %u \n ", c); _getch();) Penyenaraian 2. Mengakses pembolehubah dengan penunjuk juga digunakan dalam bahasa tahap tinggi * (sangat kerap apabila mencipta tatasusunan dinamik). penunjuk ialah pembolehubah yang mengandungi alamat pembolehubah lain (penunjuk dikatakan menunjuk kepada pembolehubah jenis yang alamatnya mengandungi). Terdapat satu tempat (unary, iaitu untuk satu operan) juga digunakan dalam bahasa operasi mengambil alamat pembolehubah * & (ampersand, seperti dalam tajuk kartun Tom&Jerry). Jika kita mempunyai iklan int a, barulah kita boleh tentukan

< тип переменной> * < имя указателя>

Ini ialah peraturan untuk mengisytiharkan penuding: penuding kepada pembolehubah daripada beberapa jenis ialah pembolehubah yang, apabila diambil tindakan oleh operasi penyahrujukan, memperoleh nilai pembolehubah daripada jenis yang sama. Penyenaraian 3 menunjukkan contoh penggunaan penunjuk dalam C.

/* mendapatkan alamat pembolehubah - membandingkan C dan Assembler */ #termasuk guna #termasuk %x #termasuk /* gunakan pengalamatan tidak langsung */ BYTE a= 10 ; BYTE * cAddr; DWORD asmAddr; BYTE b; batalkan MOV utama asmAddr, EBX;// letakkan kandungan daftar EBX ke dalam pembolehubah asmAddr, // i.e. alamat pembolehubah a// cetak alamat pembolehubah a ); cAddr=&a; // tulis alamat pembolehubah jenis BYTE kepada pembolehubah jenis BYTE* b=* cAddr; // nyahrujuk penunjuk kepada pembolehubah a"Assembler: alamat a ialah %u\n "

, asmAddr);

printf( "C: alamat a ialah %u\n ", cAddr);

printf("C: nilai a ialah %u #termasuk guna #termasuk %x #termasuk /* gunakan pengalamatan tidak langsung */\n" , b); _getch(); ) Penyenaraian 3. Penyenaraian 4 menunjukkan program yang membolehkan anda mendapatkan alamat elemen tatasusunan jenis yang berbeza bermakna C. Beri perhatian kepada nilai alamat bersebelahan unsur tatasusunan. /* menangani dalam tatasusunan */ unsigned int mas[ 4 ] ;// tatasusunan integer 4-bait unsigned int * ptrMas;// penunjuk kepada pembolehubah jenis unsigned int unsigned short int masShort[ 4 ] ;// tatasusunan integer 2-bait int pendek tidak ditandatangani * ptrMasShort;// penunjuk kepada pembolehubah jenis // nyahrujuk penunjuk kepada pembolehubah a pendek tidak ditandatangani< 4 ; i++ ) printf ("int pointer+%u = %u// nyahrujuk penunjuk kepada pembolehubah a int BYTE masBYTE[ 4 ] ; pendek tidak ditandatangani< 4 ; i++ ) printf (// tatasusunan integer 1-bait BYTE * ptrMasBYTE; // penunjuk kepada pembolehubah BYTE pendek tidak ditandatangani< 4 ; i++ ) printf ("byte pointer+%u = %u// nyahrujuk penunjuk kepada pembolehubah a void main() ( ptrMas = mas;

// letakkan alamat elemen pertama tatasusunan ke dalam penuding

ptrMasShort = masShort; ptrMasBYTE = masBYTE; printf("susunan int

); #termasuk guna #termasuk #termasuk untuk (int i= 0 ; i #termasuk #termasuk , i, ptrMas+ i); printf(" \n tatasusunan int pendek \n " "penunjuk pendek+%u = %u\n" , i, ptrMasShort+ i); printf("() - bilangan bait. Kami memerlukan tatasusunan 10 integer. Oleh itu, jumlah bilangan bait ialah saiz int (ditentukan oleh fungsi sizeof()) didarab dengan bilangan elemen tatasusunan. Pembinaan (int*) sebelum malloc() melakukan hantaran kepada jenis int* (iaitu, kini memori yang diperuntukkan akan dipertimbangkan oleh pengkompil sebagai satu set sel 4 bait di mana bilangan jenis int disimpan) */ ptint = (int * ) malloc (10 * sizeof (int ) ); /* isikan array */ untuk (int i= 0 ; i< 10 ; i++ ) ptint[ i] = i; /*paparkan elemen tatasusunan*/ untuk (int i= 0 ; i< 10 ; i++ ) printf ("%d " , ptint[ i] ) ; free (ptint) ; // memori bebas// paparkan nilai pembolehubah a

Penyenaraian 5.

Bersenam. Paparkan alamat unsur tatasusunan yang dicipta dalam atur cara yang ditunjukkan dalam Penyenaraian 5. Cuba cipta tatasusunan dinamik seperti berganda, isikannya, cetak elemen tatasusunan dan alamatnya.

Operasi aritmetik pada integer

Menambah dan menolak integer

Mari lihat 3 arahan tambahan asas. Pasukan INC menjalankan kenaikan, i.e. meningkatkan kandungan operan sebanyak 1, contohnya, INC EAX. Pasukan INC menetapkan bendera DARIPADA, SF, ZF, AF, PF bergantung kepada hasil penambahan. Pasukan TAMBAH melakukan penambahan dua operan. Hasilnya ditulis kepada operan pertama (penerima). Operan pertama boleh menjadi daftar atau pembolehubah. Operan kedua ialah daftar, pembolehubah atau nombor. Walau bagaimanapun, adalah mustahil untuk melakukan operasi penambahan pada dua pembolehubah secara serentak. Perintah bertindak pada bendera CF, OF, SF, ZF, AF, PF. Ia boleh digunakan untuk nombor yang ditandatangani dan tidak ditandatangani. Pasukan ADC melakukan penambahan dua operan seperti arahan TAMBAH dan bendera pembawa (bit). Dengan bantuannya, anda boleh menambah nombor yang saiznya melebihi 32 bit atau panjang operan asalnya melebihi 32 bit.

/* menambah integer */ #termasuk #termasuk // diperlukan untuk _getch() berfungsi #termasuk /* gunakan pengalamatan tidak langsung */ int a, b, c; DWORD d, e, f, m, n, l, k; void main() ( a= 100 ; b=- 200 ; f= 0 ; d= 0xffffffff ; e= 0x00000010 ; m= 0x12345678 ; n= 0xeeeeeeee ; l= 0x11111111 ; k2(asm2) ; k= 2__2x2 /* menambah nombor positif dan negatif */ MOV EAX, a; */ TAMBAH EAX, b; MOV c, EAX; /* menambah dua bilangan yang besar MOV EAX, e; // EAX = 0x00000010 TAMBAH d, EAX;// keputusan melebihi 4 bait, jadi bendera CF // tetapkan kepada 1: // 0xffffffff // + 0x00000010 // ---------- // oleh itu dalam dalam kes ini melaksanakan arahan dikurangkan untuk meletakkannya // pembolehubah nilai f CF /* penambahan dua nombor besar yang terletak dalam sepasang daftar */ MOV EDX, m; // meletakkan 4 bait paling ketara bagi nombor pertama dalam EDX,//EDX=0x12345678 MOV EAX, n; // meletakkan 4 bait yang lebih rendah daripada nombor pertama dalam EAX,// EAX=0xeeeeeeee MOV ECX, l; // meletakkan 4 bait atas nombor kedua dalam ECX,// ECX=0x11111111 MOV EBX, k; // meletakkan 4 bait yang lebih rendah daripada nombor pertama dalam EBX,// EBX=0x22222222 TAMBAH EAX, EBX; // menambah 4 bait rendah MOV n, EAX; ADC EDX, ECX;// menambah 4 bait yang paling ketara // nyahrujuk penunjuk kepada pembolehubah a MOV m, EDX; // nyahrujuk penunjuk kepada pembolehubah a); printf("c=a+b=%d, c); printf("f=d+e=%x%x, f, d);

printf(

"jumlah 4 bait terendah = %x\n " #termasuk , n); #termasuk // diperlukan untuk _getch() berfungsi #termasuk /* gunakan pengalamatan tidak langsung */ printf( "jumlah 4 bait tertinggi = %x\n ", m); _getch();) Penyenaraian 6. /*tolak integer*/// diperlukan untuk printf() berfungsi int a, b, c; __int64 i, j, k; void main() ( a= 100 ; b=- 200 ; i= 0x1ffffffff ; j= 0x1fffffffb ; __asm( /* tolak nombor 32-bit */ MOV EAX, a; SUB EAX, b; MOV c, EAX;/* tolak nombor 64-bit */ MOV EAX, DWORD PTR i; // meletakkan alamat 4 bait bawah nombor i dalam EAX.// Nombor 0xffffffff ditulis ke alamat ini MOV EDX, DWORD PTR i+ 4 ; // meletakkan alamat 4 bait tertinggi nombor i dalam EDX. MOV EBX, DWORD PTR j; // meletakkan alamat 4 bait bawah nombor j dalam EBX.// Nombor 0xffffffb ditulis ke alamat ini MOV ECX, DWORD PTR j+ 4 ;// meletakkan alamat 4 bait tertinggi bagi nombor j dalam ECX. // nyahrujuk penunjuk kepada pembolehubah a// Nombor 0x00000001 ditulis ke alamat ini // nyahrujuk penunjuk kepada pembolehubah a SUB EAX, EBX;

// tolak 4 bait bawah daripada 4 bait bawah nombor i

// nombor j. Operasi ini menjejaskan bendera CF

SBB EDX, ECX; // tolak 4 bait tertinggi daripada 4 bait tinggi nombor i// nombor j, serta bendera CF MOV DWORD PTR k, EAX;// letakkan 4 bait bawah hasil ke dalam memori MOV DWORD PTR k+ 4 , EDX;// letakkan 4 bait atas hasil ke dalam memori );// letakkan 4 bait bawah hasil ke dalam memori printf("c=a+b=%d, c); MOV DWORD PTR k, EAX; printf("k=i-j=%I64x

    , k); _getch();) Penyenaraian 7. Mendarab Integer Berbeza dengan penambahan dan penolakan pendaraban sensitif kepada tanda nombor, jadi terdapat dua arahan pendaraban: Dan MUL akan sama dengan 0, jika tidak - 1.

    , k); bait berganda) Berbeza dengan penambahan dan penolakan, dan hasilnya akan diletakkan dalam beberapa daftar DX:AX(bukan dalam EAX, seperti yang kelihatan logik). Sehubungan itu, jika hasilnya sesuai sepenuhnya Berbeza dengan penambahan dan penolakan, iaitu kandungan DX akan sama dengan 0, maka bendera juga akan sama dengan sifar MUL Dan sensitif kepada tanda nombor, jadi terdapat dua arahan pendaraban:.

    Akhir sekali, jika pernyataan sumber mempunyai panjang empat bait) EAX, dan hasilnya hendaklah diletakkan dalam sepasang daftar EDX:EAX. Jika kandungan EDX selepas pendaraban akan sama dengan sifar, maka nilai nol bendera akan memilikinya juga MUL Dan sensitif kepada tanda nombor, jadi terdapat dua arahan pendaraban:.

Pasukan ); mempunyai 3 pelbagai format. Format pertama adalah serupa dengan arahan MOV DWORD PTR k, EAX;. Mari lihat dua format yang lain.

IMUL operan1, operan2

operan1 mesti ada daftar operan2 boleh menjadi nombor, daftar, atau pembolehubah. Hasil daripada melakukan pendaraban ( operan1 didarab dengan operan2, dan hasilnya diletakkan di dalam operan1) boleh mengakibatkan nombor yang tidak sesuai dengan penerima. Dalam kes ini bendera MUL Dan A.F. akan sama dengan 1 (0 sebaliknya).

IMUL operan1, operan2, operan3

Dalam kes ini operan2(daftar atau pembolehubah) didarab dengan operan3(nombor) dan hasilnya dimasukkan ke dalam operan1(daftar). Jika limpahan berlaku semasa pendaraban, i.e. hasilnya tidak akan masuk ke dalam penerima, maka bendera akan ditetapkan MUL Dan sensitif kepada tanda nombor, jadi terdapat dua arahan pendaraban:. Penggunaan arahan pendaraban ditunjukkan dalam Penyenaraian 8.

#termasuk , n); #termasuk // diperlukan untuk _getch() berfungsi #termasuk /* gunakan pengalamatan tidak langsung */ DWORD a= 100000 ; __int64 b; int c=- 1000 ; int e; batal main() ( __asm( /* pendaraban tidak bertanda */ MOV EAX, 100000 ;// meletakkan nombor yang lebih besar daripada 2 bait ke dalam EAX MUL DWORD PTR a; // darabkan kandungan daftar EAX dengan a,// keputusan akan diletakkan dalam beberapa daftar // EDX:EAX MOV DWORD PTR b, EAX; // letakkannya dalam 4 bait rendah // Pembolehubah 8-bait b mempunyai 4 bait yang lebih rendah daripada hasilnya MOV DWORD PTR b+ 4 , EDX; // letakkan di bahagian atas 4 bait// Pembolehubah 8-bait b, 4 bait yang paling ketara hasil /* pendaraban yang ditandatangani */ IMUL EAX, s, 1000 ; // nyahrujuk penunjuk kepada pembolehubah a// darab c dengan 1000 dan letakkan hasilnya dalam EAX MOV e, EAX;// masukkan hasil darab ke dalam pembolehubah e // nyahrujuk penunjuk kepada pembolehubah a);

printf("a*100000 = %I64d

, b);

// tafsirkan nombor output sebagai __int64 printf("e = %d , e); _getch();

    ) 1 bait Penyenaraian 8. Menggunakan arahan darab Berbeza dengan penambahan dan penolakan Penyenaraian 7. Pembahagian integer Pembahagian nombor yang tidak ditandatangani dilakukan menggunakan arahan

    ) 2 bait DX:AX DIV Berbeza dengan penambahan dan penolakan Pembahagian integer DX nombor yang tidak ditandatangani dilakukan menggunakan arahan

    ) 4 bait. Perintah itu hanya mempunyai satu operan - ini ialah pembahagi. Pembahagi boleh menjadi daftar atau lokasi memori. Bergantung pada saiz pembahagi, dividen dipilih. EDX:EAX DIV EAX Pembahagian integer EDX nombor yang tidak ditandatangani dilakukan menggunakan arahan

Perintah bahagian yang ditandatangani IDIV sama sekali dengan arahan , e);. Adalah penting untuk arahan pembahagian nilai bendera operasi aritmetik tidak ditakrifkan. Pembahagian boleh mengakibatkan sama ada limpahan atau pembahagian sebanyak 0. Sistem pengendalian mesti mengendalikan pengecualian.

#termasuk , n); #termasuk // diperlukan untuk _getch() berfungsi #termasuk /* gunakan pengalamatan tidak langsung */ DWORD a, b, c; void main() ( a= 100000 ;// dividen - 4 bait __asm(/* bahagian tidak ditandatangani */ MOV EAX, a;// meletakkan 4 bait rendah dividen ke dalam daftar EAX MOV EDX, 0 ;// meletakkan 4 bait atas dividen ke dalam daftar EDX MOV EBX, 30 ;// meletakkan pembahagi dalam EBX (4 bait!) DIV EBX;// membahagikan kandungan EDX:EAX dengan // kandungan EBX MOV b, EAX;
  • // letakkan hasil bagi dalam b
  • NASM/YASM memerlukan perkataan apabila saiz operan tidak tersirat oleh operan yang lain. (Jika tidak ok).

MASM/TASM memerlukan perkataan ptr apabila saiz operan tidak tersirat oleh operan yang lain. (Jika tidak ok).

Setiap satu tercekik oleh sintaks yang berbeza.

AMARAN: Ini adalah kawasan yang sangat pelik tanpa sebarang piawaian ISO atau jadual BNF yang tersedia; dan saya bukan pakar dalam menavigasi medan ranjau sintaks MASM proprietari.

Dalam kes anda ia mungkin tidak membuat perbezaan, tetapi pengendali PTR mungkin bermaksud dalam kes lain:

Secara umum, ungkapan pengendali PTR terpaksa dianggap sebagai penunjuk jenis yang ditentukan:

.DATA num DWORD 0 .CODE mov ax, WORD PTR ; Muatkan nilai saiz perkataan daripada DWORD Saya rasa ada juga keperluan khusus

untuk pemasang (nasm/tasm/asm lain), dan menggunakan "byte ptr" adalah lebih mudah alih.

Semak juga bahagian 4.2.16 dalam buku dari India dan bahagian 8.12.3 (dan 8.11.3 "Jenis Konflik") dalam "Program Pengaturcaraan Bahasa Pengaturcaraan".

KEMASKINI: Terima kasih kepada Frank Kotler, nampaknya NASM "menggunakan varian sintaks pemasangan Intel" (wiki) yang tidak termasuk operasi PTR.

KEMASKINI1: Terdapat "MANUAL RUJUKAN BAHASA ASM86" asal daripada Intel, 1981-1983, pengendali PTR yang ditakrifkan pada halaman 4-15

pengendali PTR

Sintaks: Masukkan nama PTR Penerangan: Operator PTR digunakan untuk menentukan rujukan memori jenis tertentu . Penghimpun mentakrifkan arahan yang betul untuk pemasangan berdasarkan jenis operan dalam arahan. ada kes-kes tertentu

MOV WORD PTR , 5 ;set perkataan ditunjuk oleh BX = 5 INC DS:BYTE PTR 10 ;increment byte at offset 10 ;dari DS

Borang ini juga boleh digunakan untuk mengatasi atribut jenis pembolehubah atau label. Jika, sebagai contoh, anda ingin mengakses pembolehubah perkataan yang telah ditetapkan sebagai dua bait, anda boleh kod yang berikut:

MOV CL, BYTE PTR AWORD ;dapatkan bait pertama MOV CL, BYTE PTR AWORD + 1 ;dapatkan bait kedua

Nilai medan:

jenis Medan ini boleh mempunyai salah satu daripada nilai berikut: BYTE, WORD, DWORD, QWORD, TBYTE, NEAR, FAR

nama Medan ini boleh: 1. Nama boleh ubah. 2. Labelkan nama. 3. Alamat atau daftar. 4. Integer yang mewakili offset.

UPDATE2: Terima kasih kepada Uni dari Stuttgart bitrader! Terdapat manual MACRO-86 asal dari Microsoft (1981). Muka surat 3-7:

Pengendali PTR boleh digunakan dengan cara lain untuk menyimpan bait apabila menggunakan rujukan hadapan. Jika anda telah mentakrifkan FOO sebagai pemalar berterusan, anda boleh memasukkan pernyataan:

MOV, FOO

Anda boleh merujuk kepada FOO sebagai bait dengan segera. Dalam kes ini, anda boleh memasukkan mana-mana pengendali (ia bersamaan):

MOV BYTE PTR ,FOO MOV ,BYTE PTR FOO

Kenyataan ini menunjukkan kepada MACRO-86 bahawa FOO ialah bait serta-merta. Pasukan yang lebih kecil dicipta.

Dan muka surat 3-16:

mengatasi pengendali

Operator ini digunakan untuk mentakrifkan semula segmen, mengimbangi, jenis atau jarak antara pembolehubah dan label.

Indeks (PTR)

PTR

Pengendali PTR mengatasi jenis (BYTE, WORD, DWORD) atau jarak (NEAR, FAR) bagi operan.

- atribut baharu; jenis baru atau jarak baru.

ialah operan yang atributnya mesti ditindih.

Penggunaan yang paling penting dan biasa untuk PTR adalah untuk memastikan MACRO-86 memahami atribut yang perlu ada pada ungkapan. Ini benar terutamanya untuk atribut jenis. Setiap kali anda meletakkan pautan dalam program anda, PTR mengosongkan jarak atau jenis ungkapan. Dengan cara ini anda boleh mengelakkan ralat fasa.

Penggunaan kedua PTR adalah untuk mengakses data jenis yang berbeza daripada jenis dalam definisi pembolehubah. Selalunya ini berlaku dalam struktur. Jika struktur ditakrifkan sebagai WORD, tetapi anda ingin mengakses elemen sebagai bait, PTR ialah pengendali untuk ini. Walau bagaimanapun, cara yang lebih mudah ialah memperkenalkan pengendali kedua yang juga mentakrifkan struktur bait. Ini menghapuskan keperluan untuk menggunakan PTR untuk setiap rujukan struktur. Lihat Arahan LABEL dalam Bahagian 4.2.1 Arahan Memori.

CALL WORD PTR MOV BYTE PTR ARRAY, (sesuatu) TAMBAH BYTE PTR FOO,9

Selepas membaca ini dan mencari beberapa definisi sintaks daripada dokumen ini, saya percaya tatatanda PTR adalah satu kemestian. Penggunaan mov BYTE , 0 adalah tidak betul mengikut manual MACRO-86.

Peter, 2003. - 629 p.
Muat turun(pautan terus) : assembler2003.djvu Sebelumnya 1 .. 40 > .. >> Seterusnya

O Operator definisi semula jenis ptr digunakan untuk mentakrifkan semula atau menjelaskan jenis label atau pembolehubah yang ditakrifkan oleh ungkapan (Rajah 5.10). Jenis boleh mengambil salah satu daripada nilai berikut: bait, perkataan, dword, qword, tbyte, dekat, jauh. Anda akan mengetahui maksud nilai-nilai ini kemudian dalam pelajaran ini. Contohnya:

d wrd dd 0 * * *

pyu al.byte ptr d_wrd+l ;hantar bait kedua daripada double

;words Mari kita jelaskan serpihan program ini. Pembolehubah djwrd adalah jenis kata ganda. Apakah yang perlu anda lakukan jika anda tidak perlu mengakses keseluruhan nilai pembolehubah, tetapi hanya satu daripada bait yang disertakan di dalamnya (contohnya, yang kedua)? Jika anda cuba melakukan ini dengan arahan mov al. d_wrd+l, maka penterjemah akan memaparkan mesej tentang ketidakpadanan jenis operan. Pengendali ptr membenarkan anda untuk mengatasi jenis secara langsung dalam arahan dan melaksanakan arahan.

HTType!-(ptr)-Ungkapan -

nasi. 5.10. Taipkan Sintaks Operator Override

O Pengendali penggantian segmen: (titik bertitik) memaksa alamat fizikal dikira secara relatif kepada komponen segmen yang ditentukan secara khusus: "nama daftar segmen", "nama segmen" daripada arahan SEGMEN atau "nama kumpulan" yang sepadan (Gamb. 5.11).

Perkara ini sangat penting, jadi mari kita jelaskan dengan lebih terperinci. Apabila membincangkan segmentasi, kami bercakap tentang hakikat bahawa mikropemproses adalah tahap perkakasan menyokong tiga jenis segmen - kod, tindanan dan data. Apakah sokongan perkakasan ini? Sebagai contoh, untuk memilih untuk melaksanakan arahan seterusnya, mikropemproses mesti melihat kandungan daftar segmen dan hanya ia. Dan daftar ini, seperti yang kita ketahui, mengandungi alamat fizikal (belum beralih) pada permulaan segmen arahan. Untuk mendapatkan alamat arahan tertentu, mikropemproses perlu mendarab kandungan es dengan 16 (yang bermaksud anjakan sebanyak empat bit) dan menambah nilai 20-bit yang terhasil dengan kandungan 16-bit daftar i p. Perkara yang sama berlaku apabila mikropemproses memproses operasi dalam arahan mesin. Jika ia melihat bahawa operan ialah alamat (alamat berkesan, yang hanya sebahagian daripada alamat fizikal), maka ia tahu segmen mana untuk mencarinya - secara lalai ia ialah segmen yang alamat mulanya ditulis dalam segmen ds mendaftar.

Bagaimana pula dengan segmen timbunan? Lihat Pelajaran 2 di mana kami menerangkan tujuan daftar tujuan umum. Dalam konteks pertimbangan kami, kami berminat dengan daftar sp dan bp. Jika mikropemproses melihat salah satu daripada daftar ini sebagai operan (atau sebahagian daripadanya, jika operan ialah ungkapan), maka secara lalai ia menjana alamat fizikal operan, menggunakan kandungan daftar ss sebagai komponen segmennya. Apakah maksud istilah "lalai"? Ingat "refleks" yang kita bincangkan dalam Pelajaran 1. Ini ialah set program mikro dalam unit kawalan program mikro, yang setiap satunya melaksanakan salah satu arahan dalam sistem arahan mesin mikropemproses. Setiap perisian tegar beroperasi mengikut algoritmanya sendiri. Sudah tentu, anda tidak boleh mengubahnya, tetapi anda boleh melaraskannya sedikit. Ini dilakukan menggunakan medan awalan perintah mesin pilihan (lihat format arahan dalam pelajaran* 2 Jika kita bersetuju tentang cara perintah itu berfungsi, maka medan ini tiada). Jika kita ingin membuat pindaan (jika, sudah tentu, ia dibenarkan untuk arahan tertentu) kepada algoritma operasi arahan, maka perlu membentuk awalan yang sesuai. Awalan ialah nilai satu bait, nilai berangka yang menentukan tujuannya. Mikropemproses mengenali nilai yang ditentukan bahawa bait ini ialah awalan, dan kerja lanjut Program mikro dilaksanakan dengan mengambil kira arahan yang diterima untuk membetulkan operasinya. Semasa kita membincangkan bahan dalam buku, kita akan menjadi biasa dengan kebanyakan awalan yang mungkin. Kini kami berminat dengan salah satu daripadanya - awalan penggantian segmen (definisi semula). Tujuannya adalah untuk menunjukkan kepada mikropemproses (dan pada asasnya firmware) bahawa kami tidak mahu menggunakan segmen lalai. Skop untuk definisi semula sedemikian, sudah tentu, terhad. Segmen arahan tidak boleh ditakrifkan semula, alamatnya seterusnya perintah boleh laksana ditentukan secara unik oleh pasangan cs: i р. Tetapi segmen tindanan dan data adalah mungkin. Inilah yang dimaksudkan oleh pengendali ":". Penterjemah pemasang, memproses operator ini, menjana awalan penggantian segmen satu bait yang sepadan. Contohnya:

jmp metl ;bypass diperlukan, jika tidak medan ind akan dianggap sebagai perintah lain ind db 5 ;penerangan medan data dalam segmen arahan

mov al,cs:ind !mentakrifkan semula segmen membolehkannya berfungsi

;dengan data yang ditakrifkan dalam segmen kod

Mari teruskan senarai pengendali.

O Pengendali penamaan jenis struktur. (titik) juga menyebabkan pengkompil melakukan pengiraan tertentu jika ia berlaku dalam ungkapan. Kami akan membincangkan operator ini secara terperinci apabila kami memperkenalkan konsep jenis data kompleks dalam Pelajaran 12.

O Operator untuk menerima komponen segmen alamat ungkapan, seg, mengembalikan alamat fizikal segmen untuk ungkapan (Rajah 5.12), yang boleh menjadi label, pembolehubah, nama segmen, nama kumpulan atau beberapa nama simbolik.

Operasi aritmetik- TAMBAH, SUB, MUL, DIV. Banyak opcode melakukan pengiraan. Anda boleh mengenali banyak daripada mereka dengan nama mereka: tambah (tambahan), sub (penolakan), mul (darab), div (bahagi).

Tambah opcode mempunyai sintaks berikut:

Tambah destinasi, sumber

Melakukan pengiraan: sink = sink + punca.

Terdapat juga bentuk lain:

penerima sumber contoh
mendaftar mendaftar tambah ecx, edx
mendaftar ingatan tambah ecx, dword ptr / tambah ecx,
mendaftar maksudnya tambah eax, 102
ingatan maksudnya tambah dword ptr , 80
ingatan mendaftar tambah dword ptr , edx

Perintah ini sangat mudah. Ia menambahkan nilai sumber kepada nilai destinasi dan meletakkan hasilnya ke destinasi. Perintah matematik lain:

Sub penerima, sumber (penerima = penerima - sumber)
mul darab, darab (dararab = darab * darab)
pembahagi div (eax = eax/divisor, edx = baki)

Oleh kerana daftar hanya boleh menyimpan nilai integer (iaitu, nombor, bukan titik terapung), hasil pembahagian dibahagikan kepada hasil bagi dan baki. Sekarang, bergantung pada saiz sumber, hasil bagi disimpan dalam eax dan bakinya dalam edx:
* = Contohnya: jika dx = 2030h dan ax = 0040h, dx: ax = 20300040h. Dx:ax ialah nilai dword, di mana dx mewakili perkataan tinggi dan ax mewakili perkataan rendah. Edx:eax - nilai quadword (64 bit), di mana dword tertinggi berada dalam edx dan dword terendah berada dalam eax.

Sumber operasi bahagian boleh:

  1. Daftar 8-bit (al, ah, cl,...)
  2. Daftar 16-bit (ax, dx, ...)
  3. Daftar 32-bit (eax, edx, ecx...)
  4. Nilai 8-bit daripada memori (bait ptr)
  5. Nilai 16-bit daripada memori (perkataan ptr)
  6. 6a nilai memori 32-bit (dword ptr)

Sumber tidak boleh menjadi nilai segera kerana pemproses tidak akan dapat menentukan saiz operan sumber.

Operasi logik dengan bit - OR, XOR, AND, NOT. Arahan ini berfungsi dengan destinasi dan sumber, kecuali perintah "TIDAK". Setiap bit dalam destinasi dibandingkan dengan bit yang sama dalam sumber, dan bergantung pada arahan, 0 atau 1 diletakkan dalam bit destinasi:

DAN(logik DAN) menetapkan bit hasil kepada 1 jika kedua-dua bit sumber dan bit destinasi ditetapkan kepada 1.
ATAU(logik ATAU) menetapkan bit hasil kepada 1 jika salah satu bit, bit sumber atau bit destinasi, ditetapkan kepada 1.
XOR(NOT OR) menetapkan bit hasil kepada 1 jika bit sumber berbeza daripada bit destinasi.
TIDAK menyongsangkan bit sumber.

Contoh:

Mov kapak, 3406d
mov dx, 13EAh
xor ax, dx

Ax = 3406 (perpuluhan), dalam binari - 0000110101001110.

Dx = 13EA (heksadesimal), dalam perduaan - 0001001111101010.

Perlaksanaan operasi XOR pada bit ini:

Sumber = 0001001111101010 (dx)

Penerima = 0000110101001110 (ax)

Keputusan = 0001111010100101 (nilai baharu dalam kapak)

Nilai baharu dalam kapak selepas melaksanakan arahan ialah 0001111010100101 (7845 dalam perpuluhan, 1EA5 dalam perenambelasan).

Contoh lain:

Mov ecx, FFFF0000h
bukan ecx

FFFF0000 dalam binari ialah -
Jika anda menyongsangkan setiap bit, anda akan mendapat:
, dalam perenambelasan ialah 0000FFFF
Ini bermakna selepas operasi NOT, ecx akan mengandungi 0000FFFFh.

Naik/Turun - INC/DEC. Ada 2 sangat perintah mudah, DEC dan INC. Arahan ini menambah atau mengurangkan kandungan memori atau daftar sebanyak satu. Letakkan sahaja:

Inc daftar; daftar = daftar + 1
daftar dec; daftar = daftar - 1
inc dword ptr ; nilai dalam akan dinaikkan sebanyak 1.
dec dword ptr ; nilai dalam akan dikurangkan sebanyak 1.

Perintah perbandingan lain ialah ujian. Arahan Ujian melaksanakan operasi DAN pada dua operan dan menetapkan atau mengosongkan bendera yang sepadan bergantung pada hasilnya. Hasilnya tidak disimpan. Ujian digunakan untuk menguji bit, contohnya dalam daftar:

Uji eax, 100b
jnz mengimbangi

Perintah jnz akan melompat jika bit ketiga dari kanan dalam daftar ea ditetapkan. Selalunya arahan ujian digunakan untuk menyemak sama ada daftar adalah sifar:

Uji ecx, ecx
jz mengimbangi

Perintah jz akan melompat jika ecx = 0.

Perintah yang tidak melakukan apa-apa adalah tidak. Perintah ini sama sekali tidak melakukan apa-apa (perintah kosong). Ia hanya mengambil ruang dan masa. Digunakan untuk menempah ruang dalam segmen kod atau mengatur kelewatan program.

Pertukaran nilai - XCHG. Perintah XCHG juga agak mudah. Tujuan: pertukaran dua nilai antara daftar atau antara daftar dan ingatan:

Mov eax, 237j
mov ecx, 978j
xchg eax, ecx
akibatnya:
eax = 978j
ecx = 237j

Itulah penghujung pelajaran. Saya harap yang ini tidak membosankan. Pelajaran seterusnya akan memberitahu anda tentang subrutin.