» Assembler

Zminyty

Цитата:

по ссылке уже пошли какие-то дебри ассемблера

Да нет там никаких дебрей.
Суть задачи вывода - преобразовать число вроде 1234 в последовательность символов '1','2','3','4', поскольку функции вывода работают именно с символами. Алгоритм: последовательно делим число на 10, остаток от деления даёт цифру, стоящую в очередном разряде.
1234/10=123, в остатке 4. Добавляем '0' (30h), получаем символ '4'. Заносим его в буфер, смещаем указатель.
123/10=12, в остатке 3. Добавляем '0' (30h), получаем символ '3'. Заносим его в буфер, смещаем указатель.
12/10=1, в остатке 2. Добавляем '0' (30h), получаем символ '2'. Заносим его в буфер, смещаем указатель.
1/10=0, в остатке 1. Добавляем '0' (30h), получаем символ '1'. Заносим его в буфер.
Теперь в буфере образовалась искомая строка '1234', которую осталось лишь вывести.
Что конкретно непонятно?

Цитата:

т.е. если у нас есть просто число в памяти, то в каком оно виде там хранится и почему мы можем обычным способом его вывести на экран

Хранится в двоичном виде и без преобразования его не вывести.
Простой пример:

Код: mov ah,2
mov dl,36h
int 21h

Zminyty

Цитата:

хорошо,т.е. если я не буду вывосить свой ворд из ах, потом выполню арифметическую операцию над двумя числами и запишу результат операции в дополнительную, допустим, с переменную и мне понадобится её вывести на экран.здесь придётся переводить из двоичного представления в аски?я праивльно понимаю?

Не обязательно.


Цитата:

если у нас есть просто число в памяти, то в каком оно виде там хранится

Если вы определили число как строку т.е. '12345' то в памяти это будет хранится так "31h 32h 33h 34h 35h", в остальных случаях как обычное шестнадцетиричное число.

Abs62

ой да сам алгоритм понятен очень как.слава богу семестр компьютерной арифметики не зря прошелпросто страшно как-то всё так выглядит, да и не ф-ии знаю ассемблера.придется этим занятся уже на неделе, т.к. сейчас учу кое-что другое


Цитата:

На экран будет выведена цифра '6', хотя в dl лежит десятичное число 54 (шестнадцатеричное 36).

да это уже понятноспаисбо большоев принципе, очень неплохо разобралась

blaro

Цитата:

Если вы определили число как строку т.е. '12345' то в памяти это будет хранится так "31h 32h 33h 34h 35h", в остальных случаях как обычное шестнадцетиричное число.

и вам тоже спасибо

хотел установить Masm 8 под XP SP3 - пишет необходим Visual C++ 2005 express - устнавливаю файл, скачанный с download center Microsoft vcredist86.exe - запускается установка 2005 express. Проходит нормально, но Masm - снова не устанавливается, выводит ту же ошибку, что нужен Visual C++ 2005 express.
Может нужен полный Visual 2005, у меня есть дистрибутив, но в нем нет одного файла - Setup.exe - пжс, залейте на файлообменник один этот файл, у кого есть.

Помогите разобарться пожалуйста. Нужно написать программу умножения 16-х чисел на 3. Скажите, пожалуйста, где базовая ошибка. Возможно, тут написан полный бред так как это моя первая программа на Ассемблере. Заранее спасибо!
Вот мой код:
masm
model small
.data

message db 0dh,0ah,"VVedite chislo (16)"
vuvod     db 0dh,0ah,"Resultat: $"
end_question    db 0dh,0ah,"Hotite povtorit? ('y'- yes) $"

.stack 256
.code



convert_char:
sub al,'0' ;вычитаем из символа ASCII-код нуля
cmp al,10 ;если разность меньше 10, то была
;десятичная цифра - больше ничего не нужно
;делать
jb done ;команда JB - переход, если меньше
;иначе - была буква
add al,'0' ;AL=исходная буква
and al,0x5f ;приводим ее к верхнему регистру
sub al,'A'-10 ;получаем диапазон от 10
and al,0x0f ;вернуть нужное значение 0-15. Если
;буква больше F, то
;очищаем 4 старших бита AL
done:
ret ;возвращаемся



HexDigit:
cmp dl,10
jb .less
add dl,'A'-10
ret
.less:
or dl,'0'
ret


main proc ;початок процедури main
mov ax,@data ;фізична адреса сегмента даних в регістр ах
mov ds,ax ;ах записуємо в ds
vvod:
mov ax,0003h ;очистка екрану
    mov dx,offset message ;загрузка адреси строки message
int 21h ;вивід запрошення до вводу
push esi ;сохраняем указатель в стеке
xor eax,eax ;EAX = 0
xor ebx,ebx ;EBX = 0: накопитель для числа
cmp byte [esi],'-' ;число отрицательное?
jnz .next ;если нет, не пропускаем следующий
;символ
inc esi ;пропускаем символ '-'
.next:
lodsb ;читаем цифру в AL
or al,al ;конец строки?
jz .done
call convert_char ;преобразовать в число и сохранить
;его в AL
imul ebx,16 ;умножить EBX на 16, сохранить в EBX
add ebx,eax ;сложить
jmp short .next ;и повторить
.done:
xchg ebx,eax ;поместить накопленное число в EAX
pop esi ;восстановить исходное значение ESI
cmp byte [esi],'-' ;результат должен быть отрицательным?
jz .negate ;да, выполним отрицание
ret
.negate:
neg eax ;выполняем отрицание
ret ;все!

lea eax,[eax*3]

