Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
ɇɟɞɨɫɬɚɬɨɤ ɤɨɦɚɧɞ ɨɪɝɚɧɢɡɚɰɢɢ ɰɢɤɥɚ LOOP, LOOPE/LOOPZ ɢ
LOOPNE/LOOPNZ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɨɧɢ ɪɟɚɥɢɡɭɸɬ ɬɨɥɶɤɨ ɤɨɪɨɬɤɢɟ ɩɟɪɟɯɨɞɵ
(ɨɬ –128 ɞɨ +127 ɛɚɣɬ). Ⱦɥɹ ɪɚɛɨɬɵ ɫ «ɞɥɢɧɧɵɦɢ» ɩɟɪɟɯɨɞɚɦɢ ɩɪɢɞɟɬɫɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɦɚɧɞɵ ɭɫɥɨɜɧɨɝɨ ɩɟɪɟɯɨɞɚ ɢ ɤɨɦɚɧɞɭ JMP.
Ɋɚɫɫɦɨɬɪɢɦ ɮɪɚɝɦɟɧɬ ɩɪɨɝɪɚɦɦɵ, ɜ ɤɨɬɨɪɨɦ ɨɪɝɚɧɢɡɨɜɚɧɨ ɬɪɢ ɜɥɨɠɟɧɧɵɯ
ɰɢɤɥɚ.
ɉɪɢɦɟɪ 2.53. Ɉɪɝɚɧɢɡɚɰɢɹ ɧɟɫɤɨɥɶɤɢɯ ɜɥɨɠɟɧɧɵɯ ɰɢɤɥɨɜ.
.DATA
STRING DB ‘<> $' ;
.CODE
; ɉɪɢɦɟɪ ɰɢɤɥɚ ɢɡ 10 ɲɚɝɨɜ, ɤɨɬɨɪɵɟ ɛɭɞɭɬ
; ɜɵɩɨɥɧɹɬɶɫɹ ɫ ɡɚɞɟɪɠɤɨɣ ɩɨɪɹɞɤɚ ɧɟɫɤɨɥɶɤɢɯ
; ɫɟɤɭɧɞ
MOV CX,10 ; ɑɢɫɥɨ ɲɚɝɨɜ ɜɨ ɜɧɟɲɧɟɦ ɰɢɤɥɟ
; ɋɧɚɱɚɥɚ ɫɨɯɪɚɧɹɟɦ ɫɱɟɬɱɢɤ ɜ ɫɬɟɤɟ
cycle: PUSH CX ;
; ȼɵɜɟɞɟɦ ɧɚ ɷɤɪɚɧ ɫɬɪɨɤɭ ɢɡ ɬɪɟɯ ɫɢɦɜɨɥɨɜ
MOV AH,09h
MOV DX,offset INT 21h
; Ɉɪɝɚɧɢɡɭɟɦ ɩɪɨɝɪɚɦɦɧɭɸ ɡɚɞɟɪɠɤɭ
MOV CX, 100 ; ɋɱɟɬɱɢɤ ɜɥɨɠɟɧɧɨɝɨ ɰɢɤɥɚ
outer:
; ɋɧɚɱɚɥɚ ɫɨɯɪɚɧɹɟɦ ɫɱɟɬɱɢɤ ɜ ɫɬɟɤɟ
PUSH CX
MOV CX,65535 ; ɋɱɟɬɱɢɤ ɜɧɭɬɪɟɧɧɟɝɨ
ɰɢɤɥɚ
inner: LOOP inner ; ɉɨɜɬɨɪɢɦ ɤɨɦɚɧɞɭ 65535 ɪɚɡ
POP CX ; ȼɨɫɫɬɚɧɨɜɢɦ ɜɧɟɲɧɢɣ ɫɱɟɬɱɢɤ
LOOP outer ; ɉɨɜɬɨɪɢɦ 100 ɪɚɡ
POP CX ; ȼɨɫɫɬɚɧɨɜɢɦ ɫɱɟɬɱɢɤ ɜɧɟɲɧɟɝɨ ɰɢɤɥɚ
LOOP cycle ; ɉɨɜɬɨɪɢɦ ɜɧɟɲɧɢɣ ɰɢɤɥ 10 ɪɚɡ
ɉɨɫɤɨɥɶɤɭ ɤɨɦɚɧɞɚ LOOP ɜɵɩɨɥɧɹɟɬɫɹ ɜɫɟɝɞɚ ɋɏ ɪɚɡ, ɷɬɨɬ ɪɟɝɢɫɬɪ ɩɪɢɯɨɞɢɬɫɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɤɚɠɞɨɦ ɰɢɤɥɟ ɡɚɧɨɜɨ. ɉɨɷɬɨɦɭ ɩɟɪɟɞ ɜɯɨɞɨɦ ɜɨ ɜɧɭɬɪɟɧɧɢɣ (ɜɥɨɠɟɧɧɵɣ) ɰɢɤɥ ɬɟɤɭɳɟɟ ɡɧɚɱɟɧɢɟ ɫɱɟɬɱɢɤɚ ɜɧɟɲɧɟɝɨ ɰɢɤɥɚ (ɫɨɞɟɪɠɢɦɨɟ ɋɏ
) ɫɨɯɪɚɧɹɟɬɫɹ ɜ ɫɬɟɤɟ ɤɨɦɚɧɞɨɣ PUSH, ɚ ɩɟɪɟɞ ɤɨɦɚɧɞɨɣ LOOP ɜɧɟɲ-
ɧɟɝɨ ɰɢɤɥɚ ɜɨɫɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɤɨɦɚɧɞɨɣ POP.
2.3. ɂɧɬɟɪɮɟɣɫ ɹɡɵɤɨɜ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ,
ɋɢ ɢ Ⱥɫɫɟɦɛɥɟɪɚ
ɋɨɜɪɟɦɟɧɧɵɟ ɹɡɵɤɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ (Object Pascal, C,
C++, Java ɢ ɩɪ.) ɨɛɟɫɩɟɱɢɜɚɸɬ ɩɨɥɧɨɰɟɧɧɭɸ ɩɨɞɞɟɪɠɤɭ ɚɩɩɚɪɚɬɧɵɯ ɫɪɟɞɫɬɜ
ɤɨɦɩɶɸɬɟɪɚ ɢ ɩɨɡɜɨɥɹɸɬ ɫɨɡɞɚɜɚɬɶ ɤɨɦɩɚɤɬɧɵɟ ɢ ɛɵɫɬɪɨɞɟɣɫɬɜɭɸɳɢɟ ɩɪɨɝɪɚɦɦɵ. Ɉɞɧɚɤɨ ɢɧɨɝɞɚ ɜɨɡɧɢɤɚɟɬ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɢɫɩɨɥɶɡɨɜɚɧɢɹ Ⱥɫɫɟɦɛɥɟɪɚ
:
ɤɨɝɞɚ ɧɭɠɧɨ ɦɢɧɢɦɢɡɢɪɨɜɚɬɶ ɨɩɟɪɚɰɢɢ ɨɛɪɚɳɟɧɢɹ ɤ ɚɩɩɚɪɚɬɭɪɟ ɩɨ ɪɚɡ-
ɦɟɪɭ ɤɨɞɚ ɢ ɜɪɟɦɟɧɢ ɢɫɩɨɥɧɟɧɢɹ;
61
ɟɫɥɢ ɭɠɟ ɢɦɟɟɬɫɹ ɝɨɬɨɜɵɣ ɢ ɩɪɨɜɟɪɟɧɧɵɣ ɩɪɨɝɪɚɦɦɧɵɣ ɤɨɞ ɮɪɚɝɦɟɧɬɨɜ
ɩɪɨɝɪɚɦɦ ɢɥɢ ɩɨɞɩɪɨɝɪɚɦɦ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ;
ɟɫɥɢ ɧɟɨɛɯɨɞɢɦɨ ɜɵɡɵɜɚɬɶ ɮɭɧɤɰɢɢ, ɧɟ ɩɨɞɞɟɪɠɢɜɚɸɳɢɟɫɹ ɞɪɭɝɢɦɢ
ɹɡɵɤɚɦɢ.
ȼɧɟɞɪɟɧɢɟ ɤɨɞɚ Ⱥɫɫɟɦɛɥɟɪɚ ɜɨɡɦɨɠɧɨ ɞɜɭɦɹ ɫɩɨɫɨɛɚɦɢ: ɢɫɩɨɥɶɡɭɹ ɚɫɫɟɦɛɥɟɪɧɵɟ ɜɫɬɚɜɤɢ ɜ ɩɪɨɝɪɚɦɦɵ ɋɢ ɢɥɢ ɞɪɭɝɢɯ ɹɡɵɤɨɜ, ɚ ɬɚɤɠɟ ɱɟɪɟɡ ɞɢɧɚɦɢɱɟɫɤɢɟ ɛɢɛɥɢɨɬɟɤɢ (dll – Dinamic Link Library).
2.3.1. Ⱥɫɫɟɦɛɥɟɪɧɵɟ ɜɫɬɚɜɤɢ
ɋɢɧɬɚɤɫɢɫ ɜɫɬɚɜɤɢ ɚɫɫɟɦɛɥɟɪɧɨɝɨ ɤɨɞɚ ɜ ɩɪɨɝɪɚɦɦɭ, ɧɚɩɢɫɚɧɧɨɣ ɧɚ ɋɢ
(ɞɥɹ ɜɟɪɫɢɢ ɤɨɦɩɢɥɹɬɨɪɚ GCC), ɫɥɟɞɭɸɳɢɣ:
asm [volatile] ( AssemblerTemplate
: OutputOperands
[ : InputOperands
[ : Clobbers ] ]),
ɝɞɟ AssemblerTemplate – ɫɬɪɨɤɚ-ɲɚɛɥɨɧ ɚɫɫɟɦɛɥɟɪɧɨɝɨ ɤɨɞɚ;
OutputOperands – ɫɩɢɫɨɤ ɩɟɪɟɦɟɧɧɵɯ ɋɢ, ɪɚɡɞɟɥɟɧɧɵɯ ɡɚɩɹɬɵɦɢ, ɢɡɦɟɧɹɟɦɵɯ ɢɧɫɬɪɭɤɰɢɹɦɢ ɜ AssemblerTemplate;
InputOperands – ɫɩɢɫɨɤ ɜɵɪɚɠɟɧɢɣ ɋɢ, ɪɚɡɞɟɥɟɧɧɵɯ ɡɚɩɹɬɵɦɢ, ɩɪɨɱɢɬɚɧɧɵɯ ɢɧɫɬɪɭɤɰɢɹɦɢ ɜ AssemblerTemplate. Ⱦɨɩɭɫɤɚɟɬɫɹ ɩɭɫɬɨɣ ɫɩɢɫɨɤ;
Clobbers – ɫɩɢɫɨɤ
ɪɟɝɢɫɬɪɨɜ, ɪɚɡɞɟɥɟɧɧɵɯ ɡɚɩɹɬɵɦɢ, ɢɥɢ ɞɪɭɝɢɯ ɡɧɚɱɟɧɢɣ,
ɢɡɦɟɧɟɧɹɟɦɵɯ ɜ AssemblerTemplate, ɢɫɤɥɸɱɚɹ ɭɤɚɡɚɧɧɵɟ ɤɚɤ ɜɵɯɨɞɵ. Ⱦɨɩɭɫɤɚɟɬɫɹ ɩɭɫɬɨɣ ɫɩɢɫɨɤ.
Ɉɩɬɢɦɢɡɚɬɨɪɵ gcc ɢɧɨɝɞɚ ɨɬɛɪɚɫɵɜɚɸɬ ɨɩɟɪɚɬɨɪɵ asm, ɟɫɥɢ ɨɩɪɟɞɟɥɹɸɬ
ɨɬɫɭɬɫɬɜɢɟ ɜɵɯɨɞɧɵɯ ɩɟɪɟɦɟɧɧɵɯ. Ʉɪɨɦɟ ɬɨɝɨ, ɨɩɬɢɦɢɡɚɬɨɪɵ ɦɨɝɭɬ ɩɟɪɟɦɟɳɚɬɶ ɤɨɞ ɢɡ ɰɢɤɥɨɜ, ɟɫɥɢ ɨɧɢ ɫɱɢɬɚɸɬ, ɱɬɨ ɤɨɞ ɜɫɟɝɞɚ ɛɭɞɟɬ ɜɨɡɜɪɚɳɚɬɶ ɬɨɬ ɠɟ
ɪɟɡɭɥɶɬɚɬ (ɬ. ɟ. ɧɢ
ɨɞɧɨ ɢɡ ɟɝɨ ɜɯɨɞɧɵɯ ɡɧɚɱɟɧɢɣ ɧɟ ɦɟɧɹɟɬɫɹ ɦɟɠɞɭ ɜɵɡɨɜɚɦɢ).
ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɤɥɚɫɫɢɮɢɤɚɬɨɪɚ volatile ɨɬɤɥɸɱɚɟɬ ɷɬɨɬ ɜɢɞ ɨɩɬɢɦɢɡɚɰɢɢ.
ɉɪɢ ɨɩɪɟɞɟɥɟɧɧɵɯ ɨɛɫɬɨɹɬɟɥɶɫɬɜɚɯ gcc ɦɨɠɟɬ ɞɭɛɥɢɪɨɜɚɬɶ (ɢɥɢ ɭɞɚɥɹɬɶ
ɞɭɛɥɢɤɚɬɵ) ȼɚɲ ɤɨɞ ɩɪɢ ɨɩɬɢɦɢɡɚɰɢɢ. ɗɬɨ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɧɟɨɠɢɞɚɧɧɵɦ
ɞɭɛɥɢɪɭɸɳɢɦɫɹ ɫɢɦɜɨɥɶɧɵɦ ɨɲɢɛɤɚɦ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ, ɟɫɥɢ ɤɨɞ ɪɚɡɞɟɥɚ asm ɨɩɪɟɞɟɥɹɟɬ ɫɢɦɜɨɥɵ ɢɥɢ ɦɟɬɤɢ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ '% =' ɪɟɲɚɟɬ
ɷɬɭ ɩɪɨ-
ɛɥɟɦɭ.
ɋɬɪɨɤɚ-ɲɚɛɥɨɧ AssemblerTemplate ɦɨɠɟɬ ɫɨɞɟɪɠɚɬɶ ɥɸɛɵɟ ɢɧɫɬɪɭɤ-
ɰɢɢ, ɪɚɫɩɨɡɧɚɜɚɟɦɵɟ Ⱥɫɫɟɦɛɥɟɪɨɦ, ɜɤɥɸɱɚɹ ɞɢɪɟɤɬɢɜɵ. Ʉɨɦɩɢɥɹɬɨɪ gcc ɧɟ
ɚɧɚɥɢɡɢɪɭɟɬ ɫɚɦɢ ɢɧɫɬɪɭɤɰɢɢ Ⱥɫɫɟɦɛɥɟɪɚ ɢ ɧɟ ɡɧɚɟɬ, ɱɬɨ ɨɧɢ ɨɡɧɚɱɚɸɬ ɢɥɢ
ɞɚɠɟ ɹɜɥɹɟɬɫɹ ɥɢ ɨɧɢ ɞɟɣɫɬɜɢɬɟɥɶɧɵɦ ɤɨɞɨɦ Ⱥɫɫɟɦɛɥɟɪɚ. ɉɨɷɬɨɦɭ ɛɭɞɶɬɟ ɜɧɢɦɚɬɟɥɶɧɵ ɩɪɢ ɢɯ ɡɚɩɢɫɢ.
ȼɵ ɦɨɠɟɬɟ ɪɚɡɦɟɫɬɢɬɶ ɧɟɫɤɨɥɶɤɨ ɢɧɫɬɪɭɤɰɢɣ Ⱥɫɫɟɦɛɥɟɪɚ ɜ ɨɞɧɨɣ
ɫɬɪɨɤɟ
asm, ɪɚɡɞɟɥɟɧɧɨɣ ɫɩɟɰɢɚɥɶɧɵɦɢ ɫɢɦɜɨɥɚɦɢ ɩɟɪɟɜɨɞɚ ɫɬɪɨɤɢ, ɱɚɳɟ ɜɫɟɝɨ ɷɬɨ
"\n \t".
62
ɉɨɫɤɨɥɶɤɭ ɤɨɦɩɢɥɹɬɨɪ gcc ɧɟ ɚɧɚɥɢɡɢɪɭɟɬ ɲɚɛɥɨɧ Ⱥɫɫɟɦɛɥɟɪɚ, ɨɧ ɧɟ
ɜɢɞɢɬ ɤɚɤɢɯ-ɥɢɛɨ ɫɢɦɜɨɥɨɜ, ɧɚ ɤɨɬɨɪɵɟ ɫɫɵɥɚɟɬɫɹ ɲɚɛɥɨɧ. ɗɬɨ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ
ɤ ɬɨɦɭ, ɱɬɨ gcc ɨɬɦɟɧɢɬ ɷɬɢ ɫɢɦɜɨɥɵ ɤɚɤ ɧɟɨɛɴɹɜɥɟɧɧɵɟ, ɟɫɥɢ ɨɧɢ ɬɚɤɠɟ ɧɟ
ɭɤɚɡɚɧɵ ɜ ɤɚɱɟɫɬɜɟ ɨɩɟɪɚɧɞɨɜ ɜɜɨɞɚ, ɜɵɜɨɞɚ ɢɥɢ ɩɟɪɟɯɨɞɚ.
ȼ ɞɨɩɨɥɧɟɧɢɟ ɤ ɜɵɪɚɠɟɧɢɹɦ, ɨɩɢɫɚɧɧɵɯ ɨɩɟɪɚɧɞɚɦɢ ɜɜɨɞɚ, ɜɵɜɨɞɚ, ɫɬɪɨɤɢ ɫɩɟɰɢɚɥɶɧɨɝɨ
ɮɨɪɦɚɬɚ ɩɪɢɧɢɦɚɸɬ ɫɩɟɰɢɚɥɶɧɵɟ ɡɧɚɱɟɧɢɹ ɜ ɲɚɛɥɨɧɟ Ⱥɫɫɟɦ-
ɛɥɟɪɚ:
‘%%‘ ɜɵɜɨɞɢɬ ɫɢɦɜɨɥ ‘%’ ɜ ɤɨɞ Ⱥɫɫɟɦɛɥɟɪɚ;
'%='ɜɵɜɨɞɢɬ ɱɢɫɥɨ, ɭɧɢɤɚɥɶɧɨɟ ɞɥɹ ɤɚɠɞɨɝɨ ɷɤɡɟɦɩɥɹɪɚ ɨɩɟɪɚɬɨɪɚ asm
ɜɨ ɜɫɟɣ ɩɪɨɝɪɚɦɦɟ. ɗɬɨɬ ɩɚɪɚɦɟɬɪ ɩɨɥɟɡɟɧ ɩɪɢ ɫɨɡɞɚɧɢɢ ɥɨɤɚɥɶɧɵɯ ɦɟɬɨɤ ɢ ɨɛɪɚɳɟɧɢɢ ɤ ɧɢɦ ɧɟɫɤɨɥɶɤɨ ɪɚɡ ɜ ɨɞɧɨɦ ɲɚɛɥɨɧɟ, ɤɨɬɨɪɵɣ ɝɟɧɟɪɢɪɭɟɬ ɧɟɫɤɨɥɶɤɨ
ɢɧɫɬɪɭɤɰɢɣ ɚɫɫɟɦɛɥɟɪɚ;
ɤɨɦɛɢɧɚɰɢɢ ‘% {‘, ‘% |” ɢ
‘%}’ ɜɵɜɨɞɹɬ ɫɢɦɜɨɥɵ ‘{', '|'ɢ '}’,
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ, ɜ ɤɨɞ ɚɫɫɟɦɛɥɟɪɚ. ɗɬɢ ɫɢɦɜɨɥɵ ɢɦɟɸɬ ɨɫɨɛɨɟ ɡɧɚɱɟɧɢɟ ɞɥɹ
ɨɛɨɡɧɚɱɟɧɢɹ ɧɟɫɤɨɥɶɤɢɯ ɚɫɫɟɦɛɥɟɪɧɵɯ ɞɢɚɥɟɤɬɨɜ.
Ʉɨɦɩɢɥɹɬɨɪ gcc ɩɨɞɞɟɪɠɢɜɚɟɬ ɧɟɫɤɨɥɶɤɨ ɚɫɫɟɦɛɥɟɪɧɵɯ ɞɢɚɥɟɤɬɨɜ. Ɍɚɤ,
ɧɚɫɬɪɨɣɤɚ masm ɨɩɪɟɞɟɥɹɟɬ, ɱɬɨ GCC ɢɫɩɨɥɶɡɭɟɬ ɩɨ ɭɦɨɥɱɚɧɢɸ ɞɥɹ ɜɫɬɪɨɟɧɧɨɝɨ ɚɫɫɟɦɛɥɟɪɚ ɞɢɚɥɟɤɬ ɚɫɫɟɦɛɥɟɪɚ Microsoft.
ȿɫɥɢ ɜ ȼɚɲɟɦ ɤɨɞɟ ɧɟɨɛɯɨɞɢɦɨ ɩɨɞɞɟɪɠɢɜɚɬɶ ɧɟɫɤɨɥɶɤɨ ɚɫɫɟɦɛɥɟɪɧɵɯ
ɞɢɚɥɟɤɬɨɜ, ɢɫɩɨɥɶɡɭɣɬɟ ɤɨɧɫɬɪɭɤɰɢɸ
ɫɥɟɞɭɸɳɟɝɨ ɮɨɪɦɚɬɚ: {dialect0 |
dialect1 | dialect2 ...}
ɗɬɚ ɤɨɧɫɬɪɭɤɰɢɹ ɜɵɜɨɞɢɬ dialect0 ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɞɢɚɥɟɤɬɚ ʋ 0
ɞɥɹ ɤɨɦɩɢɥɹɰɢɢ ɤɨɞɚ, dialect1 ɞɥɹ ɞɢɚɥɟɤɬɚ ʋ 1 ɢ ɬ. ɞ. ȿɫɥɢ ɜ ɫɤɨɛɤɚɯ ɭɤɚɡɚɧɨ ɦɟɧɶɲɟ ɚɥɶɬɟɪɧɚɬɢɜ, ɱɟɦ ɤɨɥɢɱɟɫɬɜɨ ɞɢɚɥɟɤɬɨɜ, ɩɨɞɞɟɪɠɢɜɚɟɦɵɯ ɤɨɦɩɢɥɹɬɨɪɨɦ, ɤɨɧɫɬɪɭɤɰɢɹ ɧɢɱɟɝɨ ɧɟ ɜɵɜɨɞɢɬ.
ɇɚɩɪɢɦɟɪ, ɟɫɥɢ ɤɨɦɩɢɥɹɬɨɪ x86 ɩɨɞɞɟɪɠɢɜɚɟɬ ɞɜɚ ɞɢɚɥɟɤɬɚ («att», «intel»),
ɲɚɛɥɨɧ ɚɫɫɟɦɛɥɟɪɚ ɦɨɠɟɬ ɜɵɝɥɹɞɟɬɶ ɬɚɤ:
"bt{l %[Offset],%[Base] | %[Base],%[Offset]};
jc %l2"
ɷɤɜɢɜɚɥɟɧɬɧɨ ɨɞɧɨɦɭ ɢɡ ɜɵɪɚɠɟɧɢɣ:
ɗɬɨ
"btl %[Offset],%[Base] ; jc %l2"/* att dialect */ "bt
%[Base],%[Offset]; jc %l2"/* intel dialect */
Ɉɩɟɪɚɬɨɪ asm ɢɦɟɟɬ ɧɨɥɶ ɢɥɢ ɛɨɥɟɟ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɨɜ, ɨɛɨɡɧɚɱɚɸɳɢɯ
ɢɦɟɧɚ ɩɟɪɟɦɟɧɧɵɯ ɋɢ, ɦɨɞɢɮɢɰɢɪɭɟɦɵɯ ɤɨɞɨɦ Ⱥɫɫɟɦɛɥɟɪɚ.
ɉɪɢɦɟɪ 2.54. Ⱥɫɫɟɦɛɥɟɪɧɚɹ ɜɫɬɚɜɤɚ ɜ ɩɪɨɝɪɚɦɦɟ ɧɚ ɋɢ.
#include <stdio.h>
int main(int argc,char *argv[]) {
int a = 40;
int b;
asm("movl %1, %%eax; \
shr %%eax; \
movl %%eax, %0;"
:"=r" (b)
:"r" (a)
63
:"%eax");
printf ("a=%d b=%d\n" ,a,b);
return(0);
}
Ɉɩɟɪɚɧɞɵ ɪɚɡɞɟɥɹɸɬɫɹ ɡɚɩɹɬɵɦɢ. Ʉɚɠɞɵɣ ɨɩɟɪɚɧɞ ɢɦɟɟɬ ɫɥɟɞɭɸɳɢɣ
ɮɨɪɦɚɬ:
[[asmSymbolicName]] constraint (cvariablename), ɝɞɟ
asmSymbolicName ɭɤɚɡɵɜɚɟɬ ɫɢɦɜɨɥɢɱɟɫɤɨɟ ɢɦɹ ɞɥɹ ɨɩɟɪɚɧɞɚ;
constraint – ɷɬɨ ɫɬɪɨɤɨɜɚɹ ɤɨɧɫɬɚɧɬɚ, ɨɩɪɟɞɟɥɹɸɳɚɹ ɨɝɪɚɧɢɱɟɧɢɹ ɧɚ
ɪɚɡɦɟɳɟɧɢɟ ɨɩɟɪɚɧɞɚ;
cvariablename ɡɚɞɚɟɬ ɜɵɪɚɠɟɧɢɟ ɋɢ lvalue ɞɥɹ ɜɵɜɨɞɚ, ɤɚɤ ɩɪɚɜɢɥɨ, ɷɬɨ ɢɦɹ ɩɟɪɟɦɟɧɧɨɣ. Ʉɪɭɝɥɵɟ ɫɤɨɛɤɢ ɹɜɥɹɸɬɫɹ ɨɛɹɡɚɬɟɥɶɧɨɣ ɱɚɫɬɶɸ ɫɢɧɬɚɤɫɢɫɚ.
ɋɫɵɥɤɚ ɧɚ ɢɦɹ ɜ ɲɚɛɥɨɧɟ
Ⱥɫɫɟɦɛɥɟɪɚ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɤɜɚɞɪɚɬɧɵɟ ɫɤɨɛɤɢ
(ɬ. ɟ. "% [Ɂɧɚɱɟɧɢɟ]"). Ɉɛɴɟɦ ɢɦɟɧɢ – ɷɬɨ ɨɩɟɪɚɬɨɪ asm, ɫɨɞɟɪɠɚɳɢɣ ɨɩɪɟ-
ɞɟɥɟɧɢɟ. Ʌɸɛɨɟ ɞɨɩɭɫɬɢɦɨɟ ɢɦɹ ɩɟɪɟɦɟɧɧɨɣ ɋɢ ɪɚɡɪɟɲɟɧɨ, ɜɤɥɸɱɚɹ ɢɦɟɧɚ,
ɭɠɟ ɨɩɪɟɞɟɥɟɧɧɵɟ ɜ ɨɤɪɭɠɚɸɳɟɦ ɤɨɞɟ. ɇɟ ɦɨɠɟɬ ɛɵɬɶ ɞɜɭɯ ɨɩɟɪɚɧɞɨɜ ɜɧɭɬɪɢ
ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɨɩɟɪɚɬɨɪɚ asm, ɤɨɬɨɪɵɟ ɢɫɩɨɥɶɡɭɸɬ ɨɞɧɨ ɢ ɬɨ ɠɟ ɫɢɦɜɨɥɢɱɟ-
ɢɦɹ. ȿɫɥɢ ȼɵ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ asmSymbolicName, ɢɫɩɨɥɶɡɭɣɬɟ ɧɭɥɟɜɨɟ
ɫɤɨɟ
ɩɨɥɨɠɟɧɢɟ ɨɩɟɪɚɧɞɚ ɜ ɫɩɢɫɤɟ ɨɩɟɪɚɧɞɨɜ ɜ ɲɚɛɥɨɧɟ ɚɫɫɟɦɛɥɟɪɚ. ɇɚɩɪɢɦɟɪ, ɟɫɥɢ
ɟɫɬɶ ɬɪɢ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɚ, ɢɫɩɨɥɶɡɭɣɬɟ "%0"ɜ ɲɚɛɥɨɧɟ, ɱɬɨɛɵ ɫɫɵɥɚɬɶɫɹ ɧɚ
ɩɟɪɜɵɣ, "%1"ɞɥɹ ɫɫɵɥɤɢ ɧɚ ɜɬɨɪɨɣ ɢ "%2"ɞɥɹ ɫɫɵɥɤɢ ɧɚ ɬɪɟɬɢɣ ɨɩɟɪɚɧɞ.
Ɉɝɪɚɧɢɱɟɧɢɹ ɜɵɜɨɞɚ ɞɨɥɠɧɵ ɧɚɱɢɧɚɬɶɫɹ ɫ ‘=’ (ɩɟɪɟɦɟɧɧɚɹ, ɩɟɪɟɩɢɫɵɜɚɸɳɚɹ ɫɭɳɟɫɬɜɭɸɳɟɟ
ɡɧɚɱɟɧɢɟ) ɢɥɢ ‘+’ (ɩɪɢ ɱɬɟɧɢɢ ɢ ɡɚɩɢɫɢ). ɉɪɢ
ɢɫɩɨɥɶɡɨɜɚɧɢɢ '='ɧɟ ɞɨɩɭɫɤɚɣɬɟ, ɱɬɨɛɵ ɦɟɫɬɨɩɨɥɨɠɟɧɢɟ ɫɨɞɟɪɠɚɥɨ ɫɭɳɟɫɬɜɭɸɳɟɟ ɡɧɚɱɟɧɢɟ ɩɪɢ ɜɯɨɞɟ ɜ asm, ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɫɥɭɱɚɟɜ, ɤɨɝɞɚ ɨɩɟɪɚɧɞ
ɩɪɢɜɹɡɚɧ ɤ ɜɯɨɞɭ. ɉɨɫɥɟ ɩɪɟɮɢɤɫɚ ɞɨɥɠɧɨ ɛɵɬɶ ɨɞɧɨ ɢɥɢ ɧɟɫɤɨɥɶɤɨ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɨɝɪɚɧɢɱɟɧɢɣ, ɨɩɢɫɵɜɚɸɳɢɯ, ɝɞɟ ɧɚɯɨɞɢɬɫɹ ɡɧɚɱɟɧɢɟ. Ɉɛɳɢɟ ɨɝɪɚɧɢɱɟɧɢɹ ɜɤɥɸɱɚɸɬ ‘r’ ɞɥɹ ɪɟɝɢɫɬɪɚ
ɢ ‘m’ ɞɥɹ ɩɚɦɹɬɢ. Ʉɨɝɞɚ ɜɵ ɭɤɚɡɵɜɚɟɬɟ
ɧɟɫɤɨɥɶɤɨ ɜɨɡɦɨɠɧɵɯ ɦɟɫɬɨɩɨɥɨɠɟɧɢɣ (ɧɚɩɪɢɦɟɪ, ‘= rm’), ɤɨɦɩɢɥɹɬɨɪ ɜɵɛɢɪɚɟɬ ɧɚɢɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵɣ, ɨɫɧɨɜɚɧɧɵɣ ɧɚ ɬɟɤɭɳɟɦ ɤɨɧɬɟɤɫɬɟ.
ȼɯɨɞɧɵɟ ɨɩɟɪɚɧɞɵ ɞɟɥɚɸɬ ɞɨɫɬɭɩɧɵɦɢ ɞɥɹ ɤɨɞɚ ɫɛɨɪɤɢ ɡɧɚɱɟɧɢɹ ɩɟɪɟ-
ɦɟɧɧɵɯ ɢɡ ɩɪɨɝɪɚɦɦɵ ɋɢ.
Ɉɩɟɪɚɧɞɵ ɪɚɡɞɟɥɹɸɬɫɹ ɡɚɩɹɬɵɦɢ. ɉɪɢ ɨɩɢɫɚɧɢɢ ɨɩɟɪɚɧɞɨɜ ɢɫɩɨɥɶɡɭɣɬɟ
ɫɥɟɞɭɸɳɢɣ ɮɨɪɦɚɬ:
[[asmSymbolicName]] constraint (cexpression),
ɝɞɟ asmSymbolicName ɢ constraint ɢɦɟɸɬ ɬɨɬ ɠɟ ɫɦɵɫɥ
, ɱɬɨ ɢ ɞɥɹ ɜɵ-
ɯɨɞɧɵɯ ɨɩɟɪɚɧɞɨɜ (ɫɦ. ɜɵɲɟ);
cexpression – ɩɟɪɟɦɟɧɧɚɹ ɢɥɢ ɜɵɪɚɠɟɧɢɟ C, ɩɟɪɟɞɚɜɚɟɦɵɟ ɜ asm-ɨɩɟɪɚɬɨɪ
ɜ ɤɚɱɟɫɬɜɟ ɜɯɨɞɧɵɯ ɞɚɧɧɵɯ. Ʉɪɭɝɥɵɟ ɫɤɨɛɤɢ ɹɜɥɹɸɬɫɹ ɨɛɹɡɚɬɟɥɶɧɨɣ ɱɚɫɬɶɸ
ɫɢɧɬɚɤɫɢɫɚ.
Ʉɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪ ɜɵɛɢɪɚɟɬ ɪɟɝɢɫɬɪɵ ɞɥɹ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɜɯɨɞɧɵɯ ɨɩɟɪɚɧ-
ɞɨɜ, ɨɧ ɧɟ ɢɫɩɨɥɶɡɭɟɬ ɧɢ ɨɞɢɧ ɢɡ ɪɟɝɢɫɬɪɨɜ, ɭɤɚɡɚɧɧɵɯ ɜ ɪɚɡɞɟɥɟ Clobbers.
64
ȿɫɥɢ ɧɟɬ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɨɜ, ɨɞɧɚɤɨ ɟɫɬɶ ɜɯɨɞɧɵɟ ɨɩɟɪɚɧɞɵ, ɩɨɦɟɫɬɢɬɟ
ɞɜɚ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɯ ɞɜɨɟɬɨɱɢɹ, ɜ ɤɨɬɨɪɵɟ ɛɭɞɭɬ ɩɨɫɬɭɩɚɬɶ ɜɵɯɨɞɧɵɟ ɨɩɟɪɚɧɞɵ:
asm__ ("ɧɟɤɨɬɨɪɵɟ ɢɧɫɬɪɭɤɰɢɢ"
: / * ɇɟɬ ɜɵɯɨɞɨɜ. * /
: “R” (ɫɦɟɳɟɧɢɟ / 8));
ɉɪɟɞɭɩɪɟɠɞɟɧɢɟ. ɇɟ ɢɡɦɟɧɹɣɬɟ ɫɨɞɟɪɠɢɦɨɟ ɨɩɟɪɚɧɞɨɜ ɬɨɥɶɤɨ ɞɥɹ ɜɜɨɞɚ
(ɤɪɨɦɟ ɨɩɟɪɚɧɞɨɜ, ɩɪɢɜɹɡɚɧɧɵɯ ɤ ɜɵɯɨɞɭ). Ʉɨɦɩɢɥɹɬɨɪ ɩɪɟɞɩɨɥɚɝɚɟɬ, ɱɬɨ ɩɪɢ
ɜɵɯɨɞɟ ɢɡ ɨɩɟɪɚɬɨɪɚ asm ɷɬɢ ɨɩɟɪɚɧɞɵ ɫɨɞɟɪɠɚɬ ɬɟ ɠɟ
ɡɧɚɱɟɧɢɹ, ɱɬɨ ɢ ɩɟɪɟɞ
ɜɵɩɨɥɧɟɧɢɟɦ ɢɧɫɬɪɭɤɰɢɢ. ɇɟɜɨɡɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ Clobbers, ɱɬɨɛɵ ɫɨɨɛɳɢɬɶ ɤɨɦɩɢɥɹɬɨɪɭ, ɱɬɨ ɡɧɚɱɟɧɢɹ ɜ ɷɬɢɯ ɜɯɨɞɚɯ ɢɡɦɟɧɹɸɬɫɹ. ɇɟɨɛɯɨɞɢɦɨ ɫɜɹɡɚɬɶ ɜɯɨɞɧɭɸ ɩɟɪɟɦɟɧɧɭɸ ɫ ɜɵɯɨɞɧɨɣ ɩɟɪɟɦɟɧɧɨɣ, ɤɨɬɨɪɚɹ ɧɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ. Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɱɬɨ ɟɫɥɢ ɤɨɞ, ɤɨɬɨɪɵɣ ɫɥɟɞɭɟɬ ɡɚ ɨɩɟɪɚɬɨɪɨɦ asm,
ɧɟ ɢɫɩɨɥɶɡɭɟɬ ɧɢ ɨɞɢɧ ɢɡ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɨɜ, ɨɩɬɢɦɢɡɚɬɨɪɵ GCC ɦɨɝɭɬ
ɨɬ-
ɦɟɧɢɬɶ ɨɩɟɪɚɬɨɪ asm ɤɚɤ ɧɟɧɭɠɧɵɣ.
ȼɨ ɜɫɬɚɜɤɟ asm ɩɨɞɞɟɪɠɢɜɚɸɬɫɹ ɦɨɞɢɮɢɤɚɬɨɪɵ ɜ ɨɩɟɪɚɧɞɚɯ (ɧɚɩɪɢɦɟɪ,
ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ “%k2” ɜɦɟɫɬɨ “%2”). ɇɢɠɟ ɩɨɤɚɡɚɧ ɩɪɢɦɟɪ ɬɚɤɨɣ ɡɚɦɟɧɵ.
ɉɪɢɦɟɪ 2.55. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɢɦɟɧɨɜɚɧɧɵɯ ɩɚɪɚɦɟɬɪɨɜ.
asm ("combine %2,%0"
: "= R" (foo)
: "0"(foo), "g" (bar));
; ɉɪɢɦɟɧɟɧɢɟ ɫɢɦɜɨɥɶɧɵɯ ɢɦɟɧ
asm ("cmoveq %1,%2,%[result]"
: [Result] "= r" (result)
: "R"(ɬɟɫɬ), "r" (new),
"[result] (old));
ȼ ɷɬɨɦ ɩɪɢɦɟɪɟ ɨɝɪɚɧɢɱɟɧɢɟ «0» ɞɥɹ ɜɯɨɞɧɨɝɨ ɨɩɟɪɚɧɞɚ 1 ɝɨɜɨɪɢɬ, ɱɬɨ
ɨɧɨ ɞɨɥɠɧɨ ɡɚɧɢɦɚɬɶ ɬɨ ɠɟ ɦɟɫɬɨ, ɱɬɨ ɢ ɜɵɯɨɞɧɨɣ ɨɩɟɪɚɧɞ 0. Ɍɨɥɶɤɨ ɜɯɨɞɧɵɟ
ɨɩɟɪɚɧɞɵ ɦɨɝɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɱɢɫɥɚ ɜ ɨɝɪɚɧɢɱɟɧɢɹɯ, ɩɪɢ ɷɬɨɦ ɤɚɠɞɵɣ ɢɡ ɧɢɯ
ɞɨɥɠɟɧ ɫɫɵɥɚɬɶɫɹ ɧɚ ɜɵɯɨɞɧɨɣ ɨɩɟɪɚɧɞ. Ɍɨɥɶɤɨ ɱɢɫɥɨ (ɢɥɢ ɫɢɦɜɨɥɶɧɨɟ ɢɦɹ
Ⱥɫɫɟɦɛɥɟɪɚ) ɜ ɨɝɪɚɧɢɱɟɧɢɢ ɦɨɠɟɬ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɨɞɢɧ ɨɩɟɪɚɧɞ
ɧɚɯɨɞɢɬɫɹ
ɜ ɬɨɦ ɠɟ ɦɟɫɬɟ, ɱɬɨ ɢ ɞɪɭɝɨɣ. Ɍɨɝɨ ɮɚɤɬɚ, ɱɬɨ foo – ɡɧɚɱɟɧɢɟ ɨɛɨɢɯ ɨɩɟɪɚɧɞɨɜ,
ɧɟɞɨɫɬɚɬɨɱɧɨ, ɱɬɨɛɵ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɨɧɢ ɧɚɯɨɞɹɬɫɹ ɜ ɨɞɧɨɦ ɢ ɬɨɦ ɠɟ ɦɟɫɬɟ
ɜ ɫɝɟɧɟɪɢɪɨɜɚɧɧɨɦ ɤɨɞɟ ɚɫɫɟɦɛɥɟɪɚ.
ȿɫɥɢ ɞɥɹ ɜɵɱɢɫɥɟɧɢɹ ɬɪɟɛɭɸɬɫɹ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɪɟɝɢɫɬɪɵ, ɢɥɢ ɩɪɨɰɟɫɫɨɪɭ ɧɭɠɧɨ ɩɟɪɟɡɚɩɢɫɚɬɶ ɪɟɝɢɫɬɪ ɤɚɤ ɩɨɛɨɱɧɵɣ ɷɮɮɟɤɬ ɤɨɧɤɪɟɬɧɨɣ ɤɨɦɚɧɞɵ ɚɫɫɟɦɛɥɟɪɚ,
ɧɭɠɧɨ ɫɨɨɛɳɢɬɶ ɤɨɦɩɢɥɹɬɨɪɭ ɨɛ ɷɬɢɯ ɢɡɦɟɧɟɧɢɹɯ, ɩɟɪɟɱɢɫɥɢɬɟ ɢɯ ɜ
ɫɩɢɫɤɟ Clobber, ɤɚɠɞɵɣ ɷɥɟɦɟɧɬ ɤɨɬɨɪɨɝɨ ɹɜɥɹɟɬɫɹ ɫɬɪɨɤɨɜɨɣ ɤɨɧɫɬɚɧɬɨɣ,
ɡɚɤɥɸɱɟɧɧɨɣ ɜ ɞɜɨɣɧɵɟ ɤɚɜɵɱɤɢ ɢ ɪɚɡɞɟɥɟɧɧɨɣ ɡɚɩɹɬɵɦɢ.
Ɉɩɢɫɚɧɢɟ Clobber ɧɟ ɦɨɠɟɬ ɧɢɤɨɢɦ ɨɛɪɚɡɨɦ ɩɟɪɟɤɪɵɜɚɬɶɫɹ ɫ ɜɯɨɞɧɵɦ
ɢɥɢ ɜɵɯɨɞɧɵɦ ɨɩɟɪɚɧɞɨɦ. ɇɚɩɪɢɦɟɪ, ɭ ȼɚɫ ɦɨɠɟɬ ɧɟ ɛɵɬɶ ɨɩɟɪɚɧɞɚ, ɨɩɢɫɵɜɚɸɳɟɝɨ ɤɥɚɫɫ ɪɟɝɢɫɬɪɚ ɫ ɨɞɧɢɦ ɱɥɟɧɨɦ ɩɪɢ
ɩɟɪɟɱɢɫɥɟɧɢɢ ɷɬɨɝɨ ɪɟɝɢɫɬɪɚ ɜ ɫɩɢɫɤɟ Clobber. ɉɟɪɟɦɟɧɧɵɟ, ɨɛɴɹɜɥɟɧɧɵɟ ɞɥɹ ɡɚɩɢɫɢ ɜ ɤɨɧɤɪɟɬɧɵɯ ɪɟɝɢɫɬɪɚɯ, ɢ
ɢɫɩɨɥɶɡɭɟɦɵɟ ɜ ɤɚɱɟɫɬɜɟ ɜɯɨɞɧɵɯ ɢɥɢ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɨɜ asm, ɧɟ ɞɨɥɠɧɵ
ɭɩɨɦɢɧɚɬɶɫɹ ɜ ɨɩɢɫɚɧɢɢ Clobber.
65
Ʉɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪ ɜɵɛɢɪɚɟɬ, ɤɚɤɢɟ ɪɟɝɢɫɬɪɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɜɯɨɞɧɵɯ ɢ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɨɜ, ɨɧ ɧɟ ɢɫɩɨɥɶɡɭɟɬ ɧɢ ɨɞɧɨɝɨ ɢɡ ɢɡɦɟɧɹɟɦɵɯ ɪɟɝɢɫɬɪɨɜ. ȼ ɪɟɡɭɥɶɬɚɬɟ, ɢɡɦɟɧɹɟɦɵɟ ɪɟɝɢɫɬɪɵ ɞɨɫɬɭɩɧɵ ɞɥɹ ɥɸɛɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɤɨɞɟ ɚɫɫɟɦɛɥɟɪɚ, ɤɚɤ ɩɨɤɚɡɚɧɨ ɜ ɫɥɟɞɭɸɳɟɦ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 2.56. ɍɤɚɡɚɧɢɟ ɢɡɦɟɧɹɟɦɵɯ ɪɟɝɢɫɬɪɨɜ.
asm volatile ("movc3 %0, %1, %2"
: /* No outputs. */
: "g" (from), "g" (to), "g" (count)
: "r0", "r1", "r2", "r3", "r4", "r5");
Ʉɪɨɦɟ ɬɨɝɨ, ɟɫɬɶ ɞɜɚ ɫɩɟɰɢɚɥɶɧɵɯ ɚɪɝɭɦɟɧɬɚ
Clobber:
– "cc" ɭɤɚɡɵɜɚɟɬ, ɱɬɨ ɤɨɞ ɚɫɫɟɦɛɥɟɪɚ ɢɡɦɟɧɹɟɬ ɪɟɝɢɫɬɪ ɮɥɚɝɨɜ. ɇɚ ɧɟɤɨɬɨɪɵɯ ɦɚɲɢɧɚɯ gcc ɩɪɟɞɫɬɚɜɥɹɟɬ ɤɨɞɵ ɭɫɥɨɜɢɣ ɤɚɤ ɫɩɟɰɢɮɢɱɟɫɤɢɣ ɚɩɩɚɪɚɬɧɵɣ ɪɟɝɢɫɬɪ, ɚ "cc"ɫɥɭɠɢɬ ɞɥɹ ɨɛɨɡɧɚɱɟɧɢɹ ɷɬɨɝɨ ɪɟɝɢɫɬɪɚ. ɇɚ ɞɪɭɝɢɯ ɦɚɲɢɧɚɯ ɨɛɪɚɛɨɬɤɚ ɤɨɞɚ ɭɫɥɨɜɢɹ ɨɬɥɢɱɚɟɬɫɹ, ɢ ɭɤɚɡɚɧɢɟ "cc"ɧɢ ɧɚ ɱɬɨ ɧɟ ɜɥɢɹɟɬ;
– "memory" ɫɨɨɛɳɚɟɬ ɤɨɦɩɢɥɹɬɨɪɭ, ɱɬɨ ɤɨɞ ɫɛɨɪɤɢ
ɜɵɩɨɥɧɹɟɬ ɨɩɟɪɚɰɢɢ
ɫ ɩɚɦɹɬɶɸ: ɫɱɢɬɵɜɚɟɬ ɢɥɢ ɡɚɩɢɫɵɜɚɟɬ ɷɥɟɦɟɧɬɵ, ɨɬɥɢɱɧɵɟ ɨɬ ɬɟɯ, ɤɨɬɨɪɵɟ ɭɤɚɡɚɧɵ ɜɨ ɜɯɨɞɧɵɯ ɢ ɜɵɯɨɞɧɵɯ ɨɩɟɪɚɧɞɚɯ (ɧɚɩɪɢɦɟɪ, ɞɥɹ ɞɨɫɬɭɩɚ ɤ ɩɚɦɹɬɢ, ɧɚ
ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɨɞɢɧ ɢɡ ɜɯɨɞɧɵɯ ɩɚɪɚɦɟɬɪɨɜ). ɑɬɨɛɵ ɩɚɦɹɬɶ ɫɨɞɟɪɠɚɥɚ
ɩɪɚɜɢɥɶɧɵɟ ɡɧɚɱɟɧɢɹ, gcc ɦɨɠɟɬ ɩɨɬɪɟɛɨɜɚɬɶ ɫɨɯɪɚɧɢɬɶ ɨɩɪɟɞɟɥɟɧɧɵɟ ɡɧɚɱɟɧɢɹ ɪɟɝɢɫɬɪɨɜ ɜ ɩɚɦɹɬɢ ɩɟɪɟɞ ɜɵɩɨɥɧɟɧɢɟɦ ɤɨɞɚ ɪɚɡɞɟɥɚ
asm. Ʉɪɨɦɟ ɬɨɝɨ,
ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɩɪɟɞɩɨɥɚɝɚɟɬ, ɱɬɨ ɥɸɛɵɟ ɡɧɚɱɟɧɢɹ, ɫɱɢɬɚɧɧɵɟ ɢɡ ɩɚɦɹɬɢ ɩɟɪɟɞ
asm, ɨɫɬɚɸɬɫɹ ɧɟɢɡɦɟɧɧɵɦɢ ɩɨɫɥɟ ɷɬɨɝɨ asm, ɨɧ ɩɟɪɟɡɚɝɪɭɠɚɟɬ ɢɯ ɩɨ ɦɟɪɟ
ɧɟɨɛɯɨɞɢɦɨɫɬɢ.
ɋɨɯɪɚɧɟɧɢɟ ɪɟɝɢɫɬɪɨɜ ɜ ɩɚɦɹɬɢ ɢɦɟɟɬ ɩɨɫɥɟɞɫɬɜɢɹ ɞɥɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɢ ɦɨɠɟɬ ɛɵɬɶ ɩɪɨɛɥɟɦɨɣ ɞɥɹ ɱɭɜɫɬɜɢɬɟɥɶɧɨɝɨ ɤɨ ɜɪɟɦɟɧɢ ɢɫɩɨɥɧɟɧɢɹ ɤɨɞɚ. ɑɬɨɛɵ ɢɡɛɟɠɚɬɶ ɷɬɨɝɨ, ɧɚɩɪɢɦɟɪ, ɩɪɢ ɞɨɫɬɭɩɟ
ɤ ɞɟɫɹɬɢ ɛɚɣɬɚɦ
ɫɬɪɨɤɢ ɢɫɩɨɥɶɡɭɣɬɟ ɜɜɨɞ ɜ ɩɚɦɹɬɶ:
{"m"(({struct{char x[10];} *p=(void *)ptr; *p;}))}.
ȼ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɬɚɤɠɟ ɩɪɟɞɭɫɦɨɬɪɟɧɚ ɜɨɡɦɨɠɧɨɫɬɶ
ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɚɫɫɟɦɛɥɟɪɧɵɯ ɜɫɬɚɜɨɤ.
ȼ ɩɪɨɝɪɚɦɦɚɯ Visual C++ ɚɫɫɟɦɛɥɟɪɧɚɹ ɜɫɬɚɜɤɚ ɢɦɟɟɬ ɫɥɟɞɭɸɳɢɣ ɫɢɧɬɚɤɫɢɫ:
__ asm {
ɤɨɦɚɧɞɚ 1
ɤɨɦɚɧɞɚ 2
ɤɨɦɚɧɞɚ N
}
ɢɥɢ
__ asm ɤɨɦɚɧɞɚ 1
asm ɤɨɦɚɧɞɚ 2
__ asm ɤɨɦɚɧɞɚ N
66
ȼ Object Pascal (Delphi) ɚɫɫɟɦɛɥɟɪɧɚɹ ɜɫɬɚɜɤɚ ɞɟɥɚɟɬɫɹ ɬɚɤ:
asm
ɤɨɦɚɧɞɚ 1
ɤɨɦɚɧɞɚ 2
ɤɨɦɚɧɞɚ N
end;
ɂɧɫɬɪɭɤɰɢɢ ɜɫɬɪɨɟɧɧɨɝɨ ɚɫɫɟɦɛɥɟɪɚ ɦɨɝɭɬ ɫɫɵɥɚɬɶɫɹ ɧɚ ɩɟɪɟɦɟɧɧɵɟ C
ɢɥɢ C++ ɩɨ ɢɦɟɧɢ, ɢ ɫɨɞɟɪɠɚɬɶ:
– ɫɢɦɜɨɥɵ (ɧɚɩɪɢɦɟɪ, ɦɟɬɤɢ ɢ ɢɦɟɧɚ ɩɟɪɟɦɟɧɧɵɯ ɢ ɮɭɧɤɰɢɣ);
– ɤɨɧɫɬɚɧɬɵ, ɜɤɥɸɱɚɹ ɫɢɦɜɨɥɶɧɵɟ ɤɨɧɫɬɚɧɬɵ ɢ ɩɟɪɟɱɢɫɥɟɧɢɹ;
– ɦɚɤɪɨɫɵ ɢ ɞɢɪɟɤɬɢɜɵ ɩɪɟɩɪɨɰɟɫɫɨɪɚ ɋɢ (ɋ++);
– ɤɨɦɦɟɧɬɚɪɢɢ (/* */ ɢ //).
Ɋɟɤɨɦɟɧɞɚɰɢɹ: ɢɫɩɨɥɶɡɭɣɬɟ ɜɧɭɬɪɢ ɚɫɫɟɦɛɥɟɪɧɵɯ ɜɫɬɚɜɨɤ
ɢɦɟɧɚ ɩɟɪɟ-
ɦɟɧɧɵɯ, ɨɛɴɹɜɥɟɧɧɵɯ ɜ ɨɫɧɨɜɧɨɣ ɩɪɨɝɪɚɦɦɟ. Ɉɛɴɹɜɥɟɧɢɟ ɩɟɪɟɦɟɧɧɵɯ ɜɧɭɬɪɢ
ɚɫɫɟɦɛɥɟɪɧɨɣ ɜɫɬɚɜɤɢ ɞɨɩɭɫɬɢɦɨ, ɧɨ ɧɟɠɟɥɚɬɟɥɶɧɨ.
Ʉɨɞ ɚɫɫɟɦɛɥɟɪɧɵɯ ɩɪɨɝɪɚɦɦ, ɡɚɩɢɫɚɧɧɵɯ ɜ ɮɚɣɥɚɯ, ɭɞɨɛɧɨ ɨɮɨɪɦɥɹɬɶ ɜ
ɜɢɞɟ ɩɨɞɩɪɨɝɪɚɦɦ-ɩɪɨɰɟɞɭɪ, ɱɬɨɛɵ ɢɯ ɦɨɠɧɨ ɛɵɥɨ ɜɵɡɵɜɚɬɶ ɜ ɩɪɨɝɪɚɦɦɚɯ,
ɧɚɩɢɫɚɧɧɵɯ ɧɚ ɹɡɵɤɚɯ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ.
ɋɢɧɬɚɤɫɢɫ ɨɩɢɫɚɧɢɹ ɩɪɨɰɟɞɭɪɵ Ⱥɫɫɟɦɛɥɟɪɚ ɫɥɟɞɭɸɳɢɣ:
ɢɦɹ_ɩɪɨɰɟɞɭɪɵ PROC ; ɧɚɱɚɥɨ ɩɪɨɰɟɞɭɪɵ
ɨɩɟɪɚɬɨɪɵ ; ɬɟɥɨ
ɩɪɨɰɟɞɭɪɵ
RET ;ɜɨɡɜɪɚɬ ɢɡ ɩɪɨɰɟɞɭɪɵ
ɢɦɹ_ɩɪɨɰɟɞɭɪɵ ENDP ; ɡɚɜɟɪɲɟɧɢɟ ɩɪɨɰɟɞɭɪɵ
Ⱦɥɹ ɜɵɡɨɜɚ ɩɪɨɰɟɞɭɪ ɩɪɟɞɧɚɡɧɚɱɟɧɚ ɤɨɦɚɧɞɚ CALL. ɉɪɢ ɜɵɡɨɜɟ ɩɪɨɰɟɞɭɪɵ ɜ ɫɬɟɤɟ ɫɨɯɪɚɧɹɟɬɫɹ ɬɟɤɭɳɟɟ ɡɧɚɱɟɧɢɟ ɪɟɝɢɫɬɪɚ IP, ɱɬɨ ɨɛɟɫɩɟɱɢɜɚɟɬ ɜɨɡɜɪɚɬ ɤ ɦɟɫɬɭ ɜɵɡɨɜɚ ɜ ɨɫɧɨɜɧɨɣ ɩɪɨɝɪɚɦɦɟ.
ȼɨɡɜɪɚɬ ɢɡ ɩɪɨɰɟɞɭɪɵ ɜɵɩɨɥɧɹɟɬɫɹ ɤɨɦɚɧɞɨɣ RET. ɗɬɚ ɤɨɦɚɧɞɚ ɜɨɫɫɬɚɧɚɜɥɢɜɚɟɬ ɡɧɚɱɟɧɢɟ ɢɡ ɜɟɪɲɢɧɵ ɫɬɟɤɚ ɜ
ɪɟɝɢɫɬɪɟ IP.
ȼ ɩɪɨɝɪɚɦɦɟ ɧɚ ɹɡɵɤɟ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ, ɜɵɡɵɜɚɸɳɟɣ ɩɪɨɰɟɞɭɪɵ ɚɫɫɟɦɛɥɟɪɚ, ɫɥɟɞɭɟɬ ɨɩɢɫɚɬɶ ɩɪɨɬɨɬɢɩ ɩɪɨɰɟɞɭɪɵ.
ɉɟɪɟɞ ɩɪɨɬɨɬɢɩɨɦ ɫɥɟɞɭɟɬ ɭɤɚɡɚɬɶ ɤɨɦɩɢɥɹɬɨɪɭ, ɱɬɨ ɩɪɨɰɟɞɭɪɚ ɨɛɴɹɜɥɟɧɚ
ɜɨ ɜɧɟɲɧɟɦ ɮɚɣɥɟ ɢ ɢɦɟɟɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɟ ɩɪɚɜɢɥɨ ɜɵɡɨɜɚ, ɧɚɩɪɢɦɟɪ, “C”:
extern "C"
{
//ɩɪɨɰɟɞɭɪɚ Ⱥɫɫɟɛɥɟɪɚ ɢɡ ɜɧɟɲɧɟɝɨ ɮɚɣɥɚ
void AsmProcName();
}
Ʉɨɦɩɢɥɹɬɨɪɵ ɹɡɵɤɨɜ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ ɢɫɤɚɠɚɸɬ ɢɦɟɧɚ ɜɵɡɵɜɚɟɦɵɯ
ɮɭɧɤɰɢɣ, ɩɨɷɬɨɦɭ ɭɤɚɡɚɧɢɟ
ɩɪɚɜɢɥɚ ɜɵɡɨɜɚ ɨɛɹɡɚɬɟɥɶɧɨ.
Ⱥɫɫɟɦɛɥɟɪɧɚɹ ɩɪɨɰɟɞɭɪɚ ɞɨɥɠɧɚ ɫɨɨɬɜɟɬɫɬɜɨɜɚɬɶ ɪɹɞɭ ɬɪɟɛɨɜɚɧɢɣ:
ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɚɜɢɥɚ ɢɦɟɧɨɜɚɧɢɹ ɫɟɝɦɟɧɬɨɜ, ɩɪɢɧɹɬɵɯ ɜ ɹɡɵɤɟ ɜɵɫɨɤɨ-
ɝɨ ɭɪɨɜɧɹ;
ɹɜɧɨ ɨɩɢɫɵɜɚɬɶ ɜɫɟ ɝɥɨɛɚɥɶɧɵɟ ɢ ɜɧɟɲɧɢɟ ɢɞɟɧɬɢɮɢɤɚɬɨɪɵ;
67
ɩɨɞɞɟɪɠɢɜɚɬɶ ɩɪɢɧɹɬɭɸ ɜ ɹɡɵɤɟ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɩɟɪɟɞɚɱɢ ɩɚɪɚɦɟɬɪɨɜ ɢ ɜɨɡɜɪɚɬɚ ɡɧɚɱɟɧɢɹ ɜ ɬɨɱɤɭ ɜɵɡɨɜɚ.
Ⱥɫɫɟɦɛɥɟɪɧɵɣ ɮɚɣɥ ɞɨɥɠɟɧ ɛɵɬɶ ɧɚɩɢɫɚɧ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɞɢɪɟɤɬɢɜ
ɨɩɢɫɚɧɢɹ ɦɨɞɟɥɢ ɩɚɦɹɬɢ ɢ ɫɟɝɦɟɧɬɨɜ:
.386
.MODEL FLAT, C ;ɦɨɞɟɥɶ ɩɚɦɹɬɢ ɢ ɩɪɚɜɢɥɨ ɜɵɡɨɜɚ .DATA
...
; ɫɟɝɦɟɧɬ ɞɚɧɧɵɯ
.CODE
...
;ɫɟɝɦɟɧɬ ɤɨɞɚ
END ;ɡɚɜɟɪɲɟɧɢɟ ɦɨɞɭɥɹ
ȼɫɟ ɜɧɟɲɧɢɟ ɩɟɪɟɦɟɧɧɵɟ, ɨɩɢɫɚɧɧɵɟ ɧɚ ɹɡɵɤɟ ɜɵɫɨɤɨɝɨ
ɭɪɨɜɧɹ, ɢ ɧɚ ɤɨ-
ɬɨɪɵɟ ɫɫɵɥɚɟɬɫɹ ɚɫɫɟɦɛɥɟɪɧɚɹ ɩɪɨɰɟɞɭɪɚ, ɞɨɥɠɧɵ ɨɩɢɫɵɜɚɬɶɫɹ ɜ ɚɫɫɟɦɛɥɟɪɧɨɦ ɤɨɞɟ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɞɢɪɟɤɬɢɜɵ EXTRN:
EXTRN ɢɦɹ_ɩɟɪɟɦɟɧɧɨɣ: ɪɚɡɦɟɪ
ɉɚɪɚɦɟɬɪ ɪɚɡɦɟɪ ɡɚɞɚɟɬ ɱɢɫɥɨ ɛɚɣɬɨɜ, ɜɵɞɟɥɹɟɦɵɯ ɤɨɦɩɢɥɹɬɨɪɨɦ ɹɡɵɤɚ
ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ, ɢ ɪɚɜɟɧ (ɫɨɨɬɜɟɬɫɬɜɢɟ ɞɥɹ ɬɢɩɨɜ ɞɚɧɧɵɯ ɋ/ɋ++):
BYTE ɞɥɹ ɬɢɩɚ char;
WORD ɞɥɹ ɬɢɩɨɜ int ɢ unsigned int;
DWORD ɞɥɹ ɬɢɩɨɜ long ɢ float;
QWORD ɞɥɹ ɬɢɩɚ double (8 ɛɚɣɬ).
ɗɬɢ ɠɟ ɩɪɚɜɢɥɚ ɩɪɢɦɟɧɹɸɬɫɹ ɞɥɹ ɭɤɚɡɚɧɢɹ ɚɪɝɭɦɟɧɬɨɜ, ɩɟɪɟɞɚɜɚɟɦɵɯ ɜ
ɩɪɨɰɟɞɭɪɭ ɚɫɫɟɦɛɥɟɪɚ ɢɡ ɜɧɟɲɧɟɣ ɩɪɨɝɪɚɦɦɵ. ȿɫɥɢ ɩɟɪɟɦɟɧɧɚɹ ɨɩɢɫɚɧɚ ɩɨɫɥɟ
ɤɥɸɱɟɜɨɝɨ ɫɥɨɜɚ PROC, ɬɨ ɞɢɪɟɤɬɢɜɭ EXTRN ɭɤɚɡɵɜɚɬɶ ɧɟ ɨɛɹɡɚɬɟɥɶɧɨ.
ȼɵɡɵɜɚɟɦɚɹ ɩɪɨɰɟɞɭɪɚ ɩɟɪɟɞ ɜɨɡɜɪɚɳɟɧɢɟɦ ɜ ɬɨɱɤɭ ɜɵɡɨɜɚ ɞɨɥɠɧɚ ɜɨɫɫɬɚɧɨɜɢɬɶ ɜɫɟ ɢɡɦɟɧɹɟɦɵɟ ɪɟɝɢɫɬɪɵ, – ɩɟɪɟɞ
ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɯ ɡɧɚɱɟɧɢɹ ɧɭɠɧɨ ɫɨɯɪɚɧɹɬɶ, ɚ ɩɪɢ ɜɵɯɨɞɟ ɢɡ ɩɪɨɰɟɞɭɪɵ ɜɨɫɫɬɚɧɚɜɥɢɜɚɬɶ, ɱɬɨ ɨɛɵɱɧɨ ɪɟɚɥɢɡɭɟɬɫɹ ɩɪɢ ɩɨɦɨɳɢ ɫɬɟɤɚ.
ɇɢɠɟ ɩɪɟɞɫɬɚɜɥɟɧ ɩɪɢɦɟɪ ɞɜɭɯ ɮɚɣɥɨɜ: ɨɞɢɧ ɧɚ ɹɡɵɤɟ ɋ++ ɫ ɩɪɨɬɨɬɢɩɨɦ
ɚɫɫɟɦɛɥɟɪɧɨɣ ɩɪɨɰɟɞɭɪɵ ɢ ɟɟ ɜɵɡɨɜɨɦ, ɢ ɜɬɨɪɨɣ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ ɫ ɩɪɨɰɟɞɭɪɨɣ
ɫɥɨɠɟɧɢɹ ɞɜɭɯ ɱɢɫɟɥ.
ɉɪɢɦɟɪ 2.57. ɉɨɞɤɥɸɱɟɧɢɟ ɩɪɨɰɟɞɭɪɵ Ⱥɫɫɟɦɛɥɟɪɚ ɤ ɩɪɨɝɪɚɦɦɟ
, ɧɚɩɢ-
ɫɚɧɧɨɣ ɧɚ ɋ++.
// Ɏɚɣɥ main.cpp:
extern "C"{
int sum(); // ɉɪɨɬɨɬɢɩ ɮɭɧɤɰɢɢ Ⱥɫɫɟɛɥɟɪɚ
}
void main() {
int a, b, c;
a = scanf("%d", a); // ȼɜɨɞ ɩɟɪɟɦɟɧɧɨɣ a
b = scanf("%d", b); // ȼɜɨɞ ɩɟɪɟɦɟɧɧɨɣ b
c = sum(a,b); // ȼɵɡɨɜ ɮɭɧɤɰɢɢ, ɪɚɫɱɟɬ c
// ȼɵɜɨɞ ɧɚ ɷɤɪɚɧ
68
printf("c=%d + %d = %d",a,b,c);
}
; Ɏɚɣɥ asmproc.asm:
.386
.MODEL FLAT, C
.DATA
.CODE
;ɩɪɨɰɟɞɭɪɚ ɫ ɞɜɭɦɹ ɚɪɝɭɦɟɧɬɚɦɢ
SUM PROC a:DWORD, b:DWORD
PUSH EBX ; ɫɨɯɪɚɧɟɧɢɟ ɫɨɞɟɪɠɢɦɨɝɨ ɪɟɝɢɫɬɪɚ EBX
MOV EAX, a
MOV EBX, b
ADD EAX, EBX
POP EBX ; ɜɨɫɫɬɚɧɨɜɥɟɧɢɟ ɡɧɚɱɟɧɢɹ EBX
RET ; ɜɨɡɜɪɚɬ ɢɡ ɩɨɞɩɪɨɝɪɚɦɦɵ sum ENDP
END
2.3.2. ɉɨɞɤɥɸɱɟɧɢɟ ɞɢɧɚɦɢɱɟɫɤɢɯ ɛɢɛɥɢɨɬɟɤ
ɉɪɢ ɪɚɡɪɚɛɨɬɤɟ ɮɪɚɝɦɟɧɬɨɜ ɩɪɨɝɪɚɦɦ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ ɢɯ ɦɨɠɧɨ ɜɤɥɸɱɢɬɶ
ɜ ɫɨɫɬɚɜ ɛɢɛɥɢɨɬɟɤ ɞɢɧɚɦɢɱɟɫɤɨɣ ɤɨɦɩɨɧɨɜɤɢ (dll). ɗɬɢ ɛɢɛɥɢɨɬɟɤɢ ɫɨɞɟɪɠɚɬ
ɩɪɨɰɟɞɭɪɵ ɚɫɫɟɦɛɥɟɪɚ, ɚ ɬɚɤɠɟ ɫɩɟɰɢɚɥɶɧɭɸ ɢɧɢɰɢɚɥɢɡɢɪɭɸɳɭɸ ɩɪɨɰɟɞɭɪɭ.
ɂɧɢɰɢɚɥɢɡɢɪɭɸɳɚɹ ɩɪɨɰɟɞɭɪɚ ɩɪɢɧɢɦɚɟɬ ɬɪɢ ɨɛɹɡɚɬɟɥɶɧɵɯ ɩɚɪɚɦɟɬɪɚ, ɢ
ɢɫɩɨɥɶɡɭɟɬ ɪɟɝɢɫɬɪ ɩɪɨɰɟɫɫɨɪɚ EAX ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɬɟɤɭɳɟɝɨ ɫɨɫɬɨɹɧɢɹ: ɟɫɥɢ
EAX = -1, ɬɨ ɛɢɛɥɢɨɬɟɤɚ ɩɪɨɞɨɥɠɚɟɬ ɪɚɛɨɬɭ, ɟɫɥɢ ɠɟ EAX = 0, ɬɨ ɪɚɛɨɬɚ ɡɚɜɟɪɲɚɟɬɫɹ.
ɒɚɛɥɨɧ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ ɢɦɟɟɬ ɫɥɟɞɭɸɳɢɣ ɜɢɞ (ɫɢɧɬɚɤɫɢɫ Tur-
bo Assembler):
.386
.MODEL FLAT
PUBLIC test1
.DATA
.CODE
;ɢɧɢɰɢɚɥɢɡɢɪɭɸɳɚɹ ɩɪɨɰɟɞɭɪɚ
DllMain PROC hInstDLL:DWORD,
rs:DWORD, rsvd:DWORD
MOV EAX, -1 ; ɩɪɨɞɨɥɠɚɟɦ ɪɚɛɨɬɭ
RET
DllMain ENDP
;ɩɪɨɰɟɞɭɪɚ, ɷɤɫɩɨɪɬɢɪɭɟɦɚɹ ɢɡ ɛɢɛɥɢɨɬɟɤɢ
test1 PROC C
;ɤɨɞ ɩɪɨɰɟɞɭɪɵ
RET
test1 ENDP
END DllMain
69
ȼ ɩɪɢɜɟɞɟɧɧɨɦ ɩɪɢɦɟɪɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɫɥɟɞɭɸɳɢɟ ɩɚɪɚɦɟɬɪɵ ɢɧɢɰɢɚɥɢ-
ɡɢɪɭɸɳɟɣ ɩɪɨɰɟɞɭɪɵ:
hInstDLL – ɫɫɵɥɤɚ ɧɚ ɨɛɪɚɛɨɬɱɢɤ ɩɪɨɰɟɫɫɚ (ɨɩɢɫɚɬɟɥɶ);
rs – ɫɨɫɬɨɹɧɢɟ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ;
rsvd – ɪɟɡɟɪɜɧɵɣ ɩɚɪɚɦɟɬɪ.
ɉɚɪɚɦɟɬɪ rs ɦɨɠɟɬ ɩɪɢɧɢɦɚɬɶ ɨɞɧɨ ɢɡ ɫɥɟɞɭɸɳɢɯ ɡɧɚɱɟɧɢɣ:
DLL_PROCESS_ATTACH – ɛɢɛɥɢɨɬɟɤɚ ɡɚɝɪɭɠɚɟɬɫɹ ɜ ɚɞɪɟɫɧɨɟ ɩɪɨɫɬɪɚɧ-
ɫɬɜɨ ɩɪɨɰɟɫɫɚ ɜɩɟɪɜɵɟ. ɂɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɢɧɢɰɢɚɥɢɡɚɰɢɢ DLL;
DLL_PROCESS_DETACH – ɛɢɛɥɢɨɬɟɤɚ ɜɵɝɪɭɠɚɟɬɫɹ ɢɡ ɚɞɪɟɫɧɨɝɨ ɩɪɨ-
ɫɬɪɚɧɫɬɜɚ ɩɪɨɰɟɫɫɚ. ɂɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ
ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ;
DLL_THREAD_ATTACH – ɩɪɨɰɟɫɫ, ɩɨɪɨɠɞɟɧɧɵɣ ɛɢɛɥɢɨɬɟɤɨɣ, ɫɨɡɞɚɟɬ
ɧɨɜɭɸ ɜɟɬɜɶ;
DLL_THREAD_DETACH – ɜɟɬɜɶ ɜ ɩɪɨɰɟɫɫɟ, ɩɨɪɨɠɞɟɧɧɨɦ ɛɢɛɥɢɨɬɟɤɨɣ,
ɭɧɢɱɬɨɠɟɧɚ.
ɂɦɟɧɚ ɷɤɫɩɨɪɬɢɪɭɟɦɵɯ ɩɪɨɰɟɞɭɪ ɭɤɚɡɵɜɚɸɬ ɩɟɪɟɞ ɫɟɝɦɟɧɬɨɦ ɞɚɧɧɵɯ ɫ
ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɤɥɸɱɟɜɨɝɨ ɫɥɨɜɚ PUBLIC. ɇɟɨɛɯɨɞɢɦɨ ɬɚɤɠɟ ɫɨɡɞɚɬɶ ɮɚɣɥ
ɭɫɬɚɧɨɜɨɤ ɦɨɞɭɥɹ (ɫ ɪɚɫɲɢɪɟɧɢɟɦ *.def), ɜ ɤɨɬɨɪɨɦ ɭɤɚɡɵɜɚɟɬɫɹ ɢɦɹ ɢ ɨɩɢɫɚɧɢɟ ɫɚɦɨɣ ɛɢɛɥɢɨɬɟɤɢ, ɚ ɬɚɤɠɟ ɢɦɟɧɚ ɢ ɩɚɪɚɦɟɬɪɵ
ɫɨɞɟɪɠɚɳɢɯɫɹ ɜ ɧɟɣ ɷɤɫɩɨɪ-
ɬɢɪɭɟɦɵɯ ɩɪɨɰɟɞɭɪ.
Ɋɚɫɫɦɨɬɪɢɦ ɩɪɢɦɟɪ ɫɨɞɟɪɠɢɦɨɝɨ def-ɮɚɣɥɚ, ɫɨɡɞɚɧɧɨɝɨ ɞɥɹ ɚɫɫɟɦɛɥɟɪɧɨɝɨ ɮɚɣɥɚ MyLib.asm ɫ ɩɪɨɰɟɞɭɪɨɣ myFun:
LIBRARY MyLib
DESCRIPTION 'MyLib – ɦɨɢ asm-ɩɪɨɰɟɞɭɪɵ'
EXPORTS myFun
Ⱦɥɹ ɤɚɠɞɨɣ ɩɪɨɰɟɞɭɪɵ ɭɤɚɡɵɜɚɸɬ ɟɟ ɩɨɪɹɞɤɨɜɵɣ ɧɨɦɟɪ, ɢɫɩɨɥɶɡɭɹ ɤɚɤ
ɩɪɟɮɢɤɫ, ɫɢɦɜɨɥ @. ɗɬɨɬ ɧɨɦɟɪ ɱɚɫɬɨ ɢɫɩɨɥɶɡɭɸɬ ɞɥɹ ɜɵɡɨɜɚ ɩɪɨɰɟɞɭɪɵ ɢɡ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ. ȿɫɥɢ ɜ ɫɬɪɨɤɟ ɷɤɫɩɨɪɬɚ ɭɤɚɡɚɬɶ ɩɚɪɚɦɟɬɪ
NONAME, ɨɧ
ɡɚɩɪɟɬɢɬ ɤɨɦɩɢɥɹɬɨɪɭ ɜɤɥɸɱɚɬɶ ɢɦɹ ɩɪɨɰɟɞɭɪɵ ɜ ɬɚɛɥɢɰɭ ɷɤɫɩɨɪɬɚ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ.
ɉɨɫɥɟ ɫɨɡɞɚɧɢɹ ɢɫɯɨɞɧɨɝɨ ɤɨɞɚ ɛɢɛɥɢɨɬɟɤɢ ɢ ɮɚɣɥɚ ɭɫɬɚɧɨɜɨɤ ɦɨɞɭɥɹ
ɫɥɟɞɭɟɬ ɫɤɨɦɩɢɥɢɪɨɜɚɬɶ ɨɛɴɟɤɬɧɵɣ ɮɚɣɥ, ɩɪɢ ɷɬɨɦ ɜ ɤɚɱɟɫɬɜɟ ɩɚɪɚɦɟɬɪɚ ɤɨɦɩɨɧɨɜɳɢɤɚ ɫɥɟɞɭɟɬ ɭɤɚɡɚɬɶ ɮɚɣɥɚ ɭɫɬɚɧɨɜɨɤ ɦɨɞɭɥɹ *.def ɢ ɧɚɫɬɪɨɣɤɭ, ɭɤɚɡɵɜɚɸɳɭɸ, ɱɬɨ ɧɟɨɛɯɨɞɢɦɨ ɩɨɫɬɪɨɢɬɶ ɞɢɧɚɦɢɱɟɫɤɭɸ ɛɢɛɥɢɨɬɟɤɭ. Ⱦɥɹ ɷɬɨɝɨ ɜɵɩɨɥɧɢɬɟ ɩɪɢɜɟɞɟɧɧɭɸ ɧɢɠɟ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɤɨɦɚɧɞ.
Ⱦɥɹ Ⱥɫɫɟɦɛɥɟɪɚ TASM:
tasm32 /ml MyLib.asm
tlink32 –aa –Tpd MyLib.obj,,,,MyLib.def
Ⱦɥɹ Ⱥɫɫɟɦɛɥɟɪɚ MASM:
ml MyLib.asm /link/OUT:"MyLib.dll" /DLL /entry:
DllMain / DEF: MyLib.def /SUBSYSTEM:CONSOLE
Ɂɞɟɫɶ /link – ɡɚɩɭɫɤ ɤɨɦɩɨɧɨɜɳɢɤɚ ɫ ɩɚɪɚɦɟɬɪɚɦɢ:
/OUT: MyLib.dll – ɢɦɹ ɜɵɯɨɞɧɨɝɨ ɮɚɣɥɚ;
70
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]