pushad
xor esi,esi
converted_loop:
xor edx,edx
div 16
call HexDigit
push edx
inc esi
test eax,eax
jnz converted_loop
cld
write_loop:
pop eax
stosb
dec esi
test esi,esi
jnz write_loop
mov byte [edi],0
popad
ret
jmp end_cont ;перехід до мітке end_cont
end_cont:
    mov dx,offset end_question ;загрузка адреси строки end_question
    mov ah,9
    int 21h ;вивід строки end_question на екран
    xor ah,ah ;очистка ah
    mov ah,01h
    int 21h     ;ввід користувачем умови
    cmp al,'y' ;якщо натиснули "у"
    je vvod     ;перехід в початок програми і повтор її дій
mov ax,4c00h
int 21h ;завершеня програми
endp main
end main

Crousader

Цитата:

and al,0x5f ;приводим ее к верхнему регистру

or должно быть

люди помогите плиз, в ассамблере начинающий,можно сказать полный нубнемогу решить эти задачи
заранее оч благодарен

{y = |x-5|, если x > 0
{y = x(в квадрате)+4x-3, если x <=(меньше либо равно)0

x - должен быть в регистре C
y - должен быть в регистре D

а так же

{y = (x-1)(в квадрате), если x > 1
{y = (x+1)(в квадрате), если x <=(меньше либо равно)1

x - должен быть в регистре C
y - должен быть в регистре D

Sevand

Цитата:

в ассамблере начинающий

а что ты "начал" _сам_ в своих задачах?

Sevand

Цитата:

регистре C

Цитата:

регистре D

Таких регистров нет, может быть ecx, edx

Примерно так (только вычисление через сопроцессор выражений), ну а где/как их использовать и какой еще код нужен -на твое усмотрение.
[more]
Код:
.data
x dd 5
y dd ?
five dw 5
four dw 4
three dw 3
one dw 1


Цитата:

y = |x-5|

...
mov x,ecx
fild x ; х в регистр сопроцессора st(0)
fild five ; st(0)=5, st(1)=x
fsub ; st(0)=x-5
fabs ; st(0)=|x-5|
fist y ; y=что нужно
mov edx,y
...


Цитата:

y = x(в квадрате)+4x-3

mov x,ecx
fild x ; st(0)=x
fild x ; st(0)=x; st(1)=x
fmul ; st(0)=x*x
fild four ; st(0)=4; st(1)=x*x
fild x ; st(0)=x; st(1)=4; st(2)=x*x
fmul ; st(0)=4*x; st(1)=x*x
fadd ; st(0)=x*x+4*x
fild three ; st(0)=3; st(1)=x*x+4*x
fsub ; st(0)=x*x+4*x-3
fist y
mov edx,y


Цитата:

y = (x-1)(в квадрате)

...
fild x
fild one
fsub ; st(0)=x-1
fmul st(0),st ; st(0)=st(0)*st(0)=(x-1)^2

никто не подскажет как симулировать нажатие клавиши мыши. чета гуглю гуглю не могу найти.
для 16 битного процессора

bomzzz
А конкретнее можно, телепаты в отпуске
BIOS? DOS? Windows?

Asmix
Еще б через месяц написали ). Раз 16 битный режим, скорее всего под ДОС, значит в прерываниях разбираться надо.

aspis
16-битные приложения и в винде есть
я только потом заметил, что месяц прошел
а что же сам не удосужился, раз такой умный

Цитата:

а что же сам не удосужился, раз такой умный

Удосужился что? Я привел какую-никакую идею: ДОС - смотреть прерывания, отвечающие за работу с мышью; а если Win - ну например смотреть WinAPI/механизм сообщений (SendMessage). А Вы? )
Дальше с Вами спорить не собираюсь, но согласен, что задача поставлена некорректно и нужны уточнения.

я и не спорил, в виду отсутствия наличия предмета спора

Цитата:

Удосужился что?

судя по ответам, технические знания присутствуют, так почему же ответить товарищу bomzzz времени не нашлось

Есть такой вопрос. Предистория здесь. Если вкратце, то компилятор интела известен тем, что вставляет функции проверки типа процессора,
и, в зависимости от его типа, программа подключает математические и другие функции с разным уровнем оптимизации (SSE2,SSE3,SSE4.x и.т.д)
При этом он делает это ущербно, если ему попадается АМД процессор (пруфлинк )

Проблема в том, что новый компилятор интела генерирует слегка другой код в функции проверки, и патч для программ больше не работает.
Я в асме не силен, а тем более в асм с 64битными инструкциями. Ниже приведены сравнения функции проверки от старого компилятора (оригинал и подправленый),
а также код функции проверки, вставляемый новым компилятором в программу.
Прошу знающих людей посмотреть на код и обьяснить что происходит в новой функции по сравнению со старыми (оригинальной и модифицированой после патча)
[more=код здесь]

Код:

#old intel compiler, original code
00000000005078f0 <__intel_cpu_indicator_init>:
5078f0: 50 push %rax
5078f1: 52 push %rdx
5078f2: 51 push %rcx
5078f3: 53 push %rbx
5078f4: 57 push %rdi
5078f5: 56 push %rsi
5078f6: 55 push %rbp
5078f7: 41 54 push %r12
5078f9: 41 55 push %r13
5078fb: 41 56 push %r14
5078fd: 41 57 push %r15
5078ff: 48 89 e5 mov %rsp,%rbp
507902: 48 83 ec 50 sub $0x50,%rsp
507906: 9c pushfq
507907: 58 pop %rax
507908: 48 89 c1 mov %rax,%rcx
50790b: 48 35 00 00 20 00 xor $0x200000,%rax
507911: 50 push %rax
507912: 9d popfq
507913: 9c pushfq
507914: 58 pop %rax
507915: 48 3b c1 cmp %rcx,%rax
507918: 74 2a je 507944 <__intel_cpu_indicator_init+0x54>
50791a: 51 push %rcx
50791b: 9d popfq
50791c: 48 33 c0 xor %rax,%rax
50791f: 0f a2 cpuid
507921: 89 45 f8 mov %eax,-0x8(%rbp)
507924: 89 5d fc mov %ebx,-0x4(%rbp)
507927: 89 4d ec mov %ecx,-0x14(%rbp)
50792a: 89 55 f4 mov %edx,-0xc(%rbp)
50792d: 48 c7 c0 01 00 00 00 mov $0x1,%rax
507934: 0f a2 cpuid
507936: 89 45 f0 mov %eax,-0x10(%rbp)
507939: 89 5d e0 mov %ebx,-0x20(%rbp)
50793c: 89 4d e8 mov %ecx,-0x18(%rbp)
50793f: 89 55 e4 mov %edx,-0x1c(%rbp)
507942: eb 1b jmp 50795f <__intel_cpu_indicator_init+0x6f>
507944: 48 33 c0 xor %rax,%rax
507947: 89 45 f8 mov %eax,-0x8(%rbp)
50794a: 89 45 fc mov %eax,-0x4(%rbp)
50794d: 89 45 ec mov %eax,-0x14(%rbp)
507950: 89 45 f4 mov %eax,-0xc(%rbp)
507953: 89 45 f0 mov %eax,-0x10(%rbp)
507956: 89 45 e0 mov %eax,-0x20(%rbp)
507959: 89 45 e8 mov %eax,-0x18(%rbp)
50795c: 89 45 e4 mov %eax,-0x1c(%rbp)
50795f: 8b 45 fc mov -0x4(%rbp),%eax
507962: bb 01 00 00 00 mov $0x1,%ebx
507967: 3d 47 65 6e 75 cmp $0x756e6547,%eax
50796c: 75 1b jne 507989 <__intel_cpu_indicator_init+0x99>
50796e: 8b 45 f4 mov -0xc(%rbp),%eax
507971: 3d 69 6e 65 49 cmp $0x49656e69,%eax
507976: 75 11 jne 507989 <__intel_cpu_indicator_init+0x99>
507978: 8b 45 ec mov -0x14(%rbp),%eax
50797b: 3d 6e 74 65 6c cmp $0x6c65746e,%eax
507980: 75 07 jne 507989 <__intel_cpu_indicator_init+0x99>
507982: ba 01 00 00 00 mov $0x1,%edx
507987: eb 02 jmp 50798b <__intel_cpu_indicator_init+0x9b>
507989: 33 d2 xor %edx,%edx
50798b: 8b 45 f8 mov -0x8(%rbp),%eax
50798e: 85 c0 test %eax,%eax
507990: 0f 84 8e 00 00 00 je 507a24 <__intel_cpu_indicator_init+0x134>
507996: 85 d2 test %edx,%edx
507998: 0f 84 86 00 00 00 je 507a24 <__intel_cpu_indicator_init+0x134>
50799e: 0f b6 45 f1 movzbl -0xf(%rbp),%eax
5079a2: 83 e0 0f and $0xf,%eax
5079a5: 83 f8 0f cmp $0xf,%eax
5079a8: 75 15 jne 5079bf <__intel_cpu_indicator_init+0xcf>
5079aa: 8b 45 e8 mov -0x18(%rbp),%eax
5079ad: ba 00 08 00 00 mov $0x800,%edx
5079b2: bb 01 00 00 00 mov $0x1,%ebx
5079b7: 83 e0 01 and $0x1,%eax
5079ba: 0f 45 da cmovne %edx,%ebx
5079bd: eb 65 jmp 507a24 <__intel_cpu_indicator_init+0x134>
5079bf: 83 f8 06 cmp $0x6,%eax
5079c2: 75 60 jne 507a24 <__intel_cpu_indicator_init+0x134>
5079c4: 8b 55 e8 mov -0x18(%rbp),%edx
5079c7: b9 00 00 01 00 mov $0x10000,%ecx
5079cc: bb 00 08 00 00 mov $0x800,%ebx
5079d1: f6 c2 01 test $0x1,%dl
5079d4: 75 05 jne 5079db <__intel_cpu_indicator_init+0xeb>
5079d6: bb 01 00 00 00 mov $0x1,%ebx
5079db: f7 c2 00 02 00 00 test $0x200,%edx
5079e1: 89 d0 mov %edx,%eax
5079e3: 74 05 je 5079ea <__intel_cpu_indicator_init+0xfa>
5079e5: bb 00 10 00 00 mov $0x1000,%ebx
5079ea: f7 c2 00 00 40 00 test $0x400000,%edx
5079f0: 74 05 je 5079f7 <__intel_cpu_indicator_init+0x107>
5079f2: bb 00 40 00 00 mov $0x4000,%ebx
5079f7: f7 c2 00 00 08 00 test $0x80000,%edx
5079fd: 74 05 je 507a04 <__intel_cpu_indicator_init+0x114>
5079ff: bb 00 20 00 00 mov $0x2000,%ebx
507a04: 25 00 00 90 00 and $0x900000,%eax
507a09: 3d 00 00 90 00 cmp $0x900000,%eax
507a0e: 75 05 jne 507a15 <__intel_cpu_indicator_init+0x125>
507a10: bb 00 80 00 00 mov $0x8000,%ebx
507a15: 81 e2 02 00 00 02 and $0x2000002,%edx
507a1b: 81 fa 02 00 00 02 cmp $0x2000002,%edx
507a21: 0f 44 d9 cmove %ecx,%ebx
507a24: 48 8b 05 25 15 27 00 mov 0x271525(%rip),%rax # 778f50 <_DYNAMIC+0x308>
507a2b: 89 18 mov %ebx,(%rax)
507a2d: 48 83 c4 50 add $0x50,%rsp
507a31: 41 5f pop %r15
507a33: 41 5e pop %r14
507a35: 41 5d pop %r13
507a37: 41 5c pop %r12
507a39: 5d pop %rbp
507a3a: 5e pop %rsi
507a3b: 5f pop %rdi
507a3c: 5b pop %rbx
507a3d: 59 pop %rcx
507a3e: 5a pop %rdx
507a3f: 58 pop %rax
507a40: c3 retq
507a41: 48 8d b4 26 00 00 00 lea 0x0(%rsi,%riz,1),%rsi
507a48: 00
507a49: 48 8d bf 00 00 00 00 lea 0x0(%rdi),%rdi







#old intel compiler, patched code with intel_check_executable_patch.pl

00000000005078f0 <__intel_cpu_indicator_init>:
5078f0: 50 push %rax
5078f1: 52 push %rdx
5078f2: 51 push %rcx
5078f3: 53 push %rbx
5078f4: 57 push %rdi
5078f5: 56 push %rsi
5078f6: 55 push %rbp
5078f7: 41 54 push %r12
5078f9: 41 55 push %r13
5078fb: 41 56 push %r14
5078fd: 41 57 push %r15
5078ff: 48 89 e5 mov %rsp,%rbp
507902: 48 83 ec 50 sub $0x50,%rsp
507906: 9c pushfq
507907: 58 pop %rax
507908: 48 89 c1 mov %rax,%rcx
50790b: 48 35 00 00 20 00 xor $0x200000,%rax
507911: 50 push %rax
507912: 9d popfq
507913: 9c pushfq
507914: 58 pop %rax
507915: 48 3b c1 cmp %rcx,%rax
507918: 74 2a je 507944 <__intel_cpu_indicator_init+0x54>
50791a: 51 push %rcx
50791b: 9d popfq
50791c: 48 33 c0 xor %rax,%rax
50791f: 0f a2 cpuid
507921: 89 45 f8 mov %eax,-0x8(%rbp)
507924: 89 5d fc mov %ebx,-0x4(%rbp)
507927: 89 4d ec mov %ecx,-0x14(%rbp)
50792a: 89 55 f4 mov %edx,-0xc(%rbp)
50792d: 48 c7 c0 01 00 00 00 mov $0x1,%rax
507934: 0f a2 cpuid
507936: 89 45 f0 mov %eax,-0x10(%rbp)
507939: 89 5d e0 mov %ebx,-0x20(%rbp)
50793c: 89 4d e8 mov %ecx,-0x18(%rbp)
50793f: 89 55 e4 mov %edx,-0x1c(%rbp)
507942: eb 1b jmp 50795f <__intel_cpu_indicator_init+0x6f>
507944: 48 33 c0 xor %rax,%rax
507947: 89 45 f8 mov %eax,-0x8(%rbp)
50794a: 89 45 fc mov %eax,-0x4(%rbp)
50794d: 89 45 ec mov %eax,-0x14(%rbp)
507950: 89 45 f4 mov %eax,-0xc(%rbp)
507953: 89 45 f0 mov %eax,-0x10(%rbp)
507956: 89 45 e0 mov %eax,-0x20(%rbp)
507959: 89 45 e8 mov %eax,-0x18(%rbp)
50795c: 89 45 e4 mov %eax,-0x1c(%rbp)
50795f: 8b 45 fc mov -0x4(%rbp),%eax
507962: bb 01 00 00 00 mov $0x1,%ebx
507967: a9 00 00 00 00 test $0x0,%eax
50796c: 75 1b jne 507989 <__intel_cpu_indicator_init+0x99>
50796e: 8b 45 f4 mov -0xc(%rbp),%eax
507971: a9 00 00 00 00 test $0x0,%eax
507976: 75 11 jne 507989 <__intel_cpu_indicator_init+0x99>
507978: 8b 45 ec mov -0x14(%rbp),%eax
50797b: a9 00 00 00 00 test $0x0,%eax
507980: 75 07 jne 507989 <__intel_cpu_indicator_init+0x99>
507982: ba 01 00 00 00 mov $0x1,%edx
507987: eb 02 jmp 50798b <__intel_cpu_indicator_init+0x9b>
507989: 33 d2 xor %edx,%edx
50798b: 8b 45 f8 mov -0x8(%rbp),%eax
50798e: 85 c0 test %eax,%eax
507990: 0f 84 8e 00 00 00 je 507a24 <__intel_cpu_indicator_init+0x134>
507996: 85 d2 test %edx,%edx
507998: 0f 84 86 00 00 00 je 507a24 <__intel_cpu_indicator_init+0x134>
50799e: 0f b6 45 f1 movzbl -0xf(%rbp),%eax
5079a2: 83 e0 0f and $0xf,%eax
5079a5: 83 f8 0f cmp $0xf,%eax
5079a8: 75 15 jne 5079bf <__intel_cpu_indicator_init+0xcf>
5079aa: 8b 45 e8 mov -0x18(%rbp),%eax
5079ad: ba 00 08 00 00 mov $0x800,%edx
5079b2: bb 01 00 00 00 mov $0x1,%ebx
5079b7: 83 e0 01 and $0x1,%eax
5079ba: 0f 45 da cmovne %edx,%ebx
5079bd: eb 65 jmp 507a24 <__intel_cpu_indicator_init+0x134>
5079bf: 83 f8 06 cmp $0x6,%eax
5079c2: 75 60 jne 507a24 <__intel_cpu_indicator_init+0x134>
5079c4: 8b 55 e8 mov -0x18(%rbp),%edx
5079c7: b9 00 00 01 00 mov $0x10000,%ecx
5079cc: bb 00 08 00 00 mov $0x800,%ebx
5079d1: f6 c2 01 test $0x1,%dl
5079d4: 75 05 jne 5079db <__intel_cpu_indicator_init+0xeb>
5079d6: bb 01 00 00 00 mov $0x1,%ebx
5079db: f7 c2 00 02 00 00 test $0x200,%edx
5079e1: 89 d0 mov %edx,%eax
5079e3: 74 05 je 5079ea <__intel_cpu_indicator_init+0xfa>
5079e5: bb 00 10 00 00 mov $0x1000,%ebx
5079ea: f7 c2 00 00 40 00 test $0x400000,%edx
5079f0: 74 05 je 5079f7 <__intel_cpu_indicator_init+0x107>
5079f2: bb 00 40 00 00 mov $0x4000,%ebx
5079f7: f7 c2 00 00 08 00 test $0x80000,%edx
5079fd: 74 05 je 507a04 <__intel_cpu_indicator_init+0x114>
5079ff: bb 00 20 00 00 mov $0x2000,%ebx
507a04: 25 00 00 90 00 and $0x900000,%eax
507a09: 3d 00 00 90 00 cmp $0x900000,%eax
507a0e: 75 05 jne 507a15 <__intel_cpu_indicator_init+0x125>
507a10: bb 00 80 00 00 mov $0x8000,%ebx
507a15: 81 e2 02 00 00 02 and $0x2000002,%edx
507a1b: 81 fa 02 00 00 02 cmp $0x2000002,%edx
507a21: 0f 44 d9 cmove %ecx,%ebx
507a24: 48 8b 05 25 15 27 00 mov 0x271525(%rip),%rax # 778f50 <_DYNAMIC+0x308>
507a2b: 89 18 mov %ebx,(%rax)
507a2d: 48 83 c4 50 add $0x50,%rsp
507a31: 41 5f pop %r15
507a33: 41 5e pop %r14
507a35: 41 5d pop %r13
507a37: 41 5c pop %r12
507a39: 5d pop %rbp
507a3a: 5e pop %rsi
507a3b: 5f pop %rdi
507a3c: 5b pop %rbx
507a3d: 59 pop %rcx
507a3e: 5a pop %rdx
507a3f: 58 pop %rax
507a40: c3 retq
507a41: 48 8d b4 26 00 00 00 lea 0x0(%rsi,%riz,1),%rsi
507a48: 00
507a49: 48 8d bf 00 00 00 00 lea 0x0(%rdi),%rdi

#new intel compiler original code
000000000052cf40 <__intel_cpu_indicator_init>:
52cf40: 50 push %rax
52cf41: 52 push %rdx
52cf42: 51 push %rcx
52cf43: 53 push %rbx
52cf44: 57 push %rdi
52cf45: 56 push %rsi
52cf46: 55 push %rbp
52cf47: 41 50 push %r8
52cf49: 41 51 push %r9
52cf4b: 41 54 push %r12
52cf4d: 41 55 push %r13
52cf4f: 41 56 push %r14
52cf51: 41 57 push %r15
52cf53: 48 89 e5 mov %rsp,%rbp
52cf56: 48 83 ec 50 sub $0x50,%rsp
52cf5a: 9c pushfq
52cf5b: 58 pop %rax
52cf5c: 48 89 c1 mov %rax,%rcx
52cf5f: 48 35 00 00 20 00 xor $0x200000,%rax
52cf65: 50 push %rax
52cf66: 9d popfq
52cf67: 9c pushfq
52cf68: 58 pop %rax
52cf69: 48 3b c1 cmp %rcx,%rax
52cf6c: 74 2a je 52cf98 <__intel_cpu_indicator_init+0x58>
52cf6e: 51 push %rcx
52cf6f: 9d popfq
52cf70: 48 33 c0 xor %rax,%rax
52cf73: 0f a2 cpuid
52cf75: 89 45 ec mov %eax,-0x14(%rbp)
52cf78: 89 5d f0 mov %ebx,-0x10(%rbp)
52cf7b: 89 4d e0 mov %ecx,-0x20(%rbp)
52cf7e: 89 55 e8 mov %edx,-0x18(%rbp)
52cf81: 48 c7 c0 01 00 00 00 mov $0x1,%rax
52cf88: 0f a2 cpuid
52cf8a: 89 45 e4 mov %eax,-0x1c(%rbp)
52cf8d: 89 5d d0 mov %ebx,-0x30(%rbp)
52cf90: 89 4d dc mov %ecx,-0x24(%rbp)
52cf93: 89 55 d4 mov %edx,-0x2c(%rbp)
52cf96: eb 1b jmp 52cfb3 <__intel_cpu_indicator_init+0x73>
52cf98: 48 33 c0 xor %rax,%rax
52cf9b: 89 45 ec mov %eax,-0x14(%rbp)
52cf9e: 89 45 f0 mov %eax,-0x10(%rbp)
52cfa1: 89 45 e0 mov %eax,-0x20(%rbp)
52cfa4: 89 45 e8 mov %eax,-0x18(%rbp)
52cfa7: 89 45 e4 mov %eax,-0x1c(%rbp)
52cfaa: 89 45 d0 mov %eax,-0x30(%rbp)
52cfad: 89 45 dc mov %eax,-0x24(%rbp)
52cfb0: 89 45 d4 mov %eax,-0x2c(%rbp)
52cfb3: be 01 00 00 00 mov $0x1,%esi
52cfb8: 81 7d f0 47 65 6e 75 cmpl $0x756e6547,-0x10(%rbp)
52cfbf: 75 16 jne 52cfd7 <__intel_cpu_indicator_init+0x97>
52cfc1: 81 7d e8 69 6e 65 49 cmpl $0x49656e69,-0x18(%rbp)
52cfc8: 75 0d jne 52cfd7 <__intel_cpu_indicator_init+0x97>
52cfca: 81 7d e0 6e 74 65 6c cmpl $0x6c65746e,-0x20(%rbp)
52cfd1: 75 04 jne 52cfd7 <__intel_cpu_indicator_init+0x97>
52cfd3: 89 f0 mov %esi,%eax
52cfd5: eb 02 jmp 52cfd9 <__intel_cpu_indicator_init+0x99>
52cfd7: 33 c0 xor %eax,%eax
52cfd9: 83 7d ec 00 cmpl $0x0,-0x14(%rbp)
52cfdd: 0f 84 bd 00 00 00 je 52d0a0 <__intel_cpu_indicator_init+0x160>
52cfe3: 85 c0 test %eax,%eax
52cfe5: 0f 84 b5 00 00 00 je 52d0a0 <__intel_cpu_indicator_init+0x160>
52cfeb: 0f b6 45 e5 movzbl -0x1b(%rbp),%eax
52cfef: 83 e0 0f and $0xf,%eax
52cff2: 83 f8 0f cmp $0xf,%eax
52cff5: 75 11 jne 52d008 <__intel_cpu_indicator_init+0xc8>
52cff7: b8 00 08 00 00 mov $0x800,%eax
52cffc: f6 45 dc 01 testb $0x1,-0x24(%rbp)
52d000: 0f 45 f0 cmovne %eax,%esi
52d003: e9 98 00 00 00 jmpq 52d0a0 <__intel_cpu_indicator_init+0x160>
52d008: 83 f8 06 cmp $0x6,%eax
52d00b: 0f 85 8f 00 00 00 jne 52d0a0 <__intel_cpu_indicator_init+0x160>
52d011: 8b 5d dc mov -0x24(%rbp),%ebx
52d014: b9 00 00 01 00 mov $0x10000,%ecx
52d019: be 00 08 00 00 mov $0x800,%esi
52d01e: f6 c3 01 test $0x1,%bl
52d021: 75 05 jne 52d028 <__intel_cpu_indicator_init+0xe8>
52d023: be 01 00 00 00 mov $0x1,%esi
52d028: f7 c3 00 02 00 00 test $0x200,%ebx
52d02e: 89 d8 mov %ebx,%eax
52d030: 89 da mov %ebx,%edx
52d032: 74 05 je 52d039 <__intel_cpu_indicator_init+0xf9>
52d034: be 00 10 00 00 mov $0x1000,%esi
52d039: f7 c3 00 00 40 00 test $0x400000,%ebx
52d03f: 74 05 je 52d046 <__intel_cpu_indicator_init+0x106>
52d041: be 00 40 00 00 mov $0x4000,%esi
52d046: f7 c3 00 00 08 00 test $0x80000,%ebx
52d04c: 74 05 je 52d053 <__intel_cpu_indicator_init+0x113>
52d04e: be 00 20 00 00 mov $0x2000,%esi
52d053: 25 00 00 90 00 and $0x900000,%eax
52d058: 3d 00 00 90 00 cmp $0x900000,%eax
52d05d: 75 05 jne 52d064 <__intel_cpu_indicator_init+0x124>
52d05f: be 00 80 00 00 mov $0x8000,%esi
52d064: 81 e2 02 00 00 02 and $0x2000002,%edx
52d06a: 81 fa 02 00 00 02 cmp $0x2000002,%edx
52d070: 0f 44 f1 cmove %ecx,%esi
52d073: f7 c3 00 00 00 08 test $0x8000000,%ebx
52d079: 74 25 je 52d0a0 <__intel_cpu_indicator_init+0x160>
52d07b: b9 00 00 00 00 mov $0x0,%ecx
52d080: 0f 01 d0 xgetbv
52d083: 89 45 d8 mov %eax,-0x28(%rbp)
52d086: f7 45 dc 00 00 00 10 testl $0x10000000,-0x24(%rbp)
52d08d: 74 11 je 52d0a0 <__intel_cpu_indicator_init+0x160>
52d08f: 8b 45 d8 mov -0x28(%rbp),%eax
52d092: ba 00 00 02 00 mov $0x20000,%edx
52d097: 83 e0 06 and $0x6,%eax
52d09a: 83 f8 06 cmp $0x6,%eax
52d09d: 0f 44 f2 cmove %edx,%esi
52d0a0: 48 8b 05 a9 ae 26 00 mov 0x26aea9(%rip),%rax # 797f50 <_DYNAMIC+0x2f8>
52d0a7: 89 30 mov %esi,(%rax)
52d0a9: 48 83 c4 50 add $0x50,%rsp
52d0ad: 41 5f pop %r15
52d0af: 41 5e pop %r14
52d0b1: 41 5d pop %r13
52d0b3: 41 5c pop %r12
52d0b5: 41 59 pop %r9
52d0b7: 41 58 pop %r8
52d0b9: 5d pop %rbp
52d0ba: 5e pop %rsi
52d0bb: 5f pop %rdi
52d0bc: 5b pop %rbx
52d0bd: 59 pop %rcx
52d0be: 5a pop %rdx
52d0bf: 58 pop %rax
52d0c0: c3 retq
52d0c1: 48 8d b4 26 00 00 00 lea 0x0(%rsi,%riz,1),%rsi
52d0c8: 00
52d0c9: 48 8d bf 00 00 00 00 lea 0x0(%rdi),%rdi

Вот то, что проверяет компилятор (до и после)
А проверяет от строку "GenuineIntel" => "uneGIeniletn" (little endian у Intela) => 756e654749656e696c65746e

Старая проверка:

До

Код:
507967: 3d 47 65 6e 75 cmp $0x756e6547,%eax
50796c: 75 1b jne 507989 <__intel_cpu_indicator_init+0x99>
50796e: 8b 45 f4 mov -0xc(%rbp),%eax
507971: 3d 69 6e 65 49 cmp $0x49656e69,%eax
507976: 75 11 jne 507989 <__intel_cpu_indicator_init+0x99>
507978: 8b 45 ec mov -0x14(%rbp),%eax
50797b: 3d 6e 74 65 6c cmp $0x6c65746e,%eax
507980: 75 07 jne 507989 <__intel_cpu_indicator_init+0x99>

Шапка темы ставит в тупик. Потому как хочется написать, чтоб кто-нибудь объяснил, что делаю не так и в тоже время, это же контрольная... Писать - не писать, вот в чем вопрос!
Сильно не пинайте!
Есть выражение на Pascal:
...
i:=1;
k:=1024;
repeat
if ((i*i+k) or 9)=3 then i:=i*(i+k) else k:=k-i
until i>k;
...
Нужно в программе на Pascal совместить решение на Pascal и Assembler и ответы должны сходиться соответственно.
Реализовал программу так:
[more]
program kontr1;
uses crt;
var ax,dx,i,k:word;
begin
clrscr;
i:=1;
k:=1024;
repeat
if ((i*i+k) or 9)=3 then i:=i*(i+k) else k:=k-i
until i>k;
writeln ('Решение на Pascal ','i=',i,' k=',k);
asm
mov ax,1
mov dx,1024
@l3: mov cx,ax
mul ax
add cx,dx
or cx,9
cmp cx,3
jnz @l1
add ax,dx
mul ax
jmp @l2
@l1: sub dx,ax
@l2: cmp ax,dx
ja @l3
end;
writeln ('Решение на Assembler ','i=',ax,' k=',dx);
readln;
end.
[/more]
Помогите пожалуйста! Укажите на ошибки или напишите как должно быть

ValidolX

Цитата:

После

как то так?


Код:
52cfb8:    f7 45 f0 00 00 00 00     testl $0x0,-0x10(%rbp)
52cfbf:    75 16     jne 529b87 <__intel_cpu_indicator_init+0x97>
52cfc1:    f7 45 e8 00 00 00 00     testl $0x0,-0x18(%rbp)
52cfc8:    75 0d     jne 529b87 <__intel_cpu_indicator_init+0x97>
52cfca:    f7 45 e0 00 00 00 00     testl $0x0,-0x20(%rbp)
52cfd1:    75 04     jne 529b87 <__intel_cpu_indicator_init+0x97>

terminat0r
Скорее всего, если дальше еще нет проверок.
yurassik77
У вас масло маслянное ). Есть и переменная ах, есть еще регистр ах:
1) расчеты выполняете с использованием регистра, а при выводе используете переменную.
2) в ах - i; в dx - k, но операция умножения mul затирает значение в dx (если операнд 16 битный, значение умножения сохраняется в паре dx:ax)
Такой вариант (консольное приложение на Delphi только).
[more]
Код:
program Project1;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
i,k,tmp:word;
begin
try
{ TODO -oUser -cConsole Main : Insert code here }
i:=1;
k:=1024;
repeat
if ((i*i+k) or 9)=3 then
i:=i*(i+k)
else
k:=k-i
until i>k;
writeln ('Решение на Pascal ','i=',i,' k=',k);

i:=1;
k:=1024;
asm
finit
@CYCLE:
fild i // ((i*i+k) or 9)
fild i
fmul
fild k
fadd
fistp tmp
or tmp,9
cmp tmp,3 // if ((i*i+k) or 9)=3 then
jne @NEQ
fild i // i:=i*(i+k)
fild k
fadd
fild i
fmul
fistp i
@NEQ:
fild k // k:=k-i
fild i
fsub
fist k
mov ax,i
cmp k,ax
jge @CYCLE // until i>k;
end;

writeln ('Решение на Assembler ','i=',i,' k=',k);
readln;
except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
end.

ValidolX
aspis

Цитата:

Скорее всего, если дальше еще нет проверок.

дык кажись нет их больше. Патч заводит уже программы, которые до этого отказывались работать на АМД вообще.

Спасибо!

Ребят помогите поалуста напистаь программу, или может быть кто-то уже писал, задание выглядит так: Дана матрица 10х10 типы элементов байты. Элементы матрицы знаковые числа. Матрица находится в ОП.
Найти максимальный элемент матрицы, его координаты. Вычислить следующее выражение Ai max-1, j max-1 +Ai max+1, j max+1 /2
Матрицу рассматривать как двумерный массив. Выдать на экран матрицу, минимальный элемент, его координаты и результат вычисления выражения. Результат также поместить в файл.

Cheery12
вверху для таких случаев написано:

Цитата:

важное примечание
для тех кто считает, что здесь место халявных исполнений курсовых и лабораторных работ.
тут обычно помогают тем, кто сам хоть что-то пытается понять и сделать, но что-то не понимает, что-то не получается...
ведь ассемблер изучают и задачки на нём дают обычно не менеджерам по продажам и даже не всем физ.-мат. специальностям
вы сами избрали этот путь? вот и идите по нему сами, ножками... с ручками и с головой...

короче, тут не сборище придурков-альтруистов, которым нечего делать и они ждут-не дождутся когда вы их попросите
что-то сделать _за_ вас
если позарез надо и вы даже готовы заплатить, тогда вам сюда
удачи

Сорри не посмотрела, вот кусочек который я более менее сделала, но проблема в том что здесь надо двумерный сделать, а у меня одномерный.
STACK SEGMENT STAK
db 128
STACK ENDS
DATA SEGMENT
temp db 3 dup (' ')
ten db 10
str1 dw 0
str2 dw 1
col1 dw 0
col2 dw 1
fin_mas db 700 dup (' '), '$'
max db '?'
mas db 1,2,3,4,5,127,7,8,9,123, 128,12,13,13,16,17,18,14,19,20, 21,22,23,24,25,35,32,43,56,54, 23,23,54,4,123,23,23,65,63,34, 54,67,123,1,234,23,23,12,11,33, 1,2,3,4,5,6,7,8,9,10, 11,12,13,15,16,17,18,14,19,20, 21,22,23,24,25,35,32,43,56,54, 23,23,54,4,123,23,23,65,63,34, 54,67,123,1,234,23,23,12,11,33
file_name db 'ans.txt', 0
max_str db 'max= $'
DATA ENDS
CODE SEGMENT
ASSUME ds: DATA, ss: STACK, cs: CODE
trans proc
push cx

xor ax, ax
mov cx, 3
mov di, 0
mov al, mas[si]
loop3:
cmp ax, 0
je fin
div ten
add ah, 30h
mov temp[di], ah;
xor ah, ah
inc di

loop loop3
fin:
pop cx
ret
trans endp

console proc
push cx
mov cx, 3
mov di, 2
loop4:
mov dl, temp[di]
mov fin_mas[bx], dl
inc bx
dec di
loop loop4
pop cx
ret
console endp

start:
;max
mov cx, 100
mov si, 0
mov al, mas[si]
loop1:
cmp al, mas[si]
ja continue
mov al, max[si]

continue:
inc si
loop loop1

mov max, al

mov cx, 4
mov ah, 9
mov dx, offset max_str
int 21h

mov cx, 3
mov di, 0
xor ax, ax
mov al, max
loop9:
cmp ax, 0
je fin1
div ten
add ah, 30h
mov temp[di], ah;
xor ah, ah
inc di

loop loop9
fin1:
mov cx, 3
mov di, 2
loop10:
mov ah, 2
mov dl, temp[di]
int 21h
dec di
loop loop10


Добавлено:
Дана матрица 10 на 10 элементов. Работаем с ней, как с одномерным массивом, так как в памяти все строки расположены друг за другом. Сначала мы ищем максимальный элемент, проверяя в цикле все элементы массива. Далее переводим максимальный элемент в строку и выводим её на экран.
Поясняю что я делала.

Cheery12
Нету двумерных массивов, есть только одномерные. Все элементы в памяти располагаются последовательно друг за другом (упрощенно) в какой то области памяти. Программист сам решает как интерпретировать эту последовательность - хоть как одномерный, двумерный, n-мерный массив.
адрес элемента (i,j) можно трактовать
(база+(кол-во_элементов_в_строке*i+j) *размер_элемента)
у вас элементов в строке 10, размер 1 байт (db)
например 0 строка, 9 столбец: mas+(10*0+9)*1=mas+9; значение = 123
1 строка, 5 столбец: mas+(10*1+5)*1=mas+12; значение = 17.
Вообще это неплохо написано у Юрова, подробно и с примерами. Я бы дал совет - в программе расставлять комментарии, где поясняете что делает какой то код (ищет что то, сравнивает).

Cheery12
вверху также написано:
Цитата:

Просьба к пишущим и отвечающим все большие листинги оформлять тегом more.

ну вот, совсем другое дело...


Цитата:

проблема в том что здесь надо двумерный сделать, а у меня одномерный.

да нет в этом особой проблемы...
времени лично у меня нет, поэтому даю только шаблон -- делаешь два вложенных лупа по строкам и по элементам внутри строки, что-то типа:

Код: size_of_line = 10
num_lines = 10
num_elements = 10


lea si, offset array_address ; si будет скакать по строкам

loop_on_line:

mov bx, 0 ; это будет счётчик по элементам

loop_on_elements
тут текущий элемент в текущей строке адресуется как byte ptr [si+bx]
например
mov al, byte ptr [si+bx]
inc bx
end_loop_on_elements

add si, size_of_line
end_loop_on_line

Хорошо спасибо, может еще кто даст совет))

Скажите пожалуста, есть ли в асме знак табуляции как в Си и как перейти на новую строку? Мне надо распечатать список и чтоб было по столбикам все.

blaro
это смотря какими функциями ты собираешься пользоваться...
например, если 9-ой функцией 21-ого прерыванием ДОС, то символ $ означает конец записи и переход на новую запись

а так все теже коды, что и в Си: 0ah, 0dh и табуляция 09h

prg segment para public 'code'
assume cs:prg,ss:prg,es:prg,ds:prg
org 100h
start:
    
    mov ah, 9
    mov dx, offset Str_a
    int 21h
    
    call Get_chislo
    mov a, dl
    
    mov ah, 9
    mov dx, offset Str_b
    int 21h
    
    call Get_chislo
    mov b, dl
    mov bl, a
    mov cl, b
add bl, cl; а+b

mov cl, a
mov al, 2
mul cl; 2a

mov al, bl

div cl; (a+b)/2a


MOV AX,4C00H
INT 21H
CODES ENDS
END PROGRAM
Посмотрите пожалуста код проги: тут надо сделать ввод чисел, потом вычислить выражение Y=(a+b)/2a, и вывести в десятеричном виде, если я с регистрами не напутала то ввод и подсчет выражения должны быть правильны,а вот вывод не знаю.